PLplot
5.10.0
|
00001 /* ---------------------------------------------------------------------------- 00002 * This file was automatically generated by SWIG (http://www.swig.org). 00003 * Version 3.0.2 00004 * 00005 * This file is not intended to be easily readable and contains a number of 00006 * coding conventions designed to improve portability and efficiency. Do not make 00007 * changes to this file unless you know what you are doing--modify the SWIG 00008 * interface file instead. 00009 * ----------------------------------------------------------------------------- */ 00010 00011 #define SWIGPYTHON 00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE 00013 00014 /* ----------------------------------------------------------------------------- 00015 * This section contains generic SWIG labels for method/variable 00016 * declarations/attributes, and other compiler dependent labels. 00017 * ----------------------------------------------------------------------------- */ 00018 00019 /* template workaround for compilers that cannot correctly implement the C++ standard */ 00020 #ifndef SWIGTEMPLATEDISAMBIGUATOR 00021 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) 00022 # define SWIGTEMPLATEDISAMBIGUATOR template 00023 # elif defined(__HP_aCC) 00024 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ 00025 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ 00026 # define SWIGTEMPLATEDISAMBIGUATOR template 00027 # else 00028 # define SWIGTEMPLATEDISAMBIGUATOR 00029 # endif 00030 #endif 00031 00032 /* inline attribute */ 00033 #ifndef SWIGINLINE 00034 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) 00035 # define SWIGINLINE inline 00036 # else 00037 # define SWIGINLINE 00038 # endif 00039 #endif 00040 00041 /* attribute recognised by some compilers to avoid 'unused' warnings */ 00042 #ifndef SWIGUNUSED 00043 # if defined(__GNUC__) 00044 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 00045 # define SWIGUNUSED __attribute__ ((__unused__)) 00046 # else 00047 # define SWIGUNUSED 00048 # endif 00049 # elif defined(__ICC) 00050 # define SWIGUNUSED __attribute__ ((__unused__)) 00051 # else 00052 # define SWIGUNUSED 00053 # endif 00054 #endif 00055 00056 #ifndef SWIG_MSC_UNSUPPRESS_4505 00057 # if defined(_MSC_VER) 00058 # pragma warning(disable : 4505) /* unreferenced local function has been removed */ 00059 # endif 00060 #endif 00061 00062 #ifndef SWIGUNUSEDPARM 00063 # ifdef __cplusplus 00064 # define SWIGUNUSEDPARM(p) 00065 # else 00066 # define SWIGUNUSEDPARM(p) p SWIGUNUSED 00067 # endif 00068 #endif 00069 00070 /* internal SWIG method */ 00071 #ifndef SWIGINTERN 00072 # define SWIGINTERN static SWIGUNUSED 00073 #endif 00074 00075 /* internal inline SWIG method */ 00076 #ifndef SWIGINTERNINLINE 00077 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE 00078 #endif 00079 00080 /* exporting methods */ 00081 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 00082 # ifndef GCC_HASCLASSVISIBILITY 00083 # define GCC_HASCLASSVISIBILITY 00084 # endif 00085 #endif 00086 00087 #ifndef SWIGEXPORT 00088 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 00089 # if defined(STATIC_LINKED) 00090 # define SWIGEXPORT 00091 # else 00092 # define SWIGEXPORT __declspec(dllexport) 00093 # endif 00094 # else 00095 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) 00096 # define SWIGEXPORT __attribute__ ((visibility("default"))) 00097 # else 00098 # define SWIGEXPORT 00099 # endif 00100 # endif 00101 #endif 00102 00103 /* calling conventions for Windows */ 00104 #ifndef SWIGSTDCALL 00105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 00106 # define SWIGSTDCALL __stdcall 00107 # else 00108 # define SWIGSTDCALL 00109 # endif 00110 #endif 00111 00112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ 00113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 00114 # define _CRT_SECURE_NO_DEPRECATE 00115 #endif 00116 00117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ 00118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) 00119 # define _SCL_SECURE_NO_DEPRECATE 00120 #endif 00121 00122 00123 00124 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) 00125 /* Use debug wrappers with the Python release dll */ 00126 # undef _DEBUG 00127 # include <Python.h> 00128 # define _DEBUG 00129 #else 00130 # include <Python.h> 00131 #endif 00132 00133 /* ----------------------------------------------------------------------------- 00134 * swigrun.swg 00135 * 00136 * This file contains generic C API SWIG runtime support for pointer 00137 * type checking. 00138 * ----------------------------------------------------------------------------- */ 00139 00140 /* This should only be incremented when either the layout of swig_type_info changes, 00141 or for whatever reason, the runtime changes incompatibly */ 00142 #define SWIG_RUNTIME_VERSION "4" 00143 00144 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ 00145 #ifdef SWIG_TYPE_TABLE 00146 # define SWIG_QUOTE_STRING(x) #x 00147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) 00148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) 00149 #else 00150 # define SWIG_TYPE_TABLE_NAME 00151 #endif 00152 00153 /* 00154 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for 00155 creating a static or dynamic library from the SWIG runtime code. 00156 In 99.9% of the cases, SWIG just needs to declare them as 'static'. 00157 00158 But only do this if strictly necessary, ie, if you have problems 00159 with your compiler or suchlike. 00160 */ 00161 00162 #ifndef SWIGRUNTIME 00163 # define SWIGRUNTIME SWIGINTERN 00164 #endif 00165 00166 #ifndef SWIGRUNTIMEINLINE 00167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE 00168 #endif 00169 00170 /* Generic buffer size */ 00171 #ifndef SWIG_BUFFER_SIZE 00172 # define SWIG_BUFFER_SIZE 1024 00173 #endif 00174 00175 /* Flags for pointer conversions */ 00176 #define SWIG_POINTER_DISOWN 0x1 00177 #define SWIG_CAST_NEW_MEMORY 0x2 00178 00179 /* Flags for new pointer objects */ 00180 #define SWIG_POINTER_OWN 0x1 00181 00182 00183 /* 00184 Flags/methods for returning states. 00185 00186 The SWIG conversion methods, as ConvertPtr, return an integer 00187 that tells if the conversion was successful or not. And if not, 00188 an error code can be returned (see swigerrors.swg for the codes). 00189 00190 Use the following macros/flags to set or process the returning 00191 states. 00192 00193 In old versions of SWIG, code such as the following was usually written: 00194 00195 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { 00196 // success code 00197 } else { 00198 //fail code 00199 } 00200 00201 Now you can be more explicit: 00202 00203 int res = SWIG_ConvertPtr(obj,vptr,ty.flags); 00204 if (SWIG_IsOK(res)) { 00205 // success code 00206 } else { 00207 // fail code 00208 } 00209 00210 which is the same really, but now you can also do 00211 00212 Type *ptr; 00213 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); 00214 if (SWIG_IsOK(res)) { 00215 // success code 00216 if (SWIG_IsNewObj(res) { 00217 ... 00218 delete *ptr; 00219 } else { 00220 ... 00221 } 00222 } else { 00223 // fail code 00224 } 00225 00226 I.e., now SWIG_ConvertPtr can return new objects and you can 00227 identify the case and take care of the deallocation. Of course that 00228 also requires SWIG_ConvertPtr to return new result values, such as 00229 00230 int SWIG_ConvertPtr(obj, ptr,...) { 00231 if (<obj is ok>) { 00232 if (<need new object>) { 00233 *ptr = <ptr to new allocated object>; 00234 return SWIG_NEWOBJ; 00235 } else { 00236 *ptr = <ptr to old object>; 00237 return SWIG_OLDOBJ; 00238 } 00239 } else { 00240 return SWIG_BADOBJ; 00241 } 00242 } 00243 00244 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be 00245 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the 00246 SWIG errors code. 00247 00248 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code 00249 allows to return the 'cast rank', for example, if you have this 00250 00251 int food(double) 00252 int fooi(int); 00253 00254 and you call 00255 00256 food(1) // cast rank '1' (1 -> 1.0) 00257 fooi(1) // cast rank '0' 00258 00259 just use the SWIG_AddCast()/SWIG_CheckState() 00260 */ 00261 00262 #define SWIG_OK (0) 00263 #define SWIG_ERROR (-1) 00264 #define SWIG_IsOK(r) (r >= 0) 00265 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) 00266 00267 /* The CastRankLimit says how many bits are used for the cast rank */ 00268 #define SWIG_CASTRANKLIMIT (1 << 8) 00269 /* The NewMask denotes the object was created (using new/malloc) */ 00270 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) 00271 /* The TmpMask is for in/out typemaps that use temporal objects */ 00272 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) 00273 /* Simple returning values */ 00274 #define SWIG_BADOBJ (SWIG_ERROR) 00275 #define SWIG_OLDOBJ (SWIG_OK) 00276 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) 00277 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) 00278 /* Check, add and del mask methods */ 00279 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) 00280 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) 00281 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) 00282 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) 00283 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) 00284 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) 00285 00286 /* Cast-Rank Mode */ 00287 #if defined(SWIG_CASTRANK_MODE) 00288 # ifndef SWIG_TypeRank 00289 # define SWIG_TypeRank unsigned long 00290 # endif 00291 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ 00292 # define SWIG_MAXCASTRANK (2) 00293 # endif 00294 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) 00295 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) 00296 SWIGINTERNINLINE int SWIG_AddCast(int r) { 00297 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; 00298 } 00299 SWIGINTERNINLINE int SWIG_CheckState(int r) { 00300 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 00301 } 00302 #else /* no cast-rank mode */ 00303 # define SWIG_AddCast(r) (r) 00304 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) 00305 #endif 00306 00307 00308 #include <string.h> 00309 00310 #ifdef __cplusplus 00311 extern "C" { 00312 #endif 00313 00314 typedef void *(*swig_converter_func)(void *, int *); 00315 typedef struct swig_type_info *(*swig_dycast_func)(void **); 00316 00317 /* Structure to store information on one type */ 00318 typedef struct swig_type_info { 00319 const char *name; /* mangled name of this type */ 00320 const char *str; /* human readable name of this type */ 00321 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ 00322 struct swig_cast_info *cast; /* linked list of types that can cast into this type */ 00323 void *clientdata; /* language specific type data */ 00324 int owndata; /* flag if the structure owns the clientdata */ 00325 } swig_type_info; 00326 00327 /* Structure to store a type and conversion function used for casting */ 00328 typedef struct swig_cast_info { 00329 swig_type_info *type; /* pointer to type that is equivalent to this type */ 00330 swig_converter_func converter; /* function to cast the void pointers */ 00331 struct swig_cast_info *next; /* pointer to next cast in linked list */ 00332 struct swig_cast_info *prev; /* pointer to the previous cast */ 00333 } swig_cast_info; 00334 00335 /* Structure used to store module information 00336 * Each module generates one structure like this, and the runtime collects 00337 * all of these structures and stores them in a circularly linked list.*/ 00338 typedef struct swig_module_info { 00339 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ 00340 size_t size; /* Number of types in this module */ 00341 struct swig_module_info *next; /* Pointer to next element in circularly linked list */ 00342 swig_type_info **type_initial; /* Array of initially generated type structures */ 00343 swig_cast_info **cast_initial; /* Array of initially generated casting structures */ 00344 void *clientdata; /* Language specific module data */ 00345 } swig_module_info; 00346 00347 /* 00348 Compare two type names skipping the space characters, therefore 00349 "char*" == "char *" and "Class<int>" == "Class<int >", etc. 00350 00351 Return 0 when the two name types are equivalent, as in 00352 strncmp, but skipping ' '. 00353 */ 00354 SWIGRUNTIME int 00355 SWIG_TypeNameComp(const char *f1, const char *l1, 00356 const char *f2, const char *l2) { 00357 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { 00358 while ((*f1 == ' ') && (f1 != l1)) ++f1; 00359 while ((*f2 == ' ') && (f2 != l2)) ++f2; 00360 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; 00361 } 00362 return (int)((l1 - f1) - (l2 - f2)); 00363 } 00364 00365 /* 00366 Check type equivalence in a name list like <name1>|<name2>|... 00367 Return 0 if equal, -1 if nb < tb, 1 if nb > tb 00368 */ 00369 SWIGRUNTIME int 00370 SWIG_TypeCmp(const char *nb, const char *tb) { 00371 int equiv = 1; 00372 const char* te = tb + strlen(tb); 00373 const char* ne = nb; 00374 while (equiv != 0 && *ne) { 00375 for (nb = ne; *ne; ++ne) { 00376 if (*ne == '|') break; 00377 } 00378 equiv = SWIG_TypeNameComp(nb, ne, tb, te); 00379 if (*ne) ++ne; 00380 } 00381 return equiv; 00382 } 00383 00384 /* 00385 Check type equivalence in a name list like <name1>|<name2>|... 00386 Return 0 if not equal, 1 if equal 00387 */ 00388 SWIGRUNTIME int 00389 SWIG_TypeEquiv(const char *nb, const char *tb) { 00390 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; 00391 } 00392 00393 /* 00394 Check the typename 00395 */ 00396 SWIGRUNTIME swig_cast_info * 00397 SWIG_TypeCheck(const char *c, swig_type_info *ty) { 00398 if (ty) { 00399 swig_cast_info *iter = ty->cast; 00400 while (iter) { 00401 if (strcmp(iter->type->name, c) == 0) { 00402 if (iter == ty->cast) 00403 return iter; 00404 /* Move iter to the top of the linked list */ 00405 iter->prev->next = iter->next; 00406 if (iter->next) 00407 iter->next->prev = iter->prev; 00408 iter->next = ty->cast; 00409 iter->prev = 0; 00410 if (ty->cast) ty->cast->prev = iter; 00411 ty->cast = iter; 00412 return iter; 00413 } 00414 iter = iter->next; 00415 } 00416 } 00417 return 0; 00418 } 00419 00420 /* 00421 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison 00422 */ 00423 SWIGRUNTIME swig_cast_info * 00424 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { 00425 if (ty) { 00426 swig_cast_info *iter = ty->cast; 00427 while (iter) { 00428 if (iter->type == from) { 00429 if (iter == ty->cast) 00430 return iter; 00431 /* Move iter to the top of the linked list */ 00432 iter->prev->next = iter->next; 00433 if (iter->next) 00434 iter->next->prev = iter->prev; 00435 iter->next = ty->cast; 00436 iter->prev = 0; 00437 if (ty->cast) ty->cast->prev = iter; 00438 ty->cast = iter; 00439 return iter; 00440 } 00441 iter = iter->next; 00442 } 00443 } 00444 return 0; 00445 } 00446 00447 /* 00448 Cast a pointer up an inheritance hierarchy 00449 */ 00450 SWIGRUNTIMEINLINE void * 00451 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { 00452 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); 00453 } 00454 00455 /* 00456 Dynamic pointer casting. Down an inheritance hierarchy 00457 */ 00458 SWIGRUNTIME swig_type_info * 00459 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { 00460 swig_type_info *lastty = ty; 00461 if (!ty || !ty->dcast) return ty; 00462 while (ty && (ty->dcast)) { 00463 ty = (*ty->dcast)(ptr); 00464 if (ty) lastty = ty; 00465 } 00466 return lastty; 00467 } 00468 00469 /* 00470 Return the name associated with this type 00471 */ 00472 SWIGRUNTIMEINLINE const char * 00473 SWIG_TypeName(const swig_type_info *ty) { 00474 return ty->name; 00475 } 00476 00477 /* 00478 Return the pretty name associated with this type, 00479 that is an unmangled type name in a form presentable to the user. 00480 */ 00481 SWIGRUNTIME const char * 00482 SWIG_TypePrettyName(const swig_type_info *type) { 00483 /* The "str" field contains the equivalent pretty names of the 00484 type, separated by vertical-bar characters. We choose 00485 to print the last name, as it is often (?) the most 00486 specific. */ 00487 if (!type) return NULL; 00488 if (type->str != NULL) { 00489 const char *last_name = type->str; 00490 const char *s; 00491 for (s = type->str; *s; s++) 00492 if (*s == '|') last_name = s+1; 00493 return last_name; 00494 } 00495 else 00496 return type->name; 00497 } 00498 00499 /* 00500 Set the clientdata field for a type 00501 */ 00502 SWIGRUNTIME void 00503 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { 00504 swig_cast_info *cast = ti->cast; 00505 /* if (ti->clientdata == clientdata) return; */ 00506 ti->clientdata = clientdata; 00507 00508 while (cast) { 00509 if (!cast->converter) { 00510 swig_type_info *tc = cast->type; 00511 if (!tc->clientdata) { 00512 SWIG_TypeClientData(tc, clientdata); 00513 } 00514 } 00515 cast = cast->next; 00516 } 00517 } 00518 SWIGRUNTIME void 00519 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { 00520 SWIG_TypeClientData(ti, clientdata); 00521 ti->owndata = 1; 00522 } 00523 00524 /* 00525 Search for a swig_type_info structure only by mangled name 00526 Search is a O(log #types) 00527 00528 We start searching at module start, and finish searching when start == end. 00529 Note: if start == end at the beginning of the function, we go all the way around 00530 the circular list. 00531 */ 00532 SWIGRUNTIME swig_type_info * 00533 SWIG_MangledTypeQueryModule(swig_module_info *start, 00534 swig_module_info *end, 00535 const char *name) { 00536 swig_module_info *iter = start; 00537 do { 00538 if (iter->size) { 00539 size_t l = 0; 00540 size_t r = iter->size - 1; 00541 do { 00542 /* since l+r >= 0, we can (>> 1) instead (/ 2) */ 00543 size_t i = (l + r) >> 1; 00544 const char *iname = iter->types[i]->name; 00545 if (iname) { 00546 int compare = strcmp(name, iname); 00547 if (compare == 0) { 00548 return iter->types[i]; 00549 } else if (compare < 0) { 00550 if (i) { 00551 r = i - 1; 00552 } else { 00553 break; 00554 } 00555 } else if (compare > 0) { 00556 l = i + 1; 00557 } 00558 } else { 00559 break; /* should never happen */ 00560 } 00561 } while (l <= r); 00562 } 00563 iter = iter->next; 00564 } while (iter != end); 00565 return 0; 00566 } 00567 00568 /* 00569 Search for a swig_type_info structure for either a mangled name or a human readable name. 00570 It first searches the mangled names of the types, which is a O(log #types) 00571 If a type is not found it then searches the human readable names, which is O(#types). 00572 00573 We start searching at module start, and finish searching when start == end. 00574 Note: if start == end at the beginning of the function, we go all the way around 00575 the circular list. 00576 */ 00577 SWIGRUNTIME swig_type_info * 00578 SWIG_TypeQueryModule(swig_module_info *start, 00579 swig_module_info *end, 00580 const char *name) { 00581 /* STEP 1: Search the name field using binary search */ 00582 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); 00583 if (ret) { 00584 return ret; 00585 } else { 00586 /* STEP 2: If the type hasn't been found, do a complete search 00587 of the str field (the human readable name) */ 00588 swig_module_info *iter = start; 00589 do { 00590 size_t i = 0; 00591 for (; i < iter->size; ++i) { 00592 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) 00593 return iter->types[i]; 00594 } 00595 iter = iter->next; 00596 } while (iter != end); 00597 } 00598 00599 /* neither found a match */ 00600 return 0; 00601 } 00602 00603 /* 00604 Pack binary data into a string 00605 */ 00606 SWIGRUNTIME char * 00607 SWIG_PackData(char *c, void *ptr, size_t sz) { 00608 static const char hex[17] = "0123456789abcdef"; 00609 const unsigned char *u = (unsigned char *) ptr; 00610 const unsigned char *eu = u + sz; 00611 for (; u != eu; ++u) { 00612 unsigned char uu = *u; 00613 *(c++) = hex[(uu & 0xf0) >> 4]; 00614 *(c++) = hex[uu & 0xf]; 00615 } 00616 return c; 00617 } 00618 00619 /* 00620 Unpack binary data from a string 00621 */ 00622 SWIGRUNTIME const char * 00623 SWIG_UnpackData(const char *c, void *ptr, size_t sz) { 00624 unsigned char *u = (unsigned char *) ptr; 00625 const unsigned char *eu = u + sz; 00626 for (; u != eu; ++u) { 00627 char d = *(c++); 00628 unsigned char uu; 00629 if ((d >= '0') && (d <= '9')) 00630 uu = ((d - '0') << 4); 00631 else if ((d >= 'a') && (d <= 'f')) 00632 uu = ((d - ('a'-10)) << 4); 00633 else 00634 return (char *) 0; 00635 d = *(c++); 00636 if ((d >= '0') && (d <= '9')) 00637 uu |= (d - '0'); 00638 else if ((d >= 'a') && (d <= 'f')) 00639 uu |= (d - ('a'-10)); 00640 else 00641 return (char *) 0; 00642 *u = uu; 00643 } 00644 return c; 00645 } 00646 00647 /* 00648 Pack 'void *' into a string buffer. 00649 */ 00650 SWIGRUNTIME char * 00651 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { 00652 char *r = buff; 00653 if ((2*sizeof(void *) + 2) > bsz) return 0; 00654 *(r++) = '_'; 00655 r = SWIG_PackData(r,&ptr,sizeof(void *)); 00656 if (strlen(name) + 1 > (bsz - (r - buff))) return 0; 00657 strcpy(r,name); 00658 return buff; 00659 } 00660 00661 SWIGRUNTIME const char * 00662 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { 00663 if (*c != '_') { 00664 if (strcmp(c,"NULL") == 0) { 00665 *ptr = (void *) 0; 00666 return name; 00667 } else { 00668 return 0; 00669 } 00670 } 00671 return SWIG_UnpackData(++c,ptr,sizeof(void *)); 00672 } 00673 00674 SWIGRUNTIME char * 00675 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { 00676 char *r = buff; 00677 size_t lname = (name ? strlen(name) : 0); 00678 if ((2*sz + 2 + lname) > bsz) return 0; 00679 *(r++) = '_'; 00680 r = SWIG_PackData(r,ptr,sz); 00681 if (lname) { 00682 strncpy(r,name,lname+1); 00683 } else { 00684 *r = 0; 00685 } 00686 return buff; 00687 } 00688 00689 SWIGRUNTIME const char * 00690 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { 00691 if (*c != '_') { 00692 if (strcmp(c,"NULL") == 0) { 00693 memset(ptr,0,sz); 00694 return name; 00695 } else { 00696 return 0; 00697 } 00698 } 00699 return SWIG_UnpackData(++c,ptr,sz); 00700 } 00701 00702 #ifdef __cplusplus 00703 } 00704 #endif 00705 00706 /* Errors in SWIG */ 00707 #define SWIG_UnknownError -1 00708 #define SWIG_IOError -2 00709 #define SWIG_RuntimeError -3 00710 #define SWIG_IndexError -4 00711 #define SWIG_TypeError -5 00712 #define SWIG_DivisionByZero -6 00713 #define SWIG_OverflowError -7 00714 #define SWIG_SyntaxError -8 00715 #define SWIG_ValueError -9 00716 #define SWIG_SystemError -10 00717 #define SWIG_AttributeError -11 00718 #define SWIG_MemoryError -12 00719 #define SWIG_NullReferenceError -13 00720 00721 00722 00723 /* Compatibility macros for Python 3 */ 00724 #if PY_VERSION_HEX >= 0x03000000 00725 00726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) 00727 #define PyInt_Check(x) PyLong_Check(x) 00728 #define PyInt_AsLong(x) PyLong_AsLong(x) 00729 #define PyInt_FromLong(x) PyLong_FromLong(x) 00730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x) 00731 #define PyString_Check(name) PyBytes_Check(name) 00732 #define PyString_FromString(x) PyUnicode_FromString(x) 00733 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) 00734 #define PyString_AsString(str) PyBytes_AsString(str) 00735 #define PyString_Size(str) PyBytes_Size(str) 00736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key) 00737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE 00738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) 00739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) 00740 00741 #endif 00742 00743 #ifndef Py_TYPE 00744 # define Py_TYPE(op) ((op)->ob_type) 00745 #endif 00746 00747 /* SWIG APIs for compatibility of both Python 2 & 3 */ 00748 00749 #if PY_VERSION_HEX >= 0x03000000 00750 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat 00751 #else 00752 # define SWIG_Python_str_FromFormat PyString_FromFormat 00753 #endif 00754 00755 00756 /* Warning: This function will allocate a new string in Python 3, 00757 * so please call SWIG_Python_str_DelForPy3(x) to free the space. 00758 */ 00759 SWIGINTERN char* 00760 SWIG_Python_str_AsChar(PyObject *str) 00761 { 00762 #if PY_VERSION_HEX >= 0x03000000 00763 char *cstr; 00764 char *newstr; 00765 Py_ssize_t len; 00766 str = PyUnicode_AsUTF8String(str); 00767 PyBytes_AsStringAndSize(str, &cstr, &len); 00768 newstr = (char *) malloc(len+1); 00769 memcpy(newstr, cstr, len+1); 00770 Py_XDECREF(str); 00771 return newstr; 00772 #else 00773 return PyString_AsString(str); 00774 #endif 00775 } 00776 00777 #if PY_VERSION_HEX >= 0x03000000 00778 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) 00779 #else 00780 # define SWIG_Python_str_DelForPy3(x) 00781 #endif 00782 00783 00784 SWIGINTERN PyObject* 00785 SWIG_Python_str_FromChar(const char *c) 00786 { 00787 #if PY_VERSION_HEX >= 0x03000000 00788 return PyUnicode_FromString(c); 00789 #else 00790 return PyString_FromString(c); 00791 #endif 00792 } 00793 00794 /* Add PyOS_snprintf for old Pythons */ 00795 #if PY_VERSION_HEX < 0x02020000 00796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) 00797 # define PyOS_snprintf _snprintf 00798 # else 00799 # define PyOS_snprintf snprintf 00800 # endif 00801 #endif 00802 00803 /* A crude PyString_FromFormat implementation for old Pythons */ 00804 #if PY_VERSION_HEX < 0x02020000 00805 00806 #ifndef SWIG_PYBUFFER_SIZE 00807 # define SWIG_PYBUFFER_SIZE 1024 00808 #endif 00809 00810 static PyObject * 00811 PyString_FromFormat(const char *fmt, ...) { 00812 va_list ap; 00813 char buf[SWIG_PYBUFFER_SIZE * 2]; 00814 int res; 00815 va_start(ap, fmt); 00816 res = vsnprintf(buf, sizeof(buf), fmt, ap); 00817 va_end(ap); 00818 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); 00819 } 00820 #endif 00821 00822 /* Add PyObject_Del for old Pythons */ 00823 #if PY_VERSION_HEX < 0x01060000 00824 # define PyObject_Del(op) PyMem_DEL((op)) 00825 #endif 00826 #ifndef PyObject_DEL 00827 # define PyObject_DEL PyObject_Del 00828 #endif 00829 00830 /* A crude PyExc_StopIteration exception for old Pythons */ 00831 #if PY_VERSION_HEX < 0x02020000 00832 # ifndef PyExc_StopIteration 00833 # define PyExc_StopIteration PyExc_RuntimeError 00834 # endif 00835 # ifndef PyObject_GenericGetAttr 00836 # define PyObject_GenericGetAttr 0 00837 # endif 00838 #endif 00839 00840 /* Py_NotImplemented is defined in 2.1 and up. */ 00841 #if PY_VERSION_HEX < 0x02010000 00842 # ifndef Py_NotImplemented 00843 # define Py_NotImplemented PyExc_RuntimeError 00844 # endif 00845 #endif 00846 00847 /* A crude PyString_AsStringAndSize implementation for old Pythons */ 00848 #if PY_VERSION_HEX < 0x02010000 00849 # ifndef PyString_AsStringAndSize 00850 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} 00851 # endif 00852 #endif 00853 00854 /* PySequence_Size for old Pythons */ 00855 #if PY_VERSION_HEX < 0x02000000 00856 # ifndef PySequence_Size 00857 # define PySequence_Size PySequence_Length 00858 # endif 00859 #endif 00860 00861 /* PyBool_FromLong for old Pythons */ 00862 #if PY_VERSION_HEX < 0x02030000 00863 static 00864 PyObject *PyBool_FromLong(long ok) 00865 { 00866 PyObject *result = ok ? Py_True : Py_False; 00867 Py_INCREF(result); 00868 return result; 00869 } 00870 #endif 00871 00872 /* Py_ssize_t for old Pythons */ 00873 /* This code is as recommended by: */ 00874 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ 00875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) 00876 typedef int Py_ssize_t; 00877 # define PY_SSIZE_T_MAX INT_MAX 00878 # define PY_SSIZE_T_MIN INT_MIN 00879 typedef inquiry lenfunc; 00880 typedef intargfunc ssizeargfunc; 00881 typedef intintargfunc ssizessizeargfunc; 00882 typedef intobjargproc ssizeobjargproc; 00883 typedef intintobjargproc ssizessizeobjargproc; 00884 typedef getreadbufferproc readbufferproc; 00885 typedef getwritebufferproc writebufferproc; 00886 typedef getsegcountproc segcountproc; 00887 typedef getcharbufferproc charbufferproc; 00888 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) 00889 { 00890 long result = 0; 00891 PyObject *i = PyNumber_Int(x); 00892 if (i) { 00893 result = PyInt_AsLong(i); 00894 Py_DECREF(i); 00895 } 00896 return result; 00897 } 00898 #endif 00899 00900 #if PY_VERSION_HEX < 0x02050000 00901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x) 00902 #endif 00903 00904 #if PY_VERSION_HEX < 0x02040000 00905 #define Py_VISIT(op) \ 00906 do { \ 00907 if (op) { \ 00908 int vret = visit((op), arg); \ 00909 if (vret) \ 00910 return vret; \ 00911 } \ 00912 } while (0) 00913 #endif 00914 00915 #if PY_VERSION_HEX < 0x02030000 00916 typedef struct { 00917 PyTypeObject type; 00918 PyNumberMethods as_number; 00919 PyMappingMethods as_mapping; 00920 PySequenceMethods as_sequence; 00921 PyBufferProcs as_buffer; 00922 PyObject *name, *slots; 00923 } PyHeapTypeObject; 00924 #endif 00925 00926 #if PY_VERSION_HEX < 0x02030000 00927 typedef destructor freefunc; 00928 #endif 00929 00930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ 00931 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ 00932 (PY_MAJOR_VERSION > 3)) 00933 # define SWIGPY_USE_CAPSULE 00934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) 00935 #endif 00936 00937 #if PY_VERSION_HEX < 0x03020000 00938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) 00939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) 00940 #endif 00941 00942 /* ----------------------------------------------------------------------------- 00943 * error manipulation 00944 * ----------------------------------------------------------------------------- */ 00945 00946 SWIGRUNTIME PyObject* 00947 SWIG_Python_ErrorType(int code) { 00948 PyObject* type = 0; 00949 switch(code) { 00950 case SWIG_MemoryError: 00951 type = PyExc_MemoryError; 00952 break; 00953 case SWIG_IOError: 00954 type = PyExc_IOError; 00955 break; 00956 case SWIG_RuntimeError: 00957 type = PyExc_RuntimeError; 00958 break; 00959 case SWIG_IndexError: 00960 type = PyExc_IndexError; 00961 break; 00962 case SWIG_TypeError: 00963 type = PyExc_TypeError; 00964 break; 00965 case SWIG_DivisionByZero: 00966 type = PyExc_ZeroDivisionError; 00967 break; 00968 case SWIG_OverflowError: 00969 type = PyExc_OverflowError; 00970 break; 00971 case SWIG_SyntaxError: 00972 type = PyExc_SyntaxError; 00973 break; 00974 case SWIG_ValueError: 00975 type = PyExc_ValueError; 00976 break; 00977 case SWIG_SystemError: 00978 type = PyExc_SystemError; 00979 break; 00980 case SWIG_AttributeError: 00981 type = PyExc_AttributeError; 00982 break; 00983 default: 00984 type = PyExc_RuntimeError; 00985 } 00986 return type; 00987 } 00988 00989 00990 SWIGRUNTIME void 00991 SWIG_Python_AddErrorMsg(const char* mesg) 00992 { 00993 PyObject *type = 0; 00994 PyObject *value = 0; 00995 PyObject *traceback = 0; 00996 00997 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); 00998 if (value) { 00999 char *tmp; 01000 PyObject *old_str = PyObject_Str(value); 01001 PyErr_Clear(); 01002 Py_XINCREF(type); 01003 01004 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); 01005 SWIG_Python_str_DelForPy3(tmp); 01006 Py_DECREF(old_str); 01007 Py_DECREF(value); 01008 } else { 01009 PyErr_SetString(PyExc_RuntimeError, mesg); 01010 } 01011 } 01012 01013 #if defined(SWIG_PYTHON_NO_THREADS) 01014 # if defined(SWIG_PYTHON_THREADS) 01015 # undef SWIG_PYTHON_THREADS 01016 # endif 01017 #endif 01018 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ 01019 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) 01020 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ 01021 # define SWIG_PYTHON_USE_GIL 01022 # endif 01023 # endif 01024 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ 01025 # ifndef SWIG_PYTHON_INITIALIZE_THREADS 01026 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() 01027 # endif 01028 # ifdef __cplusplus /* C++ code */ 01029 class SWIG_Python_Thread_Block { 01030 bool status; 01031 PyGILState_STATE state; 01032 public: 01033 void end() { if (status) { PyGILState_Release(state); status = false;} } 01034 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} 01035 ~SWIG_Python_Thread_Block() { end(); } 01036 }; 01037 class SWIG_Python_Thread_Allow { 01038 bool status; 01039 PyThreadState *save; 01040 public: 01041 void end() { if (status) { PyEval_RestoreThread(save); status = false; }} 01042 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} 01043 ~SWIG_Python_Thread_Allow() { end(); } 01044 }; 01045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block 01046 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() 01047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow 01048 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() 01049 # else /* C code */ 01050 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() 01051 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) 01052 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() 01053 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) 01054 # endif 01055 # else /* Old thread way, not implemented, user must provide it */ 01056 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS) 01057 # define SWIG_PYTHON_INITIALIZE_THREADS 01058 # endif 01059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) 01060 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK 01061 # endif 01062 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK) 01063 # define SWIG_PYTHON_THREAD_END_BLOCK 01064 # endif 01065 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) 01066 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW 01067 # endif 01068 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW) 01069 # define SWIG_PYTHON_THREAD_END_ALLOW 01070 # endif 01071 # endif 01072 #else /* No thread support */ 01073 # define SWIG_PYTHON_INITIALIZE_THREADS 01074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK 01075 # define SWIG_PYTHON_THREAD_END_BLOCK 01076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW 01077 # define SWIG_PYTHON_THREAD_END_ALLOW 01078 #endif 01079 01080 /* ----------------------------------------------------------------------------- 01081 * Python API portion that goes into the runtime 01082 * ----------------------------------------------------------------------------- */ 01083 01084 #ifdef __cplusplus 01085 extern "C" { 01086 #endif 01087 01088 /* ----------------------------------------------------------------------------- 01089 * Constant declarations 01090 * ----------------------------------------------------------------------------- */ 01091 01092 /* Constant Types */ 01093 #define SWIG_PY_POINTER 4 01094 #define SWIG_PY_BINARY 5 01095 01096 /* Constant information structure */ 01097 typedef struct swig_const_info { 01098 int type; 01099 char *name; 01100 long lvalue; 01101 double dvalue; 01102 void *pvalue; 01103 swig_type_info **ptype; 01104 } swig_const_info; 01105 01106 01107 /* ----------------------------------------------------------------------------- 01108 * Wrapper of PyInstanceMethod_New() used in Python 3 01109 * It is exported to the generated module, used for -fastproxy 01110 * ----------------------------------------------------------------------------- */ 01111 #if PY_VERSION_HEX >= 0x03000000 01112 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) 01113 { 01114 return PyInstanceMethod_New(func); 01115 } 01116 #else 01117 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) 01118 { 01119 return NULL; 01120 } 01121 #endif 01122 01123 #ifdef __cplusplus 01124 } 01125 #endif 01126 01127 01128 /* ----------------------------------------------------------------------------- 01129 * pyrun.swg 01130 * 01131 * This file contains the runtime support for Python modules 01132 * and includes code for managing global variables and pointer 01133 * type checking. 01134 * 01135 * ----------------------------------------------------------------------------- */ 01136 01137 /* Common SWIG API */ 01138 01139 /* for raw pointers */ 01140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) 01141 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) 01142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) 01143 01144 #ifdef SWIGPYTHON_BUILTIN 01145 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) 01146 #else 01147 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) 01148 #endif 01149 01150 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) 01151 01152 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) 01153 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) 01154 #define swig_owntype int 01155 01156 /* for raw packed data */ 01157 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) 01158 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) 01159 01160 /* for class or struct pointers */ 01161 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) 01162 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) 01163 01164 /* for C or C++ function pointers */ 01165 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) 01166 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) 01167 01168 /* for C++ member pointers, ie, member methods */ 01169 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) 01170 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) 01171 01172 01173 /* Runtime API */ 01174 01175 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) 01176 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) 01177 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj) 01178 01179 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj 01180 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg 01181 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) 01182 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 01183 #define SWIG_fail goto fail 01184 01185 01186 /* Runtime API implementation */ 01187 01188 /* Error manipulation */ 01189 01190 SWIGINTERN void 01191 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { 01192 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 01193 PyErr_SetObject(errtype, obj); 01194 Py_DECREF(obj); 01195 SWIG_PYTHON_THREAD_END_BLOCK; 01196 } 01197 01198 SWIGINTERN void 01199 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { 01200 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 01201 PyErr_SetString(errtype, msg); 01202 SWIG_PYTHON_THREAD_END_BLOCK; 01203 } 01204 01205 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) 01206 01207 /* Set a constant value */ 01208 01209 #if defined(SWIGPYTHON_BUILTIN) 01210 01211 SWIGINTERN void 01212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { 01213 PyObject *s = PyString_InternFromString(key); 01214 PyList_Append(seq, s); 01215 Py_DECREF(s); 01216 } 01217 01218 SWIGINTERN void 01219 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { 01220 #if PY_VERSION_HEX < 0x02030000 01221 PyDict_SetItemString(d, (char *)name, obj); 01222 #else 01223 PyDict_SetItemString(d, name, obj); 01224 #endif 01225 Py_DECREF(obj); 01226 if (public_interface) 01227 SwigPyBuiltin_AddPublicSymbol(public_interface, name); 01228 } 01229 01230 #else 01231 01232 SWIGINTERN void 01233 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { 01234 #if PY_VERSION_HEX < 0x02030000 01235 PyDict_SetItemString(d, (char *)name, obj); 01236 #else 01237 PyDict_SetItemString(d, name, obj); 01238 #endif 01239 Py_DECREF(obj); 01240 } 01241 01242 #endif 01243 01244 /* Append a value to the result obj */ 01245 01246 SWIGINTERN PyObject* 01247 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { 01248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE) 01249 if (!result) { 01250 result = obj; 01251 } else if (result == Py_None) { 01252 Py_DECREF(result); 01253 result = obj; 01254 } else { 01255 if (!PyList_Check(result)) { 01256 PyObject *o2 = result; 01257 result = PyList_New(1); 01258 PyList_SetItem(result, 0, o2); 01259 } 01260 PyList_Append(result,obj); 01261 Py_DECREF(obj); 01262 } 01263 return result; 01264 #else 01265 PyObject* o2; 01266 PyObject* o3; 01267 if (!result) { 01268 result = obj; 01269 } else if (result == Py_None) { 01270 Py_DECREF(result); 01271 result = obj; 01272 } else { 01273 if (!PyTuple_Check(result)) { 01274 o2 = result; 01275 result = PyTuple_New(1); 01276 PyTuple_SET_ITEM(result, 0, o2); 01277 } 01278 o3 = PyTuple_New(1); 01279 PyTuple_SET_ITEM(o3, 0, obj); 01280 o2 = result; 01281 result = PySequence_Concat(o2, o3); 01282 Py_DECREF(o2); 01283 Py_DECREF(o3); 01284 } 01285 return result; 01286 #endif 01287 } 01288 01289 /* Unpack the argument tuple */ 01290 01291 SWIGINTERN int 01292 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) 01293 { 01294 if (!args) { 01295 if (!min && !max) { 01296 return 1; 01297 } else { 01298 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 01299 name, (min == max ? "" : "at least "), (int)min); 01300 return 0; 01301 } 01302 } 01303 if (!PyTuple_Check(args)) { 01304 if (min <= 1 && max >= 1) { 01305 int i; 01306 objs[0] = args; 01307 for (i = 1; i < max; ++i) { 01308 objs[i] = 0; 01309 } 01310 return 2; 01311 } 01312 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); 01313 return 0; 01314 } else { 01315 Py_ssize_t l = PyTuple_GET_SIZE(args); 01316 if (l < min) { 01317 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 01318 name, (min == max ? "" : "at least "), (int)min, (int)l); 01319 return 0; 01320 } else if (l > max) { 01321 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 01322 name, (min == max ? "" : "at most "), (int)max, (int)l); 01323 return 0; 01324 } else { 01325 int i; 01326 for (i = 0; i < l; ++i) { 01327 objs[i] = PyTuple_GET_ITEM(args, i); 01328 } 01329 for (; l < max; ++l) { 01330 objs[l] = 0; 01331 } 01332 return i + 1; 01333 } 01334 } 01335 } 01336 01337 /* A functor is a function object with one single object argument */ 01338 #if PY_VERSION_HEX >= 0x02020000 01339 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); 01340 #else 01341 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); 01342 #endif 01343 01344 /* 01345 Helper for static pointer initialization for both C and C++ code, for example 01346 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); 01347 */ 01348 #ifdef __cplusplus 01349 #define SWIG_STATIC_POINTER(var) var 01350 #else 01351 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var 01352 #endif 01353 01354 /* ----------------------------------------------------------------------------- 01355 * Pointer declarations 01356 * ----------------------------------------------------------------------------- */ 01357 01358 /* Flags for new pointer objects */ 01359 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) 01360 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) 01361 01362 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) 01363 01364 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) 01365 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) 01366 01367 #ifdef __cplusplus 01368 extern "C" { 01369 #endif 01370 01371 /* How to access Py_None */ 01372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 01373 # ifndef SWIG_PYTHON_NO_BUILD_NONE 01374 # ifndef SWIG_PYTHON_BUILD_NONE 01375 # define SWIG_PYTHON_BUILD_NONE 01376 # endif 01377 # endif 01378 #endif 01379 01380 #ifdef SWIG_PYTHON_BUILD_NONE 01381 # ifdef Py_None 01382 # undef Py_None 01383 # define Py_None SWIG_Py_None() 01384 # endif 01385 SWIGRUNTIMEINLINE PyObject * 01386 _SWIG_Py_None(void) 01387 { 01388 PyObject *none = Py_BuildValue((char*)""); 01389 Py_DECREF(none); 01390 return none; 01391 } 01392 SWIGRUNTIME PyObject * 01393 SWIG_Py_None(void) 01394 { 01395 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); 01396 return none; 01397 } 01398 #endif 01399 01400 /* The python void return value */ 01401 01402 SWIGRUNTIMEINLINE PyObject * 01403 SWIG_Py_Void(void) 01404 { 01405 PyObject *none = Py_None; 01406 Py_INCREF(none); 01407 return none; 01408 } 01409 01410 /* SwigPyClientData */ 01411 01412 typedef struct { 01413 PyObject *klass; 01414 PyObject *newraw; 01415 PyObject *newargs; 01416 PyObject *destroy; 01417 int delargs; 01418 int implicitconv; 01419 PyTypeObject *pytype; 01420 } SwigPyClientData; 01421 01422 SWIGRUNTIMEINLINE int 01423 SWIG_Python_CheckImplicit(swig_type_info *ty) 01424 { 01425 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; 01426 return data ? data->implicitconv : 0; 01427 } 01428 01429 SWIGRUNTIMEINLINE PyObject * 01430 SWIG_Python_ExceptionType(swig_type_info *desc) { 01431 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; 01432 PyObject *klass = data ? data->klass : 0; 01433 return (klass ? klass : PyExc_RuntimeError); 01434 } 01435 01436 01437 SWIGRUNTIME SwigPyClientData * 01438 SwigPyClientData_New(PyObject* obj) 01439 { 01440 if (!obj) { 01441 return 0; 01442 } else { 01443 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); 01444 /* the klass element */ 01445 data->klass = obj; 01446 Py_INCREF(data->klass); 01447 /* the newraw method and newargs arguments used to create a new raw instance */ 01448 if (PyClass_Check(obj)) { 01449 data->newraw = 0; 01450 data->newargs = obj; 01451 Py_INCREF(obj); 01452 } else { 01453 #if (PY_VERSION_HEX < 0x02020000) 01454 data->newraw = 0; 01455 #else 01456 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); 01457 #endif 01458 if (data->newraw) { 01459 Py_INCREF(data->newraw); 01460 data->newargs = PyTuple_New(1); 01461 PyTuple_SetItem(data->newargs, 0, obj); 01462 } else { 01463 data->newargs = obj; 01464 } 01465 Py_INCREF(data->newargs); 01466 } 01467 /* the destroy method, aka as the C++ delete method */ 01468 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); 01469 if (PyErr_Occurred()) { 01470 PyErr_Clear(); 01471 data->destroy = 0; 01472 } 01473 if (data->destroy) { 01474 int flags; 01475 Py_INCREF(data->destroy); 01476 flags = PyCFunction_GET_FLAGS(data->destroy); 01477 #ifdef METH_O 01478 data->delargs = !(flags & (METH_O)); 01479 #else 01480 data->delargs = 0; 01481 #endif 01482 } else { 01483 data->delargs = 0; 01484 } 01485 data->implicitconv = 0; 01486 data->pytype = 0; 01487 return data; 01488 } 01489 } 01490 01491 SWIGRUNTIME void 01492 SwigPyClientData_Del(SwigPyClientData *data) { 01493 Py_XDECREF(data->newraw); 01494 Py_XDECREF(data->newargs); 01495 Py_XDECREF(data->destroy); 01496 } 01497 01498 /* =============== SwigPyObject =====================*/ 01499 01500 typedef struct { 01501 PyObject_HEAD 01502 void *ptr; 01503 swig_type_info *ty; 01504 int own; 01505 PyObject *next; 01506 #ifdef SWIGPYTHON_BUILTIN 01507 PyObject *dict; 01508 #endif 01509 } SwigPyObject; 01510 01511 SWIGRUNTIME PyObject * 01512 SwigPyObject_long(SwigPyObject *v) 01513 { 01514 return PyLong_FromVoidPtr(v->ptr); 01515 } 01516 01517 SWIGRUNTIME PyObject * 01518 SwigPyObject_format(const char* fmt, SwigPyObject *v) 01519 { 01520 PyObject *res = NULL; 01521 PyObject *args = PyTuple_New(1); 01522 if (args) { 01523 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { 01524 PyObject *ofmt = SWIG_Python_str_FromChar(fmt); 01525 if (ofmt) { 01526 #if PY_VERSION_HEX >= 0x03000000 01527 res = PyUnicode_Format(ofmt,args); 01528 #else 01529 res = PyString_Format(ofmt,args); 01530 #endif 01531 Py_DECREF(ofmt); 01532 } 01533 Py_DECREF(args); 01534 } 01535 } 01536 return res; 01537 } 01538 01539 SWIGRUNTIME PyObject * 01540 SwigPyObject_oct(SwigPyObject *v) 01541 { 01542 return SwigPyObject_format("%o",v); 01543 } 01544 01545 SWIGRUNTIME PyObject * 01546 SwigPyObject_hex(SwigPyObject *v) 01547 { 01548 return SwigPyObject_format("%x",v); 01549 } 01550 01551 SWIGRUNTIME PyObject * 01552 #ifdef METH_NOARGS 01553 SwigPyObject_repr(SwigPyObject *v) 01554 #else 01555 SwigPyObject_repr(SwigPyObject *v, PyObject *args) 01556 #endif 01557 { 01558 const char *name = SWIG_TypePrettyName(v->ty); 01559 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v); 01560 if (v->next) { 01561 # ifdef METH_NOARGS 01562 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); 01563 # else 01564 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); 01565 # endif 01566 # if PY_VERSION_HEX >= 0x03000000 01567 PyObject *joined = PyUnicode_Concat(repr, nrep); 01568 Py_DecRef(repr); 01569 Py_DecRef(nrep); 01570 repr = joined; 01571 # else 01572 PyString_ConcatAndDel(&repr,nrep); 01573 # endif 01574 } 01575 return repr; 01576 } 01577 01578 SWIGRUNTIME int 01579 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) 01580 { 01581 void *i = v->ptr; 01582 void *j = w->ptr; 01583 return (i < j) ? -1 : ((i > j) ? 1 : 0); 01584 } 01585 01586 /* Added for Python 3.x, would it also be useful for Python 2.x? */ 01587 SWIGRUNTIME PyObject* 01588 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) 01589 { 01590 PyObject* res; 01591 if( op != Py_EQ && op != Py_NE ) { 01592 Py_INCREF(Py_NotImplemented); 01593 return Py_NotImplemented; 01594 } 01595 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); 01596 return res; 01597 } 01598 01599 01600 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); 01601 01602 #ifdef SWIGPYTHON_BUILTIN 01603 static swig_type_info *SwigPyObject_stype = 0; 01604 SWIGRUNTIME PyTypeObject* 01605 SwigPyObject_type(void) { 01606 SwigPyClientData *cd; 01607 assert(SwigPyObject_stype); 01608 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; 01609 assert(cd); 01610 assert(cd->pytype); 01611 return cd->pytype; 01612 } 01613 #else 01614 SWIGRUNTIME PyTypeObject* 01615 SwigPyObject_type(void) { 01616 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); 01617 return type; 01618 } 01619 #endif 01620 01621 SWIGRUNTIMEINLINE int 01622 SwigPyObject_Check(PyObject *op) { 01623 #ifdef SWIGPYTHON_BUILTIN 01624 PyTypeObject *target_tp = SwigPyObject_type(); 01625 if (PyType_IsSubtype(op->ob_type, target_tp)) 01626 return 1; 01627 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); 01628 #else 01629 return (Py_TYPE(op) == SwigPyObject_type()) 01630 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); 01631 #endif 01632 } 01633 01634 SWIGRUNTIME PyObject * 01635 SwigPyObject_New(void *ptr, swig_type_info *ty, int own); 01636 01637 SWIGRUNTIME void 01638 SwigPyObject_dealloc(PyObject *v) 01639 { 01640 SwigPyObject *sobj = (SwigPyObject *) v; 01641 PyObject *next = sobj->next; 01642 if (sobj->own == SWIG_POINTER_OWN) { 01643 swig_type_info *ty = sobj->ty; 01644 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; 01645 PyObject *destroy = data ? data->destroy : 0; 01646 if (destroy) { 01647 /* destroy is always a VARARGS method */ 01648 PyObject *res; 01649 if (data->delargs) { 01650 /* we need to create a temporary object to carry the destroy operation */ 01651 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); 01652 res = SWIG_Python_CallFunctor(destroy, tmp); 01653 Py_DECREF(tmp); 01654 } else { 01655 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); 01656 PyObject *mself = PyCFunction_GET_SELF(destroy); 01657 res = ((*meth)(mself, v)); 01658 } 01659 Py_XDECREF(res); 01660 } 01661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) 01662 else { 01663 const char *name = SWIG_TypePrettyName(ty); 01664 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); 01665 } 01666 #endif 01667 } 01668 Py_XDECREF(next); 01669 PyObject_DEL(v); 01670 } 01671 01672 SWIGRUNTIME PyObject* 01673 SwigPyObject_append(PyObject* v, PyObject* next) 01674 { 01675 SwigPyObject *sobj = (SwigPyObject *) v; 01676 #ifndef METH_O 01677 PyObject *tmp = 0; 01678 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; 01679 next = tmp; 01680 #endif 01681 if (!SwigPyObject_Check(next)) { 01682 return NULL; 01683 } 01684 sobj->next = next; 01685 Py_INCREF(next); 01686 return SWIG_Py_Void(); 01687 } 01688 01689 SWIGRUNTIME PyObject* 01690 #ifdef METH_NOARGS 01691 SwigPyObject_next(PyObject* v) 01692 #else 01693 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 01694 #endif 01695 { 01696 SwigPyObject *sobj = (SwigPyObject *) v; 01697 if (sobj->next) { 01698 Py_INCREF(sobj->next); 01699 return sobj->next; 01700 } else { 01701 return SWIG_Py_Void(); 01702 } 01703 } 01704 01705 SWIGINTERN PyObject* 01706 #ifdef METH_NOARGS 01707 SwigPyObject_disown(PyObject *v) 01708 #else 01709 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 01710 #endif 01711 { 01712 SwigPyObject *sobj = (SwigPyObject *)v; 01713 sobj->own = 0; 01714 return SWIG_Py_Void(); 01715 } 01716 01717 SWIGINTERN PyObject* 01718 #ifdef METH_NOARGS 01719 SwigPyObject_acquire(PyObject *v) 01720 #else 01721 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 01722 #endif 01723 { 01724 SwigPyObject *sobj = (SwigPyObject *)v; 01725 sobj->own = SWIG_POINTER_OWN; 01726 return SWIG_Py_Void(); 01727 } 01728 01729 SWIGINTERN PyObject* 01730 SwigPyObject_own(PyObject *v, PyObject *args) 01731 { 01732 PyObject *val = 0; 01733 #if (PY_VERSION_HEX < 0x02020000) 01734 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) 01735 #elif (PY_VERSION_HEX < 0x02050000) 01736 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 01737 #else 01738 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 01739 #endif 01740 { 01741 return NULL; 01742 } 01743 else 01744 { 01745 SwigPyObject *sobj = (SwigPyObject *)v; 01746 PyObject *obj = PyBool_FromLong(sobj->own); 01747 if (val) { 01748 #ifdef METH_NOARGS 01749 if (PyObject_IsTrue(val)) { 01750 SwigPyObject_acquire(v); 01751 } else { 01752 SwigPyObject_disown(v); 01753 } 01754 #else 01755 if (PyObject_IsTrue(val)) { 01756 SwigPyObject_acquire(v,args); 01757 } else { 01758 SwigPyObject_disown(v,args); 01759 } 01760 #endif 01761 } 01762 return obj; 01763 } 01764 } 01765 01766 #ifdef METH_O 01767 static PyMethodDef 01768 swigobject_methods[] = { 01769 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, 01770 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, 01771 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, 01772 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, 01773 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, 01774 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, 01775 {0, 0, 0, 0} 01776 }; 01777 #else 01778 static PyMethodDef 01779 swigobject_methods[] = { 01780 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, 01781 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, 01782 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, 01783 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, 01784 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, 01785 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, 01786 {0, 0, 0, 0} 01787 }; 01788 #endif 01789 01790 #if PY_VERSION_HEX < 0x02020000 01791 SWIGINTERN PyObject * 01792 SwigPyObject_getattr(SwigPyObject *sobj,char *name) 01793 { 01794 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); 01795 } 01796 #endif 01797 01798 SWIGRUNTIME PyTypeObject* 01799 SwigPyObject_TypeOnce(void) { 01800 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; 01801 01802 static PyNumberMethods SwigPyObject_as_number = { 01803 (binaryfunc)0, /*nb_add*/ 01804 (binaryfunc)0, /*nb_subtract*/ 01805 (binaryfunc)0, /*nb_multiply*/ 01806 /* nb_divide removed in Python 3 */ 01807 #if PY_VERSION_HEX < 0x03000000 01808 (binaryfunc)0, /*nb_divide*/ 01809 #endif 01810 (binaryfunc)0, /*nb_remainder*/ 01811 (binaryfunc)0, /*nb_divmod*/ 01812 (ternaryfunc)0,/*nb_power*/ 01813 (unaryfunc)0, /*nb_negative*/ 01814 (unaryfunc)0, /*nb_positive*/ 01815 (unaryfunc)0, /*nb_absolute*/ 01816 (inquiry)0, /*nb_nonzero*/ 01817 0, /*nb_invert*/ 01818 0, /*nb_lshift*/ 01819 0, /*nb_rshift*/ 01820 0, /*nb_and*/ 01821 0, /*nb_xor*/ 01822 0, /*nb_or*/ 01823 #if PY_VERSION_HEX < 0x03000000 01824 0, /*nb_coerce*/ 01825 #endif 01826 (unaryfunc)SwigPyObject_long, /*nb_int*/ 01827 #if PY_VERSION_HEX < 0x03000000 01828 (unaryfunc)SwigPyObject_long, /*nb_long*/ 01829 #else 01830 0, /*nb_reserved*/ 01831 #endif 01832 (unaryfunc)0, /*nb_float*/ 01833 #if PY_VERSION_HEX < 0x03000000 01834 (unaryfunc)SwigPyObject_oct, /*nb_oct*/ 01835 (unaryfunc)SwigPyObject_hex, /*nb_hex*/ 01836 #endif 01837 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */ 01838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ 01839 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ 01840 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ 01841 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ 01842 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 01843 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ 01844 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ 01845 #endif 01846 }; 01847 01848 static PyTypeObject swigpyobject_type; 01849 static int type_init = 0; 01850 if (!type_init) { 01851 const PyTypeObject tmp = { 01852 /* PyObject header changed in Python 3 */ 01853 #if PY_VERSION_HEX >= 0x03000000 01854 PyVarObject_HEAD_INIT(NULL, 0) 01855 #else 01856 PyObject_HEAD_INIT(NULL) 01857 0, /* ob_size */ 01858 #endif 01859 (char *)"SwigPyObject", /* tp_name */ 01860 sizeof(SwigPyObject), /* tp_basicsize */ 01861 0, /* tp_itemsize */ 01862 (destructor)SwigPyObject_dealloc, /* tp_dealloc */ 01863 0, /* tp_print */ 01864 #if PY_VERSION_HEX < 0x02020000 01865 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ 01866 #else 01867 (getattrfunc)0, /* tp_getattr */ 01868 #endif 01869 (setattrfunc)0, /* tp_setattr */ 01870 #if PY_VERSION_HEX >= 0x03000000 01871 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ 01872 #else 01873 (cmpfunc)SwigPyObject_compare, /* tp_compare */ 01874 #endif 01875 (reprfunc)SwigPyObject_repr, /* tp_repr */ 01876 &SwigPyObject_as_number, /* tp_as_number */ 01877 0, /* tp_as_sequence */ 01878 0, /* tp_as_mapping */ 01879 (hashfunc)0, /* tp_hash */ 01880 (ternaryfunc)0, /* tp_call */ 01881 0, /* tp_str */ 01882 PyObject_GenericGetAttr, /* tp_getattro */ 01883 0, /* tp_setattro */ 01884 0, /* tp_as_buffer */ 01885 Py_TPFLAGS_DEFAULT, /* tp_flags */ 01886 swigobject_doc, /* tp_doc */ 01887 0, /* tp_traverse */ 01888 0, /* tp_clear */ 01889 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ 01890 0, /* tp_weaklistoffset */ 01891 #if PY_VERSION_HEX >= 0x02020000 01892 0, /* tp_iter */ 01893 0, /* tp_iternext */ 01894 swigobject_methods, /* tp_methods */ 01895 0, /* tp_members */ 01896 0, /* tp_getset */ 01897 0, /* tp_base */ 01898 0, /* tp_dict */ 01899 0, /* tp_descr_get */ 01900 0, /* tp_descr_set */ 01901 0, /* tp_dictoffset */ 01902 0, /* tp_init */ 01903 0, /* tp_alloc */ 01904 0, /* tp_new */ 01905 0, /* tp_free */ 01906 0, /* tp_is_gc */ 01907 0, /* tp_bases */ 01908 0, /* tp_mro */ 01909 0, /* tp_cache */ 01910 0, /* tp_subclasses */ 01911 0, /* tp_weaklist */ 01912 #endif 01913 #if PY_VERSION_HEX >= 0x02030000 01914 0, /* tp_del */ 01915 #endif 01916 #if PY_VERSION_HEX >= 0x02060000 01917 0, /* tp_version */ 01918 #endif 01919 #ifdef COUNT_ALLOCS 01920 0,0,0,0 /* tp_alloc -> tp_next */ 01921 #endif 01922 }; 01923 swigpyobject_type = tmp; 01924 type_init = 1; 01925 #if PY_VERSION_HEX < 0x02020000 01926 swigpyobject_type.ob_type = &PyType_Type; 01927 #else 01928 if (PyType_Ready(&swigpyobject_type) < 0) 01929 return NULL; 01930 #endif 01931 } 01932 return &swigpyobject_type; 01933 } 01934 01935 SWIGRUNTIME PyObject * 01936 SwigPyObject_New(void *ptr, swig_type_info *ty, int own) 01937 { 01938 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); 01939 if (sobj) { 01940 sobj->ptr = ptr; 01941 sobj->ty = ty; 01942 sobj->own = own; 01943 sobj->next = 0; 01944 } 01945 return (PyObject *)sobj; 01946 } 01947 01948 /* ----------------------------------------------------------------------------- 01949 * Implements a simple Swig Packed type, and use it instead of string 01950 * ----------------------------------------------------------------------------- */ 01951 01952 typedef struct { 01953 PyObject_HEAD 01954 void *pack; 01955 swig_type_info *ty; 01956 size_t size; 01957 } SwigPyPacked; 01958 01959 SWIGRUNTIME int 01960 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) 01961 { 01962 char result[SWIG_BUFFER_SIZE]; 01963 fputs("<Swig Packed ", fp); 01964 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { 01965 fputs("at ", fp); 01966 fputs(result, fp); 01967 } 01968 fputs(v->ty->name,fp); 01969 fputs(">", fp); 01970 return 0; 01971 } 01972 01973 SWIGRUNTIME PyObject * 01974 SwigPyPacked_repr(SwigPyPacked *v) 01975 { 01976 char result[SWIG_BUFFER_SIZE]; 01977 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { 01978 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name); 01979 } else { 01980 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name); 01981 } 01982 } 01983 01984 SWIGRUNTIME PyObject * 01985 SwigPyPacked_str(SwigPyPacked *v) 01986 { 01987 char result[SWIG_BUFFER_SIZE]; 01988 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ 01989 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); 01990 } else { 01991 return SWIG_Python_str_FromChar(v->ty->name); 01992 } 01993 } 01994 01995 SWIGRUNTIME int 01996 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) 01997 { 01998 size_t i = v->size; 01999 size_t j = w->size; 02000 int s = (i < j) ? -1 : ((i > j) ? 1 : 0); 02001 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); 02002 } 02003 02004 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); 02005 02006 SWIGRUNTIME PyTypeObject* 02007 SwigPyPacked_type(void) { 02008 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); 02009 return type; 02010 } 02011 02012 SWIGRUNTIMEINLINE int 02013 SwigPyPacked_Check(PyObject *op) { 02014 return ((op)->ob_type == SwigPyPacked_TypeOnce()) 02015 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); 02016 } 02017 02018 SWIGRUNTIME void 02019 SwigPyPacked_dealloc(PyObject *v) 02020 { 02021 if (SwigPyPacked_Check(v)) { 02022 SwigPyPacked *sobj = (SwigPyPacked *) v; 02023 free(sobj->pack); 02024 } 02025 PyObject_DEL(v); 02026 } 02027 02028 SWIGRUNTIME PyTypeObject* 02029 SwigPyPacked_TypeOnce(void) { 02030 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; 02031 static PyTypeObject swigpypacked_type; 02032 static int type_init = 0; 02033 if (!type_init) { 02034 const PyTypeObject tmp = { 02035 /* PyObject header changed in Python 3 */ 02036 #if PY_VERSION_HEX>=0x03000000 02037 PyVarObject_HEAD_INIT(NULL, 0) 02038 #else 02039 PyObject_HEAD_INIT(NULL) 02040 0, /* ob_size */ 02041 #endif 02042 (char *)"SwigPyPacked", /* tp_name */ 02043 sizeof(SwigPyPacked), /* tp_basicsize */ 02044 0, /* tp_itemsize */ 02045 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ 02046 (printfunc)SwigPyPacked_print, /* tp_print */ 02047 (getattrfunc)0, /* tp_getattr */ 02048 (setattrfunc)0, /* tp_setattr */ 02049 #if PY_VERSION_HEX>=0x03000000 02050 0, /* tp_reserved in 3.0.1 */ 02051 #else 02052 (cmpfunc)SwigPyPacked_compare, /* tp_compare */ 02053 #endif 02054 (reprfunc)SwigPyPacked_repr, /* tp_repr */ 02055 0, /* tp_as_number */ 02056 0, /* tp_as_sequence */ 02057 0, /* tp_as_mapping */ 02058 (hashfunc)0, /* tp_hash */ 02059 (ternaryfunc)0, /* tp_call */ 02060 (reprfunc)SwigPyPacked_str, /* tp_str */ 02061 PyObject_GenericGetAttr, /* tp_getattro */ 02062 0, /* tp_setattro */ 02063 0, /* tp_as_buffer */ 02064 Py_TPFLAGS_DEFAULT, /* tp_flags */ 02065 swigpacked_doc, /* tp_doc */ 02066 0, /* tp_traverse */ 02067 0, /* tp_clear */ 02068 0, /* tp_richcompare */ 02069 0, /* tp_weaklistoffset */ 02070 #if PY_VERSION_HEX >= 0x02020000 02071 0, /* tp_iter */ 02072 0, /* tp_iternext */ 02073 0, /* tp_methods */ 02074 0, /* tp_members */ 02075 0, /* tp_getset */ 02076 0, /* tp_base */ 02077 0, /* tp_dict */ 02078 0, /* tp_descr_get */ 02079 0, /* tp_descr_set */ 02080 0, /* tp_dictoffset */ 02081 0, /* tp_init */ 02082 0, /* tp_alloc */ 02083 0, /* tp_new */ 02084 0, /* tp_free */ 02085 0, /* tp_is_gc */ 02086 0, /* tp_bases */ 02087 0, /* tp_mro */ 02088 0, /* tp_cache */ 02089 0, /* tp_subclasses */ 02090 0, /* tp_weaklist */ 02091 #endif 02092 #if PY_VERSION_HEX >= 0x02030000 02093 0, /* tp_del */ 02094 #endif 02095 #if PY_VERSION_HEX >= 0x02060000 02096 0, /* tp_version */ 02097 #endif 02098 #ifdef COUNT_ALLOCS 02099 0,0,0,0 /* tp_alloc -> tp_next */ 02100 #endif 02101 }; 02102 swigpypacked_type = tmp; 02103 type_init = 1; 02104 #if PY_VERSION_HEX < 0x02020000 02105 swigpypacked_type.ob_type = &PyType_Type; 02106 #else 02107 if (PyType_Ready(&swigpypacked_type) < 0) 02108 return NULL; 02109 #endif 02110 } 02111 return &swigpypacked_type; 02112 } 02113 02114 SWIGRUNTIME PyObject * 02115 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) 02116 { 02117 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); 02118 if (sobj) { 02119 void *pack = malloc(size); 02120 if (pack) { 02121 memcpy(pack, ptr, size); 02122 sobj->pack = pack; 02123 sobj->ty = ty; 02124 sobj->size = size; 02125 } else { 02126 PyObject_DEL((PyObject *) sobj); 02127 sobj = 0; 02128 } 02129 } 02130 return (PyObject *) sobj; 02131 } 02132 02133 SWIGRUNTIME swig_type_info * 02134 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) 02135 { 02136 if (SwigPyPacked_Check(obj)) { 02137 SwigPyPacked *sobj = (SwigPyPacked *)obj; 02138 if (sobj->size != size) return 0; 02139 memcpy(ptr, sobj->pack, size); 02140 return sobj->ty; 02141 } else { 02142 return 0; 02143 } 02144 } 02145 02146 /* ----------------------------------------------------------------------------- 02147 * pointers/data manipulation 02148 * ----------------------------------------------------------------------------- */ 02149 02150 SWIGRUNTIMEINLINE PyObject * 02151 _SWIG_This(void) 02152 { 02153 return SWIG_Python_str_FromChar("this"); 02154 } 02155 02156 static PyObject *swig_this = NULL; 02157 02158 SWIGRUNTIME PyObject * 02159 SWIG_This(void) 02160 { 02161 if (swig_this == NULL) 02162 swig_this = _SWIG_This(); 02163 return swig_this; 02164 } 02165 02166 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ 02167 02168 /* TODO: I don't know how to implement the fast getset in Python 3 right now */ 02169 #if PY_VERSION_HEX>=0x03000000 02170 #define SWIG_PYTHON_SLOW_GETSET_THIS 02171 #endif 02172 02173 SWIGRUNTIME SwigPyObject * 02174 SWIG_Python_GetSwigThis(PyObject *pyobj) 02175 { 02176 PyObject *obj; 02177 02178 if (SwigPyObject_Check(pyobj)) 02179 return (SwigPyObject *) pyobj; 02180 02181 #ifdef SWIGPYTHON_BUILTIN 02182 (void)obj; 02183 # ifdef PyWeakref_CheckProxy 02184 if (PyWeakref_CheckProxy(pyobj)) { 02185 pyobj = PyWeakref_GET_OBJECT(pyobj); 02186 if (pyobj && SwigPyObject_Check(pyobj)) 02187 return (SwigPyObject*) pyobj; 02188 } 02189 # endif 02190 return NULL; 02191 #else 02192 02193 obj = 0; 02194 02195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) 02196 if (PyInstance_Check(pyobj)) { 02197 obj = _PyInstance_Lookup(pyobj, SWIG_This()); 02198 } else { 02199 PyObject **dictptr = _PyObject_GetDictPtr(pyobj); 02200 if (dictptr != NULL) { 02201 PyObject *dict = *dictptr; 02202 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; 02203 } else { 02204 #ifdef PyWeakref_CheckProxy 02205 if (PyWeakref_CheckProxy(pyobj)) { 02206 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); 02207 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; 02208 } 02209 #endif 02210 obj = PyObject_GetAttr(pyobj,SWIG_This()); 02211 if (obj) { 02212 Py_DECREF(obj); 02213 } else { 02214 if (PyErr_Occurred()) PyErr_Clear(); 02215 return 0; 02216 } 02217 } 02218 } 02219 #else 02220 obj = PyObject_GetAttr(pyobj,SWIG_This()); 02221 if (obj) { 02222 Py_DECREF(obj); 02223 } else { 02224 if (PyErr_Occurred()) PyErr_Clear(); 02225 return 0; 02226 } 02227 #endif 02228 if (obj && !SwigPyObject_Check(obj)) { 02229 /* a PyObject is called 'this', try to get the 'real this' 02230 SwigPyObject from it */ 02231 return SWIG_Python_GetSwigThis(obj); 02232 } 02233 return (SwigPyObject *)obj; 02234 #endif 02235 } 02236 02237 /* Acquire a pointer value */ 02238 02239 SWIGRUNTIME int 02240 SWIG_Python_AcquirePtr(PyObject *obj, int own) { 02241 if (own == SWIG_POINTER_OWN) { 02242 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); 02243 if (sobj) { 02244 int oldown = sobj->own; 02245 sobj->own = own; 02246 return oldown; 02247 } 02248 } 02249 return 0; 02250 } 02251 02252 /* Convert a pointer value */ 02253 02254 SWIGRUNTIME int 02255 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { 02256 int res; 02257 SwigPyObject *sobj; 02258 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; 02259 02260 if (!obj) 02261 return SWIG_ERROR; 02262 if (obj == Py_None && !implicit_conv) { 02263 if (ptr) 02264 *ptr = 0; 02265 return SWIG_OK; 02266 } 02267 02268 res = SWIG_ERROR; 02269 02270 sobj = SWIG_Python_GetSwigThis(obj); 02271 if (own) 02272 *own = 0; 02273 while (sobj) { 02274 void *vptr = sobj->ptr; 02275 if (ty) { 02276 swig_type_info *to = sobj->ty; 02277 if (to == ty) { 02278 /* no type cast needed */ 02279 if (ptr) *ptr = vptr; 02280 break; 02281 } else { 02282 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); 02283 if (!tc) { 02284 sobj = (SwigPyObject *)sobj->next; 02285 } else { 02286 if (ptr) { 02287 int newmemory = 0; 02288 *ptr = SWIG_TypeCast(tc,vptr,&newmemory); 02289 if (newmemory == SWIG_CAST_NEW_MEMORY) { 02290 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ 02291 if (own) 02292 *own = *own | SWIG_CAST_NEW_MEMORY; 02293 } 02294 } 02295 break; 02296 } 02297 } 02298 } else { 02299 if (ptr) *ptr = vptr; 02300 break; 02301 } 02302 } 02303 if (sobj) { 02304 if (own) 02305 *own = *own | sobj->own; 02306 if (flags & SWIG_POINTER_DISOWN) { 02307 sobj->own = 0; 02308 } 02309 res = SWIG_OK; 02310 } else { 02311 if (implicit_conv) { 02312 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; 02313 if (data && !data->implicitconv) { 02314 PyObject *klass = data->klass; 02315 if (klass) { 02316 PyObject *impconv; 02317 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ 02318 impconv = SWIG_Python_CallFunctor(klass, obj); 02319 data->implicitconv = 0; 02320 if (PyErr_Occurred()) { 02321 PyErr_Clear(); 02322 impconv = 0; 02323 } 02324 if (impconv) { 02325 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); 02326 if (iobj) { 02327 void *vptr; 02328 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); 02329 if (SWIG_IsOK(res)) { 02330 if (ptr) { 02331 *ptr = vptr; 02332 /* transfer the ownership to 'ptr' */ 02333 iobj->own = 0; 02334 res = SWIG_AddCast(res); 02335 res = SWIG_AddNewMask(res); 02336 } else { 02337 res = SWIG_AddCast(res); 02338 } 02339 } 02340 } 02341 Py_DECREF(impconv); 02342 } 02343 } 02344 } 02345 } 02346 if (!SWIG_IsOK(res) && obj == Py_None) { 02347 if (ptr) 02348 *ptr = 0; 02349 if (PyErr_Occurred()) 02350 PyErr_Clear(); 02351 res = SWIG_OK; 02352 } 02353 } 02354 return res; 02355 } 02356 02357 /* Convert a function ptr value */ 02358 02359 SWIGRUNTIME int 02360 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { 02361 if (!PyCFunction_Check(obj)) { 02362 return SWIG_ConvertPtr(obj, ptr, ty, 0); 02363 } else { 02364 void *vptr = 0; 02365 02366 /* here we get the method pointer for callbacks */ 02367 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); 02368 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; 02369 if (desc) 02370 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; 02371 if (!desc) 02372 return SWIG_ERROR; 02373 if (ty) { 02374 swig_cast_info *tc = SWIG_TypeCheck(desc,ty); 02375 if (tc) { 02376 int newmemory = 0; 02377 *ptr = SWIG_TypeCast(tc,vptr,&newmemory); 02378 assert(!newmemory); /* newmemory handling not yet implemented */ 02379 } else { 02380 return SWIG_ERROR; 02381 } 02382 } else { 02383 *ptr = vptr; 02384 } 02385 return SWIG_OK; 02386 } 02387 } 02388 02389 /* Convert a packed value value */ 02390 02391 SWIGRUNTIME int 02392 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { 02393 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); 02394 if (!to) return SWIG_ERROR; 02395 if (ty) { 02396 if (to != ty) { 02397 /* check type cast? */ 02398 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); 02399 if (!tc) return SWIG_ERROR; 02400 } 02401 } 02402 return SWIG_OK; 02403 } 02404 02405 /* ----------------------------------------------------------------------------- 02406 * Create a new pointer object 02407 * ----------------------------------------------------------------------------- */ 02408 02409 /* 02410 Create a new instance object, without calling __init__, and set the 02411 'this' attribute. 02412 */ 02413 02414 SWIGRUNTIME PyObject* 02415 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) 02416 { 02417 #if (PY_VERSION_HEX >= 0x02020000) 02418 PyObject *inst = 0; 02419 PyObject *newraw = data->newraw; 02420 if (newraw) { 02421 inst = PyObject_Call(newraw, data->newargs, NULL); 02422 if (inst) { 02423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) 02424 PyObject **dictptr = _PyObject_GetDictPtr(inst); 02425 if (dictptr != NULL) { 02426 PyObject *dict = *dictptr; 02427 if (dict == NULL) { 02428 dict = PyDict_New(); 02429 *dictptr = dict; 02430 PyDict_SetItem(dict, SWIG_This(), swig_this); 02431 } 02432 } 02433 #else 02434 PyObject *key = SWIG_This(); 02435 PyObject_SetAttr(inst, key, swig_this); 02436 #endif 02437 } 02438 } else { 02439 #if PY_VERSION_HEX >= 0x03000000 02440 inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); 02441 if (inst) { 02442 PyObject_SetAttr(inst, SWIG_This(), swig_this); 02443 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; 02444 } 02445 #else 02446 PyObject *dict = PyDict_New(); 02447 if (dict) { 02448 PyDict_SetItem(dict, SWIG_This(), swig_this); 02449 inst = PyInstance_NewRaw(data->newargs, dict); 02450 Py_DECREF(dict); 02451 } 02452 #endif 02453 } 02454 return inst; 02455 #else 02456 #if (PY_VERSION_HEX >= 0x02010000) 02457 PyObject *inst = 0; 02458 PyObject *dict = PyDict_New(); 02459 if (dict) { 02460 PyDict_SetItem(dict, SWIG_This(), swig_this); 02461 inst = PyInstance_NewRaw(data->newargs, dict); 02462 Py_DECREF(dict); 02463 } 02464 return (PyObject *) inst; 02465 #else 02466 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); 02467 if (inst == NULL) { 02468 return NULL; 02469 } 02470 inst->in_class = (PyClassObject *)data->newargs; 02471 Py_INCREF(inst->in_class); 02472 inst->in_dict = PyDict_New(); 02473 if (inst->in_dict == NULL) { 02474 Py_DECREF(inst); 02475 return NULL; 02476 } 02477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS 02478 inst->in_weakreflist = NULL; 02479 #endif 02480 #ifdef Py_TPFLAGS_GC 02481 PyObject_GC_Init(inst); 02482 #endif 02483 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); 02484 return (PyObject *) inst; 02485 #endif 02486 #endif 02487 } 02488 02489 SWIGRUNTIME void 02490 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) 02491 { 02492 PyObject *dict; 02493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) 02494 PyObject **dictptr = _PyObject_GetDictPtr(inst); 02495 if (dictptr != NULL) { 02496 dict = *dictptr; 02497 if (dict == NULL) { 02498 dict = PyDict_New(); 02499 *dictptr = dict; 02500 } 02501 PyDict_SetItem(dict, SWIG_This(), swig_this); 02502 return; 02503 } 02504 #endif 02505 dict = PyObject_GetAttrString(inst, (char*)"__dict__"); 02506 PyDict_SetItem(dict, SWIG_This(), swig_this); 02507 Py_DECREF(dict); 02508 } 02509 02510 02511 SWIGINTERN PyObject * 02512 SWIG_Python_InitShadowInstance(PyObject *args) { 02513 PyObject *obj[2]; 02514 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { 02515 return NULL; 02516 } else { 02517 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); 02518 if (sthis) { 02519 SwigPyObject_append((PyObject*) sthis, obj[1]); 02520 } else { 02521 SWIG_Python_SetSwigThis(obj[0], obj[1]); 02522 } 02523 return SWIG_Py_Void(); 02524 } 02525 } 02526 02527 /* Create a new pointer object */ 02528 02529 SWIGRUNTIME PyObject * 02530 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { 02531 SwigPyClientData *clientdata; 02532 PyObject * robj; 02533 int own; 02534 02535 if (!ptr) 02536 return SWIG_Py_Void(); 02537 02538 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; 02539 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; 02540 if (clientdata && clientdata->pytype) { 02541 SwigPyObject *newobj; 02542 if (flags & SWIG_BUILTIN_TP_INIT) { 02543 newobj = (SwigPyObject*) self; 02544 if (newobj->ptr) { 02545 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); 02546 while (newobj->next) 02547 newobj = (SwigPyObject *) newobj->next; 02548 newobj->next = next_self; 02549 newobj = (SwigPyObject *)next_self; 02550 } 02551 } else { 02552 newobj = PyObject_New(SwigPyObject, clientdata->pytype); 02553 } 02554 if (newobj) { 02555 newobj->ptr = ptr; 02556 newobj->ty = type; 02557 newobj->own = own; 02558 newobj->next = 0; 02559 #ifdef SWIGPYTHON_BUILTIN 02560 newobj->dict = 0; 02561 #endif 02562 return (PyObject*) newobj; 02563 } 02564 return SWIG_Py_Void(); 02565 } 02566 02567 assert(!(flags & SWIG_BUILTIN_TP_INIT)); 02568 02569 robj = SwigPyObject_New(ptr, type, own); 02570 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { 02571 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); 02572 Py_DECREF(robj); 02573 robj = inst; 02574 } 02575 return robj; 02576 } 02577 02578 /* Create a new packed object */ 02579 02580 SWIGRUNTIMEINLINE PyObject * 02581 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { 02582 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); 02583 } 02584 02585 /* -----------------------------------------------------------------------------* 02586 * Get type list 02587 * -----------------------------------------------------------------------------*/ 02588 02589 #ifdef SWIG_LINK_RUNTIME 02590 void *SWIG_ReturnGlobalTypeList(void *); 02591 #endif 02592 02593 SWIGRUNTIME swig_module_info * 02594 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { 02595 static void *type_pointer = (void *)0; 02596 /* first check if module already created */ 02597 if (!type_pointer) { 02598 #ifdef SWIG_LINK_RUNTIME 02599 type_pointer = SWIG_ReturnGlobalTypeList((void *)0); 02600 #else 02601 # ifdef SWIGPY_USE_CAPSULE 02602 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); 02603 # else 02604 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, 02605 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); 02606 # endif 02607 if (PyErr_Occurred()) { 02608 PyErr_Clear(); 02609 type_pointer = (void *)0; 02610 } 02611 #endif 02612 } 02613 return (swig_module_info *) type_pointer; 02614 } 02615 02616 #if PY_MAJOR_VERSION < 2 02617 /* PyModule_AddObject function was introduced in Python 2.0. The following function 02618 is copied out of Python/modsupport.c in python version 2.3.4 */ 02619 SWIGINTERN int 02620 PyModule_AddObject(PyObject *m, char *name, PyObject *o) 02621 { 02622 PyObject *dict; 02623 if (!PyModule_Check(m)) { 02624 PyErr_SetString(PyExc_TypeError, 02625 "PyModule_AddObject() needs module as first arg"); 02626 return SWIG_ERROR; 02627 } 02628 if (!o) { 02629 PyErr_SetString(PyExc_TypeError, 02630 "PyModule_AddObject() needs non-NULL value"); 02631 return SWIG_ERROR; 02632 } 02633 02634 dict = PyModule_GetDict(m); 02635 if (dict == NULL) { 02636 /* Internal error -- modules must have a dict! */ 02637 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", 02638 PyModule_GetName(m)); 02639 return SWIG_ERROR; 02640 } 02641 if (PyDict_SetItemString(dict, name, o)) 02642 return SWIG_ERROR; 02643 Py_DECREF(o); 02644 return SWIG_OK; 02645 } 02646 #endif 02647 02648 SWIGRUNTIME void 02649 #ifdef SWIGPY_USE_CAPSULE 02650 SWIG_Python_DestroyModule(PyObject *obj) 02651 #else 02652 SWIG_Python_DestroyModule(void *vptr) 02653 #endif 02654 { 02655 #ifdef SWIGPY_USE_CAPSULE 02656 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); 02657 #else 02658 swig_module_info *swig_module = (swig_module_info *) vptr; 02659 #endif 02660 swig_type_info **types = swig_module->types; 02661 size_t i; 02662 for (i =0; i < swig_module->size; ++i) { 02663 swig_type_info *ty = types[i]; 02664 if (ty->owndata) { 02665 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; 02666 if (data) SwigPyClientData_Del(data); 02667 } 02668 } 02669 Py_DECREF(SWIG_This()); 02670 swig_this = NULL; 02671 } 02672 02673 SWIGRUNTIME void 02674 SWIG_Python_SetModule(swig_module_info *swig_module) { 02675 #if PY_VERSION_HEX >= 0x03000000 02676 /* Add a dummy module object into sys.modules */ 02677 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); 02678 #else 02679 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ 02680 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); 02681 #endif 02682 #ifdef SWIGPY_USE_CAPSULE 02683 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); 02684 if (pointer && module) { 02685 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); 02686 } else { 02687 Py_XDECREF(pointer); 02688 } 02689 #else 02690 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); 02691 if (pointer && module) { 02692 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); 02693 } else { 02694 Py_XDECREF(pointer); 02695 } 02696 #endif 02697 } 02698 02699 /* The python cached type query */ 02700 SWIGRUNTIME PyObject * 02701 SWIG_Python_TypeCache(void) { 02702 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); 02703 return cache; 02704 } 02705 02706 SWIGRUNTIME swig_type_info * 02707 SWIG_Python_TypeQuery(const char *type) 02708 { 02709 PyObject *cache = SWIG_Python_TypeCache(); 02710 PyObject *key = SWIG_Python_str_FromChar(type); 02711 PyObject *obj = PyDict_GetItem(cache, key); 02712 swig_type_info *descriptor; 02713 if (obj) { 02714 #ifdef SWIGPY_USE_CAPSULE 02715 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); 02716 #else 02717 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); 02718 #endif 02719 } else { 02720 swig_module_info *swig_module = SWIG_GetModule(0); 02721 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); 02722 if (descriptor) { 02723 #ifdef SWIGPY_USE_CAPSULE 02724 obj = PyCapsule_New((void*) descriptor, NULL, NULL); 02725 #else 02726 obj = PyCObject_FromVoidPtr(descriptor, NULL); 02727 #endif 02728 PyDict_SetItem(cache, key, obj); 02729 Py_DECREF(obj); 02730 } 02731 } 02732 Py_DECREF(key); 02733 return descriptor; 02734 } 02735 02736 /* 02737 For backward compatibility only 02738 */ 02739 #define SWIG_POINTER_EXCEPTION 0 02740 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) 02741 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) 02742 02743 SWIGRUNTIME int 02744 SWIG_Python_AddErrMesg(const char* mesg, int infront) 02745 { 02746 if (PyErr_Occurred()) { 02747 PyObject *type = 0; 02748 PyObject *value = 0; 02749 PyObject *traceback = 0; 02750 PyErr_Fetch(&type, &value, &traceback); 02751 if (value) { 02752 char *tmp; 02753 PyObject *old_str = PyObject_Str(value); 02754 Py_XINCREF(type); 02755 PyErr_Clear(); 02756 if (infront) { 02757 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); 02758 } else { 02759 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); 02760 } 02761 SWIG_Python_str_DelForPy3(tmp); 02762 Py_DECREF(old_str); 02763 } 02764 return 1; 02765 } else { 02766 return 0; 02767 } 02768 } 02769 02770 SWIGRUNTIME int 02771 SWIG_Python_ArgFail(int argnum) 02772 { 02773 if (PyErr_Occurred()) { 02774 /* add information about failing argument */ 02775 char mesg[256]; 02776 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); 02777 return SWIG_Python_AddErrMesg(mesg, 1); 02778 } else { 02779 return 0; 02780 } 02781 } 02782 02783 SWIGRUNTIMEINLINE const char * 02784 SwigPyObject_GetDesc(PyObject *self) 02785 { 02786 SwigPyObject *v = (SwigPyObject *)self; 02787 swig_type_info *ty = v ? v->ty : 0; 02788 return ty ? ty->str : ""; 02789 } 02790 02791 SWIGRUNTIME void 02792 SWIG_Python_TypeError(const char *type, PyObject *obj) 02793 { 02794 if (type) { 02795 #if defined(SWIG_COBJECT_TYPES) 02796 if (obj && SwigPyObject_Check(obj)) { 02797 const char *otype = (const char *) SwigPyObject_GetDesc(obj); 02798 if (otype) { 02799 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", 02800 type, otype); 02801 return; 02802 } 02803 } else 02804 #endif 02805 { 02806 const char *otype = (obj ? obj->ob_type->tp_name : 0); 02807 if (otype) { 02808 PyObject *str = PyObject_Str(obj); 02809 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; 02810 if (cstr) { 02811 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", 02812 type, otype, cstr); 02813 SWIG_Python_str_DelForPy3(cstr); 02814 } else { 02815 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", 02816 type, otype); 02817 } 02818 Py_XDECREF(str); 02819 return; 02820 } 02821 } 02822 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); 02823 } else { 02824 PyErr_Format(PyExc_TypeError, "unexpected type is received"); 02825 } 02826 } 02827 02828 02829 /* Convert a pointer value, signal an exception on a type mismatch */ 02830 SWIGRUNTIME void * 02831 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { 02832 void *result; 02833 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { 02834 PyErr_Clear(); 02835 #if SWIG_POINTER_EXCEPTION 02836 if (flags) { 02837 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); 02838 SWIG_Python_ArgFail(argnum); 02839 } 02840 #endif 02841 } 02842 return result; 02843 } 02844 02845 #ifdef SWIGPYTHON_BUILTIN 02846 SWIGRUNTIME int 02847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { 02848 PyTypeObject *tp = obj->ob_type; 02849 PyObject *descr; 02850 PyObject *encoded_name; 02851 descrsetfunc f; 02852 int res = -1; 02853 02854 # ifdef Py_USING_UNICODE 02855 if (PyString_Check(name)) { 02856 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); 02857 if (!name) 02858 return -1; 02859 } else if (!PyUnicode_Check(name)) 02860 # else 02861 if (!PyString_Check(name)) 02862 # endif 02863 { 02864 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); 02865 return -1; 02866 } else { 02867 Py_INCREF(name); 02868 } 02869 02870 if (!tp->tp_dict) { 02871 if (PyType_Ready(tp) < 0) 02872 goto done; 02873 } 02874 02875 descr = _PyType_Lookup(tp, name); 02876 f = NULL; 02877 if (descr != NULL) 02878 f = descr->ob_type->tp_descr_set; 02879 if (!f) { 02880 if (PyString_Check(name)) { 02881 encoded_name = name; 02882 Py_INCREF(name); 02883 } else { 02884 encoded_name = PyUnicode_AsUTF8String(name); 02885 } 02886 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); 02887 Py_DECREF(encoded_name); 02888 } else { 02889 res = f(descr, obj, value); 02890 } 02891 02892 done: 02893 Py_DECREF(name); 02894 return res; 02895 } 02896 #endif 02897 02898 02899 #ifdef __cplusplus 02900 } 02901 #endif 02902 02903 02904 02905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 02906 02907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 02908 02909 02910 02911 /* -------- TYPES TABLE (BEGIN) -------- */ 02912 02913 #define SWIGTYPE_p_PLGraphicsIn swig_types[0] 02914 #define SWIGTYPE_p_PLcGrid swig_types[1] 02915 #define SWIGTYPE_p_PLcGrid2 swig_types[2] 02916 #define SWIGTYPE_p_char swig_types[3] 02917 #define SWIGTYPE_p_double swig_types[4] 02918 #define SWIGTYPE_p_f_double_double__int swig_types[5] 02919 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6] 02920 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7] 02921 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8] 02922 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9] 02923 #define SWIGTYPE_p_int swig_types[10] 02924 #define SWIGTYPE_p_p_char swig_types[11] 02925 #define SWIGTYPE_p_p_double swig_types[12] 02926 #define SWIGTYPE_p_unsigned_int swig_types[13] 02927 static swig_type_info *swig_types[15]; 02928 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0}; 02929 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) 02930 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) 02931 02932 /* -------- TYPES TABLE (END) -------- */ 02933 02934 #if (PY_VERSION_HEX <= 0x02000000) 02935 # if !defined(SWIG_PYTHON_CLASSIC) 02936 # error "This python version requires swig to be run with the '-classic' option" 02937 # endif 02938 #endif 02939 02940 /*----------------------------------------------- 02941 @(target):= _plplotc.so 02942 ------------------------------------------------*/ 02943 #if PY_VERSION_HEX >= 0x03000000 02944 # define SWIG_init PyInit__plplotc 02945 02946 #else 02947 # define SWIG_init init_plplotc 02948 02949 #endif 02950 #define SWIG_name "_plplotc" 02951 02952 #define SWIGVERSION 0x030002 02953 #define SWIG_VERSION SWIGVERSION 02954 02955 02956 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 02957 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 02958 02959 02960 // define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 02961 #include <numpy/arrayobject.h> 02962 #include "plplot.h" 02963 #include "plplotP.h" 02964 02965 #define NPY_PLINT NPY_INT32 02966 02967 #ifdef PL_DOUBLE 02968 #define NPY_PLFLT NPY_FLOAT64 02969 #else 02970 #define NPY_PLFLT NPY_FLOAT32 02971 #endif 02972 02973 // python-1.5 compatibility mode? 02974 #if !defined ( PySequence_Fast_GET_ITEM ) 02975 #define PySequence_Fast_GET_ITEM PySequence_GetItem 02976 #endif 02977 #define PySequence_Size PySequence_Length 02978 02979 02980 static PLINT Alen = 0; 02981 static PLINT Xlen = 0, Ylen = 0; 02982 02983 02984 SWIGINTERN int 02985 SWIG_AsVal_double (PyObject *obj, double *val) 02986 { 02987 int res = SWIG_TypeError; 02988 if (PyFloat_Check(obj)) { 02989 if (val) *val = PyFloat_AsDouble(obj); 02990 return SWIG_OK; 02991 } else if (PyInt_Check(obj)) { 02992 if (val) *val = PyInt_AsLong(obj); 02993 return SWIG_OK; 02994 } else if (PyLong_Check(obj)) { 02995 double v = PyLong_AsDouble(obj); 02996 if (!PyErr_Occurred()) { 02997 if (val) *val = v; 02998 return SWIG_OK; 02999 } else { 03000 PyErr_Clear(); 03001 } 03002 } 03003 #ifdef SWIG_PYTHON_CAST_MODE 03004 { 03005 int dispatch = 0; 03006 double d = PyFloat_AsDouble(obj); 03007 if (!PyErr_Occurred()) { 03008 if (val) *val = d; 03009 return SWIG_AddCast(SWIG_OK); 03010 } else { 03011 PyErr_Clear(); 03012 } 03013 if (!dispatch) { 03014 long v = PyLong_AsLong(obj); 03015 if (!PyErr_Occurred()) { 03016 if (val) *val = v; 03017 return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); 03018 } else { 03019 PyErr_Clear(); 03020 } 03021 } 03022 } 03023 #endif 03024 return res; 03025 } 03026 03027 03028 #define SWIG_From_double PyFloat_FromDouble 03029 03030 03031 typedef PLINT ( *defined_func )( PLFLT, PLFLT ); 03032 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* ); 03033 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer ); 03034 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer ); 03035 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* ); 03036 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer ); 03037 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ); 03038 03039 03040 SWIGINTERNINLINE PyObject* 03041 SWIG_From_int (int value) 03042 { 03043 return PyInt_FromLong((long) value); 03044 } 03045 03046 03047 #include <limits.h> 03048 #if !defined(SWIG_NO_LLONG_MAX) 03049 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) 03050 # define LLONG_MAX __LONG_LONG_MAX__ 03051 # define LLONG_MIN (-LLONG_MAX - 1LL) 03052 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) 03053 # endif 03054 #endif 03055 03056 03057 #include <float.h> 03058 03059 03060 #include <math.h> 03061 03062 03063 SWIGINTERNINLINE int 03064 SWIG_CanCastAsInteger(double *d, double min, double max) { 03065 double x = *d; 03066 if ((min <= x && x <= max)) { 03067 double fx = floor(x); 03068 double cx = ceil(x); 03069 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ 03070 if ((errno == EDOM) || (errno == ERANGE)) { 03071 errno = 0; 03072 } else { 03073 double summ, reps, diff; 03074 if (rd < x) { 03075 diff = x - rd; 03076 } else if (rd > x) { 03077 diff = rd - x; 03078 } else { 03079 return 1; 03080 } 03081 summ = rd + x; 03082 reps = diff/summ; 03083 if (reps < 8*DBL_EPSILON) { 03084 *d = rd; 03085 return 1; 03086 } 03087 } 03088 } 03089 return 0; 03090 } 03091 03092 03093 SWIGINTERN int 03094 SWIG_AsVal_long (PyObject *obj, long* val) 03095 { 03096 if (PyInt_Check(obj)) { 03097 if (val) *val = PyInt_AsLong(obj); 03098 return SWIG_OK; 03099 } else if (PyLong_Check(obj)) { 03100 long v = PyLong_AsLong(obj); 03101 if (!PyErr_Occurred()) { 03102 if (val) *val = v; 03103 return SWIG_OK; 03104 } else { 03105 PyErr_Clear(); 03106 } 03107 } 03108 #ifdef SWIG_PYTHON_CAST_MODE 03109 { 03110 int dispatch = 0; 03111 long v = PyInt_AsLong(obj); 03112 if (!PyErr_Occurred()) { 03113 if (val) *val = v; 03114 return SWIG_AddCast(SWIG_OK); 03115 } else { 03116 PyErr_Clear(); 03117 } 03118 if (!dispatch) { 03119 double d; 03120 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); 03121 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { 03122 if (val) *val = (long)(d); 03123 return res; 03124 } 03125 } 03126 } 03127 #endif 03128 return SWIG_TypeError; 03129 } 03130 03131 03132 SWIGINTERN int 03133 SWIG_AsVal_int (PyObject * obj, int *val) 03134 { 03135 long v; 03136 int res = SWIG_AsVal_long (obj, &v); 03137 if (SWIG_IsOK(res)) { 03138 if ((v < INT_MIN || v > INT_MAX)) { 03139 return SWIG_OverflowError; 03140 } else { 03141 if (val) *val = (int)(v); 03142 } 03143 } 03144 return res; 03145 } 03146 03147 03148 SWIGINTERN int 03149 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 03150 { 03151 #if PY_VERSION_HEX < 0x03000000 03152 if (PyInt_Check(obj)) { 03153 long v = PyInt_AsLong(obj); 03154 if (v >= 0) { 03155 if (val) *val = v; 03156 return SWIG_OK; 03157 } else { 03158 return SWIG_OverflowError; 03159 } 03160 } else 03161 #endif 03162 if (PyLong_Check(obj)) { 03163 unsigned long v = PyLong_AsUnsignedLong(obj); 03164 if (!PyErr_Occurred()) { 03165 if (val) *val = v; 03166 return SWIG_OK; 03167 } else { 03168 PyErr_Clear(); 03169 #if PY_VERSION_HEX >= 0x03000000 03170 { 03171 long v = PyLong_AsLong(obj); 03172 if (!PyErr_Occurred()) { 03173 if (v < 0) { 03174 return SWIG_OverflowError; 03175 } 03176 } else { 03177 PyErr_Clear(); 03178 } 03179 } 03180 #endif 03181 } 03182 } 03183 #ifdef SWIG_PYTHON_CAST_MODE 03184 { 03185 int dispatch = 0; 03186 unsigned long v = PyLong_AsUnsignedLong(obj); 03187 if (!PyErr_Occurred()) { 03188 if (val) *val = v; 03189 return SWIG_AddCast(SWIG_OK); 03190 } else { 03191 PyErr_Clear(); 03192 } 03193 if (!dispatch) { 03194 double d; 03195 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); 03196 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { 03197 if (val) *val = (unsigned long)(d); 03198 return res; 03199 } 03200 } 03201 } 03202 #endif 03203 return SWIG_TypeError; 03204 } 03205 03206 03207 SWIGINTERN int 03208 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) 03209 { 03210 unsigned long v; 03211 int res = SWIG_AsVal_unsigned_SS_long (obj, &v); 03212 if (SWIG_IsOK(res)) { 03213 if ((v > UINT_MAX)) { 03214 return SWIG_OverflowError; 03215 } else { 03216 if (val) *val = (unsigned int)(v); 03217 } 03218 } 03219 return res; 03220 } 03221 03222 03223 SWIGINTERNINLINE PyObject* 03224 SWIG_From_unsigned_SS_int (unsigned int value) 03225 { 03226 return PyInt_FromSize_t((size_t) value); 03227 } 03228 03229 03230 SWIGINTERN swig_type_info* 03231 SWIG_pchar_descriptor(void) 03232 { 03233 static int init = 0; 03234 static swig_type_info* info = 0; 03235 if (!init) { 03236 info = SWIG_TypeQuery("_p_char"); 03237 init = 1; 03238 } 03239 return info; 03240 } 03241 03242 03243 SWIGINTERN int 03244 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) 03245 { 03246 #if PY_VERSION_HEX>=0x03000000 03247 if (PyUnicode_Check(obj)) 03248 #else 03249 if (PyString_Check(obj)) 03250 #endif 03251 { 03252 char *cstr; Py_ssize_t len; 03253 #if PY_VERSION_HEX>=0x03000000 03254 if (!alloc && cptr) { 03255 /* We can't allow converting without allocation, since the internal 03256 representation of string in Python 3 is UCS-2/UCS-4 but we require 03257 a UTF-8 representation. 03258 TODO(bhy) More detailed explanation */ 03259 return SWIG_RuntimeError; 03260 } 03261 obj = PyUnicode_AsUTF8String(obj); 03262 PyBytes_AsStringAndSize(obj, &cstr, &len); 03263 if(alloc) *alloc = SWIG_NEWOBJ; 03264 #else 03265 PyString_AsStringAndSize(obj, &cstr, &len); 03266 #endif 03267 if (cptr) { 03268 if (alloc) { 03269 /* 03270 In python the user should not be able to modify the inner 03271 string representation. To warranty that, if you define 03272 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string 03273 buffer is always returned. 03274 03275 The default behavior is just to return the pointer value, 03276 so, be careful. 03277 */ 03278 #if defined(SWIG_PYTHON_SAFE_CSTRINGS) 03279 if (*alloc != SWIG_OLDOBJ) 03280 #else 03281 if (*alloc == SWIG_NEWOBJ) 03282 #endif 03283 { 03284 *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); 03285 *alloc = SWIG_NEWOBJ; 03286 } 03287 else { 03288 *cptr = cstr; 03289 *alloc = SWIG_OLDOBJ; 03290 } 03291 } else { 03292 #if PY_VERSION_HEX>=0x03000000 03293 assert(0); /* Should never reach here in Python 3 */ 03294 #endif 03295 *cptr = SWIG_Python_str_AsChar(obj); 03296 } 03297 } 03298 if (psize) *psize = len + 1; 03299 #if PY_VERSION_HEX>=0x03000000 03300 Py_XDECREF(obj); 03301 #endif 03302 return SWIG_OK; 03303 } else { 03304 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); 03305 if (pchar_descriptor) { 03306 void* vptr = 0; 03307 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { 03308 if (cptr) *cptr = (char *) vptr; 03309 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; 03310 if (alloc) *alloc = SWIG_OLDOBJ; 03311 return SWIG_OK; 03312 } 03313 } 03314 } 03315 return SWIG_TypeError; 03316 } 03317 03318 03319 SWIGINTERN int 03320 SWIG_AsCharArray(PyObject * obj, char *val, size_t size) 03321 { 03322 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; 03323 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); 03324 if (SWIG_IsOK(res)) { 03325 /* special case of single char conversion when we don't need space for NUL */ 03326 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize; 03327 if (csize <= size) { 03328 if (val) { 03329 if (csize) memcpy(val, cptr, csize*sizeof(char)); 03330 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); 03331 } 03332 if (alloc == SWIG_NEWOBJ) { 03333 free((char*)cptr); 03334 res = SWIG_DelNewMask(res); 03335 } 03336 return res; 03337 } 03338 if (alloc == SWIG_NEWOBJ) free((char*)cptr); 03339 } 03340 return SWIG_TypeError; 03341 } 03342 03343 03344 SWIGINTERNINLINE PyObject * 03345 SWIG_FromCharPtrAndSize(const char* carray, size_t size) 03346 { 03347 if (carray) { 03348 if (size > INT_MAX) { 03349 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); 03350 return pchar_descriptor ? 03351 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); 03352 } else { 03353 #if PY_VERSION_HEX >= 0x03000000 03354 #if PY_VERSION_HEX >= 0x03010000 03355 return PyUnicode_DecodeUTF8(carray, (int)(size), "surrogateescape"); 03356 #else 03357 return PyUnicode_FromStringAndSize(carray, (int)(size)); 03358 #endif 03359 #else 03360 return PyString_FromStringAndSize(carray, (int)(size)); 03361 #endif 03362 } 03363 } else { 03364 return SWIG_Py_Void(); 03365 } 03366 } 03367 03368 03369 size_t 03370 SWIG_strnlen(const char* s, size_t maxlen) 03371 { 03372 const char *p; 03373 for (p = s; maxlen-- && *p; p++) 03374 ; 03375 return p - s; 03376 } 03377 03378 03379 03380 03381 03382 #define t_output_helper SWIG_Python_AppendOutput 03383 03384 03385 SWIGINTERN int 03386 SWIG_AsVal_char (PyObject * obj, char *val) 03387 { 03388 int res = SWIG_AsCharArray(obj, val, 1); 03389 if (!SWIG_IsOK(res)) { 03390 long v; 03391 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v)); 03392 if (SWIG_IsOK(res)) { 03393 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) { 03394 if (val) *val = (char)(v); 03395 } else { 03396 res = SWIG_OverflowError; 03397 } 03398 } 03399 } 03400 return res; 03401 } 03402 03403 #ifdef __cplusplus 03404 extern "C" { 03405 #endif 03406 03407 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims ); 03408 03409 // some really twisted stuff to allow calling a single precision library from python 03410 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims ) 03411 { 03412 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT, 03413 mindims, maxdims ); 03414 if ( !tmp ) 03415 { 03416 // could be an incoming long array which can't be "safely" converted, do it anyway 03417 if ( PyArray_Check( in ) ) 03418 { 03419 PyErr_Clear(); 03420 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT ); 03421 } 03422 } 03423 return tmp; 03424 } 03425 03426 03427 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject 03428 03429 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 03430 PyObject *resultobj = 0; 03431 PLFLT arg1 ; 03432 PLFLT arg2 ; 03433 PLFLT *arg3 = (PLFLT *) 0 ; 03434 PLFLT *arg4 = (PLFLT *) 0 ; 03435 PLPointer arg5 = (PLPointer) 0 ; 03436 double val1 ; 03437 int ecode1 = 0 ; 03438 double val2 ; 03439 int ecode2 = 0 ; 03440 PLFLT temp3 ; 03441 int res3 = SWIG_TMPOBJ ; 03442 PLFLT temp4 ; 03443 int res4 = SWIG_TMPOBJ ; 03444 PyObject * obj0 = 0 ; 03445 PyObject * obj1 = 0 ; 03446 03447 arg3 = &temp3; 03448 arg4 = &temp4; 03449 { 03450 arg5 = NULL; 03451 } 03452 if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail; 03453 ecode1 = SWIG_AsVal_double(obj0, &val1); 03454 if (!SWIG_IsOK(ecode1)) { 03455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'"); 03456 } 03457 arg1 = (PLFLT)(val1); 03458 ecode2 = SWIG_AsVal_double(obj1, &val2); 03459 if (!SWIG_IsOK(ecode2)) { 03460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'"); 03461 } 03462 arg2 = (PLFLT)(val2); 03463 pltr0(arg1,arg2,arg3,arg4,arg5); 03464 resultobj = SWIG_Py_Void(); 03465 if (SWIG_IsTmpObj(res3)) { 03466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 03467 } else { 03468 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 03470 } 03471 if (SWIG_IsTmpObj(res4)) { 03472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 03473 } else { 03474 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 03476 } 03477 return resultobj; 03478 fail: 03479 return NULL; 03480 } 03481 03482 03483 03484 PyArrayObject *pltr_xg, *pltr_yg; 03485 static PLcGrid tmpGrid1; 03486 static PLcGrid2 tmpGrid2; 03487 03488 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg ); 03489 void cleanup_PLcGrid1( void ); 03490 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg ); 03491 void cleanup_PLcGrid2( void ); 03492 03493 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg ) 03494 { 03495 // fprintf(stderr, "marshal PLcGrid1\n"); 03496 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 ) 03497 { 03498 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." ); 03499 return NULL; 03500 } 03501 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ), 03502 NPY_PLFLT, 1, 1 ); 03503 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ), 03504 NPY_PLFLT, 1, 1 ); 03505 if ( pltr_xg == 0 || pltr_yg == 0 ) 03506 { 03507 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." ); 03508 return NULL; 03509 } 03510 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0]; 03511 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0]; 03512 if ( isimg == 0 ) 03513 { 03514 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny ) 03515 { 03516 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." ); 03517 return NULL; 03518 } 03519 } 03520 else 03521 { 03522 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 ) 03523 { 03524 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." ); 03525 return NULL; 03526 } 03527 } 03528 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg ); 03529 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg ); 03530 return &tmpGrid1; 03531 } 03532 03533 void cleanup_PLcGrid1( void ) 03534 { 03535 // fprintf(stderr, "cleanup PLcGrid1\n"); 03536 Py_CLEAR( pltr_xg ); 03537 Py_CLEAR( pltr_yg ); 03538 } 03539 03540 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg ) 03541 { 03542 int i, size; 03543 // fprintf(stderr, "marshal PLcGrid2\n"); 03544 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 ) 03545 { 03546 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." ); 03547 return NULL; 03548 } 03549 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ), 03550 NPY_PLFLT, 2, 2 ); 03551 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ), 03552 NPY_PLFLT, 2, 2 ); 03553 if ( pltr_xg == 0 || pltr_yg == 0 ) 03554 { 03555 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." ); 03556 return NULL; 03557 } 03558 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] || 03559 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] ) 03560 { 03561 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." ); 03562 return NULL; 03563 } 03564 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0]; 03565 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1]; 03566 if ( isimg == 0 ) 03567 { 03568 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny ) 03569 { 03570 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." ); 03571 return NULL; 03572 } 03573 } 03574 else 03575 { 03576 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 ) 03577 { 03578 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." ); 03579 return NULL; 03580 } 03581 } 03582 size = tmpGrid2.ny; 03583 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx ); 03584 for ( i = 0; i < tmpGrid2.nx; i++ ) 03585 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size ); 03586 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx ); 03587 for ( i = 0; i < tmpGrid2.nx; i++ ) 03588 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size ); 03589 return &tmpGrid2; 03590 } 03591 03592 void cleanup_PLcGrid2( void ) 03593 { 03594 // fprintf(stderr, "cleanup PLcGrid2\n"); 03595 free( tmpGrid2.xg ); 03596 free( tmpGrid2.yg ); 03597 Py_CLEAR( pltr_xg ); 03598 Py_CLEAR( pltr_yg ); 03599 } 03600 03601 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 03602 PyObject *resultobj = 0; 03603 PLFLT arg1 ; 03604 PLFLT arg2 ; 03605 PLFLT *arg3 = (PLFLT *) 0 ; 03606 PLFLT *arg4 = (PLFLT *) 0 ; 03607 PLcGrid *arg5 = (PLcGrid *) 0 ; 03608 double val1 ; 03609 int ecode1 = 0 ; 03610 double val2 ; 03611 int ecode2 = 0 ; 03612 PLFLT temp3 ; 03613 int res3 = SWIG_TMPOBJ ; 03614 PLFLT temp4 ; 03615 int res4 = SWIG_TMPOBJ ; 03616 PyObject * obj0 = 0 ; 03617 PyObject * obj1 = 0 ; 03618 PyObject * obj2 = 0 ; 03619 03620 arg3 = &temp3; 03621 arg4 = &temp4; 03622 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail; 03623 ecode1 = SWIG_AsVal_double(obj0, &val1); 03624 if (!SWIG_IsOK(ecode1)) { 03625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'"); 03626 } 03627 arg1 = (PLFLT)(val1); 03628 ecode2 = SWIG_AsVal_double(obj1, &val2); 03629 if (!SWIG_IsOK(ecode2)) { 03630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'"); 03631 } 03632 arg2 = (PLFLT)(val2); 03633 { 03634 arg5 = marshal_PLcGrid1( obj2, 0 ); 03635 if ( !arg5 ) 03636 return NULL; 03637 } 03638 pltr1(arg1,arg2,arg3,arg4,arg5); 03639 resultobj = SWIG_Py_Void(); 03640 if (SWIG_IsTmpObj(res3)) { 03641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 03642 } else { 03643 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 03645 } 03646 if (SWIG_IsTmpObj(res4)) { 03647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 03648 } else { 03649 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 03651 } 03652 { 03653 cleanup_PLcGrid1(); 03654 } 03655 return resultobj; 03656 fail: 03657 { 03658 cleanup_PLcGrid1(); 03659 } 03660 return NULL; 03661 } 03662 03663 03664 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 03665 PyObject *resultobj = 0; 03666 PLFLT arg1 ; 03667 PLFLT arg2 ; 03668 PLFLT *arg3 = (PLFLT *) 0 ; 03669 PLFLT *arg4 = (PLFLT *) 0 ; 03670 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ; 03671 double val1 ; 03672 int ecode1 = 0 ; 03673 double val2 ; 03674 int ecode2 = 0 ; 03675 PLFLT temp3 ; 03676 int res3 = SWIG_TMPOBJ ; 03677 PLFLT temp4 ; 03678 int res4 = SWIG_TMPOBJ ; 03679 PyObject * obj0 = 0 ; 03680 PyObject * obj1 = 0 ; 03681 PyObject * obj2 = 0 ; 03682 03683 arg3 = &temp3; 03684 arg4 = &temp4; 03685 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail; 03686 ecode1 = SWIG_AsVal_double(obj0, &val1); 03687 if (!SWIG_IsOK(ecode1)) { 03688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'"); 03689 } 03690 arg1 = (PLFLT)(val1); 03691 ecode2 = SWIG_AsVal_double(obj1, &val2); 03692 if (!SWIG_IsOK(ecode2)) { 03693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'"); 03694 } 03695 arg2 = (PLFLT)(val2); 03696 { 03697 arg5 = marshal_PLcGrid2( obj2, 0 ); 03698 if ( !arg5 ) 03699 return NULL; 03700 } 03701 pltr2(arg1,arg2,arg3,arg4,arg5); 03702 resultobj = SWIG_Py_Void(); 03703 if (SWIG_IsTmpObj(res3)) { 03704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 03705 } else { 03706 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 03708 } 03709 if (SWIG_IsTmpObj(res4)) { 03710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 03711 } else { 03712 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 03713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 03714 } 03715 { 03716 cleanup_PLcGrid2(); 03717 } 03718 return resultobj; 03719 fail: 03720 { 03721 cleanup_PLcGrid2(); 03722 } 03723 return NULL; 03724 } 03725 03726 03727 03728 // helper code for handling the callback 03729 #if 0 03730 static PyInterpreterState *save_interp = NULL; 03731 #endif 03732 enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type; 03733 PyObject* python_pltr = NULL; 03734 PyObject* python_f2eval = NULL; 03735 PyObject* python_ct = NULL; 03736 PyObject* python_mapform = NULL; 03737 PyObject* python_label = NULL; 03738 03739 #if 0 03740 #define MY_BLOCK_THREADS { \ 03741 PyThreadState *prev_state, *new_state; \ 03742 /* need to have started a thread at some stage */ \ 03743 /* for the following to work */ \ 03744 PyEval_AcquireLock(); \ 03745 new_state = PyThreadState_New( save_interp ); \ 03746 prev_state = PyThreadState_Swap( new_state ); 03747 #define MY_UNBLOCK_THREADS \ 03748 new_state = PyThreadState_Swap( prev_state ); \ 03749 PyThreadState_Clear( new_state ); \ 03750 PyEval_ReleaseLock(); \ 03751 PyThreadState_Delete( new_state ); \ 03752 } 03753 #else 03754 #define MY_BLOCK_THREADS 03755 #define MY_UNBLOCK_THREADS 03756 #endif 03757 03758 // Function prototypes 03759 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data ); 03760 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data ); 03761 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data ); 03762 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data ); 03763 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y ); 03764 pltr_func marshal_pltr( PyObject* input ); 03765 void cleanup_pltr( void ); 03766 ct_func marshal_ct( PyObject* input ); 03767 void cleanup_ct( void ); 03768 mapform_func marshal_mapform( PyObject* input ); 03769 void cleanup_mapform( void ); 03770 PLPointer marshal_PLPointer( PyObject* input, int isimg ); 03771 void cleanup_PLPointer( void ); 03772 03773 03774 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback 03775 03776 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data ) 03777 { 03778 PyObject *pdata, *arglist, *result; 03779 PyArrayObject *tmp; 03780 03781 // the data argument is acutally a pointer to a python object 03782 pdata = (PyObject *) data; 03783 if ( data == NULL ) 03784 { 03785 pdata = Py_None; 03786 } 03787 if ( python_pltr ) // if not something is terribly wrong 03788 { // hold a reference to the data object 03789 Py_XINCREF( pdata ); 03790 // grab the Global Interpreter Lock to be sure threads don't mess us up 03791 MY_BLOCK_THREADS 03792 // build the argument list 03793 #ifdef PL_DOUBLE 03794 arglist = Py_BuildValue( "(ddO)", x, y, pdata ); 03795 #else 03796 arglist = Py_BuildValue( "(ffO)", x, y, pdata ); 03797 #endif 03798 if ( arglist == NULL ) 03799 { 03800 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" ); 03801 *tx = *ty = 0; 03802 return; 03803 } 03804 // call the python function 03805 result = PyEval_CallObject( python_pltr, arglist ); 03806 // release the argument list 03807 Py_CLEAR( arglist ); 03808 // check and unpack the result 03809 if ( result == NULL ) 03810 { 03811 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" ); 03812 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." ); 03813 *tx = *ty = 0; 03814 } 03815 else 03816 { 03817 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 ); 03818 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 ) 03819 { 03820 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" ); 03821 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." ); 03822 *tx = *ty = 0; 03823 } 03824 else 03825 { 03826 PLFLT* t = (PLFLT *) PyArray_DATA( tmp ); 03827 *tx = t[0]; 03828 *ty = t[1]; 03829 Py_CLEAR( tmp ); 03830 } 03831 } 03832 // release the result 03833 Py_CLEAR( result ); 03834 // release the global interpreter lock 03835 MY_UNBLOCK_THREADS 03836 } 03837 } 03838 03839 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data ) 03840 { 03841 PyObject *pdata, *arglist, *result; 03842 PLFLT fresult = 0.0; 03843 03844 // the data argument is acutally a pointer to a python object 03845 pdata = (PyObject *) data; 03846 if ( python_f2eval ) // if not something is terribly wrong 03847 { // hold a reference to the data object 03848 Py_XINCREF( pdata ); 03849 // grab the Global Interpreter Lock to be sure threads don't mess us up 03850 MY_BLOCK_THREADS 03851 // build the argument list 03852 arglist = Py_BuildValue( "(iiO)", x, y, pdata ); 03853 // call the python function 03854 result = PyEval_CallObject( python_f2eval, arglist ); 03855 // release the argument list 03856 Py_CLEAR( arglist ); 03857 // check and unpack the result 03858 if ( !PyFloat_Check( result ) ) 03859 { 03860 fprintf( stderr, "f2eval callback must return a float\n" ); 03861 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." ); 03862 } 03863 else 03864 { 03865 // should I test the type here? 03866 fresult = (PLFLT) PyFloat_AsDouble( result ); 03867 } 03868 // release the result 03869 Py_CLEAR( result ); 03870 // release the global interpreter lock 03871 MY_UNBLOCK_THREADS 03872 } 03873 return fresult; 03874 } 03875 03876 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data ) 03877 { 03878 PyObject *pdata, *arglist, *result; 03879 char *pystring; 03880 03881 // the data argument is acutally a pointer to a python object 03882 if ( data ) 03883 pdata = (PyObject *) data; 03884 else 03885 pdata = Py_None; 03886 if ( python_label ) // if not something is terribly wrong 03887 { // hold a reference to the data object 03888 Py_XINCREF( pdata ); 03889 // grab the Global Interpreter Lock to be sure threads don't mess us up 03890 MY_BLOCK_THREADS 03891 // build the argument list 03892 #ifdef PL_DOUBLE 03893 arglist = Py_BuildValue( "(ldO)", axis, value, pdata ); 03894 #else 03895 arglist = Py_BuildValue( "(lfO)", axis, value, pdata ); 03896 #endif 03897 // call the python function 03898 result = PyEval_CallObject( python_label, arglist ); 03899 // release the argument list 03900 //Py_CLEAR(arglist); 03901 // check and unpack the result 03902 if ( result == NULL ) 03903 { 03904 fprintf( stderr, "label callback failed with 3 arguments\n" ); 03905 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." ); 03906 } 03907 else if ( !PyString_Check( result ) ) 03908 { 03909 fprintf( stderr, "label callback must return a string\n" ); 03910 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." ); 03911 } 03912 else 03913 { 03914 // should I test the type here? 03915 pystring = PyString_AsString( result ); 03916 strncpy( string, pystring, len ); 03917 } 03918 // release the result 03919 Py_CLEAR( result ); 03920 // release the global interpreter lock 03921 MY_UNBLOCK_THREADS 03922 } 03923 } 03924 03925 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data ) 03926 { 03927 PyObject *px, *py, *pdata, *arglist, *result; 03928 npy_intp n; 03929 n = 1; 03930 03931 // the data argument is acutally a pointer to a python object 03932 pdata = (PyObject *) data; 03933 if ( data == NULL ) 03934 { 03935 pdata = Py_None; 03936 } 03937 if ( python_ct ) // if not something is terribly wrong 03938 { // hold a reference to the data object 03939 Py_XINCREF( pdata ); 03940 // grab the Global Interpreter Lock to be sure threads don't mess us up 03941 MY_BLOCK_THREADS 03942 // build the argument list 03943 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt ); 03944 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt ); 03945 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata ); 03946 // call the python function 03947 result = PyEval_CallObject( python_ct, arglist ); 03948 // release the argument list 03949 Py_CLEAR( arglist ); 03950 Py_CLEAR( px ); 03951 Py_CLEAR( py ); 03952 Py_CLEAR( pdata ); 03953 // check and unpack the result 03954 if ( result == NULL ) 03955 { 03956 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" ); 03957 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." ); 03958 } 03959 // release the result 03960 Py_CLEAR( result ); 03961 // release the global interpreter lock 03962 MY_UNBLOCK_THREADS 03963 } 03964 } 03965 03966 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y ) 03967 { 03968 PyObject *px, *py, *arglist, *result; 03969 // PyArrayObject *tmpx, *tmpy; 03970 // PLFLT *xx, *yy; 03971 // PLINT i; 03972 npy_intp nn; 03973 nn = n; 03974 03975 if ( python_mapform ) // if not something is terribly wrong 03976 { // grab the Global Interpreter Lock to be sure threads don't mess us up 03977 MY_BLOCK_THREADS 03978 // build the argument list 03979 #ifdef PL_HAVE_PTHREAD 03980 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x ); 03981 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y ); 03982 #else 03983 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x ); 03984 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y ); 03985 #endif 03986 arglist = Py_BuildValue( "(iOO)", n, px, py ); 03987 // call the python function 03988 result = PyEval_CallObject( python_mapform, arglist ); 03989 // release the argument list 03990 Py_CLEAR( arglist ); 03991 Py_CLEAR( px ); 03992 Py_CLEAR( py ); 03993 // check and unpack the result 03994 if ( result == NULL ) 03995 { 03996 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" ); 03997 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." ); 03998 } 03999 // release the result 04000 Py_CLEAR( result ); 04001 // release the global interpreter lock 04002 MY_UNBLOCK_THREADS 04003 } 04004 } 04005 04006 // marshal the pltr function pointer argument 04007 pltr_func marshal_pltr( PyObject* input ) 04008 { 04009 pltr_func result = do_pltr_callback; 04010 PyObject * rep = PyObject_Repr( input ); 04011 if ( rep ) 04012 { 04013 char* str = PyString_AsString( rep ); 04014 if ( strcmp( str, "<built-in function pltr0>" ) == 0 ) 04015 { 04016 result = pltr0; 04017 pltr_type = CB_0; 04018 python_pltr = NULL; 04019 } 04020 else if ( strcmp( str, "<built-in function pltr1>" ) == 0 ) 04021 { 04022 result = pltr1; 04023 pltr_type = CB_1; 04024 python_pltr = NULL; 04025 } 04026 else if ( strcmp( str, "<built-in function pltr2>" ) == 0 ) 04027 { 04028 result = pltr2; 04029 pltr_type = CB_2; 04030 python_pltr = NULL; 04031 } 04032 else 04033 { 04034 python_pltr = input; 04035 pltr_type = CB_Python; 04036 Py_XINCREF( input ); 04037 } 04038 Py_CLEAR( rep ); 04039 } 04040 else 04041 { 04042 python_pltr = input; 04043 pltr_type = CB_Python; 04044 Py_XINCREF( input ); 04045 } 04046 return result; 04047 } 04048 04049 void cleanup_pltr( void ) 04050 { 04051 Py_CLEAR( python_pltr ); 04052 python_pltr = 0; 04053 } 04054 04055 // marshal the ct function pointer argument 04056 ct_func marshal_ct( PyObject* input ) 04057 { 04058 ct_func result = do_ct_callback; 04059 python_ct = input; 04060 Py_XINCREF( input ); 04061 return result; 04062 } 04063 04064 void cleanup_ct( void ) 04065 { 04066 Py_CLEAR( python_ct ); 04067 python_ct = 0; 04068 } 04069 04070 // marshal the mapform function pointer argument 04071 mapform_func marshal_mapform( PyObject* input ) 04072 { 04073 mapform_func result = do_mapform_callback; 04074 python_mapform = input; 04075 Py_XINCREF( input ); 04076 return result; 04077 } 04078 04079 void cleanup_mapform( void ) 04080 { 04081 Py_CLEAR( python_mapform ); 04082 python_mapform = 0; 04083 } 04084 04085 PLPointer marshal_PLPointer( PyObject* input, int isimg ) 04086 { 04087 PLPointer result = NULL; 04088 switch ( pltr_type ) 04089 { 04090 case CB_0: 04091 break; 04092 case CB_1: 04093 if ( input != Py_None ) 04094 result = marshal_PLcGrid1( input, isimg ); 04095 break; 04096 case CB_2: 04097 if ( input != Py_None ) 04098 result = marshal_PLcGrid2( input, isimg ); 04099 break; 04100 case CB_Python: 04101 Py_XINCREF( input ); 04102 result = (PLPointer *) input; 04103 break; 04104 default: 04105 fprintf( stderr, "pltr_type is invalid\n" ); 04106 } 04107 return result; 04108 } 04109 04110 void cleanup_PLPointer( void ) 04111 { 04112 switch ( pltr_type ) 04113 { 04114 case CB_0: 04115 break; 04116 case CB_1: 04117 cleanup_PLcGrid1(); 04118 break; 04119 case CB_2: 04120 cleanup_PLcGrid2(); 04121 break; 04122 case CB_Python: 04123 Py_CLEAR( python_pltr ); 04124 break; 04125 default: 04126 fprintf( stderr, "pltr_type is invalid\n" ); 04127 } 04128 python_pltr = 0; 04129 pltr_type = CB_0; 04130 } 04131 04132 04133 04134 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04135 PyObject *resultobj = 0; 04136 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04137 int arg2 ; 04138 void *argp1 = 0 ; 04139 int res1 = 0 ; 04140 int val2 ; 04141 int ecode2 = 0 ; 04142 PyObject * obj0 = 0 ; 04143 PyObject * obj1 = 0 ; 04144 04145 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail; 04146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04147 if (!SWIG_IsOK(res1)) { 04148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04149 } 04150 arg1 = (PLGraphicsIn *)(argp1); 04151 ecode2 = SWIG_AsVal_int(obj1, &val2); 04152 if (!SWIG_IsOK(ecode2)) { 04153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'"); 04154 } 04155 arg2 = (int)(val2); 04156 if (arg1) (arg1)->type = arg2; 04157 resultobj = SWIG_Py_Void(); 04158 return resultobj; 04159 fail: 04160 return NULL; 04161 } 04162 04163 04164 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04165 PyObject *resultobj = 0; 04166 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04167 void *argp1 = 0 ; 04168 int res1 = 0 ; 04169 PyObject * obj0 = 0 ; 04170 int result; 04171 04172 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail; 04173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04174 if (!SWIG_IsOK(res1)) { 04175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04176 } 04177 arg1 = (PLGraphicsIn *)(argp1); 04178 result = (int) ((arg1)->type); 04179 resultobj = SWIG_From_int((int)(result)); 04180 return resultobj; 04181 fail: 04182 return NULL; 04183 } 04184 04185 04186 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04187 PyObject *resultobj = 0; 04188 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04189 unsigned int arg2 ; 04190 void *argp1 = 0 ; 04191 int res1 = 0 ; 04192 unsigned int val2 ; 04193 int ecode2 = 0 ; 04194 PyObject * obj0 = 0 ; 04195 PyObject * obj1 = 0 ; 04196 04197 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail; 04198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04199 if (!SWIG_IsOK(res1)) { 04200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04201 } 04202 arg1 = (PLGraphicsIn *)(argp1); 04203 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); 04204 if (!SWIG_IsOK(ecode2)) { 04205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'"); 04206 } 04207 arg2 = (unsigned int)(val2); 04208 if (arg1) (arg1)->state = arg2; 04209 resultobj = SWIG_Py_Void(); 04210 return resultobj; 04211 fail: 04212 return NULL; 04213 } 04214 04215 04216 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04217 PyObject *resultobj = 0; 04218 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04219 void *argp1 = 0 ; 04220 int res1 = 0 ; 04221 PyObject * obj0 = 0 ; 04222 unsigned int result; 04223 04224 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail; 04225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04226 if (!SWIG_IsOK(res1)) { 04227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04228 } 04229 arg1 = (PLGraphicsIn *)(argp1); 04230 result = (unsigned int) ((arg1)->state); 04231 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 04232 return resultobj; 04233 fail: 04234 return NULL; 04235 } 04236 04237 04238 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04239 PyObject *resultobj = 0; 04240 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04241 unsigned int arg2 ; 04242 void *argp1 = 0 ; 04243 int res1 = 0 ; 04244 unsigned int val2 ; 04245 int ecode2 = 0 ; 04246 PyObject * obj0 = 0 ; 04247 PyObject * obj1 = 0 ; 04248 04249 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail; 04250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04251 if (!SWIG_IsOK(res1)) { 04252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04253 } 04254 arg1 = (PLGraphicsIn *)(argp1); 04255 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); 04256 if (!SWIG_IsOK(ecode2)) { 04257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'"); 04258 } 04259 arg2 = (unsigned int)(val2); 04260 if (arg1) (arg1)->keysym = arg2; 04261 resultobj = SWIG_Py_Void(); 04262 return resultobj; 04263 fail: 04264 return NULL; 04265 } 04266 04267 04268 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04269 PyObject *resultobj = 0; 04270 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04271 void *argp1 = 0 ; 04272 int res1 = 0 ; 04273 PyObject * obj0 = 0 ; 04274 unsigned int result; 04275 04276 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail; 04277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04278 if (!SWIG_IsOK(res1)) { 04279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04280 } 04281 arg1 = (PLGraphicsIn *)(argp1); 04282 result = (unsigned int) ((arg1)->keysym); 04283 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 04284 return resultobj; 04285 fail: 04286 return NULL; 04287 } 04288 04289 04290 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04291 PyObject *resultobj = 0; 04292 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04293 unsigned int arg2 ; 04294 void *argp1 = 0 ; 04295 int res1 = 0 ; 04296 unsigned int val2 ; 04297 int ecode2 = 0 ; 04298 PyObject * obj0 = 0 ; 04299 PyObject * obj1 = 0 ; 04300 04301 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail; 04302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04303 if (!SWIG_IsOK(res1)) { 04304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04305 } 04306 arg1 = (PLGraphicsIn *)(argp1); 04307 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); 04308 if (!SWIG_IsOK(ecode2)) { 04309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'"); 04310 } 04311 arg2 = (unsigned int)(val2); 04312 if (arg1) (arg1)->button = arg2; 04313 resultobj = SWIG_Py_Void(); 04314 return resultobj; 04315 fail: 04316 return NULL; 04317 } 04318 04319 04320 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04321 PyObject *resultobj = 0; 04322 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04323 void *argp1 = 0 ; 04324 int res1 = 0 ; 04325 PyObject * obj0 = 0 ; 04326 unsigned int result; 04327 04328 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail; 04329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04330 if (!SWIG_IsOK(res1)) { 04331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04332 } 04333 arg1 = (PLGraphicsIn *)(argp1); 04334 result = (unsigned int) ((arg1)->button); 04335 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 04336 return resultobj; 04337 fail: 04338 return NULL; 04339 } 04340 04341 04342 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04343 PyObject *resultobj = 0; 04344 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04345 PLINT arg2 ; 04346 void *argp1 = 0 ; 04347 int res1 = 0 ; 04348 int val2 ; 04349 int ecode2 = 0 ; 04350 PyObject * obj0 = 0 ; 04351 PyObject * obj1 = 0 ; 04352 04353 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail; 04354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04355 if (!SWIG_IsOK(res1)) { 04356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04357 } 04358 arg1 = (PLGraphicsIn *)(argp1); 04359 ecode2 = SWIG_AsVal_int(obj1, &val2); 04360 if (!SWIG_IsOK(ecode2)) { 04361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'"); 04362 } 04363 arg2 = (PLINT)(val2); 04364 if (arg1) (arg1)->subwindow = arg2; 04365 resultobj = SWIG_Py_Void(); 04366 return resultobj; 04367 fail: 04368 return NULL; 04369 } 04370 04371 04372 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04373 PyObject *resultobj = 0; 04374 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04375 void *argp1 = 0 ; 04376 int res1 = 0 ; 04377 PyObject * obj0 = 0 ; 04378 PLINT result; 04379 04380 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail; 04381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04382 if (!SWIG_IsOK(res1)) { 04383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04384 } 04385 arg1 = (PLGraphicsIn *)(argp1); 04386 result = (PLINT) ((arg1)->subwindow); 04387 resultobj = SWIG_From_int((int)(result)); 04388 return resultobj; 04389 fail: 04390 return NULL; 04391 } 04392 04393 04394 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04395 PyObject *resultobj = 0; 04396 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04397 char *arg2 ; 04398 void *argp1 = 0 ; 04399 int res1 = 0 ; 04400 char temp2[16] ; 04401 int res2 ; 04402 PyObject * obj0 = 0 ; 04403 PyObject * obj1 = 0 ; 04404 04405 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail; 04406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04407 if (!SWIG_IsOK(res1)) { 04408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04409 } 04410 arg1 = (PLGraphicsIn *)(argp1); 04411 res2 = SWIG_AsCharArray(obj1, temp2, 16); 04412 if (!SWIG_IsOK(res2)) { 04413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'"); 04414 } 04415 arg2 = (char *)(temp2); 04416 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char)); 04417 else memset(arg1->string,0,16*sizeof(char)); 04418 resultobj = SWIG_Py_Void(); 04419 return resultobj; 04420 fail: 04421 return NULL; 04422 } 04423 04424 04425 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04426 PyObject *resultobj = 0; 04427 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04428 void *argp1 = 0 ; 04429 int res1 = 0 ; 04430 PyObject * obj0 = 0 ; 04431 char *result = 0 ; 04432 04433 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail; 04434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04435 if (!SWIG_IsOK(res1)) { 04436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04437 } 04438 arg1 = (PLGraphicsIn *)(argp1); 04439 result = (char *)(char *) ((arg1)->string); 04440 { 04441 size_t size = SWIG_strnlen(result, 16); 04442 04443 04444 04445 resultobj = SWIG_FromCharPtrAndSize(result, size); 04446 } 04447 return resultobj; 04448 fail: 04449 return NULL; 04450 } 04451 04452 04453 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04454 PyObject *resultobj = 0; 04455 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04456 int arg2 ; 04457 void *argp1 = 0 ; 04458 int res1 = 0 ; 04459 int val2 ; 04460 int ecode2 = 0 ; 04461 PyObject * obj0 = 0 ; 04462 PyObject * obj1 = 0 ; 04463 04464 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail; 04465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04466 if (!SWIG_IsOK(res1)) { 04467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04468 } 04469 arg1 = (PLGraphicsIn *)(argp1); 04470 ecode2 = SWIG_AsVal_int(obj1, &val2); 04471 if (!SWIG_IsOK(ecode2)) { 04472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'"); 04473 } 04474 arg2 = (int)(val2); 04475 if (arg1) (arg1)->pX = arg2; 04476 resultobj = SWIG_Py_Void(); 04477 return resultobj; 04478 fail: 04479 return NULL; 04480 } 04481 04482 04483 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04484 PyObject *resultobj = 0; 04485 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04486 void *argp1 = 0 ; 04487 int res1 = 0 ; 04488 PyObject * obj0 = 0 ; 04489 int result; 04490 04491 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail; 04492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04493 if (!SWIG_IsOK(res1)) { 04494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04495 } 04496 arg1 = (PLGraphicsIn *)(argp1); 04497 result = (int) ((arg1)->pX); 04498 resultobj = SWIG_From_int((int)(result)); 04499 return resultobj; 04500 fail: 04501 return NULL; 04502 } 04503 04504 04505 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04506 PyObject *resultobj = 0; 04507 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04508 int arg2 ; 04509 void *argp1 = 0 ; 04510 int res1 = 0 ; 04511 int val2 ; 04512 int ecode2 = 0 ; 04513 PyObject * obj0 = 0 ; 04514 PyObject * obj1 = 0 ; 04515 04516 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail; 04517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04518 if (!SWIG_IsOK(res1)) { 04519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04520 } 04521 arg1 = (PLGraphicsIn *)(argp1); 04522 ecode2 = SWIG_AsVal_int(obj1, &val2); 04523 if (!SWIG_IsOK(ecode2)) { 04524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'"); 04525 } 04526 arg2 = (int)(val2); 04527 if (arg1) (arg1)->pY = arg2; 04528 resultobj = SWIG_Py_Void(); 04529 return resultobj; 04530 fail: 04531 return NULL; 04532 } 04533 04534 04535 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04536 PyObject *resultobj = 0; 04537 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04538 void *argp1 = 0 ; 04539 int res1 = 0 ; 04540 PyObject * obj0 = 0 ; 04541 int result; 04542 04543 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail; 04544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04545 if (!SWIG_IsOK(res1)) { 04546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04547 } 04548 arg1 = (PLGraphicsIn *)(argp1); 04549 result = (int) ((arg1)->pY); 04550 resultobj = SWIG_From_int((int)(result)); 04551 return resultobj; 04552 fail: 04553 return NULL; 04554 } 04555 04556 04557 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04558 PyObject *resultobj = 0; 04559 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04560 PLFLT arg2 ; 04561 void *argp1 = 0 ; 04562 int res1 = 0 ; 04563 double val2 ; 04564 int ecode2 = 0 ; 04565 PyObject * obj0 = 0 ; 04566 PyObject * obj1 = 0 ; 04567 04568 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail; 04569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04570 if (!SWIG_IsOK(res1)) { 04571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04572 } 04573 arg1 = (PLGraphicsIn *)(argp1); 04574 ecode2 = SWIG_AsVal_double(obj1, &val2); 04575 if (!SWIG_IsOK(ecode2)) { 04576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'"); 04577 } 04578 arg2 = (PLFLT)(val2); 04579 if (arg1) (arg1)->dX = arg2; 04580 resultobj = SWIG_Py_Void(); 04581 return resultobj; 04582 fail: 04583 return NULL; 04584 } 04585 04586 04587 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04588 PyObject *resultobj = 0; 04589 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04590 void *argp1 = 0 ; 04591 int res1 = 0 ; 04592 PyObject * obj0 = 0 ; 04593 PLFLT result; 04594 04595 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail; 04596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04597 if (!SWIG_IsOK(res1)) { 04598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04599 } 04600 arg1 = (PLGraphicsIn *)(argp1); 04601 result = (PLFLT) ((arg1)->dX); 04602 resultobj = SWIG_From_double((double)(result)); 04603 return resultobj; 04604 fail: 04605 return NULL; 04606 } 04607 04608 04609 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04610 PyObject *resultobj = 0; 04611 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04612 PLFLT arg2 ; 04613 void *argp1 = 0 ; 04614 int res1 = 0 ; 04615 double val2 ; 04616 int ecode2 = 0 ; 04617 PyObject * obj0 = 0 ; 04618 PyObject * obj1 = 0 ; 04619 04620 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail; 04621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04622 if (!SWIG_IsOK(res1)) { 04623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04624 } 04625 arg1 = (PLGraphicsIn *)(argp1); 04626 ecode2 = SWIG_AsVal_double(obj1, &val2); 04627 if (!SWIG_IsOK(ecode2)) { 04628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'"); 04629 } 04630 arg2 = (PLFLT)(val2); 04631 if (arg1) (arg1)->dY = arg2; 04632 resultobj = SWIG_Py_Void(); 04633 return resultobj; 04634 fail: 04635 return NULL; 04636 } 04637 04638 04639 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04640 PyObject *resultobj = 0; 04641 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04642 void *argp1 = 0 ; 04643 int res1 = 0 ; 04644 PyObject * obj0 = 0 ; 04645 PLFLT result; 04646 04647 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail; 04648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04649 if (!SWIG_IsOK(res1)) { 04650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04651 } 04652 arg1 = (PLGraphicsIn *)(argp1); 04653 result = (PLFLT) ((arg1)->dY); 04654 resultobj = SWIG_From_double((double)(result)); 04655 return resultobj; 04656 fail: 04657 return NULL; 04658 } 04659 04660 04661 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04662 PyObject *resultobj = 0; 04663 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04664 PLFLT arg2 ; 04665 void *argp1 = 0 ; 04666 int res1 = 0 ; 04667 double val2 ; 04668 int ecode2 = 0 ; 04669 PyObject * obj0 = 0 ; 04670 PyObject * obj1 = 0 ; 04671 04672 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail; 04673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04674 if (!SWIG_IsOK(res1)) { 04675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04676 } 04677 arg1 = (PLGraphicsIn *)(argp1); 04678 ecode2 = SWIG_AsVal_double(obj1, &val2); 04679 if (!SWIG_IsOK(ecode2)) { 04680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'"); 04681 } 04682 arg2 = (PLFLT)(val2); 04683 if (arg1) (arg1)->wX = arg2; 04684 resultobj = SWIG_Py_Void(); 04685 return resultobj; 04686 fail: 04687 return NULL; 04688 } 04689 04690 04691 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04692 PyObject *resultobj = 0; 04693 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04694 void *argp1 = 0 ; 04695 int res1 = 0 ; 04696 PyObject * obj0 = 0 ; 04697 PLFLT result; 04698 04699 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail; 04700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04701 if (!SWIG_IsOK(res1)) { 04702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04703 } 04704 arg1 = (PLGraphicsIn *)(argp1); 04705 result = (PLFLT) ((arg1)->wX); 04706 resultobj = SWIG_From_double((double)(result)); 04707 return resultobj; 04708 fail: 04709 return NULL; 04710 } 04711 04712 04713 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04714 PyObject *resultobj = 0; 04715 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04716 PLFLT arg2 ; 04717 void *argp1 = 0 ; 04718 int res1 = 0 ; 04719 double val2 ; 04720 int ecode2 = 0 ; 04721 PyObject * obj0 = 0 ; 04722 PyObject * obj1 = 0 ; 04723 04724 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail; 04725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04726 if (!SWIG_IsOK(res1)) { 04727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04728 } 04729 arg1 = (PLGraphicsIn *)(argp1); 04730 ecode2 = SWIG_AsVal_double(obj1, &val2); 04731 if (!SWIG_IsOK(ecode2)) { 04732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'"); 04733 } 04734 arg2 = (PLFLT)(val2); 04735 if (arg1) (arg1)->wY = arg2; 04736 resultobj = SWIG_Py_Void(); 04737 return resultobj; 04738 fail: 04739 return NULL; 04740 } 04741 04742 04743 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04744 PyObject *resultobj = 0; 04745 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04746 void *argp1 = 0 ; 04747 int res1 = 0 ; 04748 PyObject * obj0 = 0 ; 04749 PLFLT result; 04750 04751 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail; 04752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 04753 if (!SWIG_IsOK(res1)) { 04754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04755 } 04756 arg1 = (PLGraphicsIn *)(argp1); 04757 result = (PLFLT) ((arg1)->wY); 04758 resultobj = SWIG_From_double((double)(result)); 04759 return resultobj; 04760 fail: 04761 return NULL; 04762 } 04763 04764 04765 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04766 PyObject *resultobj = 0; 04767 PLGraphicsIn *result = 0 ; 04768 04769 if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail; 04770 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn)); 04771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW | 0 ); 04772 return resultobj; 04773 fail: 04774 return NULL; 04775 } 04776 04777 04778 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04779 PyObject *resultobj = 0; 04780 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 04781 void *argp1 = 0 ; 04782 int res1 = 0 ; 04783 PyObject * obj0 = 0 ; 04784 04785 if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail; 04786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 ); 04787 if (!SWIG_IsOK(res1)) { 04788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 04789 } 04790 arg1 = (PLGraphicsIn *)(argp1); 04791 free((char *) arg1); 04792 resultobj = SWIG_Py_Void(); 04793 return resultobj; 04794 fail: 04795 return NULL; 04796 } 04797 04798 04799 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04800 PyObject *obj; 04801 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 04802 SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj)); 04803 return SWIG_Py_Void(); 04804 } 04805 04806 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04807 PyObject *resultobj = 0; 04808 PLINT arg1 ; 04809 int val1 ; 04810 int ecode1 = 0 ; 04811 PyObject * obj0 = 0 ; 04812 04813 if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail; 04814 ecode1 = SWIG_AsVal_int(obj0, &val1); 04815 if (!SWIG_IsOK(ecode1)) { 04816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'"); 04817 } 04818 arg1 = (PLINT)(val1); 04819 plsxwin(arg1); 04820 resultobj = SWIG_Py_Void(); 04821 return resultobj; 04822 fail: 04823 return NULL; 04824 } 04825 04826 04827 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04828 PyObject *resultobj = 0; 04829 PLINT arg1 ; 04830 PLINT arg2 ; 04831 int val1 ; 04832 int ecode1 = 0 ; 04833 int val2 ; 04834 int ecode2 = 0 ; 04835 PyObject * obj0 = 0 ; 04836 PyObject * obj1 = 0 ; 04837 04838 if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail; 04839 ecode1 = SWIG_AsVal_int(obj0, &val1); 04840 if (!SWIG_IsOK(ecode1)) { 04841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'"); 04842 } 04843 arg1 = (PLINT)(val1); 04844 ecode2 = SWIG_AsVal_int(obj1, &val2); 04845 if (!SWIG_IsOK(ecode2)) { 04846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'"); 04847 } 04848 arg2 = (PLINT)(val2); 04849 pl_setcontlabelformat(arg1,arg2); 04850 resultobj = SWIG_Py_Void(); 04851 return resultobj; 04852 fail: 04853 return NULL; 04854 } 04855 04856 04857 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04858 PyObject *resultobj = 0; 04859 PLFLT arg1 ; 04860 PLFLT arg2 ; 04861 PLFLT arg3 ; 04862 PLINT arg4 ; 04863 double val1 ; 04864 int ecode1 = 0 ; 04865 double val2 ; 04866 int ecode2 = 0 ; 04867 double val3 ; 04868 int ecode3 = 0 ; 04869 int val4 ; 04870 int ecode4 = 0 ; 04871 PyObject * obj0 = 0 ; 04872 PyObject * obj1 = 0 ; 04873 PyObject * obj2 = 0 ; 04874 PyObject * obj3 = 0 ; 04875 04876 if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 04877 ecode1 = SWIG_AsVal_double(obj0, &val1); 04878 if (!SWIG_IsOK(ecode1)) { 04879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'"); 04880 } 04881 arg1 = (PLFLT)(val1); 04882 ecode2 = SWIG_AsVal_double(obj1, &val2); 04883 if (!SWIG_IsOK(ecode2)) { 04884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'"); 04885 } 04886 arg2 = (PLFLT)(val2); 04887 ecode3 = SWIG_AsVal_double(obj2, &val3); 04888 if (!SWIG_IsOK(ecode3)) { 04889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'"); 04890 } 04891 arg3 = (PLFLT)(val3); 04892 ecode4 = SWIG_AsVal_int(obj3, &val4); 04893 if (!SWIG_IsOK(ecode4)) { 04894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'"); 04895 } 04896 arg4 = (PLINT)(val4); 04897 pl_setcontlabelparam(arg1,arg2,arg3,arg4); 04898 resultobj = SWIG_Py_Void(); 04899 return resultobj; 04900 fail: 04901 return NULL; 04902 } 04903 04904 04905 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04906 PyObject *resultobj = 0; 04907 PLINT arg1 ; 04908 int val1 ; 04909 int ecode1 = 0 ; 04910 PyObject * obj0 = 0 ; 04911 04912 if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail; 04913 ecode1 = SWIG_AsVal_int(obj0, &val1); 04914 if (!SWIG_IsOK(ecode1)) { 04915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'"); 04916 } 04917 arg1 = (PLINT)(val1); 04918 pladv(arg1); 04919 resultobj = SWIG_Py_Void(); 04920 return resultobj; 04921 fail: 04922 return NULL; 04923 } 04924 04925 04926 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 04927 PyObject *resultobj = 0; 04928 PLFLT arg1 ; 04929 PLFLT arg2 ; 04930 PLFLT arg3 ; 04931 PLFLT arg4 ; 04932 PLFLT arg5 ; 04933 PLFLT arg6 ; 04934 PLFLT arg7 ; 04935 PLBOOL arg8 ; 04936 double val1 ; 04937 int ecode1 = 0 ; 04938 double val2 ; 04939 int ecode2 = 0 ; 04940 double val3 ; 04941 int ecode3 = 0 ; 04942 double val4 ; 04943 int ecode4 = 0 ; 04944 double val5 ; 04945 int ecode5 = 0 ; 04946 double val6 ; 04947 int ecode6 = 0 ; 04948 double val7 ; 04949 int ecode7 = 0 ; 04950 int val8 ; 04951 int ecode8 = 0 ; 04952 PyObject * obj0 = 0 ; 04953 PyObject * obj1 = 0 ; 04954 PyObject * obj2 = 0 ; 04955 PyObject * obj3 = 0 ; 04956 PyObject * obj4 = 0 ; 04957 PyObject * obj5 = 0 ; 04958 PyObject * obj6 = 0 ; 04959 PyObject * obj7 = 0 ; 04960 04961 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; 04962 ecode1 = SWIG_AsVal_double(obj0, &val1); 04963 if (!SWIG_IsOK(ecode1)) { 04964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'"); 04965 } 04966 arg1 = (PLFLT)(val1); 04967 ecode2 = SWIG_AsVal_double(obj1, &val2); 04968 if (!SWIG_IsOK(ecode2)) { 04969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'"); 04970 } 04971 arg2 = (PLFLT)(val2); 04972 ecode3 = SWIG_AsVal_double(obj2, &val3); 04973 if (!SWIG_IsOK(ecode3)) { 04974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'"); 04975 } 04976 arg3 = (PLFLT)(val3); 04977 ecode4 = SWIG_AsVal_double(obj3, &val4); 04978 if (!SWIG_IsOK(ecode4)) { 04979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'"); 04980 } 04981 arg4 = (PLFLT)(val4); 04982 ecode5 = SWIG_AsVal_double(obj4, &val5); 04983 if (!SWIG_IsOK(ecode5)) { 04984 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'"); 04985 } 04986 arg5 = (PLFLT)(val5); 04987 ecode6 = SWIG_AsVal_double(obj5, &val6); 04988 if (!SWIG_IsOK(ecode6)) { 04989 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'"); 04990 } 04991 arg6 = (PLFLT)(val6); 04992 ecode7 = SWIG_AsVal_double(obj6, &val7); 04993 if (!SWIG_IsOK(ecode7)) { 04994 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'"); 04995 } 04996 arg7 = (PLFLT)(val7); 04997 ecode8 = SWIG_AsVal_int(obj7, &val8); 04998 if (!SWIG_IsOK(ecode8)) { 04999 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'"); 05000 } 05001 arg8 = (PLBOOL)(val8); 05002 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); 05003 resultobj = SWIG_Py_Void(); 05004 return resultobj; 05005 fail: 05006 return NULL; 05007 } 05008 05009 05010 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05011 PyObject *resultobj = 0; 05012 PLFLT arg1 ; 05013 PLFLT arg2 ; 05014 char *arg3 = (char *) 0 ; 05015 PLFLT arg4 ; 05016 PLINT arg5 ; 05017 char *arg6 = (char *) 0 ; 05018 PLFLT arg7 ; 05019 PLINT arg8 ; 05020 double val1 ; 05021 int ecode1 = 0 ; 05022 double val2 ; 05023 int ecode2 = 0 ; 05024 int res3 ; 05025 char *buf3 = 0 ; 05026 int alloc3 = 0 ; 05027 double val4 ; 05028 int ecode4 = 0 ; 05029 int val5 ; 05030 int ecode5 = 0 ; 05031 int res6 ; 05032 char *buf6 = 0 ; 05033 int alloc6 = 0 ; 05034 double val7 ; 05035 int ecode7 = 0 ; 05036 int val8 ; 05037 int ecode8 = 0 ; 05038 PyObject * obj0 = 0 ; 05039 PyObject * obj1 = 0 ; 05040 PyObject * obj2 = 0 ; 05041 PyObject * obj3 = 0 ; 05042 PyObject * obj4 = 0 ; 05043 PyObject * obj5 = 0 ; 05044 PyObject * obj6 = 0 ; 05045 PyObject * obj7 = 0 ; 05046 05047 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; 05048 ecode1 = SWIG_AsVal_double(obj0, &val1); 05049 if (!SWIG_IsOK(ecode1)) { 05050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'"); 05051 } 05052 arg1 = (PLFLT)(val1); 05053 ecode2 = SWIG_AsVal_double(obj1, &val2); 05054 if (!SWIG_IsOK(ecode2)) { 05055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'"); 05056 } 05057 arg2 = (PLFLT)(val2); 05058 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); 05059 if (!SWIG_IsOK(res3)) { 05060 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'"); 05061 } 05062 arg3 = (char *)(buf3); 05063 ecode4 = SWIG_AsVal_double(obj3, &val4); 05064 if (!SWIG_IsOK(ecode4)) { 05065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'"); 05066 } 05067 arg4 = (PLFLT)(val4); 05068 ecode5 = SWIG_AsVal_int(obj4, &val5); 05069 if (!SWIG_IsOK(ecode5)) { 05070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'"); 05071 } 05072 arg5 = (PLINT)(val5); 05073 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6); 05074 if (!SWIG_IsOK(res6)) { 05075 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'"); 05076 } 05077 arg6 = (char *)(buf6); 05078 ecode7 = SWIG_AsVal_double(obj6, &val7); 05079 if (!SWIG_IsOK(ecode7)) { 05080 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'"); 05081 } 05082 arg7 = (PLFLT)(val7); 05083 ecode8 = SWIG_AsVal_int(obj7, &val8); 05084 if (!SWIG_IsOK(ecode8)) { 05085 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'"); 05086 } 05087 arg8 = (PLINT)(val8); 05088 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8); 05089 resultobj = SWIG_Py_Void(); 05090 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 05091 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 05092 return resultobj; 05093 fail: 05094 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 05095 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 05096 return NULL; 05097 } 05098 05099 05100 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05101 PyObject *resultobj = 0; 05102 PLINT arg1 ; 05103 PLFLT *arg2 = (PLFLT *) 0 ; 05104 PLFLT *arg3 = (PLFLT *) 0 ; 05105 PLINT arg4 ; 05106 PyArrayObject *tmp1 = NULL ; 05107 PyArrayObject *tmp3 = NULL ; 05108 int val4 ; 05109 int ecode4 = 0 ; 05110 PyObject * obj0 = 0 ; 05111 PyObject * obj1 = 0 ; 05112 PyObject * obj2 = 0 ; 05113 05114 if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail; 05115 { 05116 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 05117 if ( tmp1 == NULL ) 05118 return NULL; 05119 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 05120 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 05121 } 05122 { 05123 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 05124 if ( tmp3 == NULL ) 05125 return NULL; 05126 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 05127 { 05128 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 05129 return NULL; 05130 } 05131 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 05132 } 05133 ecode4 = SWIG_AsVal_int(obj2, &val4); 05134 if (!SWIG_IsOK(ecode4)) { 05135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'"); 05136 } 05137 arg4 = (PLINT)(val4); 05138 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4); 05139 resultobj = SWIG_Py_Void(); 05140 { 05141 Py_CLEAR( tmp1 ); 05142 } 05143 { 05144 Py_CLEAR( tmp3 ); 05145 } 05146 return resultobj; 05147 fail: 05148 { 05149 Py_CLEAR( tmp1 ); 05150 } 05151 { 05152 Py_CLEAR( tmp3 ); 05153 } 05154 return NULL; 05155 } 05156 05157 05158 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05159 PyObject *resultobj = 0; 05160 PLINT *arg1 = (PLINT *) 0 ; 05161 PLINT *arg2 = (PLINT *) 0 ; 05162 PLINT *arg3 = (PLINT *) 0 ; 05163 PLINT *arg4 = (PLINT *) 0 ; 05164 PLINT *arg5 = (PLINT *) 0 ; 05165 PLFLT *arg6 = (PLFLT *) 0 ; 05166 PLFLT arg7 ; 05167 PLINT temp1 ; 05168 int res1 = SWIG_TMPOBJ ; 05169 PLINT temp2 ; 05170 int res2 = SWIG_TMPOBJ ; 05171 PLINT temp3 ; 05172 int res3 = SWIG_TMPOBJ ; 05173 PLINT temp4 ; 05174 int res4 = SWIG_TMPOBJ ; 05175 PLINT temp5 ; 05176 int res5 = SWIG_TMPOBJ ; 05177 PLFLT temp6 ; 05178 int res6 = SWIG_TMPOBJ ; 05179 double val7 ; 05180 int ecode7 = 0 ; 05181 PyObject * obj0 = 0 ; 05182 05183 arg1 = &temp1; 05184 arg2 = &temp2; 05185 arg3 = &temp3; 05186 arg4 = &temp4; 05187 arg5 = &temp5; 05188 arg6 = &temp6; 05189 if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail; 05190 ecode7 = SWIG_AsVal_double(obj0, &val7); 05191 if (!SWIG_IsOK(ecode7)) { 05192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'"); 05193 } 05194 arg7 = (PLFLT)(val7); 05195 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 05196 resultobj = SWIG_Py_Void(); 05197 if (SWIG_IsTmpObj(res1)) { 05198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 05199 } else { 05200 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 05202 } 05203 if (SWIG_IsTmpObj(res2)) { 05204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 05205 } else { 05206 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 05208 } 05209 if (SWIG_IsTmpObj(res3)) { 05210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 05211 } else { 05212 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 05214 } 05215 if (SWIG_IsTmpObj(res4)) { 05216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); 05217 } else { 05218 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags)); 05220 } 05221 if (SWIG_IsTmpObj(res5)) { 05222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5))); 05223 } else { 05224 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags)); 05226 } 05227 if (SWIG_IsTmpObj(res6)) { 05228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6))); 05229 } else { 05230 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags)); 05232 } 05233 return resultobj; 05234 fail: 05235 return NULL; 05236 } 05237 05238 05239 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05240 PyObject *resultobj = 0; 05241 05242 if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail; 05243 plbop(); 05244 resultobj = SWIG_Py_Void(); 05245 return resultobj; 05246 fail: 05247 return NULL; 05248 } 05249 05250 05251 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05252 PyObject *resultobj = 0; 05253 char *arg1 = (char *) 0 ; 05254 PLFLT arg2 ; 05255 PLINT arg3 ; 05256 char *arg4 = (char *) 0 ; 05257 PLFLT arg5 ; 05258 PLINT arg6 ; 05259 int res1 ; 05260 char *buf1 = 0 ; 05261 int alloc1 = 0 ; 05262 double val2 ; 05263 int ecode2 = 0 ; 05264 int val3 ; 05265 int ecode3 = 0 ; 05266 int res4 ; 05267 char *buf4 = 0 ; 05268 int alloc4 = 0 ; 05269 double val5 ; 05270 int ecode5 = 0 ; 05271 int val6 ; 05272 int ecode6 = 0 ; 05273 PyObject * obj0 = 0 ; 05274 PyObject * obj1 = 0 ; 05275 PyObject * obj2 = 0 ; 05276 PyObject * obj3 = 0 ; 05277 PyObject * obj4 = 0 ; 05278 PyObject * obj5 = 0 ; 05279 05280 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 05281 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 05282 if (!SWIG_IsOK(res1)) { 05283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'"); 05284 } 05285 arg1 = (char *)(buf1); 05286 ecode2 = SWIG_AsVal_double(obj1, &val2); 05287 if (!SWIG_IsOK(ecode2)) { 05288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'"); 05289 } 05290 arg2 = (PLFLT)(val2); 05291 ecode3 = SWIG_AsVal_int(obj2, &val3); 05292 if (!SWIG_IsOK(ecode3)) { 05293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'"); 05294 } 05295 arg3 = (PLINT)(val3); 05296 res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); 05297 if (!SWIG_IsOK(res4)) { 05298 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'"); 05299 } 05300 arg4 = (char *)(buf4); 05301 ecode5 = SWIG_AsVal_double(obj4, &val5); 05302 if (!SWIG_IsOK(ecode5)) { 05303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'"); 05304 } 05305 arg5 = (PLFLT)(val5); 05306 ecode6 = SWIG_AsVal_int(obj5, &val6); 05307 if (!SWIG_IsOK(ecode6)) { 05308 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'"); 05309 } 05310 arg6 = (PLINT)(val6); 05311 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6); 05312 resultobj = SWIG_Py_Void(); 05313 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 05314 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 05315 return resultobj; 05316 fail: 05317 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 05318 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 05319 return NULL; 05320 } 05321 05322 05323 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05324 PyObject *resultobj = 0; 05325 char *arg1 = (char *) 0 ; 05326 char *arg2 = (char *) 0 ; 05327 PLFLT arg3 ; 05328 PLINT arg4 ; 05329 char *arg5 = (char *) 0 ; 05330 char *arg6 = (char *) 0 ; 05331 PLFLT arg7 ; 05332 PLINT arg8 ; 05333 char *arg9 = (char *) 0 ; 05334 char *arg10 = (char *) 0 ; 05335 PLFLT arg11 ; 05336 PLINT arg12 ; 05337 int res1 ; 05338 char *buf1 = 0 ; 05339 int alloc1 = 0 ; 05340 int res2 ; 05341 char *buf2 = 0 ; 05342 int alloc2 = 0 ; 05343 double val3 ; 05344 int ecode3 = 0 ; 05345 int val4 ; 05346 int ecode4 = 0 ; 05347 int res5 ; 05348 char *buf5 = 0 ; 05349 int alloc5 = 0 ; 05350 int res6 ; 05351 char *buf6 = 0 ; 05352 int alloc6 = 0 ; 05353 double val7 ; 05354 int ecode7 = 0 ; 05355 int val8 ; 05356 int ecode8 = 0 ; 05357 int res9 ; 05358 char *buf9 = 0 ; 05359 int alloc9 = 0 ; 05360 int res10 ; 05361 char *buf10 = 0 ; 05362 int alloc10 = 0 ; 05363 double val11 ; 05364 int ecode11 = 0 ; 05365 int val12 ; 05366 int ecode12 = 0 ; 05367 PyObject * obj0 = 0 ; 05368 PyObject * obj1 = 0 ; 05369 PyObject * obj2 = 0 ; 05370 PyObject * obj3 = 0 ; 05371 PyObject * obj4 = 0 ; 05372 PyObject * obj5 = 0 ; 05373 PyObject * obj6 = 0 ; 05374 PyObject * obj7 = 0 ; 05375 PyObject * obj8 = 0 ; 05376 PyObject * obj9 = 0 ; 05377 PyObject * obj10 = 0 ; 05378 PyObject * obj11 = 0 ; 05379 05380 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail; 05381 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 05382 if (!SWIG_IsOK(res1)) { 05383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'"); 05384 } 05385 arg1 = (char *)(buf1); 05386 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 05387 if (!SWIG_IsOK(res2)) { 05388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'"); 05389 } 05390 arg2 = (char *)(buf2); 05391 ecode3 = SWIG_AsVal_double(obj2, &val3); 05392 if (!SWIG_IsOK(ecode3)) { 05393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'"); 05394 } 05395 arg3 = (PLFLT)(val3); 05396 ecode4 = SWIG_AsVal_int(obj3, &val4); 05397 if (!SWIG_IsOK(ecode4)) { 05398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'"); 05399 } 05400 arg4 = (PLINT)(val4); 05401 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); 05402 if (!SWIG_IsOK(res5)) { 05403 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'"); 05404 } 05405 arg5 = (char *)(buf5); 05406 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6); 05407 if (!SWIG_IsOK(res6)) { 05408 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'"); 05409 } 05410 arg6 = (char *)(buf6); 05411 ecode7 = SWIG_AsVal_double(obj6, &val7); 05412 if (!SWIG_IsOK(ecode7)) { 05413 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'"); 05414 } 05415 arg7 = (PLFLT)(val7); 05416 ecode8 = SWIG_AsVal_int(obj7, &val8); 05417 if (!SWIG_IsOK(ecode8)) { 05418 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'"); 05419 } 05420 arg8 = (PLINT)(val8); 05421 res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9); 05422 if (!SWIG_IsOK(res9)) { 05423 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'"); 05424 } 05425 arg9 = (char *)(buf9); 05426 res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10); 05427 if (!SWIG_IsOK(res10)) { 05428 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'"); 05429 } 05430 arg10 = (char *)(buf10); 05431 ecode11 = SWIG_AsVal_double(obj10, &val11); 05432 if (!SWIG_IsOK(ecode11)) { 05433 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'"); 05434 } 05435 arg11 = (PLFLT)(val11); 05436 ecode12 = SWIG_AsVal_int(obj11, &val12); 05437 if (!SWIG_IsOK(ecode12)) { 05438 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'"); 05439 } 05440 arg12 = (PLINT)(val12); 05441 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); 05442 resultobj = SWIG_Py_Void(); 05443 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 05444 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 05445 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 05446 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 05447 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9); 05448 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10); 05449 return resultobj; 05450 fail: 05451 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 05452 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 05453 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 05454 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 05455 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9); 05456 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10); 05457 return NULL; 05458 } 05459 05460 05461 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05462 PyObject *resultobj = 0; 05463 PLFLT arg1 ; 05464 PLFLT arg2 ; 05465 PLFLT *arg3 = (PLFLT *) 0 ; 05466 PLFLT *arg4 = (PLFLT *) 0 ; 05467 PLINT *arg5 = (PLINT *) 0 ; 05468 double val1 ; 05469 int ecode1 = 0 ; 05470 double val2 ; 05471 int ecode2 = 0 ; 05472 PLFLT temp3 ; 05473 int res3 = SWIG_TMPOBJ ; 05474 PLFLT temp4 ; 05475 int res4 = SWIG_TMPOBJ ; 05476 PLINT temp5 ; 05477 int res5 = SWIG_TMPOBJ ; 05478 PyObject * obj0 = 0 ; 05479 PyObject * obj1 = 0 ; 05480 05481 arg3 = &temp3; 05482 arg4 = &temp4; 05483 arg5 = &temp5; 05484 if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail; 05485 ecode1 = SWIG_AsVal_double(obj0, &val1); 05486 if (!SWIG_IsOK(ecode1)) { 05487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'"); 05488 } 05489 arg1 = (PLFLT)(val1); 05490 ecode2 = SWIG_AsVal_double(obj1, &val2); 05491 if (!SWIG_IsOK(ecode2)) { 05492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'"); 05493 } 05494 arg2 = (PLFLT)(val2); 05495 plcalc_world(arg1,arg2,arg3,arg4,arg5); 05496 resultobj = SWIG_Py_Void(); 05497 if (SWIG_IsTmpObj(res3)) { 05498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 05499 } else { 05500 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 05502 } 05503 if (SWIG_IsTmpObj(res4)) { 05504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 05505 } else { 05506 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 05508 } 05509 if (SWIG_IsTmpObj(res5)) { 05510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5))); 05511 } else { 05512 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags)); 05514 } 05515 return resultobj; 05516 fail: 05517 return NULL; 05518 } 05519 05520 05521 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05522 PyObject *resultobj = 0; 05523 05524 if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail; 05525 plclear(); 05526 resultobj = SWIG_Py_Void(); 05527 return resultobj; 05528 fail: 05529 return NULL; 05530 } 05531 05532 05533 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05534 PyObject *resultobj = 0; 05535 PLINT arg1 ; 05536 int val1 ; 05537 int ecode1 = 0 ; 05538 PyObject * obj0 = 0 ; 05539 05540 if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail; 05541 ecode1 = SWIG_AsVal_int(obj0, &val1); 05542 if (!SWIG_IsOK(ecode1)) { 05543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'"); 05544 } 05545 arg1 = (PLINT)(val1); 05546 plcol0(arg1); 05547 resultobj = SWIG_Py_Void(); 05548 return resultobj; 05549 fail: 05550 return NULL; 05551 } 05552 05553 05554 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05555 PyObject *resultobj = 0; 05556 PLFLT arg1 ; 05557 double val1 ; 05558 int ecode1 = 0 ; 05559 PyObject * obj0 = 0 ; 05560 05561 if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail; 05562 ecode1 = SWIG_AsVal_double(obj0, &val1); 05563 if (!SWIG_IsOK(ecode1)) { 05564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'"); 05565 } 05566 arg1 = (PLFLT)(val1); 05567 plcol1(arg1); 05568 resultobj = SWIG_Py_Void(); 05569 return resultobj; 05570 fail: 05571 return NULL; 05572 } 05573 05574 05575 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05576 PyObject *resultobj = 0; 05577 PLFLT arg1 ; 05578 PLFLT arg2 ; 05579 PLFLT arg3 ; 05580 PLINT arg4 ; 05581 PLBOOL arg5 ; 05582 PLINT arg6 ; 05583 PLINT arg7 ; 05584 PLINT arg8 ; 05585 PLINT arg9 ; 05586 PLINT arg10 ; 05587 PLFLT arg11 ; 05588 double val1 ; 05589 int ecode1 = 0 ; 05590 double val2 ; 05591 int ecode2 = 0 ; 05592 double val3 ; 05593 int ecode3 = 0 ; 05594 int val4 ; 05595 int ecode4 = 0 ; 05596 int val5 ; 05597 int ecode5 = 0 ; 05598 int val6 ; 05599 int ecode6 = 0 ; 05600 int val7 ; 05601 int ecode7 = 0 ; 05602 int val8 ; 05603 int ecode8 = 0 ; 05604 int val9 ; 05605 int ecode9 = 0 ; 05606 int val10 ; 05607 int ecode10 = 0 ; 05608 double val11 ; 05609 int ecode11 = 0 ; 05610 PyObject * obj0 = 0 ; 05611 PyObject * obj1 = 0 ; 05612 PyObject * obj2 = 0 ; 05613 PyObject * obj3 = 0 ; 05614 PyObject * obj4 = 0 ; 05615 PyObject * obj5 = 0 ; 05616 PyObject * obj6 = 0 ; 05617 PyObject * obj7 = 0 ; 05618 PyObject * obj8 = 0 ; 05619 PyObject * obj9 = 0 ; 05620 PyObject * obj10 = 0 ; 05621 05622 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; 05623 ecode1 = SWIG_AsVal_double(obj0, &val1); 05624 if (!SWIG_IsOK(ecode1)) { 05625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'"); 05626 } 05627 arg1 = (PLFLT)(val1); 05628 ecode2 = SWIG_AsVal_double(obj1, &val2); 05629 if (!SWIG_IsOK(ecode2)) { 05630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'"); 05631 } 05632 arg2 = (PLFLT)(val2); 05633 ecode3 = SWIG_AsVal_double(obj2, &val3); 05634 if (!SWIG_IsOK(ecode3)) { 05635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'"); 05636 } 05637 arg3 = (PLFLT)(val3); 05638 ecode4 = SWIG_AsVal_int(obj3, &val4); 05639 if (!SWIG_IsOK(ecode4)) { 05640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'"); 05641 } 05642 arg4 = (PLINT)(val4); 05643 ecode5 = SWIG_AsVal_int(obj4, &val5); 05644 if (!SWIG_IsOK(ecode5)) { 05645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'"); 05646 } 05647 arg5 = (PLBOOL)(val5); 05648 ecode6 = SWIG_AsVal_int(obj5, &val6); 05649 if (!SWIG_IsOK(ecode6)) { 05650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'"); 05651 } 05652 arg6 = (PLINT)(val6); 05653 ecode7 = SWIG_AsVal_int(obj6, &val7); 05654 if (!SWIG_IsOK(ecode7)) { 05655 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'"); 05656 } 05657 arg7 = (PLINT)(val7); 05658 ecode8 = SWIG_AsVal_int(obj7, &val8); 05659 if (!SWIG_IsOK(ecode8)) { 05660 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'"); 05661 } 05662 arg8 = (PLINT)(val8); 05663 ecode9 = SWIG_AsVal_int(obj8, &val9); 05664 if (!SWIG_IsOK(ecode9)) { 05665 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'"); 05666 } 05667 arg9 = (PLINT)(val9); 05668 ecode10 = SWIG_AsVal_int(obj9, &val10); 05669 if (!SWIG_IsOK(ecode10)) { 05670 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'"); 05671 } 05672 arg10 = (PLINT)(val10); 05673 ecode11 = SWIG_AsVal_double(obj10, &val11); 05674 if (!SWIG_IsOK(ecode11)) { 05675 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'"); 05676 } 05677 arg11 = (PLFLT)(val11); 05678 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); 05679 resultobj = SWIG_Py_Void(); 05680 return resultobj; 05681 fail: 05682 return NULL; 05683 } 05684 05685 05686 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05687 PyObject *resultobj = 0; 05688 PLFLT **arg1 = (PLFLT **) 0 ; 05689 PLINT arg2 ; 05690 PLINT arg3 ; 05691 PLINT arg4 ; 05692 PLINT arg5 ; 05693 PLINT arg6 ; 05694 PLINT arg7 ; 05695 PLFLT *arg8 = (PLFLT *) 0 ; 05696 PLINT arg9 ; 05697 pltr_func arg10 = (pltr_func) 0 ; 05698 PLPointer arg11 = (PLPointer) 0 ; 05699 PyArrayObject *tmp1 = NULL ; 05700 int val4 ; 05701 int ecode4 = 0 ; 05702 int val5 ; 05703 int ecode5 = 0 ; 05704 int val6 ; 05705 int ecode6 = 0 ; 05706 int val7 ; 05707 int ecode7 = 0 ; 05708 PyArrayObject *tmp8 = NULL ; 05709 PyObject * obj0 = 0 ; 05710 PyObject * obj1 = 0 ; 05711 PyObject * obj2 = 0 ; 05712 PyObject * obj3 = 0 ; 05713 PyObject * obj4 = 0 ; 05714 PyObject * obj5 = 0 ; 05715 PyObject * obj6 = 0 ; 05716 PyObject * obj7 = 0 ; 05717 05718 { 05719 python_pltr = 0; 05720 arg10 = NULL; 05721 } 05722 { 05723 arg11 = NULL; 05724 } 05725 if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; 05726 { 05727 int i, size; 05728 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 05729 if ( tmp1 == NULL ) 05730 return NULL; 05731 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 05732 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 05733 size = arg3; 05734 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 05735 for ( i = 0; i < arg2; i++ ) 05736 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 05737 } 05738 ecode4 = SWIG_AsVal_int(obj1, &val4); 05739 if (!SWIG_IsOK(ecode4)) { 05740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'"); 05741 } 05742 arg4 = (PLINT)(val4); 05743 ecode5 = SWIG_AsVal_int(obj2, &val5); 05744 if (!SWIG_IsOK(ecode5)) { 05745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'"); 05746 } 05747 arg5 = (PLINT)(val5); 05748 ecode6 = SWIG_AsVal_int(obj3, &val6); 05749 if (!SWIG_IsOK(ecode6)) { 05750 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'"); 05751 } 05752 arg6 = (PLINT)(val6); 05753 ecode7 = SWIG_AsVal_int(obj4, &val7); 05754 if (!SWIG_IsOK(ecode7)) { 05755 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'"); 05756 } 05757 arg7 = (PLINT)(val7); 05758 { 05759 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 ); 05760 if ( tmp8 == NULL ) 05761 return NULL; 05762 arg9 = PyArray_DIMS( tmp8 )[0]; 05763 arg8 = (PLFLT *) PyArray_DATA( tmp8 ); 05764 } 05765 if (obj6) { 05766 { 05767 // it must be a callable or None 05768 if ( obj6 == Py_None ) 05769 { 05770 arg10 = NULL; 05771 } 05772 else 05773 { 05774 if ( !PyCallable_Check( (PyObject *) obj6 ) ) 05775 { 05776 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" ); 05777 return NULL; 05778 } 05779 arg10 = marshal_pltr( obj6 ); 05780 } 05781 } 05782 } 05783 if (obj7) { 05784 { 05785 if ( obj7 == Py_None ) 05786 arg11 = NULL; 05787 else 05788 { 05789 arg11 = marshal_PLPointer( obj7, 0 ); 05790 } 05791 } 05792 } 05793 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11); 05794 resultobj = SWIG_Py_Void(); 05795 { 05796 Py_CLEAR( tmp1 ); 05797 free( arg1 ); 05798 } 05799 { 05800 Py_CLEAR( tmp8 ); 05801 } 05802 { 05803 cleanup_pltr(); 05804 } 05805 { 05806 cleanup_PLPointer(); 05807 } 05808 return resultobj; 05809 fail: 05810 { 05811 Py_CLEAR( tmp1 ); 05812 free( arg1 ); 05813 } 05814 { 05815 Py_CLEAR( tmp8 ); 05816 } 05817 { 05818 cleanup_pltr(); 05819 } 05820 { 05821 cleanup_PLPointer(); 05822 } 05823 return NULL; 05824 } 05825 05826 05827 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05828 PyObject *resultobj = 0; 05829 PLINT arg1 ; 05830 PLINT arg2 ; 05831 PLINT arg3 ; 05832 PLINT arg4 ; 05833 PLINT arg5 ; 05834 PLFLT arg6 ; 05835 PLFLT *arg7 = (PLFLT *) 0 ; 05836 int val1 ; 05837 int ecode1 = 0 ; 05838 int val2 ; 05839 int ecode2 = 0 ; 05840 int val3 ; 05841 int ecode3 = 0 ; 05842 int val4 ; 05843 int ecode4 = 0 ; 05844 int val5 ; 05845 int ecode5 = 0 ; 05846 double val6 ; 05847 int ecode6 = 0 ; 05848 PLFLT temp7 ; 05849 int res7 = SWIG_TMPOBJ ; 05850 PyObject * obj0 = 0 ; 05851 PyObject * obj1 = 0 ; 05852 PyObject * obj2 = 0 ; 05853 PyObject * obj3 = 0 ; 05854 PyObject * obj4 = 0 ; 05855 PyObject * obj5 = 0 ; 05856 05857 arg7 = &temp7; 05858 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 05859 ecode1 = SWIG_AsVal_int(obj0, &val1); 05860 if (!SWIG_IsOK(ecode1)) { 05861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'"); 05862 } 05863 arg1 = (PLINT)(val1); 05864 ecode2 = SWIG_AsVal_int(obj1, &val2); 05865 if (!SWIG_IsOK(ecode2)) { 05866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'"); 05867 } 05868 arg2 = (PLINT)(val2); 05869 ecode3 = SWIG_AsVal_int(obj2, &val3); 05870 if (!SWIG_IsOK(ecode3)) { 05871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'"); 05872 } 05873 arg3 = (PLINT)(val3); 05874 ecode4 = SWIG_AsVal_int(obj3, &val4); 05875 if (!SWIG_IsOK(ecode4)) { 05876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'"); 05877 } 05878 arg4 = (PLINT)(val4); 05879 ecode5 = SWIG_AsVal_int(obj4, &val5); 05880 if (!SWIG_IsOK(ecode5)) { 05881 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'"); 05882 } 05883 arg5 = (PLINT)(val5); 05884 ecode6 = SWIG_AsVal_double(obj5, &val6); 05885 if (!SWIG_IsOK(ecode6)) { 05886 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'"); 05887 } 05888 arg6 = (PLFLT)(val6); 05889 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 05890 resultobj = SWIG_Py_Void(); 05891 if (SWIG_IsTmpObj(res7)) { 05892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7))); 05893 } else { 05894 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 05895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags)); 05896 } 05897 return resultobj; 05898 fail: 05899 return NULL; 05900 } 05901 05902 05903 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05904 PyObject *resultobj = 0; 05905 PLINT arg1 ; 05906 PLBOOL arg2 ; 05907 int val1 ; 05908 int ecode1 = 0 ; 05909 int val2 ; 05910 int ecode2 = 0 ; 05911 PyObject * obj0 = 0 ; 05912 PyObject * obj1 = 0 ; 05913 05914 if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail; 05915 ecode1 = SWIG_AsVal_int(obj0, &val1); 05916 if (!SWIG_IsOK(ecode1)) { 05917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'"); 05918 } 05919 arg1 = (PLINT)(val1); 05920 ecode2 = SWIG_AsVal_int(obj1, &val2); 05921 if (!SWIG_IsOK(ecode2)) { 05922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'"); 05923 } 05924 arg2 = (PLBOOL)(val2); 05925 plcpstrm(arg1,arg2); 05926 resultobj = SWIG_Py_Void(); 05927 return resultobj; 05928 fail: 05929 return NULL; 05930 } 05931 05932 05933 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05934 PyObject *resultobj = 0; 05935 05936 if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail; 05937 plend(); 05938 resultobj = SWIG_Py_Void(); 05939 return resultobj; 05940 fail: 05941 return NULL; 05942 } 05943 05944 05945 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05946 PyObject *resultobj = 0; 05947 05948 if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail; 05949 plend1(); 05950 resultobj = SWIG_Py_Void(); 05951 return resultobj; 05952 fail: 05953 return NULL; 05954 } 05955 05956 05957 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 05958 PyObject *resultobj = 0; 05959 PLFLT arg1 ; 05960 PLFLT arg2 ; 05961 PLFLT arg3 ; 05962 PLFLT arg4 ; 05963 PLINT arg5 ; 05964 PLINT arg6 ; 05965 double val1 ; 05966 int ecode1 = 0 ; 05967 double val2 ; 05968 int ecode2 = 0 ; 05969 double val3 ; 05970 int ecode3 = 0 ; 05971 double val4 ; 05972 int ecode4 = 0 ; 05973 int val5 ; 05974 int ecode5 = 0 ; 05975 int val6 ; 05976 int ecode6 = 0 ; 05977 PyObject * obj0 = 0 ; 05978 PyObject * obj1 = 0 ; 05979 PyObject * obj2 = 0 ; 05980 PyObject * obj3 = 0 ; 05981 PyObject * obj4 = 0 ; 05982 PyObject * obj5 = 0 ; 05983 05984 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 05985 ecode1 = SWIG_AsVal_double(obj0, &val1); 05986 if (!SWIG_IsOK(ecode1)) { 05987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'"); 05988 } 05989 arg1 = (PLFLT)(val1); 05990 ecode2 = SWIG_AsVal_double(obj1, &val2); 05991 if (!SWIG_IsOK(ecode2)) { 05992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'"); 05993 } 05994 arg2 = (PLFLT)(val2); 05995 ecode3 = SWIG_AsVal_double(obj2, &val3); 05996 if (!SWIG_IsOK(ecode3)) { 05997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'"); 05998 } 05999 arg3 = (PLFLT)(val3); 06000 ecode4 = SWIG_AsVal_double(obj3, &val4); 06001 if (!SWIG_IsOK(ecode4)) { 06002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'"); 06003 } 06004 arg4 = (PLFLT)(val4); 06005 ecode5 = SWIG_AsVal_int(obj4, &val5); 06006 if (!SWIG_IsOK(ecode5)) { 06007 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'"); 06008 } 06009 arg5 = (PLINT)(val5); 06010 ecode6 = SWIG_AsVal_int(obj5, &val6); 06011 if (!SWIG_IsOK(ecode6)) { 06012 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'"); 06013 } 06014 arg6 = (PLINT)(val6); 06015 plenv(arg1,arg2,arg3,arg4,arg5,arg6); 06016 resultobj = SWIG_Py_Void(); 06017 return resultobj; 06018 fail: 06019 return NULL; 06020 } 06021 06022 06023 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06024 PyObject *resultobj = 0; 06025 PLFLT arg1 ; 06026 PLFLT arg2 ; 06027 PLFLT arg3 ; 06028 PLFLT arg4 ; 06029 PLINT arg5 ; 06030 PLINT arg6 ; 06031 double val1 ; 06032 int ecode1 = 0 ; 06033 double val2 ; 06034 int ecode2 = 0 ; 06035 double val3 ; 06036 int ecode3 = 0 ; 06037 double val4 ; 06038 int ecode4 = 0 ; 06039 int val5 ; 06040 int ecode5 = 0 ; 06041 int val6 ; 06042 int ecode6 = 0 ; 06043 PyObject * obj0 = 0 ; 06044 PyObject * obj1 = 0 ; 06045 PyObject * obj2 = 0 ; 06046 PyObject * obj3 = 0 ; 06047 PyObject * obj4 = 0 ; 06048 PyObject * obj5 = 0 ; 06049 06050 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 06051 ecode1 = SWIG_AsVal_double(obj0, &val1); 06052 if (!SWIG_IsOK(ecode1)) { 06053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'"); 06054 } 06055 arg1 = (PLFLT)(val1); 06056 ecode2 = SWIG_AsVal_double(obj1, &val2); 06057 if (!SWIG_IsOK(ecode2)) { 06058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'"); 06059 } 06060 arg2 = (PLFLT)(val2); 06061 ecode3 = SWIG_AsVal_double(obj2, &val3); 06062 if (!SWIG_IsOK(ecode3)) { 06063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'"); 06064 } 06065 arg3 = (PLFLT)(val3); 06066 ecode4 = SWIG_AsVal_double(obj3, &val4); 06067 if (!SWIG_IsOK(ecode4)) { 06068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'"); 06069 } 06070 arg4 = (PLFLT)(val4); 06071 ecode5 = SWIG_AsVal_int(obj4, &val5); 06072 if (!SWIG_IsOK(ecode5)) { 06073 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'"); 06074 } 06075 arg5 = (PLINT)(val5); 06076 ecode6 = SWIG_AsVal_int(obj5, &val6); 06077 if (!SWIG_IsOK(ecode6)) { 06078 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'"); 06079 } 06080 arg6 = (PLINT)(val6); 06081 plenv0(arg1,arg2,arg3,arg4,arg5,arg6); 06082 resultobj = SWIG_Py_Void(); 06083 return resultobj; 06084 fail: 06085 return NULL; 06086 } 06087 06088 06089 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06090 PyObject *resultobj = 0; 06091 06092 if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail; 06093 pleop(); 06094 resultobj = SWIG_Py_Void(); 06095 return resultobj; 06096 fail: 06097 return NULL; 06098 } 06099 06100 06101 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06102 PyObject *resultobj = 0; 06103 PLINT arg1 ; 06104 PLFLT *arg2 = (PLFLT *) 0 ; 06105 PLFLT *arg3 = (PLFLT *) 0 ; 06106 PLFLT *arg4 = (PLFLT *) 0 ; 06107 PyArrayObject *tmp1 = NULL ; 06108 PyArrayObject *tmp3 = NULL ; 06109 PyArrayObject *tmp4 = NULL ; 06110 PyObject * obj0 = 0 ; 06111 PyObject * obj1 = 0 ; 06112 PyObject * obj2 = 0 ; 06113 06114 if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail; 06115 { 06116 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 06117 if ( tmp1 == NULL ) 06118 return NULL; 06119 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 06120 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 06121 } 06122 { 06123 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 06124 if ( tmp3 == NULL ) 06125 return NULL; 06126 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 06127 { 06128 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06129 return NULL; 06130 } 06131 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 06132 } 06133 { 06134 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 06135 if ( tmp4 == NULL ) 06136 return NULL; 06137 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 06138 { 06139 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06140 return NULL; 06141 } 06142 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 06143 } 06144 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4); 06145 resultobj = SWIG_Py_Void(); 06146 { 06147 Py_CLEAR( tmp1 ); 06148 } 06149 { 06150 Py_CLEAR( tmp3 ); 06151 } 06152 { 06153 Py_CLEAR( tmp4 ); 06154 } 06155 return resultobj; 06156 fail: 06157 { 06158 Py_CLEAR( tmp1 ); 06159 } 06160 { 06161 Py_CLEAR( tmp3 ); 06162 } 06163 { 06164 Py_CLEAR( tmp4 ); 06165 } 06166 return NULL; 06167 } 06168 06169 06170 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06171 PyObject *resultobj = 0; 06172 PLINT arg1 ; 06173 PLFLT *arg2 = (PLFLT *) 0 ; 06174 PLFLT *arg3 = (PLFLT *) 0 ; 06175 PLFLT *arg4 = (PLFLT *) 0 ; 06176 PyArrayObject *tmp1 = NULL ; 06177 PyArrayObject *tmp3 = NULL ; 06178 PyArrayObject *tmp4 = NULL ; 06179 PyObject * obj0 = 0 ; 06180 PyObject * obj1 = 0 ; 06181 PyObject * obj2 = 0 ; 06182 06183 if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail; 06184 { 06185 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 06186 if ( tmp1 == NULL ) 06187 return NULL; 06188 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 06189 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 06190 } 06191 { 06192 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 06193 if ( tmp3 == NULL ) 06194 return NULL; 06195 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 06196 { 06197 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06198 return NULL; 06199 } 06200 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 06201 } 06202 { 06203 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 06204 if ( tmp4 == NULL ) 06205 return NULL; 06206 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 06207 { 06208 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06209 return NULL; 06210 } 06211 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 06212 } 06213 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4); 06214 resultobj = SWIG_Py_Void(); 06215 { 06216 Py_CLEAR( tmp1 ); 06217 } 06218 { 06219 Py_CLEAR( tmp3 ); 06220 } 06221 { 06222 Py_CLEAR( tmp4 ); 06223 } 06224 return resultobj; 06225 fail: 06226 { 06227 Py_CLEAR( tmp1 ); 06228 } 06229 { 06230 Py_CLEAR( tmp3 ); 06231 } 06232 { 06233 Py_CLEAR( tmp4 ); 06234 } 06235 return NULL; 06236 } 06237 06238 06239 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06240 PyObject *resultobj = 0; 06241 06242 if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail; 06243 plfamadv(); 06244 resultobj = SWIG_Py_Void(); 06245 return resultobj; 06246 fail: 06247 return NULL; 06248 } 06249 06250 06251 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06252 PyObject *resultobj = 0; 06253 PLINT arg1 ; 06254 PLFLT *arg2 = (PLFLT *) 0 ; 06255 PLFLT *arg3 = (PLFLT *) 0 ; 06256 PyArrayObject *tmp1 = NULL ; 06257 PyArrayObject *tmp3 = NULL ; 06258 PyObject * obj0 = 0 ; 06259 PyObject * obj1 = 0 ; 06260 06261 if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail; 06262 { 06263 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 06264 if ( tmp1 == NULL ) 06265 return NULL; 06266 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 06267 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 06268 } 06269 { 06270 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 06271 if ( tmp3 == NULL ) 06272 return NULL; 06273 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 06274 { 06275 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06276 return NULL; 06277 } 06278 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 06279 } 06280 plfill(arg1,(double const *)arg2,(double const *)arg3); 06281 resultobj = SWIG_Py_Void(); 06282 { 06283 Py_CLEAR( tmp1 ); 06284 } 06285 { 06286 Py_CLEAR( tmp3 ); 06287 } 06288 return resultobj; 06289 fail: 06290 { 06291 Py_CLEAR( tmp1 ); 06292 } 06293 { 06294 Py_CLEAR( tmp3 ); 06295 } 06296 return NULL; 06297 } 06298 06299 06300 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06301 PyObject *resultobj = 0; 06302 PLINT arg1 ; 06303 PLFLT *arg2 = (PLFLT *) 0 ; 06304 PLFLT *arg3 = (PLFLT *) 0 ; 06305 PLFLT *arg4 = (PLFLT *) 0 ; 06306 PyArrayObject *tmp1 = NULL ; 06307 PyArrayObject *tmp3 = NULL ; 06308 PyArrayObject *tmp4 = NULL ; 06309 PyObject * obj0 = 0 ; 06310 PyObject * obj1 = 0 ; 06311 PyObject * obj2 = 0 ; 06312 06313 if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail; 06314 { 06315 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 06316 if ( tmp1 == NULL ) 06317 return NULL; 06318 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 06319 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 06320 } 06321 { 06322 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 06323 if ( tmp3 == NULL ) 06324 return NULL; 06325 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 06326 { 06327 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06328 return NULL; 06329 } 06330 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 06331 } 06332 { 06333 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 06334 if ( tmp4 == NULL ) 06335 return NULL; 06336 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 06337 { 06338 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06339 return NULL; 06340 } 06341 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 06342 } 06343 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4); 06344 resultobj = SWIG_Py_Void(); 06345 { 06346 Py_CLEAR( tmp1 ); 06347 } 06348 { 06349 Py_CLEAR( tmp3 ); 06350 } 06351 { 06352 Py_CLEAR( tmp4 ); 06353 } 06354 return resultobj; 06355 fail: 06356 { 06357 Py_CLEAR( tmp1 ); 06358 } 06359 { 06360 Py_CLEAR( tmp3 ); 06361 } 06362 { 06363 Py_CLEAR( tmp4 ); 06364 } 06365 return NULL; 06366 } 06367 06368 06369 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06370 PyObject *resultobj = 0; 06371 PLINT arg1 ; 06372 PLFLT *arg2 = (PLFLT *) 0 ; 06373 PLFLT *arg3 = (PLFLT *) 0 ; 06374 PLFLT arg4 ; 06375 PyArrayObject *tmp1 = NULL ; 06376 PyArrayObject *tmp3 = NULL ; 06377 double val4 ; 06378 int ecode4 = 0 ; 06379 PyObject * obj0 = 0 ; 06380 PyObject * obj1 = 0 ; 06381 PyObject * obj2 = 0 ; 06382 06383 if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail; 06384 { 06385 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 06386 if ( tmp1 == NULL ) 06387 return NULL; 06388 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 06389 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 06390 } 06391 { 06392 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 06393 if ( tmp3 == NULL ) 06394 return NULL; 06395 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 06396 { 06397 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 06398 return NULL; 06399 } 06400 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 06401 } 06402 ecode4 = SWIG_AsVal_double(obj2, &val4); 06403 if (!SWIG_IsOK(ecode4)) { 06404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'"); 06405 } 06406 arg4 = (PLFLT)(val4); 06407 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4); 06408 resultobj = SWIG_Py_Void(); 06409 { 06410 Py_CLEAR( tmp1 ); 06411 } 06412 { 06413 Py_CLEAR( tmp3 ); 06414 } 06415 return resultobj; 06416 fail: 06417 { 06418 Py_CLEAR( tmp1 ); 06419 } 06420 { 06421 Py_CLEAR( tmp3 ); 06422 } 06423 return NULL; 06424 } 06425 06426 06427 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06428 PyObject *resultobj = 0; 06429 06430 if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail; 06431 plflush(); 06432 resultobj = SWIG_Py_Void(); 06433 return resultobj; 06434 fail: 06435 return NULL; 06436 } 06437 06438 06439 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06440 PyObject *resultobj = 0; 06441 PLINT arg1 ; 06442 int val1 ; 06443 int ecode1 = 0 ; 06444 PyObject * obj0 = 0 ; 06445 06446 if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail; 06447 ecode1 = SWIG_AsVal_int(obj0, &val1); 06448 if (!SWIG_IsOK(ecode1)) { 06449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'"); 06450 } 06451 arg1 = (PLINT)(val1); 06452 plfont(arg1); 06453 resultobj = SWIG_Py_Void(); 06454 return resultobj; 06455 fail: 06456 return NULL; 06457 } 06458 06459 06460 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06461 PyObject *resultobj = 0; 06462 PLINT arg1 ; 06463 int val1 ; 06464 int ecode1 = 0 ; 06465 PyObject * obj0 = 0 ; 06466 06467 if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail; 06468 ecode1 = SWIG_AsVal_int(obj0, &val1); 06469 if (!SWIG_IsOK(ecode1)) { 06470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'"); 06471 } 06472 arg1 = (PLINT)(val1); 06473 plfontld(arg1); 06474 resultobj = SWIG_Py_Void(); 06475 return resultobj; 06476 fail: 06477 return NULL; 06478 } 06479 06480 06481 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06482 PyObject *resultobj = 0; 06483 PLFLT *arg1 = (PLFLT *) 0 ; 06484 PLFLT *arg2 = (PLFLT *) 0 ; 06485 PLFLT temp1 ; 06486 int res1 = SWIG_TMPOBJ ; 06487 PLFLT temp2 ; 06488 int res2 = SWIG_TMPOBJ ; 06489 06490 arg1 = &temp1; 06491 arg2 = &temp2; 06492 if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail; 06493 plgchr(arg1,arg2); 06494 resultobj = SWIG_Py_Void(); 06495 if (SWIG_IsTmpObj(res1)) { 06496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 06497 } else { 06498 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 06500 } 06501 if (SWIG_IsTmpObj(res2)) { 06502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 06503 } else { 06504 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 06506 } 06507 return resultobj; 06508 fail: 06509 return NULL; 06510 } 06511 06512 06513 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06514 PyObject *resultobj = 0; 06515 PLINT arg1 ; 06516 PLINT *arg2 = (PLINT *) 0 ; 06517 PLINT *arg3 = (PLINT *) 0 ; 06518 PLINT *arg4 = (PLINT *) 0 ; 06519 int val1 ; 06520 int ecode1 = 0 ; 06521 PLINT temp2 ; 06522 int res2 = SWIG_TMPOBJ ; 06523 PLINT temp3 ; 06524 int res3 = SWIG_TMPOBJ ; 06525 PLINT temp4 ; 06526 int res4 = SWIG_TMPOBJ ; 06527 PyObject * obj0 = 0 ; 06528 06529 arg2 = &temp2; 06530 arg3 = &temp3; 06531 arg4 = &temp4; 06532 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail; 06533 ecode1 = SWIG_AsVal_int(obj0, &val1); 06534 if (!SWIG_IsOK(ecode1)) { 06535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'"); 06536 } 06537 arg1 = (PLINT)(val1); 06538 plgcol0(arg1,arg2,arg3,arg4); 06539 resultobj = SWIG_Py_Void(); 06540 if (SWIG_IsTmpObj(res2)) { 06541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06542 } else { 06543 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 06545 } 06546 if (SWIG_IsTmpObj(res3)) { 06547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 06548 } else { 06549 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 06551 } 06552 if (SWIG_IsTmpObj(res4)) { 06553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); 06554 } else { 06555 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags)); 06557 } 06558 return resultobj; 06559 fail: 06560 return NULL; 06561 } 06562 06563 06564 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06565 PyObject *resultobj = 0; 06566 PLINT arg1 ; 06567 PLINT *arg2 = (PLINT *) 0 ; 06568 PLINT *arg3 = (PLINT *) 0 ; 06569 PLINT *arg4 = (PLINT *) 0 ; 06570 PLFLT *arg5 = (PLFLT *) 0 ; 06571 int val1 ; 06572 int ecode1 = 0 ; 06573 PLINT temp2 ; 06574 int res2 = SWIG_TMPOBJ ; 06575 PLINT temp3 ; 06576 int res3 = SWIG_TMPOBJ ; 06577 PLINT temp4 ; 06578 int res4 = SWIG_TMPOBJ ; 06579 PLFLT temp5 ; 06580 int res5 = SWIG_TMPOBJ ; 06581 PyObject * obj0 = 0 ; 06582 06583 arg2 = &temp2; 06584 arg3 = &temp3; 06585 arg4 = &temp4; 06586 arg5 = &temp5; 06587 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail; 06588 ecode1 = SWIG_AsVal_int(obj0, &val1); 06589 if (!SWIG_IsOK(ecode1)) { 06590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'"); 06591 } 06592 arg1 = (PLINT)(val1); 06593 plgcol0a(arg1,arg2,arg3,arg4,arg5); 06594 resultobj = SWIG_Py_Void(); 06595 if (SWIG_IsTmpObj(res2)) { 06596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06597 } else { 06598 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 06600 } 06601 if (SWIG_IsTmpObj(res3)) { 06602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 06603 } else { 06604 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 06606 } 06607 if (SWIG_IsTmpObj(res4)) { 06608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); 06609 } else { 06610 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags)); 06612 } 06613 if (SWIG_IsTmpObj(res5)) { 06614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5))); 06615 } else { 06616 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags)); 06618 } 06619 return resultobj; 06620 fail: 06621 return NULL; 06622 } 06623 06624 06625 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06626 PyObject *resultobj = 0; 06627 PLINT *arg1 = (PLINT *) 0 ; 06628 PLINT *arg2 = (PLINT *) 0 ; 06629 PLINT *arg3 = (PLINT *) 0 ; 06630 PLINT temp1 ; 06631 int res1 = SWIG_TMPOBJ ; 06632 PLINT temp2 ; 06633 int res2 = SWIG_TMPOBJ ; 06634 PLINT temp3 ; 06635 int res3 = SWIG_TMPOBJ ; 06636 06637 arg1 = &temp1; 06638 arg2 = &temp2; 06639 arg3 = &temp3; 06640 if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail; 06641 plgcolbg(arg1,arg2,arg3); 06642 resultobj = SWIG_Py_Void(); 06643 if (SWIG_IsTmpObj(res1)) { 06644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 06645 } else { 06646 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 06648 } 06649 if (SWIG_IsTmpObj(res2)) { 06650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06651 } else { 06652 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 06654 } 06655 if (SWIG_IsTmpObj(res3)) { 06656 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 06657 } else { 06658 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 06660 } 06661 return resultobj; 06662 fail: 06663 return NULL; 06664 } 06665 06666 06667 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06668 PyObject *resultobj = 0; 06669 PLINT *arg1 = (PLINT *) 0 ; 06670 PLINT *arg2 = (PLINT *) 0 ; 06671 PLINT *arg3 = (PLINT *) 0 ; 06672 PLFLT *arg4 = (PLFLT *) 0 ; 06673 PLINT temp1 ; 06674 int res1 = SWIG_TMPOBJ ; 06675 PLINT temp2 ; 06676 int res2 = SWIG_TMPOBJ ; 06677 PLINT temp3 ; 06678 int res3 = SWIG_TMPOBJ ; 06679 PLFLT temp4 ; 06680 int res4 = SWIG_TMPOBJ ; 06681 06682 arg1 = &temp1; 06683 arg2 = &temp2; 06684 arg3 = &temp3; 06685 arg4 = &temp4; 06686 if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail; 06687 plgcolbga(arg1,arg2,arg3,arg4); 06688 resultobj = SWIG_Py_Void(); 06689 if (SWIG_IsTmpObj(res1)) { 06690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 06691 } else { 06692 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 06694 } 06695 if (SWIG_IsTmpObj(res2)) { 06696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06697 } else { 06698 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 06700 } 06701 if (SWIG_IsTmpObj(res3)) { 06702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 06703 } else { 06704 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 06706 } 06707 if (SWIG_IsTmpObj(res4)) { 06708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 06709 } else { 06710 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 06712 } 06713 return resultobj; 06714 fail: 06715 return NULL; 06716 } 06717 06718 06719 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06720 PyObject *resultobj = 0; 06721 PLINT *arg1 = (PLINT *) 0 ; 06722 PLINT temp1 ; 06723 int res1 = SWIG_TMPOBJ ; 06724 06725 arg1 = &temp1; 06726 if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail; 06727 plgcompression(arg1); 06728 resultobj = SWIG_Py_Void(); 06729 if (SWIG_IsTmpObj(res1)) { 06730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 06731 } else { 06732 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 06734 } 06735 return resultobj; 06736 fail: 06737 return NULL; 06738 } 06739 06740 06741 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06742 PyObject *resultobj = 0; 06743 char *arg1 = (char *) 0 ; 06744 char buff1[1000] ; 06745 06746 { 06747 arg1 = buff1; 06748 } 06749 if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail; 06750 plgdev(arg1); 06751 resultobj = SWIG_Py_Void(); 06752 { 06753 PyObject *o = PyString_FromString( arg1 ); 06754 resultobj = t_output_helper( resultobj, o ); 06755 } 06756 return resultobj; 06757 fail: 06758 return NULL; 06759 } 06760 06761 06762 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06763 PyObject *resultobj = 0; 06764 PLFLT *arg1 = (PLFLT *) 0 ; 06765 PLFLT *arg2 = (PLFLT *) 0 ; 06766 PLFLT *arg3 = (PLFLT *) 0 ; 06767 PLFLT *arg4 = (PLFLT *) 0 ; 06768 PLFLT temp1 ; 06769 int res1 = SWIG_TMPOBJ ; 06770 PLFLT temp2 ; 06771 int res2 = SWIG_TMPOBJ ; 06772 PLFLT temp3 ; 06773 int res3 = SWIG_TMPOBJ ; 06774 PLFLT temp4 ; 06775 int res4 = SWIG_TMPOBJ ; 06776 06777 arg1 = &temp1; 06778 arg2 = &temp2; 06779 arg3 = &temp3; 06780 arg4 = &temp4; 06781 if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail; 06782 plgdidev(arg1,arg2,arg3,arg4); 06783 resultobj = SWIG_Py_Void(); 06784 if (SWIG_IsTmpObj(res1)) { 06785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 06786 } else { 06787 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 06789 } 06790 if (SWIG_IsTmpObj(res2)) { 06791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 06792 } else { 06793 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 06795 } 06796 if (SWIG_IsTmpObj(res3)) { 06797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 06798 } else { 06799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 06801 } 06802 if (SWIG_IsTmpObj(res4)) { 06803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 06804 } else { 06805 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 06807 } 06808 return resultobj; 06809 fail: 06810 return NULL; 06811 } 06812 06813 06814 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06815 PyObject *resultobj = 0; 06816 PLFLT *arg1 = (PLFLT *) 0 ; 06817 PLFLT temp1 ; 06818 int res1 = SWIG_TMPOBJ ; 06819 06820 arg1 = &temp1; 06821 if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail; 06822 plgdiori(arg1); 06823 resultobj = SWIG_Py_Void(); 06824 if (SWIG_IsTmpObj(res1)) { 06825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 06826 } else { 06827 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 06829 } 06830 return resultobj; 06831 fail: 06832 return NULL; 06833 } 06834 06835 06836 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06837 PyObject *resultobj = 0; 06838 PLFLT *arg1 = (PLFLT *) 0 ; 06839 PLFLT *arg2 = (PLFLT *) 0 ; 06840 PLFLT *arg3 = (PLFLT *) 0 ; 06841 PLFLT *arg4 = (PLFLT *) 0 ; 06842 PLFLT temp1 ; 06843 int res1 = SWIG_TMPOBJ ; 06844 PLFLT temp2 ; 06845 int res2 = SWIG_TMPOBJ ; 06846 PLFLT temp3 ; 06847 int res3 = SWIG_TMPOBJ ; 06848 PLFLT temp4 ; 06849 int res4 = SWIG_TMPOBJ ; 06850 06851 arg1 = &temp1; 06852 arg2 = &temp2; 06853 arg3 = &temp3; 06854 arg4 = &temp4; 06855 if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail; 06856 plgdiplt(arg1,arg2,arg3,arg4); 06857 resultobj = SWIG_Py_Void(); 06858 if (SWIG_IsTmpObj(res1)) { 06859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 06860 } else { 06861 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 06863 } 06864 if (SWIG_IsTmpObj(res2)) { 06865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 06866 } else { 06867 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 06869 } 06870 if (SWIG_IsTmpObj(res3)) { 06871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 06872 } else { 06873 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 06875 } 06876 if (SWIG_IsTmpObj(res4)) { 06877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 06878 } else { 06879 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 06881 } 06882 return resultobj; 06883 fail: 06884 return NULL; 06885 } 06886 06887 06888 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06889 PyObject *resultobj = 0; 06890 PLINT *arg1 = (PLINT *) 0 ; 06891 PLINT *arg2 = (PLINT *) 0 ; 06892 PLINT *arg3 = (PLINT *) 0 ; 06893 PLINT temp1 ; 06894 int res1 = SWIG_TMPOBJ ; 06895 PLINT temp2 ; 06896 int res2 = SWIG_TMPOBJ ; 06897 PLINT temp3 ; 06898 int res3 = SWIG_TMPOBJ ; 06899 06900 arg1 = &temp1; 06901 arg2 = &temp2; 06902 arg3 = &temp3; 06903 if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail; 06904 plgfam(arg1,arg2,arg3); 06905 resultobj = SWIG_Py_Void(); 06906 if (SWIG_IsTmpObj(res1)) { 06907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 06908 } else { 06909 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 06911 } 06912 if (SWIG_IsTmpObj(res2)) { 06913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06914 } else { 06915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 06917 } 06918 if (SWIG_IsTmpObj(res3)) { 06919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 06920 } else { 06921 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 06923 } 06924 return resultobj; 06925 fail: 06926 return NULL; 06927 } 06928 06929 06930 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06931 PyObject *resultobj = 0; 06932 PLUNICODE *arg1 = (PLUNICODE *) 0 ; 06933 PLUNICODE temp1 ; 06934 int res1 = SWIG_TMPOBJ ; 06935 06936 arg1 = &temp1; 06937 if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail; 06938 plgfci(arg1); 06939 resultobj = SWIG_Py_Void(); 06940 if (SWIG_IsTmpObj(res1)) { 06941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1))); 06942 } else { 06943 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags)); 06945 } 06946 return resultobj; 06947 fail: 06948 return NULL; 06949 } 06950 06951 06952 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06953 PyObject *resultobj = 0; 06954 char *arg1 = (char *) 0 ; 06955 char buff1[1000] ; 06956 06957 { 06958 arg1 = buff1; 06959 } 06960 if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail; 06961 plgfnam(arg1); 06962 resultobj = SWIG_Py_Void(); 06963 { 06964 PyObject *o = PyString_FromString( arg1 ); 06965 resultobj = t_output_helper( resultobj, o ); 06966 } 06967 return resultobj; 06968 fail: 06969 return NULL; 06970 } 06971 06972 06973 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 06974 PyObject *resultobj = 0; 06975 PLINT *arg1 = (PLINT *) 0 ; 06976 PLINT *arg2 = (PLINT *) 0 ; 06977 PLINT *arg3 = (PLINT *) 0 ; 06978 PLINT temp1 ; 06979 int res1 = SWIG_TMPOBJ ; 06980 PLINT temp2 ; 06981 int res2 = SWIG_TMPOBJ ; 06982 PLINT temp3 ; 06983 int res3 = SWIG_TMPOBJ ; 06984 06985 arg1 = &temp1; 06986 arg2 = &temp2; 06987 arg3 = &temp3; 06988 if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail; 06989 plgfont(arg1,arg2,arg3); 06990 resultobj = SWIG_Py_Void(); 06991 if (SWIG_IsTmpObj(res1)) { 06992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 06993 } else { 06994 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 06995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 06996 } 06997 if (SWIG_IsTmpObj(res2)) { 06998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 06999 } else { 07000 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 07002 } 07003 if (SWIG_IsTmpObj(res3)) { 07004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 07005 } else { 07006 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 07008 } 07009 return resultobj; 07010 fail: 07011 return NULL; 07012 } 07013 07014 07015 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07016 PyObject *resultobj = 0; 07017 PLINT *arg1 = (PLINT *) 0 ; 07018 PLINT temp1 ; 07019 int res1 = SWIG_TMPOBJ ; 07020 07021 arg1 = &temp1; 07022 if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail; 07023 plglevel(arg1); 07024 resultobj = SWIG_Py_Void(); 07025 if (SWIG_IsTmpObj(res1)) { 07026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 07027 } else { 07028 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07029 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 07030 } 07031 return resultobj; 07032 fail: 07033 return NULL; 07034 } 07035 07036 07037 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07038 PyObject *resultobj = 0; 07039 PLFLT *arg1 = (PLFLT *) 0 ; 07040 PLFLT *arg2 = (PLFLT *) 0 ; 07041 PLINT *arg3 = (PLINT *) 0 ; 07042 PLINT *arg4 = (PLINT *) 0 ; 07043 PLINT *arg5 = (PLINT *) 0 ; 07044 PLINT *arg6 = (PLINT *) 0 ; 07045 PLFLT temp1 ; 07046 int res1 = SWIG_TMPOBJ ; 07047 PLFLT temp2 ; 07048 int res2 = SWIG_TMPOBJ ; 07049 PLINT temp3 ; 07050 int res3 = SWIG_TMPOBJ ; 07051 PLINT temp4 ; 07052 int res4 = SWIG_TMPOBJ ; 07053 PLINT temp5 ; 07054 int res5 = SWIG_TMPOBJ ; 07055 PLINT temp6 ; 07056 int res6 = SWIG_TMPOBJ ; 07057 07058 arg1 = &temp1; 07059 arg2 = &temp2; 07060 arg3 = &temp3; 07061 arg4 = &temp4; 07062 arg5 = &temp5; 07063 arg6 = &temp6; 07064 if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail; 07065 plgpage(arg1,arg2,arg3,arg4,arg5,arg6); 07066 resultobj = SWIG_Py_Void(); 07067 if (SWIG_IsTmpObj(res1)) { 07068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 07069 } else { 07070 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 07072 } 07073 if (SWIG_IsTmpObj(res2)) { 07074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 07075 } else { 07076 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 07078 } 07079 if (SWIG_IsTmpObj(res3)) { 07080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); 07081 } else { 07082 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); 07084 } 07085 if (SWIG_IsTmpObj(res4)) { 07086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); 07087 } else { 07088 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags)); 07090 } 07091 if (SWIG_IsTmpObj(res5)) { 07092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5))); 07093 } else { 07094 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags)); 07096 } 07097 if (SWIG_IsTmpObj(res6)) { 07098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6))); 07099 } else { 07100 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags)); 07102 } 07103 return resultobj; 07104 fail: 07105 return NULL; 07106 } 07107 07108 07109 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07110 PyObject *resultobj = 0; 07111 07112 if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail; 07113 plgra(); 07114 resultobj = SWIG_Py_Void(); 07115 return resultobj; 07116 fail: 07117 return NULL; 07118 } 07119 07120 07121 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07122 PyObject *resultobj = 0; 07123 PLFLT *arg1 = (PLFLT *) 0 ; 07124 PLFLT *arg2 = (PLFLT *) 0 ; 07125 PLFLT *arg3 = (PLFLT *) 0 ; 07126 PLINT arg4 ; 07127 PLFLT *arg5 = (PLFLT *) 0 ; 07128 PLINT arg6 ; 07129 PLFLT *arg7 = (PLFLT *) 0 ; 07130 PLINT arg8 ; 07131 PLFLT **arg9 = (PLFLT **) 0 ; 07132 PLINT arg10 ; 07133 PLFLT arg11 ; 07134 PyArrayObject *tmp1 = NULL ; 07135 PyArrayObject *tmp2 = NULL ; 07136 PyArrayObject *tmp3 = NULL ; 07137 PyArrayObject *tmp5 = NULL ; 07138 PyArrayObject *tmp7 = NULL ; 07139 PyObject *array7 = NULL ; 07140 int val10 ; 07141 int ecode10 = 0 ; 07142 double val11 ; 07143 int ecode11 = 0 ; 07144 PyObject * obj0 = 0 ; 07145 PyObject * obj1 = 0 ; 07146 PyObject * obj2 = 0 ; 07147 PyObject * obj3 = 0 ; 07148 PyObject * obj4 = 0 ; 07149 PyObject * obj5 = 0 ; 07150 PyObject * obj6 = 0 ; 07151 07152 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; 07153 { 07154 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 07155 if ( tmp1 == NULL ) 07156 return NULL; 07157 Alen = PyArray_DIMS( tmp1 )[0]; 07158 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 07159 } 07160 { 07161 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 07162 if ( tmp2 == NULL ) 07163 return NULL; 07164 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 07165 { 07166 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 07167 return NULL; 07168 } 07169 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 07170 } 07171 { 07172 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 07173 if ( tmp3 == NULL ) 07174 return NULL; 07175 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 07176 { 07177 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 07178 return NULL; 07179 } 07180 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 07181 arg4 = PyArray_DIMS( tmp3 )[0]; 07182 } 07183 { 07184 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 ); 07185 if ( tmp5 == NULL ) 07186 return NULL; 07187 Xlen = PyArray_DIMS( tmp5 )[0]; 07188 arg6 = Xlen; 07189 arg5 = (PLFLT *) PyArray_DATA( tmp5 ); 07190 } 07191 { 07192 int i, size; 07193 npy_intp dims[2]; 07194 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 07195 if ( tmp7 == NULL ) 07196 return NULL; 07197 Ylen = PyArray_DIMS( tmp7 )[0]; 07198 arg8 = Ylen; 07199 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 07200 // Make created 2D array7 have dimensions from prior ArrayX in the argument 07201 // list and this ArrayY. 07202 dims[0] = Xlen; 07203 dims[1] = Ylen; 07204 array7 = PyArray_SimpleNew( 2, dims, NPY_FLOAT64 ); 07205 if ( !array7 ) 07206 return NULL; 07207 size = Ylen; 07208 arg9 = (double **) malloc( sizeof ( double * ) * (size_t) Xlen ); 07209 for ( i = 0; i < Xlen; i++ ) 07210 arg9[i] = ( (double *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size ); 07211 } 07212 ecode10 = SWIG_AsVal_int(obj5, &val10); 07213 if (!SWIG_IsOK(ecode10)) { 07214 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'"); 07215 } 07216 arg10 = (PLINT)(val10); 07217 ecode11 = SWIG_AsVal_double(obj6, &val11); 07218 if (!SWIG_IsOK(ecode11)) { 07219 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'"); 07220 } 07221 arg11 = (PLFLT)(val11); 07222 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11); 07223 resultobj = SWIG_Py_Void(); 07224 { 07225 resultobj = SWIG_Python_AppendOutput( resultobj, array7 ); 07226 } 07227 { 07228 Py_CLEAR( tmp1 ); 07229 } 07230 { 07231 Py_CLEAR( tmp2 ); 07232 } 07233 { 07234 Py_CLEAR( tmp3 ); 07235 } 07236 { 07237 Py_CLEAR( tmp5 ); 07238 } 07239 { 07240 Py_CLEAR( tmp7 ); 07241 free( arg9 ); 07242 } 07243 return resultobj; 07244 fail: 07245 { 07246 Py_CLEAR( tmp1 ); 07247 } 07248 { 07249 Py_CLEAR( tmp2 ); 07250 } 07251 { 07252 Py_CLEAR( tmp3 ); 07253 } 07254 { 07255 Py_CLEAR( tmp5 ); 07256 } 07257 { 07258 Py_CLEAR( tmp7 ); 07259 free( arg9 ); 07260 } 07261 return NULL; 07262 } 07263 07264 07265 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07266 PyObject *resultobj = 0; 07267 PLFLT *arg1 = (PLFLT *) 0 ; 07268 PLFLT *arg2 = (PLFLT *) 0 ; 07269 PLFLT *arg3 = (PLFLT *) 0 ; 07270 PLFLT *arg4 = (PLFLT *) 0 ; 07271 PLFLT temp1 ; 07272 int res1 = SWIG_TMPOBJ ; 07273 PLFLT temp2 ; 07274 int res2 = SWIG_TMPOBJ ; 07275 PLFLT temp3 ; 07276 int res3 = SWIG_TMPOBJ ; 07277 PLFLT temp4 ; 07278 int res4 = SWIG_TMPOBJ ; 07279 07280 arg1 = &temp1; 07281 arg2 = &temp2; 07282 arg3 = &temp3; 07283 arg4 = &temp4; 07284 if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail; 07285 plgspa(arg1,arg2,arg3,arg4); 07286 resultobj = SWIG_Py_Void(); 07287 if (SWIG_IsTmpObj(res1)) { 07288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 07289 } else { 07290 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 07292 } 07293 if (SWIG_IsTmpObj(res2)) { 07294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 07295 } else { 07296 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 07298 } 07299 if (SWIG_IsTmpObj(res3)) { 07300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 07301 } else { 07302 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 07304 } 07305 if (SWIG_IsTmpObj(res4)) { 07306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 07307 } else { 07308 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 07310 } 07311 return resultobj; 07312 fail: 07313 return NULL; 07314 } 07315 07316 07317 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07318 PyObject *resultobj = 0; 07319 PLINT *arg1 = (PLINT *) 0 ; 07320 PLINT temp1 ; 07321 int res1 = SWIG_TMPOBJ ; 07322 07323 arg1 = &temp1; 07324 if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail; 07325 plgstrm(arg1); 07326 resultobj = SWIG_Py_Void(); 07327 if (SWIG_IsTmpObj(res1)) { 07328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 07329 } else { 07330 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 07332 } 07333 return resultobj; 07334 fail: 07335 return NULL; 07336 } 07337 07338 07339 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07340 PyObject *resultobj = 0; 07341 char *arg1 = (char *) 0 ; 07342 char buff1[1000] ; 07343 07344 { 07345 arg1 = buff1; 07346 } 07347 if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail; 07348 plgver(arg1); 07349 resultobj = SWIG_Py_Void(); 07350 { 07351 PyObject *o = PyString_FromString( arg1 ); 07352 resultobj = t_output_helper( resultobj, o ); 07353 } 07354 return resultobj; 07355 fail: 07356 return NULL; 07357 } 07358 07359 07360 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07361 PyObject *resultobj = 0; 07362 PLFLT *arg1 = (PLFLT *) 0 ; 07363 PLFLT *arg2 = (PLFLT *) 0 ; 07364 PLFLT *arg3 = (PLFLT *) 0 ; 07365 PLFLT *arg4 = (PLFLT *) 0 ; 07366 PLFLT temp1 ; 07367 int res1 = SWIG_TMPOBJ ; 07368 PLFLT temp2 ; 07369 int res2 = SWIG_TMPOBJ ; 07370 PLFLT temp3 ; 07371 int res3 = SWIG_TMPOBJ ; 07372 PLFLT temp4 ; 07373 int res4 = SWIG_TMPOBJ ; 07374 07375 arg1 = &temp1; 07376 arg2 = &temp2; 07377 arg3 = &temp3; 07378 arg4 = &temp4; 07379 if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail; 07380 plgvpd(arg1,arg2,arg3,arg4); 07381 resultobj = SWIG_Py_Void(); 07382 if (SWIG_IsTmpObj(res1)) { 07383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 07384 } else { 07385 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 07387 } 07388 if (SWIG_IsTmpObj(res2)) { 07389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 07390 } else { 07391 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 07393 } 07394 if (SWIG_IsTmpObj(res3)) { 07395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 07396 } else { 07397 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 07399 } 07400 if (SWIG_IsTmpObj(res4)) { 07401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 07402 } else { 07403 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 07405 } 07406 return resultobj; 07407 fail: 07408 return NULL; 07409 } 07410 07411 07412 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07413 PyObject *resultobj = 0; 07414 PLFLT *arg1 = (PLFLT *) 0 ; 07415 PLFLT *arg2 = (PLFLT *) 0 ; 07416 PLFLT *arg3 = (PLFLT *) 0 ; 07417 PLFLT *arg4 = (PLFLT *) 0 ; 07418 PLFLT temp1 ; 07419 int res1 = SWIG_TMPOBJ ; 07420 PLFLT temp2 ; 07421 int res2 = SWIG_TMPOBJ ; 07422 PLFLT temp3 ; 07423 int res3 = SWIG_TMPOBJ ; 07424 PLFLT temp4 ; 07425 int res4 = SWIG_TMPOBJ ; 07426 07427 arg1 = &temp1; 07428 arg2 = &temp2; 07429 arg3 = &temp3; 07430 arg4 = &temp4; 07431 if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail; 07432 plgvpw(arg1,arg2,arg3,arg4); 07433 resultobj = SWIG_Py_Void(); 07434 if (SWIG_IsTmpObj(res1)) { 07435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 07436 } else { 07437 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 07439 } 07440 if (SWIG_IsTmpObj(res2)) { 07441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 07442 } else { 07443 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 07445 } 07446 if (SWIG_IsTmpObj(res3)) { 07447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3))); 07448 } else { 07449 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags)); 07451 } 07452 if (SWIG_IsTmpObj(res4)) { 07453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 07454 } else { 07455 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 07457 } 07458 return resultobj; 07459 fail: 07460 return NULL; 07461 } 07462 07463 07464 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07465 PyObject *resultobj = 0; 07466 PLINT *arg1 = (PLINT *) 0 ; 07467 PLINT *arg2 = (PLINT *) 0 ; 07468 PLINT temp1 ; 07469 int res1 = SWIG_TMPOBJ ; 07470 PLINT temp2 ; 07471 int res2 = SWIG_TMPOBJ ; 07472 07473 arg1 = &temp1; 07474 arg2 = &temp2; 07475 if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail; 07476 plgxax(arg1,arg2); 07477 resultobj = SWIG_Py_Void(); 07478 if (SWIG_IsTmpObj(res1)) { 07479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 07480 } else { 07481 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 07483 } 07484 if (SWIG_IsTmpObj(res2)) { 07485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 07486 } else { 07487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 07489 } 07490 return resultobj; 07491 fail: 07492 return NULL; 07493 } 07494 07495 07496 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07497 PyObject *resultobj = 0; 07498 PLINT *arg1 = (PLINT *) 0 ; 07499 PLINT *arg2 = (PLINT *) 0 ; 07500 PLINT temp1 ; 07501 int res1 = SWIG_TMPOBJ ; 07502 PLINT temp2 ; 07503 int res2 = SWIG_TMPOBJ ; 07504 07505 arg1 = &temp1; 07506 arg2 = &temp2; 07507 if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail; 07508 plgyax(arg1,arg2); 07509 resultobj = SWIG_Py_Void(); 07510 if (SWIG_IsTmpObj(res1)) { 07511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 07512 } else { 07513 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 07515 } 07516 if (SWIG_IsTmpObj(res2)) { 07517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 07518 } else { 07519 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 07521 } 07522 return resultobj; 07523 fail: 07524 return NULL; 07525 } 07526 07527 07528 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07529 PyObject *resultobj = 0; 07530 PLINT *arg1 = (PLINT *) 0 ; 07531 PLINT *arg2 = (PLINT *) 0 ; 07532 PLINT temp1 ; 07533 int res1 = SWIG_TMPOBJ ; 07534 PLINT temp2 ; 07535 int res2 = SWIG_TMPOBJ ; 07536 07537 arg1 = &temp1; 07538 arg2 = &temp2; 07539 if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail; 07540 plgzax(arg1,arg2); 07541 resultobj = SWIG_Py_Void(); 07542 if (SWIG_IsTmpObj(res1)) { 07543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 07544 } else { 07545 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 07547 } 07548 if (SWIG_IsTmpObj(res2)) { 07549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 07550 } else { 07551 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 07553 } 07554 return resultobj; 07555 fail: 07556 return NULL; 07557 } 07558 07559 07560 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07561 PyObject *resultobj = 0; 07562 PLINT arg1 ; 07563 PLFLT *arg2 = (PLFLT *) 0 ; 07564 PLFLT arg3 ; 07565 PLFLT arg4 ; 07566 PLINT arg5 ; 07567 PLINT arg6 ; 07568 PyArrayObject *tmp1 = NULL ; 07569 double val3 ; 07570 int ecode3 = 0 ; 07571 double val4 ; 07572 int ecode4 = 0 ; 07573 int val5 ; 07574 int ecode5 = 0 ; 07575 int val6 ; 07576 int ecode6 = 0 ; 07577 PyObject * obj0 = 0 ; 07578 PyObject * obj1 = 0 ; 07579 PyObject * obj2 = 0 ; 07580 PyObject * obj3 = 0 ; 07581 PyObject * obj4 = 0 ; 07582 07583 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 07584 { 07585 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 07586 if ( tmp1 == NULL ) 07587 return NULL; 07588 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 07589 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 07590 } 07591 ecode3 = SWIG_AsVal_double(obj1, &val3); 07592 if (!SWIG_IsOK(ecode3)) { 07593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'"); 07594 } 07595 arg3 = (PLFLT)(val3); 07596 ecode4 = SWIG_AsVal_double(obj2, &val4); 07597 if (!SWIG_IsOK(ecode4)) { 07598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'"); 07599 } 07600 arg4 = (PLFLT)(val4); 07601 ecode5 = SWIG_AsVal_int(obj3, &val5); 07602 if (!SWIG_IsOK(ecode5)) { 07603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'"); 07604 } 07605 arg5 = (PLINT)(val5); 07606 ecode6 = SWIG_AsVal_int(obj4, &val6); 07607 if (!SWIG_IsOK(ecode6)) { 07608 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'"); 07609 } 07610 arg6 = (PLINT)(val6); 07611 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6); 07612 resultobj = SWIG_Py_Void(); 07613 { 07614 Py_CLEAR( tmp1 ); 07615 } 07616 return resultobj; 07617 fail: 07618 { 07619 Py_CLEAR( tmp1 ); 07620 } 07621 return NULL; 07622 } 07623 07624 07625 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07626 PyObject *resultobj = 0; 07627 PLFLT arg1 ; 07628 PLFLT arg2 ; 07629 PLFLT arg3 ; 07630 PLFLT *arg4 = (PLFLT *) 0 ; 07631 PLFLT *arg5 = (PLFLT *) 0 ; 07632 PLFLT *arg6 = (PLFLT *) 0 ; 07633 double val1 ; 07634 int ecode1 = 0 ; 07635 double val2 ; 07636 int ecode2 = 0 ; 07637 double val3 ; 07638 int ecode3 = 0 ; 07639 PLFLT temp4 ; 07640 int res4 = SWIG_TMPOBJ ; 07641 PLFLT temp5 ; 07642 int res5 = SWIG_TMPOBJ ; 07643 PLFLT temp6 ; 07644 int res6 = SWIG_TMPOBJ ; 07645 PyObject * obj0 = 0 ; 07646 PyObject * obj1 = 0 ; 07647 PyObject * obj2 = 0 ; 07648 07649 arg4 = &temp4; 07650 arg5 = &temp5; 07651 arg6 = &temp6; 07652 if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail; 07653 ecode1 = SWIG_AsVal_double(obj0, &val1); 07654 if (!SWIG_IsOK(ecode1)) { 07655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'"); 07656 } 07657 arg1 = (PLFLT)(val1); 07658 ecode2 = SWIG_AsVal_double(obj1, &val2); 07659 if (!SWIG_IsOK(ecode2)) { 07660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'"); 07661 } 07662 arg2 = (PLFLT)(val2); 07663 ecode3 = SWIG_AsVal_double(obj2, &val3); 07664 if (!SWIG_IsOK(ecode3)) { 07665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'"); 07666 } 07667 arg3 = (PLFLT)(val3); 07668 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6); 07669 resultobj = SWIG_Py_Void(); 07670 if (SWIG_IsTmpObj(res4)) { 07671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 07672 } else { 07673 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 07675 } 07676 if (SWIG_IsTmpObj(res5)) { 07677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5))); 07678 } else { 07679 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags)); 07681 } 07682 if (SWIG_IsTmpObj(res6)) { 07683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6))); 07684 } else { 07685 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 07686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags)); 07687 } 07688 return resultobj; 07689 fail: 07690 return NULL; 07691 } 07692 07693 07694 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07695 PyObject *resultobj = 0; 07696 07697 if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail; 07698 plinit(); 07699 resultobj = SWIG_Py_Void(); 07700 return resultobj; 07701 fail: 07702 return NULL; 07703 } 07704 07705 07706 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07707 PyObject *resultobj = 0; 07708 PLFLT arg1 ; 07709 PLFLT arg2 ; 07710 PLFLT arg3 ; 07711 PLFLT arg4 ; 07712 double val1 ; 07713 int ecode1 = 0 ; 07714 double val2 ; 07715 int ecode2 = 0 ; 07716 double val3 ; 07717 int ecode3 = 0 ; 07718 double val4 ; 07719 int ecode4 = 0 ; 07720 PyObject * obj0 = 0 ; 07721 PyObject * obj1 = 0 ; 07722 PyObject * obj2 = 0 ; 07723 PyObject * obj3 = 0 ; 07724 07725 if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 07726 ecode1 = SWIG_AsVal_double(obj0, &val1); 07727 if (!SWIG_IsOK(ecode1)) { 07728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'"); 07729 } 07730 arg1 = (PLFLT)(val1); 07731 ecode2 = SWIG_AsVal_double(obj1, &val2); 07732 if (!SWIG_IsOK(ecode2)) { 07733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'"); 07734 } 07735 arg2 = (PLFLT)(val2); 07736 ecode3 = SWIG_AsVal_double(obj2, &val3); 07737 if (!SWIG_IsOK(ecode3)) { 07738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'"); 07739 } 07740 arg3 = (PLFLT)(val3); 07741 ecode4 = SWIG_AsVal_double(obj3, &val4); 07742 if (!SWIG_IsOK(ecode4)) { 07743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'"); 07744 } 07745 arg4 = (PLFLT)(val4); 07746 pljoin(arg1,arg2,arg3,arg4); 07747 resultobj = SWIG_Py_Void(); 07748 return resultobj; 07749 fail: 07750 return NULL; 07751 } 07752 07753 07754 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07755 PyObject *resultobj = 0; 07756 char *arg1 = (char *) 0 ; 07757 char *arg2 = (char *) 0 ; 07758 char *arg3 = (char *) 0 ; 07759 int res1 ; 07760 char *buf1 = 0 ; 07761 int alloc1 = 0 ; 07762 int res2 ; 07763 char *buf2 = 0 ; 07764 int alloc2 = 0 ; 07765 int res3 ; 07766 char *buf3 = 0 ; 07767 int alloc3 = 0 ; 07768 PyObject * obj0 = 0 ; 07769 PyObject * obj1 = 0 ; 07770 PyObject * obj2 = 0 ; 07771 07772 if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail; 07773 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 07774 if (!SWIG_IsOK(res1)) { 07775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'"); 07776 } 07777 arg1 = (char *)(buf1); 07778 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 07779 if (!SWIG_IsOK(res2)) { 07780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'"); 07781 } 07782 arg2 = (char *)(buf2); 07783 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); 07784 if (!SWIG_IsOK(res3)) { 07785 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'"); 07786 } 07787 arg3 = (char *)(buf3); 07788 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3); 07789 resultobj = SWIG_Py_Void(); 07790 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 07791 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 07792 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 07793 return resultobj; 07794 fail: 07795 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 07796 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 07797 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 07798 return NULL; 07799 } 07800 07801 07802 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 07803 PyObject *resultobj = 0; 07804 PLFLT *arg1 = (PLFLT *) 0 ; 07805 PLFLT *arg2 = (PLFLT *) 0 ; 07806 PLINT arg3 ; 07807 PLINT arg4 ; 07808 PLFLT arg5 ; 07809 PLFLT arg6 ; 07810 PLFLT arg7 ; 07811 PLINT arg8 ; 07812 PLINT arg9 ; 07813 PLINT arg10 ; 07814 PLINT arg11 ; 07815 PLINT arg12 ; 07816 PLINT arg13 ; 07817 PLINT *arg14 = (PLINT *) 0 ; 07818 PLFLT arg15 ; 07819 PLFLT arg16 ; 07820 PLFLT arg17 ; 07821 PLFLT arg18 ; 07822 PLINT *arg19 = (PLINT *) 0 ; 07823 char **arg20 = (char **) 0 ; 07824 PLINT *arg21 = (PLINT *) 0 ; 07825 PLINT *arg22 = (PLINT *) 0 ; 07826 PLFLT *arg23 = (PLFLT *) 0 ; 07827 PLFLT *arg24 = (PLFLT *) 0 ; 07828 PLINT *arg25 = (PLINT *) 0 ; 07829 PLINT *arg26 = (PLINT *) 0 ; 07830 PLFLT *arg27 = (PLFLT *) 0 ; 07831 PLINT *arg28 = (PLINT *) 0 ; 07832 PLFLT *arg29 = (PLFLT *) 0 ; 07833 PLINT *arg30 = (PLINT *) 0 ; 07834 char **arg31 = (char **) 0 ; 07835 PLFLT temp1 ; 07836 int res1 = SWIG_TMPOBJ ; 07837 PLFLT temp2 ; 07838 int res2 = SWIG_TMPOBJ ; 07839 int val3 ; 07840 int ecode3 = 0 ; 07841 int val4 ; 07842 int ecode4 = 0 ; 07843 double val5 ; 07844 int ecode5 = 0 ; 07845 double val6 ; 07846 int ecode6 = 0 ; 07847 double val7 ; 07848 int ecode7 = 0 ; 07849 int val8 ; 07850 int ecode8 = 0 ; 07851 int val9 ; 07852 int ecode9 = 0 ; 07853 int val10 ; 07854 int ecode10 = 0 ; 07855 int val11 ; 07856 int ecode11 = 0 ; 07857 int val12 ; 07858 int ecode12 = 0 ; 07859 PyArrayObject *tmp13 = NULL ; 07860 double val15 ; 07861 int ecode15 = 0 ; 07862 double val16 ; 07863 int ecode16 = 0 ; 07864 double val17 ; 07865 int ecode17 = 0 ; 07866 double val18 ; 07867 int ecode18 = 0 ; 07868 PyArrayObject *tmp19 = NULL ; 07869 PyArrayObject *tmp20 = NULL ; 07870 PyArrayObject *tmp21 = NULL ; 07871 PyArrayObject *tmp22 = NULL ; 07872 PyArrayObject *tmp23 = NULL ; 07873 PyArrayObject *tmp24 = NULL ; 07874 PyArrayObject *tmp25 = NULL ; 07875 PyArrayObject *tmp26 = NULL ; 07876 PyArrayObject *tmp27 = NULL ; 07877 PyArrayObject *tmp28 = NULL ; 07878 PyArrayObject *tmp29 = NULL ; 07879 PyArrayObject *tmp30 = NULL ; 07880 PyArrayObject *tmp31 = NULL ; 07881 PyObject * obj0 = 0 ; 07882 PyObject * obj1 = 0 ; 07883 PyObject * obj2 = 0 ; 07884 PyObject * obj3 = 0 ; 07885 PyObject * obj4 = 0 ; 07886 PyObject * obj5 = 0 ; 07887 PyObject * obj6 = 0 ; 07888 PyObject * obj7 = 0 ; 07889 PyObject * obj8 = 0 ; 07890 PyObject * obj9 = 0 ; 07891 PyObject * obj10 = 0 ; 07892 PyObject * obj11 = 0 ; 07893 PyObject * obj12 = 0 ; 07894 PyObject * obj13 = 0 ; 07895 PyObject * obj14 = 0 ; 07896 PyObject * obj15 = 0 ; 07897 PyObject * obj16 = 0 ; 07898 PyObject * obj17 = 0 ; 07899 PyObject * obj18 = 0 ; 07900 PyObject * obj19 = 0 ; 07901 PyObject * obj20 = 0 ; 07902 PyObject * obj21 = 0 ; 07903 PyObject * obj22 = 0 ; 07904 PyObject * obj23 = 0 ; 07905 PyObject * obj24 = 0 ; 07906 PyObject * obj25 = 0 ; 07907 PyObject * obj26 = 0 ; 07908 PyObject * obj27 = 0 ; 07909 07910 arg1 = &temp1; 07911 arg2 = &temp2; 07912 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; 07913 ecode3 = SWIG_AsVal_int(obj0, &val3); 07914 if (!SWIG_IsOK(ecode3)) { 07915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'"); 07916 } 07917 arg3 = (PLINT)(val3); 07918 ecode4 = SWIG_AsVal_int(obj1, &val4); 07919 if (!SWIG_IsOK(ecode4)) { 07920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'"); 07921 } 07922 arg4 = (PLINT)(val4); 07923 ecode5 = SWIG_AsVal_double(obj2, &val5); 07924 if (!SWIG_IsOK(ecode5)) { 07925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'"); 07926 } 07927 arg5 = (PLFLT)(val5); 07928 ecode6 = SWIG_AsVal_double(obj3, &val6); 07929 if (!SWIG_IsOK(ecode6)) { 07930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'"); 07931 } 07932 arg6 = (PLFLT)(val6); 07933 ecode7 = SWIG_AsVal_double(obj4, &val7); 07934 if (!SWIG_IsOK(ecode7)) { 07935 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'"); 07936 } 07937 arg7 = (PLFLT)(val7); 07938 ecode8 = SWIG_AsVal_int(obj5, &val8); 07939 if (!SWIG_IsOK(ecode8)) { 07940 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'"); 07941 } 07942 arg8 = (PLINT)(val8); 07943 ecode9 = SWIG_AsVal_int(obj6, &val9); 07944 if (!SWIG_IsOK(ecode9)) { 07945 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'"); 07946 } 07947 arg9 = (PLINT)(val9); 07948 ecode10 = SWIG_AsVal_int(obj7, &val10); 07949 if (!SWIG_IsOK(ecode10)) { 07950 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'"); 07951 } 07952 arg10 = (PLINT)(val10); 07953 ecode11 = SWIG_AsVal_int(obj8, &val11); 07954 if (!SWIG_IsOK(ecode11)) { 07955 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'"); 07956 } 07957 arg11 = (PLINT)(val11); 07958 ecode12 = SWIG_AsVal_int(obj9, &val12); 07959 if (!SWIG_IsOK(ecode12)) { 07960 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'"); 07961 } 07962 arg12 = (PLINT)(val12); 07963 { 07964 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 ); 07965 if ( tmp13 == NULL ) 07966 return NULL; 07967 arg13 = Alen = PyArray_DIMS( tmp13 )[0]; 07968 arg14 = (PLINT *) PyArray_DATA( tmp13 ); 07969 } 07970 ecode15 = SWIG_AsVal_double(obj11, &val15); 07971 if (!SWIG_IsOK(ecode15)) { 07972 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'"); 07973 } 07974 arg15 = (PLFLT)(val15); 07975 ecode16 = SWIG_AsVal_double(obj12, &val16); 07976 if (!SWIG_IsOK(ecode16)) { 07977 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'"); 07978 } 07979 arg16 = (PLFLT)(val16); 07980 ecode17 = SWIG_AsVal_double(obj13, &val17); 07981 if (!SWIG_IsOK(ecode17)) { 07982 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'"); 07983 } 07984 arg17 = (PLFLT)(val17); 07985 ecode18 = SWIG_AsVal_double(obj14, &val18); 07986 if (!SWIG_IsOK(ecode18)) { 07987 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'"); 07988 } 07989 arg18 = (PLFLT)(val18); 07990 { 07991 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 ); 07992 if ( tmp19 == NULL ) 07993 return NULL; 07994 if ( PyArray_DIMS( tmp19 )[0] != Alen ) 07995 { 07996 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 07997 return NULL; 07998 } 07999 arg19 = (PLINT *) PyArray_DATA( tmp19 ); 08000 } 08001 { 08002 int i; 08003 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 ); 08004 if ( tmp20 == NULL ) 08005 return NULL; 08006 if ( PyArray_DIMS( tmp20 )[0] != Alen ) 08007 { 08008 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08009 return NULL; 08010 } 08011 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen ); 08012 for ( i = 0; i < Alen; i++ ) 08013 { 08014 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0]; 08015 if ( arg20[i] == NULL ) 08016 { 08017 free( arg20 ); 08018 return NULL; 08019 } 08020 } 08021 } 08022 { 08023 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 ); 08024 if ( tmp21 == NULL ) 08025 return NULL; 08026 if ( PyArray_DIMS( tmp21 )[0] != Alen ) 08027 { 08028 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08029 return NULL; 08030 } 08031 arg21 = (PLINT *) PyArray_DATA( tmp21 ); 08032 } 08033 { 08034 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 ); 08035 if ( tmp22 == NULL ) 08036 return NULL; 08037 if ( PyArray_DIMS( tmp22 )[0] != Alen ) 08038 { 08039 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08040 return NULL; 08041 } 08042 arg22 = (PLINT *) PyArray_DATA( tmp22 ); 08043 } 08044 { 08045 if ( obj19 != Py_None ) 08046 { 08047 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 ); 08048 if ( tmp23 == NULL ) 08049 return NULL; 08050 if ( PyArray_DIMS( tmp23 )[0] != Alen ) 08051 { 08052 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08053 return NULL; 08054 } 08055 arg23 = (PLFLT *) PyArray_DATA( tmp23 ); 08056 } 08057 else 08058 { 08059 arg23 = NULL; 08060 } 08061 } 08062 { 08063 if ( obj20 != Py_None ) 08064 { 08065 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 ); 08066 if ( tmp24 == NULL ) 08067 return NULL; 08068 if ( PyArray_DIMS( tmp24 )[0] != Alen ) 08069 { 08070 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08071 return NULL; 08072 } 08073 arg24 = (PLFLT *) PyArray_DATA( tmp24 ); 08074 } 08075 else 08076 { 08077 arg24 = NULL; 08078 } 08079 } 08080 { 08081 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 ); 08082 if ( tmp25 == NULL ) 08083 return NULL; 08084 if ( PyArray_DIMS( tmp25 )[0] != Alen ) 08085 { 08086 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08087 return NULL; 08088 } 08089 arg25 = (PLINT *) PyArray_DATA( tmp25 ); 08090 } 08091 { 08092 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 ); 08093 if ( tmp26 == NULL ) 08094 return NULL; 08095 if ( PyArray_DIMS( tmp26 )[0] != Alen ) 08096 { 08097 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08098 return NULL; 08099 } 08100 arg26 = (PLINT *) PyArray_DATA( tmp26 ); 08101 } 08102 { 08103 if ( obj23 != Py_None ) 08104 { 08105 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 ); 08106 if ( tmp27 == NULL ) 08107 return NULL; 08108 if ( PyArray_DIMS( tmp27 )[0] != Alen ) 08109 { 08110 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08111 return NULL; 08112 } 08113 arg27 = (PLFLT *) PyArray_DATA( tmp27 ); 08114 } 08115 else 08116 { 08117 arg27 = NULL; 08118 } 08119 } 08120 { 08121 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 ); 08122 if ( tmp28 == NULL ) 08123 return NULL; 08124 if ( PyArray_DIMS( tmp28 )[0] != Alen ) 08125 { 08126 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08127 return NULL; 08128 } 08129 arg28 = (PLINT *) PyArray_DATA( tmp28 ); 08130 } 08131 { 08132 if ( obj25 != Py_None ) 08133 { 08134 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 ); 08135 if ( tmp29 == NULL ) 08136 return NULL; 08137 if ( PyArray_DIMS( tmp29 )[0] != Alen ) 08138 { 08139 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08140 return NULL; 08141 } 08142 arg29 = (PLFLT *) PyArray_DATA( tmp29 ); 08143 } 08144 else 08145 { 08146 arg29 = NULL; 08147 } 08148 } 08149 { 08150 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 ); 08151 if ( tmp30 == NULL ) 08152 return NULL; 08153 if ( PyArray_DIMS( tmp30 )[0] != Alen ) 08154 { 08155 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08156 return NULL; 08157 } 08158 arg30 = (PLINT *) PyArray_DATA( tmp30 ); 08159 } 08160 { 08161 int i; 08162 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 ); 08163 if ( tmp31 == NULL ) 08164 return NULL; 08165 if ( PyArray_DIMS( tmp31 )[0] != Alen ) 08166 { 08167 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08168 return NULL; 08169 } 08170 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen ); 08171 for ( i = 0; i < Alen; i++ ) 08172 { 08173 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0]; 08174 if ( arg31[i] == NULL ) 08175 { 08176 free( arg31 ); 08177 return NULL; 08178 } 08179 } 08180 } 08181 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); 08182 resultobj = SWIG_Py_Void(); 08183 if (SWIG_IsTmpObj(res1)) { 08184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 08185 } else { 08186 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 08187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 08188 } 08189 if (SWIG_IsTmpObj(res2)) { 08190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 08191 } else { 08192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 08193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 08194 } 08195 { 08196 Py_CLEAR( tmp13 ); 08197 } 08198 { 08199 Py_CLEAR( tmp19 ); 08200 } 08201 { 08202 Py_CLEAR( tmp20 ); free( arg20 ); 08203 } 08204 { 08205 Py_CLEAR( tmp21 ); 08206 } 08207 { 08208 Py_CLEAR( tmp22 ); 08209 } 08210 { 08211 Py_CLEAR( tmp23 ); 08212 } 08213 { 08214 Py_CLEAR( tmp24 ); 08215 } 08216 { 08217 Py_CLEAR( tmp25 ); 08218 } 08219 { 08220 Py_CLEAR( tmp26 ); 08221 } 08222 { 08223 Py_CLEAR( tmp27 ); 08224 } 08225 { 08226 Py_CLEAR( tmp28 ); 08227 } 08228 { 08229 Py_CLEAR( tmp29 ); 08230 } 08231 { 08232 Py_CLEAR( tmp30 ); 08233 } 08234 { 08235 Py_CLEAR( tmp31 ); free( arg31 ); 08236 } 08237 return resultobj; 08238 fail: 08239 { 08240 Py_CLEAR( tmp13 ); 08241 } 08242 { 08243 Py_CLEAR( tmp19 ); 08244 } 08245 { 08246 Py_CLEAR( tmp20 ); free( arg20 ); 08247 } 08248 { 08249 Py_CLEAR( tmp21 ); 08250 } 08251 { 08252 Py_CLEAR( tmp22 ); 08253 } 08254 { 08255 Py_CLEAR( tmp23 ); 08256 } 08257 { 08258 Py_CLEAR( tmp24 ); 08259 } 08260 { 08261 Py_CLEAR( tmp25 ); 08262 } 08263 { 08264 Py_CLEAR( tmp26 ); 08265 } 08266 { 08267 Py_CLEAR( tmp27 ); 08268 } 08269 { 08270 Py_CLEAR( tmp28 ); 08271 } 08272 { 08273 Py_CLEAR( tmp29 ); 08274 } 08275 { 08276 Py_CLEAR( tmp30 ); 08277 } 08278 { 08279 Py_CLEAR( tmp31 ); free( arg31 ); 08280 } 08281 return NULL; 08282 } 08283 08284 08285 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08286 PyObject *resultobj = 0; 08287 PLFLT *arg1 = (PLFLT *) 0 ; 08288 PLFLT *arg2 = (PLFLT *) 0 ; 08289 PLINT arg3 ; 08290 PLINT arg4 ; 08291 PLFLT arg5 ; 08292 PLFLT arg6 ; 08293 PLFLT arg7 ; 08294 PLFLT arg8 ; 08295 PLINT arg9 ; 08296 PLINT arg10 ; 08297 PLINT arg11 ; 08298 PLFLT arg12 ; 08299 PLFLT arg13 ; 08300 PLINT arg14 ; 08301 PLFLT arg15 ; 08302 PLINT arg16 ; 08303 PLINT *arg17 = (PLINT *) 0 ; 08304 char **arg18 = (char **) 0 ; 08305 PLINT arg19 ; 08306 char **arg20 = (char **) 0 ; 08307 PLFLT *arg21 = (PLFLT *) 0 ; 08308 PLINT *arg22 = (PLINT *) 0 ; 08309 PLINT *arg23 = (PLINT *) 0 ; 08310 PLFLT **arg24 = (PLFLT **) 0 ; 08311 PLFLT temp1 ; 08312 int res1 = SWIG_TMPOBJ ; 08313 PLFLT temp2 ; 08314 int res2 = SWIG_TMPOBJ ; 08315 int val3 ; 08316 int ecode3 = 0 ; 08317 int val4 ; 08318 int ecode4 = 0 ; 08319 double val5 ; 08320 int ecode5 = 0 ; 08321 double val6 ; 08322 int ecode6 = 0 ; 08323 double val7 ; 08324 int ecode7 = 0 ; 08325 double val8 ; 08326 int ecode8 = 0 ; 08327 int val9 ; 08328 int ecode9 = 0 ; 08329 int val10 ; 08330 int ecode10 = 0 ; 08331 int val11 ; 08332 int ecode11 = 0 ; 08333 double val12 ; 08334 int ecode12 = 0 ; 08335 double val13 ; 08336 int ecode13 = 0 ; 08337 int val14 ; 08338 int ecode14 = 0 ; 08339 double val15 ; 08340 int ecode15 = 0 ; 08341 PyArrayObject *tmp16 = NULL ; 08342 PyArrayObject *tmp18 = NULL ; 08343 PyArrayObject *tmp19 = NULL ; 08344 PyArrayObject *tmp21 = NULL ; 08345 PyArrayObject *tmp22 = NULL ; 08346 PyArrayObject *tmp23 = NULL ; 08347 PyArrayObject *tmp24 = NULL ; 08348 PyObject * obj0 = 0 ; 08349 PyObject * obj1 = 0 ; 08350 PyObject * obj2 = 0 ; 08351 PyObject * obj3 = 0 ; 08352 PyObject * obj4 = 0 ; 08353 PyObject * obj5 = 0 ; 08354 PyObject * obj6 = 0 ; 08355 PyObject * obj7 = 0 ; 08356 PyObject * obj8 = 0 ; 08357 PyObject * obj9 = 0 ; 08358 PyObject * obj10 = 0 ; 08359 PyObject * obj11 = 0 ; 08360 PyObject * obj12 = 0 ; 08361 PyObject * obj13 = 0 ; 08362 PyObject * obj14 = 0 ; 08363 PyObject * obj15 = 0 ; 08364 PyObject * obj16 = 0 ; 08365 PyObject * obj17 = 0 ; 08366 PyObject * obj18 = 0 ; 08367 PyObject * obj19 = 0 ; 08368 08369 arg1 = &temp1; 08370 arg2 = &temp2; 08371 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; 08372 ecode3 = SWIG_AsVal_int(obj0, &val3); 08373 if (!SWIG_IsOK(ecode3)) { 08374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'"); 08375 } 08376 arg3 = (PLINT)(val3); 08377 ecode4 = SWIG_AsVal_int(obj1, &val4); 08378 if (!SWIG_IsOK(ecode4)) { 08379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'"); 08380 } 08381 arg4 = (PLINT)(val4); 08382 ecode5 = SWIG_AsVal_double(obj2, &val5); 08383 if (!SWIG_IsOK(ecode5)) { 08384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'"); 08385 } 08386 arg5 = (PLFLT)(val5); 08387 ecode6 = SWIG_AsVal_double(obj3, &val6); 08388 if (!SWIG_IsOK(ecode6)) { 08389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'"); 08390 } 08391 arg6 = (PLFLT)(val6); 08392 ecode7 = SWIG_AsVal_double(obj4, &val7); 08393 if (!SWIG_IsOK(ecode7)) { 08394 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'"); 08395 } 08396 arg7 = (PLFLT)(val7); 08397 ecode8 = SWIG_AsVal_double(obj5, &val8); 08398 if (!SWIG_IsOK(ecode8)) { 08399 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'"); 08400 } 08401 arg8 = (PLFLT)(val8); 08402 ecode9 = SWIG_AsVal_int(obj6, &val9); 08403 if (!SWIG_IsOK(ecode9)) { 08404 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'"); 08405 } 08406 arg9 = (PLINT)(val9); 08407 ecode10 = SWIG_AsVal_int(obj7, &val10); 08408 if (!SWIG_IsOK(ecode10)) { 08409 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'"); 08410 } 08411 arg10 = (PLINT)(val10); 08412 ecode11 = SWIG_AsVal_int(obj8, &val11); 08413 if (!SWIG_IsOK(ecode11)) { 08414 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'"); 08415 } 08416 arg11 = (PLINT)(val11); 08417 ecode12 = SWIG_AsVal_double(obj9, &val12); 08418 if (!SWIG_IsOK(ecode12)) { 08419 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'"); 08420 } 08421 arg12 = (PLFLT)(val12); 08422 ecode13 = SWIG_AsVal_double(obj10, &val13); 08423 if (!SWIG_IsOK(ecode13)) { 08424 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'"); 08425 } 08426 arg13 = (PLFLT)(val13); 08427 ecode14 = SWIG_AsVal_int(obj11, &val14); 08428 if (!SWIG_IsOK(ecode14)) { 08429 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'"); 08430 } 08431 arg14 = (PLINT)(val14); 08432 ecode15 = SWIG_AsVal_double(obj12, &val15); 08433 if (!SWIG_IsOK(ecode15)) { 08434 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'"); 08435 } 08436 arg15 = (PLFLT)(val15); 08437 { 08438 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 ); 08439 if ( tmp16 == NULL ) 08440 return NULL; 08441 arg16 = Alen = PyArray_DIMS( tmp16 )[0]; 08442 arg17 = (PLINT *) PyArray_DATA( tmp16 ); 08443 } 08444 { 08445 int i; 08446 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 ); 08447 if ( tmp18 == NULL ) 08448 return NULL; 08449 if ( PyArray_DIMS( tmp18 )[0] != Alen ) 08450 { 08451 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08452 return NULL; 08453 } 08454 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen ); 08455 for ( i = 0; i < Alen; i++ ) 08456 { 08457 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0]; 08458 if ( arg18[i] == NULL ) 08459 { 08460 free( arg18 ); 08461 return NULL; 08462 } 08463 } 08464 } 08465 { 08466 int i; 08467 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 ); 08468 if ( tmp19 == NULL ) 08469 return NULL; 08470 Alen = PyArray_DIMS( tmp19 )[0]; 08471 arg19 = Alen; 08472 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen ); 08473 for ( i = 0; i < Alen; i++ ) 08474 { 08475 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0]; 08476 if ( arg20[i] == NULL ) 08477 { 08478 free( arg20 ); 08479 return NULL; 08480 } 08481 } 08482 } 08483 { 08484 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 ); 08485 if ( tmp21 == NULL ) 08486 return NULL; 08487 if ( PyArray_DIMS( tmp21 )[0] != Alen ) 08488 { 08489 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08490 return NULL; 08491 } 08492 arg21 = (PLFLT *) PyArray_DATA( tmp21 ); 08493 } 08494 { 08495 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 ); 08496 if ( tmp22 == NULL ) 08497 return NULL; 08498 if ( PyArray_DIMS( tmp22 )[0] != Alen ) 08499 { 08500 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08501 return NULL; 08502 } 08503 arg22 = (PLINT *) PyArray_DATA( tmp22 ); 08504 } 08505 { 08506 int i; 08507 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 ); 08508 if ( tmp23 == NULL ) 08509 return NULL; 08510 if ( PyArray_DIMS( tmp23 )[0] != Alen ) 08511 { 08512 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08513 return NULL; 08514 } 08515 Xlen = PyArray_DIMS( tmp23 )[0]; 08516 arg23 = (PLINT *) PyArray_DATA( tmp23 ); 08517 Ylen = -1; 08518 for ( i = 0; i < Xlen; i++ ) 08519 if ( arg23[i] > Ylen ) 08520 Ylen = arg23[i]; 08521 } 08522 { 08523 int i, size; 08524 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 ); 08525 if ( tmp24 == NULL ) 08526 return NULL; 08527 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen ) 08528 { 08529 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 08530 return NULL; 08531 } 08532 size = Ylen; 08533 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen ); 08534 for ( i = 0; i < Xlen; i++ ) 08535 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size ); 08536 } 08537 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); 08538 resultobj = SWIG_Py_Void(); 08539 if (SWIG_IsTmpObj(res1)) { 08540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 08541 } else { 08542 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 08543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 08544 } 08545 if (SWIG_IsTmpObj(res2)) { 08546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 08547 } else { 08548 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 08549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 08550 } 08551 { 08552 Py_CLEAR( tmp16 ); 08553 } 08554 { 08555 Py_CLEAR( tmp18 ); free( arg18 ); 08556 } 08557 { 08558 Py_CLEAR( tmp19 ); free( arg20 ); 08559 } 08560 { 08561 Py_CLEAR( tmp21 ); 08562 } 08563 { 08564 Py_CLEAR( tmp22 ); 08565 } 08566 { 08567 Py_CLEAR( tmp23 ); 08568 } 08569 { 08570 Py_CLEAR( tmp24 ); 08571 free( arg24 ); 08572 } 08573 return resultobj; 08574 fail: 08575 { 08576 Py_CLEAR( tmp16 ); 08577 } 08578 { 08579 Py_CLEAR( tmp18 ); free( arg18 ); 08580 } 08581 { 08582 Py_CLEAR( tmp19 ); free( arg20 ); 08583 } 08584 { 08585 Py_CLEAR( tmp21 ); 08586 } 08587 { 08588 Py_CLEAR( tmp22 ); 08589 } 08590 { 08591 Py_CLEAR( tmp23 ); 08592 } 08593 { 08594 Py_CLEAR( tmp24 ); 08595 free( arg24 ); 08596 } 08597 return NULL; 08598 } 08599 08600 08601 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08602 PyObject *resultobj = 0; 08603 PLFLT arg1 ; 08604 PLFLT arg2 ; 08605 PLFLT arg3 ; 08606 double val1 ; 08607 int ecode1 = 0 ; 08608 double val2 ; 08609 int ecode2 = 0 ; 08610 double val3 ; 08611 int ecode3 = 0 ; 08612 PyObject * obj0 = 0 ; 08613 PyObject * obj1 = 0 ; 08614 PyObject * obj2 = 0 ; 08615 08616 if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail; 08617 ecode1 = SWIG_AsVal_double(obj0, &val1); 08618 if (!SWIG_IsOK(ecode1)) { 08619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'"); 08620 } 08621 arg1 = (PLFLT)(val1); 08622 ecode2 = SWIG_AsVal_double(obj1, &val2); 08623 if (!SWIG_IsOK(ecode2)) { 08624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'"); 08625 } 08626 arg2 = (PLFLT)(val2); 08627 ecode3 = SWIG_AsVal_double(obj2, &val3); 08628 if (!SWIG_IsOK(ecode3)) { 08629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'"); 08630 } 08631 arg3 = (PLFLT)(val3); 08632 pllightsource(arg1,arg2,arg3); 08633 resultobj = SWIG_Py_Void(); 08634 return resultobj; 08635 fail: 08636 return NULL; 08637 } 08638 08639 08640 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08641 PyObject *resultobj = 0; 08642 PLINT arg1 ; 08643 PLFLT *arg2 = (PLFLT *) 0 ; 08644 PLFLT *arg3 = (PLFLT *) 0 ; 08645 PyArrayObject *tmp1 = NULL ; 08646 PyArrayObject *tmp3 = NULL ; 08647 PyObject * obj0 = 0 ; 08648 PyObject * obj1 = 0 ; 08649 08650 if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail; 08651 { 08652 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 08653 if ( tmp1 == NULL ) 08654 return NULL; 08655 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 08656 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 08657 } 08658 { 08659 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 08660 if ( tmp3 == NULL ) 08661 return NULL; 08662 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 08663 { 08664 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08665 return NULL; 08666 } 08667 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 08668 } 08669 plline(arg1,(double const *)arg2,(double const *)arg3); 08670 resultobj = SWIG_Py_Void(); 08671 { 08672 Py_CLEAR( tmp1 ); 08673 } 08674 { 08675 Py_CLEAR( tmp3 ); 08676 } 08677 return resultobj; 08678 fail: 08679 { 08680 Py_CLEAR( tmp1 ); 08681 } 08682 { 08683 Py_CLEAR( tmp3 ); 08684 } 08685 return NULL; 08686 } 08687 08688 08689 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08690 PyObject *resultobj = 0; 08691 PLINT arg1 ; 08692 PLFLT *arg2 = (PLFLT *) 0 ; 08693 PLFLT *arg3 = (PLFLT *) 0 ; 08694 PLFLT *arg4 = (PLFLT *) 0 ; 08695 PyArrayObject *tmp1 = NULL ; 08696 PyArrayObject *tmp3 = NULL ; 08697 PyArrayObject *tmp4 = NULL ; 08698 PyObject * obj0 = 0 ; 08699 PyObject * obj1 = 0 ; 08700 PyObject * obj2 = 0 ; 08701 08702 if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail; 08703 { 08704 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 08705 if ( tmp1 == NULL ) 08706 return NULL; 08707 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 08708 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 08709 } 08710 { 08711 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 08712 if ( tmp3 == NULL ) 08713 return NULL; 08714 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 08715 { 08716 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08717 return NULL; 08718 } 08719 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 08720 } 08721 { 08722 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 08723 if ( tmp4 == NULL ) 08724 return NULL; 08725 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 08726 { 08727 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 08728 return NULL; 08729 } 08730 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 08731 } 08732 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4); 08733 resultobj = SWIG_Py_Void(); 08734 { 08735 Py_CLEAR( tmp1 ); 08736 } 08737 { 08738 Py_CLEAR( tmp3 ); 08739 } 08740 { 08741 Py_CLEAR( tmp4 ); 08742 } 08743 return resultobj; 08744 fail: 08745 { 08746 Py_CLEAR( tmp1 ); 08747 } 08748 { 08749 Py_CLEAR( tmp3 ); 08750 } 08751 { 08752 Py_CLEAR( tmp4 ); 08753 } 08754 return NULL; 08755 } 08756 08757 08758 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08759 PyObject *resultobj = 0; 08760 PLINT arg1 ; 08761 int val1 ; 08762 int ecode1 = 0 ; 08763 PyObject * obj0 = 0 ; 08764 08765 if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail; 08766 ecode1 = SWIG_AsVal_int(obj0, &val1); 08767 if (!SWIG_IsOK(ecode1)) { 08768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'"); 08769 } 08770 arg1 = (PLINT)(val1); 08771 pllsty(arg1); 08772 resultobj = SWIG_Py_Void(); 08773 return resultobj; 08774 fail: 08775 return NULL; 08776 } 08777 08778 08779 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08780 PyObject *resultobj = 0; 08781 PLFLT *arg1 = (PLFLT *) 0 ; 08782 PLFLT *arg2 = (PLFLT *) 0 ; 08783 PLFLT **arg3 = (PLFLT **) 0 ; 08784 PLINT arg4 ; 08785 PLINT arg5 ; 08786 PLINT arg6 ; 08787 PyArrayObject *tmp1 = NULL ; 08788 PyArrayObject *tmp2 = NULL ; 08789 PyArrayObject *tmp3 = NULL ; 08790 int val6 ; 08791 int ecode6 = 0 ; 08792 PyObject * obj0 = 0 ; 08793 PyObject * obj1 = 0 ; 08794 PyObject * obj2 = 0 ; 08795 PyObject * obj3 = 0 ; 08796 08797 if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 08798 { 08799 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 08800 if ( tmp1 == NULL ) 08801 return NULL; 08802 Xlen = PyArray_DIMS( tmp1 )[0]; 08803 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 08804 } 08805 { 08806 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 08807 if ( tmp2 == NULL ) 08808 return NULL; 08809 Ylen = PyArray_DIMS( tmp2 )[0]; 08810 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 08811 } 08812 { 08813 int i, size; 08814 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 08815 if ( tmp3 == NULL ) 08816 return NULL; 08817 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 08818 { 08819 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 08820 return NULL; 08821 } 08822 arg4 = PyArray_DIMS( tmp3 )[0]; 08823 arg5 = PyArray_DIMS( tmp3 )[1]; 08824 size = arg5; 08825 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 08826 for ( i = 0; i < arg4; i++ ) 08827 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 08828 } 08829 ecode6 = SWIG_AsVal_int(obj3, &val6); 08830 if (!SWIG_IsOK(ecode6)) { 08831 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'"); 08832 } 08833 arg6 = (PLINT)(val6); 08834 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6); 08835 resultobj = SWIG_Py_Void(); 08836 { 08837 Py_CLEAR( tmp1 ); 08838 } 08839 { 08840 Py_CLEAR( tmp2 ); 08841 } 08842 { 08843 Py_CLEAR( tmp3 ); 08844 free( arg3 ); 08845 } 08846 return resultobj; 08847 fail: 08848 { 08849 Py_CLEAR( tmp1 ); 08850 } 08851 { 08852 Py_CLEAR( tmp2 ); 08853 } 08854 { 08855 Py_CLEAR( tmp3 ); 08856 free( arg3 ); 08857 } 08858 return NULL; 08859 } 08860 08861 08862 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08863 PyObject *resultobj = 0; 08864 PLFLT *arg1 = (PLFLT *) 0 ; 08865 PLFLT *arg2 = (PLFLT *) 0 ; 08866 PLFLT **arg3 = (PLFLT **) 0 ; 08867 PLINT arg4 ; 08868 PLINT arg5 ; 08869 PLINT arg6 ; 08870 PLFLT *arg7 = (PLFLT *) 0 ; 08871 PLINT arg8 ; 08872 PyArrayObject *tmp1 = NULL ; 08873 PyArrayObject *tmp2 = NULL ; 08874 PyArrayObject *tmp3 = NULL ; 08875 int val6 ; 08876 int ecode6 = 0 ; 08877 PyArrayObject *tmp7 = NULL ; 08878 PyObject * obj0 = 0 ; 08879 PyObject * obj1 = 0 ; 08880 PyObject * obj2 = 0 ; 08881 PyObject * obj3 = 0 ; 08882 PyObject * obj4 = 0 ; 08883 08884 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 08885 { 08886 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 08887 if ( tmp1 == NULL ) 08888 return NULL; 08889 Xlen = PyArray_DIMS( tmp1 )[0]; 08890 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 08891 } 08892 { 08893 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 08894 if ( tmp2 == NULL ) 08895 return NULL; 08896 Ylen = PyArray_DIMS( tmp2 )[0]; 08897 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 08898 } 08899 { 08900 int i, size; 08901 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 08902 if ( tmp3 == NULL ) 08903 return NULL; 08904 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 08905 { 08906 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 08907 return NULL; 08908 } 08909 arg4 = PyArray_DIMS( tmp3 )[0]; 08910 arg5 = PyArray_DIMS( tmp3 )[1]; 08911 size = arg5; 08912 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 08913 for ( i = 0; i < arg4; i++ ) 08914 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 08915 } 08916 ecode6 = SWIG_AsVal_int(obj3, &val6); 08917 if (!SWIG_IsOK(ecode6)) { 08918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'"); 08919 } 08920 arg6 = (PLINT)(val6); 08921 { 08922 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 08923 if ( tmp7 == NULL ) 08924 return NULL; 08925 arg8 = PyArray_DIMS( tmp7 )[0]; 08926 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 08927 } 08928 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8); 08929 resultobj = SWIG_Py_Void(); 08930 { 08931 Py_CLEAR( tmp1 ); 08932 } 08933 { 08934 Py_CLEAR( tmp2 ); 08935 } 08936 { 08937 Py_CLEAR( tmp3 ); 08938 free( arg3 ); 08939 } 08940 { 08941 Py_CLEAR( tmp7 ); 08942 } 08943 return resultobj; 08944 fail: 08945 { 08946 Py_CLEAR( tmp1 ); 08947 } 08948 { 08949 Py_CLEAR( tmp2 ); 08950 } 08951 { 08952 Py_CLEAR( tmp3 ); 08953 free( arg3 ); 08954 } 08955 { 08956 Py_CLEAR( tmp7 ); 08957 } 08958 return NULL; 08959 } 08960 08961 08962 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08963 PyObject *resultobj = 0; 08964 PLINT *arg1 = (PLINT *) 0 ; 08965 PLINT temp1 ; 08966 int res1 = SWIG_TMPOBJ ; 08967 08968 arg1 = &temp1; 08969 if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail; 08970 plmkstrm(arg1); 08971 resultobj = SWIG_Py_Void(); 08972 if (SWIG_IsTmpObj(res1)) { 08973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 08974 } else { 08975 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 08976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 08977 } 08978 return resultobj; 08979 fail: 08980 return NULL; 08981 } 08982 08983 08984 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 08985 PyObject *resultobj = 0; 08986 char *arg1 = (char *) 0 ; 08987 PLFLT arg2 ; 08988 PLFLT arg3 ; 08989 PLFLT arg4 ; 08990 char *arg5 = (char *) 0 ; 08991 int res1 ; 08992 char *buf1 = 0 ; 08993 int alloc1 = 0 ; 08994 double val2 ; 08995 int ecode2 = 0 ; 08996 double val3 ; 08997 int ecode3 = 0 ; 08998 double val4 ; 08999 int ecode4 = 0 ; 09000 int res5 ; 09001 char *buf5 = 0 ; 09002 int alloc5 = 0 ; 09003 PyObject * obj0 = 0 ; 09004 PyObject * obj1 = 0 ; 09005 PyObject * obj2 = 0 ; 09006 PyObject * obj3 = 0 ; 09007 PyObject * obj4 = 0 ; 09008 09009 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09010 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 09011 if (!SWIG_IsOK(res1)) { 09012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'"); 09013 } 09014 arg1 = (char *)(buf1); 09015 ecode2 = SWIG_AsVal_double(obj1, &val2); 09016 if (!SWIG_IsOK(ecode2)) { 09017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'"); 09018 } 09019 arg2 = (PLFLT)(val2); 09020 ecode3 = SWIG_AsVal_double(obj2, &val3); 09021 if (!SWIG_IsOK(ecode3)) { 09022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'"); 09023 } 09024 arg3 = (PLFLT)(val3); 09025 ecode4 = SWIG_AsVal_double(obj3, &val4); 09026 if (!SWIG_IsOK(ecode4)) { 09027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'"); 09028 } 09029 arg4 = (PLFLT)(val4); 09030 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); 09031 if (!SWIG_IsOK(res5)) { 09032 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'"); 09033 } 09034 arg5 = (char *)(buf5); 09035 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5); 09036 resultobj = SWIG_Py_Void(); 09037 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 09038 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 09039 return resultobj; 09040 fail: 09041 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 09042 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 09043 return NULL; 09044 } 09045 09046 09047 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09048 PyObject *resultobj = 0; 09049 char *arg1 = (char *) 0 ; 09050 PLFLT arg2 ; 09051 PLFLT arg3 ; 09052 PLFLT arg4 ; 09053 char *arg5 = (char *) 0 ; 09054 int res1 ; 09055 char *buf1 = 0 ; 09056 int alloc1 = 0 ; 09057 double val2 ; 09058 int ecode2 = 0 ; 09059 double val3 ; 09060 int ecode3 = 0 ; 09061 double val4 ; 09062 int ecode4 = 0 ; 09063 int res5 ; 09064 char *buf5 = 0 ; 09065 int alloc5 = 0 ; 09066 PyObject * obj0 = 0 ; 09067 PyObject * obj1 = 0 ; 09068 PyObject * obj2 = 0 ; 09069 PyObject * obj3 = 0 ; 09070 PyObject * obj4 = 0 ; 09071 09072 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09073 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 09074 if (!SWIG_IsOK(res1)) { 09075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'"); 09076 } 09077 arg1 = (char *)(buf1); 09078 ecode2 = SWIG_AsVal_double(obj1, &val2); 09079 if (!SWIG_IsOK(ecode2)) { 09080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'"); 09081 } 09082 arg2 = (PLFLT)(val2); 09083 ecode3 = SWIG_AsVal_double(obj2, &val3); 09084 if (!SWIG_IsOK(ecode3)) { 09085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'"); 09086 } 09087 arg3 = (PLFLT)(val3); 09088 ecode4 = SWIG_AsVal_double(obj3, &val4); 09089 if (!SWIG_IsOK(ecode4)) { 09090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'"); 09091 } 09092 arg4 = (PLFLT)(val4); 09093 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); 09094 if (!SWIG_IsOK(res5)) { 09095 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'"); 09096 } 09097 arg5 = (char *)(buf5); 09098 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5); 09099 resultobj = SWIG_Py_Void(); 09100 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 09101 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 09102 return resultobj; 09103 fail: 09104 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 09105 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 09106 return NULL; 09107 } 09108 09109 09110 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09111 PyObject *resultobj = 0; 09112 PLFLT *arg1 = (PLFLT *) 0 ; 09113 PLFLT *arg2 = (PLFLT *) 0 ; 09114 PLFLT **arg3 = (PLFLT **) 0 ; 09115 PLINT arg4 ; 09116 PLINT arg5 ; 09117 PLINT arg6 ; 09118 PLBOOL arg7 ; 09119 PyArrayObject *tmp1 = NULL ; 09120 PyArrayObject *tmp2 = NULL ; 09121 PyArrayObject *tmp3 = NULL ; 09122 int val6 ; 09123 int ecode6 = 0 ; 09124 int val7 ; 09125 int ecode7 = 0 ; 09126 PyObject * obj0 = 0 ; 09127 PyObject * obj1 = 0 ; 09128 PyObject * obj2 = 0 ; 09129 PyObject * obj3 = 0 ; 09130 PyObject * obj4 = 0 ; 09131 09132 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09133 { 09134 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09135 if ( tmp1 == NULL ) 09136 return NULL; 09137 Xlen = PyArray_DIMS( tmp1 )[0]; 09138 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 09139 } 09140 { 09141 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09142 if ( tmp2 == NULL ) 09143 return NULL; 09144 Ylen = PyArray_DIMS( tmp2 )[0]; 09145 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 09146 } 09147 { 09148 int i, size; 09149 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 09150 if ( tmp3 == NULL ) 09151 return NULL; 09152 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 09153 { 09154 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 09155 return NULL; 09156 } 09157 arg4 = PyArray_DIMS( tmp3 )[0]; 09158 arg5 = PyArray_DIMS( tmp3 )[1]; 09159 size = arg5; 09160 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 09161 for ( i = 0; i < arg4; i++ ) 09162 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 09163 } 09164 ecode6 = SWIG_AsVal_int(obj3, &val6); 09165 if (!SWIG_IsOK(ecode6)) { 09166 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'"); 09167 } 09168 arg6 = (PLINT)(val6); 09169 ecode7 = SWIG_AsVal_int(obj4, &val7); 09170 if (!SWIG_IsOK(ecode7)) { 09171 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'"); 09172 } 09173 arg7 = (PLBOOL)(val7); 09174 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7); 09175 resultobj = SWIG_Py_Void(); 09176 { 09177 Py_CLEAR( tmp1 ); 09178 } 09179 { 09180 Py_CLEAR( tmp2 ); 09181 } 09182 { 09183 Py_CLEAR( tmp3 ); 09184 free( arg3 ); 09185 } 09186 return resultobj; 09187 fail: 09188 { 09189 Py_CLEAR( tmp1 ); 09190 } 09191 { 09192 Py_CLEAR( tmp2 ); 09193 } 09194 { 09195 Py_CLEAR( tmp3 ); 09196 free( arg3 ); 09197 } 09198 return NULL; 09199 } 09200 09201 09202 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09203 PyObject *resultobj = 0; 09204 PLFLT *arg1 = (PLFLT *) 0 ; 09205 PLFLT *arg2 = (PLFLT *) 0 ; 09206 PLFLT **arg3 = (PLFLT **) 0 ; 09207 PLINT arg4 ; 09208 PLINT arg5 ; 09209 PLINT arg6 ; 09210 PLFLT *arg7 = (PLFLT *) 0 ; 09211 PLINT arg8 ; 09212 PyArrayObject *tmp1 = NULL ; 09213 PyArrayObject *tmp2 = NULL ; 09214 PyArrayObject *tmp3 = NULL ; 09215 int val6 ; 09216 int ecode6 = 0 ; 09217 PyArrayObject *tmp7 = NULL ; 09218 PyObject * obj0 = 0 ; 09219 PyObject * obj1 = 0 ; 09220 PyObject * obj2 = 0 ; 09221 PyObject * obj3 = 0 ; 09222 PyObject * obj4 = 0 ; 09223 09224 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09225 { 09226 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09227 if ( tmp1 == NULL ) 09228 return NULL; 09229 Xlen = PyArray_DIMS( tmp1 )[0]; 09230 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 09231 } 09232 { 09233 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09234 if ( tmp2 == NULL ) 09235 return NULL; 09236 Ylen = PyArray_DIMS( tmp2 )[0]; 09237 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 09238 } 09239 { 09240 int i, size; 09241 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 09242 if ( tmp3 == NULL ) 09243 return NULL; 09244 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 09245 { 09246 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 09247 return NULL; 09248 } 09249 arg4 = PyArray_DIMS( tmp3 )[0]; 09250 arg5 = PyArray_DIMS( tmp3 )[1]; 09251 size = arg5; 09252 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 09253 for ( i = 0; i < arg4; i++ ) 09254 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 09255 } 09256 ecode6 = SWIG_AsVal_int(obj3, &val6); 09257 if (!SWIG_IsOK(ecode6)) { 09258 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'"); 09259 } 09260 arg6 = (PLINT)(val6); 09261 { 09262 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 09263 if ( tmp7 == NULL ) 09264 return NULL; 09265 arg8 = PyArray_DIMS( tmp7 )[0]; 09266 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 09267 } 09268 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8); 09269 resultobj = SWIG_Py_Void(); 09270 { 09271 Py_CLEAR( tmp1 ); 09272 } 09273 { 09274 Py_CLEAR( tmp2 ); 09275 } 09276 { 09277 Py_CLEAR( tmp3 ); 09278 free( arg3 ); 09279 } 09280 { 09281 Py_CLEAR( tmp7 ); 09282 } 09283 return resultobj; 09284 fail: 09285 { 09286 Py_CLEAR( tmp1 ); 09287 } 09288 { 09289 Py_CLEAR( tmp2 ); 09290 } 09291 { 09292 Py_CLEAR( tmp3 ); 09293 free( arg3 ); 09294 } 09295 { 09296 Py_CLEAR( tmp7 ); 09297 } 09298 return NULL; 09299 } 09300 09301 09302 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09303 PyObject *resultobj = 0; 09304 PLFLT *arg1 = (PLFLT *) 0 ; 09305 PLFLT *arg2 = (PLFLT *) 0 ; 09306 PLFLT **arg3 = (PLFLT **) 0 ; 09307 PLINT arg4 ; 09308 PLINT arg5 ; 09309 PLINT arg6 ; 09310 PLFLT *arg7 = (PLFLT *) 0 ; 09311 PLINT arg8 ; 09312 PLINT arg9 ; 09313 PLINT arg10 ; 09314 PLINT *arg11 = (PLINT *) 0 ; 09315 PLINT *arg12 = (PLINT *) 0 ; 09316 PyArrayObject *tmp1 = NULL ; 09317 PyArrayObject *tmp2 = NULL ; 09318 PyArrayObject *tmp3 = NULL ; 09319 int val6 ; 09320 int ecode6 = 0 ; 09321 PyArrayObject *tmp7 = NULL ; 09322 int val9 ; 09323 int ecode9 = 0 ; 09324 PyArrayObject *tmp10 = NULL ; 09325 PyArrayObject *tmp12 = NULL ; 09326 PyObject * obj0 = 0 ; 09327 PyObject * obj1 = 0 ; 09328 PyObject * obj2 = 0 ; 09329 PyObject * obj3 = 0 ; 09330 PyObject * obj4 = 0 ; 09331 PyObject * obj5 = 0 ; 09332 PyObject * obj6 = 0 ; 09333 PyObject * obj7 = 0 ; 09334 09335 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; 09336 { 09337 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09338 if ( tmp1 == NULL ) 09339 return NULL; 09340 Xlen = PyArray_DIMS( tmp1 )[0]; 09341 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 09342 } 09343 { 09344 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09345 if ( tmp2 == NULL ) 09346 return NULL; 09347 Ylen = PyArray_DIMS( tmp2 )[0]; 09348 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 09349 } 09350 { 09351 int i, size; 09352 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 09353 if ( tmp3 == NULL ) 09354 return NULL; 09355 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 09356 { 09357 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 09358 return NULL; 09359 } 09360 arg4 = PyArray_DIMS( tmp3 )[0]; 09361 arg5 = PyArray_DIMS( tmp3 )[1]; 09362 size = arg5; 09363 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 09364 for ( i = 0; i < arg4; i++ ) 09365 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 09366 } 09367 ecode6 = SWIG_AsVal_int(obj3, &val6); 09368 if (!SWIG_IsOK(ecode6)) { 09369 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'"); 09370 } 09371 arg6 = (PLINT)(val6); 09372 { 09373 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 09374 if ( tmp7 == NULL ) 09375 return NULL; 09376 arg8 = PyArray_DIMS( tmp7 )[0]; 09377 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 09378 } 09379 ecode9 = SWIG_AsVal_int(obj5, &val9); 09380 if (!SWIG_IsOK(ecode9)) { 09381 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'"); 09382 } 09383 arg9 = (PLINT)(val9); 09384 { 09385 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 ); 09386 if ( tmp10 == NULL ) 09387 return NULL; 09388 arg10 = Alen = PyArray_DIMS( tmp10 )[0]; 09389 arg11 = (PLINT *) PyArray_DATA( tmp10 ); 09390 } 09391 { 09392 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 ); 09393 if ( tmp12 == NULL ) 09394 return NULL; 09395 if ( PyArray_DIMS( tmp12 )[0] != Alen ) 09396 { 09397 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09398 return NULL; 09399 } 09400 arg12 = (PLINT *) PyArray_DATA( tmp12 ); 09401 } 09402 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); 09403 resultobj = SWIG_Py_Void(); 09404 { 09405 Py_CLEAR( tmp1 ); 09406 } 09407 { 09408 Py_CLEAR( tmp2 ); 09409 } 09410 { 09411 Py_CLEAR( tmp3 ); 09412 free( arg3 ); 09413 } 09414 { 09415 Py_CLEAR( tmp7 ); 09416 } 09417 { 09418 Py_CLEAR( tmp10 ); 09419 } 09420 { 09421 Py_CLEAR( tmp12 ); 09422 } 09423 return resultobj; 09424 fail: 09425 { 09426 Py_CLEAR( tmp1 ); 09427 } 09428 { 09429 Py_CLEAR( tmp2 ); 09430 } 09431 { 09432 Py_CLEAR( tmp3 ); 09433 free( arg3 ); 09434 } 09435 { 09436 Py_CLEAR( tmp7 ); 09437 } 09438 { 09439 Py_CLEAR( tmp10 ); 09440 } 09441 { 09442 Py_CLEAR( tmp12 ); 09443 } 09444 return NULL; 09445 } 09446 09447 09448 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09449 PyObject *resultobj = 0; 09450 PLFLT *arg1 = (PLFLT *) 0 ; 09451 PLFLT *arg2 = (PLFLT *) 0 ; 09452 PLFLT **arg3 = (PLFLT **) 0 ; 09453 PLINT arg4 ; 09454 PLINT arg5 ; 09455 PLINT arg6 ; 09456 PLFLT *arg7 = (PLFLT *) 0 ; 09457 PLINT arg8 ; 09458 PyArrayObject *tmp1 = NULL ; 09459 PyArrayObject *tmp2 = NULL ; 09460 PyArrayObject *tmp3 = NULL ; 09461 int val6 ; 09462 int ecode6 = 0 ; 09463 PyArrayObject *tmp7 = NULL ; 09464 PyObject * obj0 = 0 ; 09465 PyObject * obj1 = 0 ; 09466 PyObject * obj2 = 0 ; 09467 PyObject * obj3 = 0 ; 09468 PyObject * obj4 = 0 ; 09469 09470 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09471 { 09472 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09473 if ( tmp1 == NULL ) 09474 return NULL; 09475 Xlen = PyArray_DIMS( tmp1 )[0]; 09476 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 09477 } 09478 { 09479 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09480 if ( tmp2 == NULL ) 09481 return NULL; 09482 Ylen = PyArray_DIMS( tmp2 )[0]; 09483 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 09484 } 09485 { 09486 int i, size; 09487 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 09488 if ( tmp3 == NULL ) 09489 return NULL; 09490 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 09491 { 09492 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 09493 return NULL; 09494 } 09495 arg4 = PyArray_DIMS( tmp3 )[0]; 09496 arg5 = PyArray_DIMS( tmp3 )[1]; 09497 size = arg5; 09498 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 09499 for ( i = 0; i < arg4; i++ ) 09500 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 09501 } 09502 ecode6 = SWIG_AsVal_int(obj3, &val6); 09503 if (!SWIG_IsOK(ecode6)) { 09504 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'"); 09505 } 09506 arg6 = (PLINT)(val6); 09507 { 09508 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 09509 if ( tmp7 == NULL ) 09510 return NULL; 09511 arg8 = PyArray_DIMS( tmp7 )[0]; 09512 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 09513 } 09514 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8); 09515 resultobj = SWIG_Py_Void(); 09516 { 09517 Py_CLEAR( tmp1 ); 09518 } 09519 { 09520 Py_CLEAR( tmp2 ); 09521 } 09522 { 09523 Py_CLEAR( tmp3 ); 09524 free( arg3 ); 09525 } 09526 { 09527 Py_CLEAR( tmp7 ); 09528 } 09529 return resultobj; 09530 fail: 09531 { 09532 Py_CLEAR( tmp1 ); 09533 } 09534 { 09535 Py_CLEAR( tmp2 ); 09536 } 09537 { 09538 Py_CLEAR( tmp3 ); 09539 free( arg3 ); 09540 } 09541 { 09542 Py_CLEAR( tmp7 ); 09543 } 09544 return NULL; 09545 } 09546 09547 09548 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09549 PyObject *resultobj = 0; 09550 PLFLT *arg1 = (PLFLT *) 0 ; 09551 PLFLT *arg2 = (PLFLT *) 0 ; 09552 PLFLT **arg3 = (PLFLT **) 0 ; 09553 PLINT arg4 ; 09554 PLINT arg5 ; 09555 PLINT arg6 ; 09556 PLFLT *arg7 = (PLFLT *) 0 ; 09557 PLINT arg8 ; 09558 PLINT arg9 ; 09559 PLINT arg10 ; 09560 PLINT *arg11 = (PLINT *) 0 ; 09561 PLINT *arg12 = (PLINT *) 0 ; 09562 PyArrayObject *tmp1 = NULL ; 09563 PyArrayObject *tmp2 = NULL ; 09564 PyArrayObject *tmp3 = NULL ; 09565 int val6 ; 09566 int ecode6 = 0 ; 09567 PyArrayObject *tmp7 = NULL ; 09568 int val9 ; 09569 int ecode9 = 0 ; 09570 PyArrayObject *tmp10 = NULL ; 09571 PyArrayObject *tmp12 = NULL ; 09572 PyObject * obj0 = 0 ; 09573 PyObject * obj1 = 0 ; 09574 PyObject * obj2 = 0 ; 09575 PyObject * obj3 = 0 ; 09576 PyObject * obj4 = 0 ; 09577 PyObject * obj5 = 0 ; 09578 PyObject * obj6 = 0 ; 09579 PyObject * obj7 = 0 ; 09580 09581 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; 09582 { 09583 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09584 if ( tmp1 == NULL ) 09585 return NULL; 09586 Xlen = PyArray_DIMS( tmp1 )[0]; 09587 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 09588 } 09589 { 09590 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09591 if ( tmp2 == NULL ) 09592 return NULL; 09593 Ylen = PyArray_DIMS( tmp2 )[0]; 09594 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 09595 } 09596 { 09597 int i, size; 09598 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 ); 09599 if ( tmp3 == NULL ) 09600 return NULL; 09601 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] ) 09602 { 09603 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 09604 return NULL; 09605 } 09606 arg4 = PyArray_DIMS( tmp3 )[0]; 09607 arg5 = PyArray_DIMS( tmp3 )[1]; 09608 size = arg5; 09609 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 ); 09610 for ( i = 0; i < arg4; i++ ) 09611 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size ); 09612 } 09613 ecode6 = SWIG_AsVal_int(obj3, &val6); 09614 if (!SWIG_IsOK(ecode6)) { 09615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'"); 09616 } 09617 arg6 = (PLINT)(val6); 09618 { 09619 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 09620 if ( tmp7 == NULL ) 09621 return NULL; 09622 arg8 = PyArray_DIMS( tmp7 )[0]; 09623 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 09624 } 09625 ecode9 = SWIG_AsVal_int(obj5, &val9); 09626 if (!SWIG_IsOK(ecode9)) { 09627 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'"); 09628 } 09629 arg9 = (PLINT)(val9); 09630 { 09631 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 ); 09632 if ( tmp10 == NULL ) 09633 return NULL; 09634 arg10 = Alen = PyArray_DIMS( tmp10 )[0]; 09635 arg11 = (PLINT *) PyArray_DATA( tmp10 ); 09636 } 09637 { 09638 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 ); 09639 if ( tmp12 == NULL ) 09640 return NULL; 09641 if ( PyArray_DIMS( tmp12 )[0] != Alen ) 09642 { 09643 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09644 return NULL; 09645 } 09646 arg12 = (PLINT *) PyArray_DATA( tmp12 ); 09647 } 09648 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); 09649 resultobj = SWIG_Py_Void(); 09650 { 09651 Py_CLEAR( tmp1 ); 09652 } 09653 { 09654 Py_CLEAR( tmp2 ); 09655 } 09656 { 09657 Py_CLEAR( tmp3 ); 09658 free( arg3 ); 09659 } 09660 { 09661 Py_CLEAR( tmp7 ); 09662 } 09663 { 09664 Py_CLEAR( tmp10 ); 09665 } 09666 { 09667 Py_CLEAR( tmp12 ); 09668 } 09669 return resultobj; 09670 fail: 09671 { 09672 Py_CLEAR( tmp1 ); 09673 } 09674 { 09675 Py_CLEAR( tmp2 ); 09676 } 09677 { 09678 Py_CLEAR( tmp3 ); 09679 free( arg3 ); 09680 } 09681 { 09682 Py_CLEAR( tmp7 ); 09683 } 09684 { 09685 Py_CLEAR( tmp10 ); 09686 } 09687 { 09688 Py_CLEAR( tmp12 ); 09689 } 09690 return NULL; 09691 } 09692 09693 09694 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09695 PyObject *resultobj = 0; 09696 int *arg1 = (int *) 0 ; 09697 char **arg2 = (char **) 0 ; 09698 PLINT arg3 ; 09699 int tmp1 ; 09700 int val3 ; 09701 int ecode3 = 0 ; 09702 PyObject * obj0 = 0 ; 09703 PyObject * obj1 = 0 ; 09704 PLINT result; 09705 09706 if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail; 09707 { 09708 int i; 09709 if ( !PyList_Check( obj0 ) ) 09710 { 09711 PyErr_SetString( PyExc_ValueError, "Expecting a list" ); 09712 return NULL; 09713 } 09714 tmp1 = PyList_Size( obj0 ); 09715 arg1 = &tmp1; 09716 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) ); 09717 for ( i = 0; i < tmp1; i++ ) 09718 { 09719 PyObject *s = PyList_GetItem( obj0, i ); 09720 if ( !PyString_Check( s ) ) 09721 { 09722 free( arg2 ); 09723 PyErr_SetString( PyExc_ValueError, "List items must be strings" ); 09724 return NULL; 09725 } 09726 arg2[i] = PyString_AsString( s ); 09727 } 09728 arg2[i] = 0; 09729 } 09730 ecode3 = SWIG_AsVal_int(obj1, &val3); 09731 if (!SWIG_IsOK(ecode3)) { 09732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'"); 09733 } 09734 arg3 = (PLINT)(val3); 09735 result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3); 09736 resultobj = SWIG_From_int((int)(result)); 09737 { 09738 if ( arg2 ) 09739 free( arg2 ); 09740 } 09741 return resultobj; 09742 fail: 09743 { 09744 if ( arg2 ) 09745 free( arg2 ); 09746 } 09747 return NULL; 09748 } 09749 09750 09751 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09752 PyObject *resultobj = 0; 09753 PLINT arg1 ; 09754 PLINT *arg2 = (PLINT *) 0 ; 09755 PLINT *arg3 = (PLINT *) 0 ; 09756 PyArrayObject *tmp1 = NULL ; 09757 PyArrayObject *tmp3 = NULL ; 09758 PyObject * obj0 = 0 ; 09759 PyObject * obj1 = 0 ; 09760 09761 if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail; 09762 { 09763 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 09764 if ( tmp1 == NULL ) 09765 return NULL; 09766 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 09767 arg2 = (PLINT *) PyArray_DATA( tmp1 ); 09768 } 09769 { 09770 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 09771 if ( tmp3 == NULL ) 09772 return NULL; 09773 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 09774 { 09775 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09776 return NULL; 09777 } 09778 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 09779 } 09780 plpat(arg1,(int const *)arg2,(int const *)arg3); 09781 resultobj = SWIG_Py_Void(); 09782 { 09783 Py_CLEAR( tmp1 ); 09784 } 09785 { 09786 Py_CLEAR( tmp3 ); 09787 } 09788 return resultobj; 09789 fail: 09790 { 09791 Py_CLEAR( tmp1 ); 09792 } 09793 { 09794 Py_CLEAR( tmp3 ); 09795 } 09796 return NULL; 09797 } 09798 09799 09800 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09801 PyObject *resultobj = 0; 09802 PLINT arg1 ; 09803 PLFLT arg2 ; 09804 PLFLT arg3 ; 09805 PLFLT arg4 ; 09806 PLFLT arg5 ; 09807 int val1 ; 09808 int ecode1 = 0 ; 09809 double val2 ; 09810 int ecode2 = 0 ; 09811 double val3 ; 09812 int ecode3 = 0 ; 09813 double val4 ; 09814 int ecode4 = 0 ; 09815 double val5 ; 09816 int ecode5 = 0 ; 09817 PyObject * obj0 = 0 ; 09818 PyObject * obj1 = 0 ; 09819 PyObject * obj2 = 0 ; 09820 PyObject * obj3 = 0 ; 09821 PyObject * obj4 = 0 ; 09822 09823 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 09824 ecode1 = SWIG_AsVal_int(obj0, &val1); 09825 if (!SWIG_IsOK(ecode1)) { 09826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'"); 09827 } 09828 arg1 = (PLINT)(val1); 09829 ecode2 = SWIG_AsVal_double(obj1, &val2); 09830 if (!SWIG_IsOK(ecode2)) { 09831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'"); 09832 } 09833 arg2 = (PLFLT)(val2); 09834 ecode3 = SWIG_AsVal_double(obj2, &val3); 09835 if (!SWIG_IsOK(ecode3)) { 09836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'"); 09837 } 09838 arg3 = (PLFLT)(val3); 09839 ecode4 = SWIG_AsVal_double(obj3, &val4); 09840 if (!SWIG_IsOK(ecode4)) { 09841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'"); 09842 } 09843 arg4 = (PLFLT)(val4); 09844 ecode5 = SWIG_AsVal_double(obj4, &val5); 09845 if (!SWIG_IsOK(ecode5)) { 09846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'"); 09847 } 09848 arg5 = (PLFLT)(val5); 09849 plpath(arg1,arg2,arg3,arg4,arg5); 09850 resultobj = SWIG_Py_Void(); 09851 return resultobj; 09852 fail: 09853 return NULL; 09854 } 09855 09856 09857 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09858 PyObject *resultobj = 0; 09859 PLINT arg1 ; 09860 PLFLT *arg2 = (PLFLT *) 0 ; 09861 PLFLT *arg3 = (PLFLT *) 0 ; 09862 PLINT arg4 ; 09863 PyArrayObject *tmp1 = NULL ; 09864 PyArrayObject *tmp3 = NULL ; 09865 int val4 ; 09866 int ecode4 = 0 ; 09867 PyObject * obj0 = 0 ; 09868 PyObject * obj1 = 0 ; 09869 PyObject * obj2 = 0 ; 09870 09871 if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail; 09872 { 09873 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09874 if ( tmp1 == NULL ) 09875 return NULL; 09876 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 09877 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 09878 } 09879 { 09880 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09881 if ( tmp3 == NULL ) 09882 return NULL; 09883 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 09884 { 09885 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09886 return NULL; 09887 } 09888 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 09889 } 09890 ecode4 = SWIG_AsVal_int(obj2, &val4); 09891 if (!SWIG_IsOK(ecode4)) { 09892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'"); 09893 } 09894 arg4 = (PLINT)(val4); 09895 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4); 09896 resultobj = SWIG_Py_Void(); 09897 { 09898 Py_CLEAR( tmp1 ); 09899 } 09900 { 09901 Py_CLEAR( tmp3 ); 09902 } 09903 return resultobj; 09904 fail: 09905 { 09906 Py_CLEAR( tmp1 ); 09907 } 09908 { 09909 Py_CLEAR( tmp3 ); 09910 } 09911 return NULL; 09912 } 09913 09914 09915 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09916 PyObject *resultobj = 0; 09917 PLINT arg1 ; 09918 PLFLT *arg2 = (PLFLT *) 0 ; 09919 PLFLT *arg3 = (PLFLT *) 0 ; 09920 PLFLT *arg4 = (PLFLT *) 0 ; 09921 PLINT arg5 ; 09922 PyArrayObject *tmp1 = NULL ; 09923 PyArrayObject *tmp3 = NULL ; 09924 PyArrayObject *tmp4 = NULL ; 09925 int val5 ; 09926 int ecode5 = 0 ; 09927 PyObject * obj0 = 0 ; 09928 PyObject * obj1 = 0 ; 09929 PyObject * obj2 = 0 ; 09930 PyObject * obj3 = 0 ; 09931 09932 if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 09933 { 09934 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 09935 if ( tmp1 == NULL ) 09936 return NULL; 09937 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 09938 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 09939 } 09940 { 09941 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 09942 if ( tmp3 == NULL ) 09943 return NULL; 09944 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 09945 { 09946 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09947 return NULL; 09948 } 09949 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 09950 } 09951 { 09952 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 09953 if ( tmp4 == NULL ) 09954 return NULL; 09955 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 09956 { 09957 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 09958 return NULL; 09959 } 09960 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 09961 } 09962 ecode5 = SWIG_AsVal_int(obj3, &val5); 09963 if (!SWIG_IsOK(ecode5)) { 09964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'"); 09965 } 09966 arg5 = (PLINT)(val5); 09967 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5); 09968 resultobj = SWIG_Py_Void(); 09969 { 09970 Py_CLEAR( tmp1 ); 09971 } 09972 { 09973 Py_CLEAR( tmp3 ); 09974 } 09975 { 09976 Py_CLEAR( tmp4 ); 09977 } 09978 return resultobj; 09979 fail: 09980 { 09981 Py_CLEAR( tmp1 ); 09982 } 09983 { 09984 Py_CLEAR( tmp3 ); 09985 } 09986 { 09987 Py_CLEAR( tmp4 ); 09988 } 09989 return NULL; 09990 } 09991 09992 09993 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 09994 PyObject *resultobj = 0; 09995 PLINT arg1 ; 09996 PLFLT *arg2 = (PLFLT *) 0 ; 09997 PLFLT *arg3 = (PLFLT *) 0 ; 09998 PLFLT *arg4 = (PLFLT *) 0 ; 09999 PLBOOL *arg5 = (PLBOOL *) 0 ; 10000 PLBOOL arg6 ; 10001 PyArrayObject *tmp1 = NULL ; 10002 PyArrayObject *tmp3 = NULL ; 10003 PyArrayObject *tmp4 = NULL ; 10004 PyArrayObject *tmp5 = NULL ; 10005 int val6 ; 10006 int ecode6 = 0 ; 10007 PyObject * obj0 = 0 ; 10008 PyObject * obj1 = 0 ; 10009 PyObject * obj2 = 0 ; 10010 PyObject * obj3 = 0 ; 10011 PyObject * obj4 = 0 ; 10012 10013 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 10014 { 10015 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 10016 if ( tmp1 == NULL ) 10017 return NULL; 10018 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 10019 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 10020 } 10021 { 10022 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 10023 if ( tmp3 == NULL ) 10024 return NULL; 10025 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 10026 { 10027 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10028 return NULL; 10029 } 10030 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 10031 } 10032 { 10033 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 10034 if ( tmp4 == NULL ) 10035 return NULL; 10036 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 10037 { 10038 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10039 return NULL; 10040 } 10041 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 10042 } 10043 { 10044 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 ); 10045 if ( tmp5 == NULL ) 10046 return NULL; 10047 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 ) 10048 { 10049 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." ); 10050 return NULL; 10051 } 10052 arg5 = (PLINT *) PyArray_DATA( tmp5 ); 10053 } 10054 ecode6 = SWIG_AsVal_int(obj4, &val6); 10055 if (!SWIG_IsOK(ecode6)) { 10056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'"); 10057 } 10058 arg6 = (PLBOOL)(val6); 10059 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6); 10060 resultobj = SWIG_Py_Void(); 10061 { 10062 Py_CLEAR( tmp1 ); 10063 } 10064 { 10065 Py_CLEAR( tmp3 ); 10066 } 10067 { 10068 Py_CLEAR( tmp4 ); 10069 } 10070 { 10071 Py_CLEAR( tmp5 ); 10072 } 10073 return resultobj; 10074 fail: 10075 { 10076 Py_CLEAR( tmp1 ); 10077 } 10078 { 10079 Py_CLEAR( tmp3 ); 10080 } 10081 { 10082 Py_CLEAR( tmp4 ); 10083 } 10084 { 10085 Py_CLEAR( tmp5 ); 10086 } 10087 return NULL; 10088 } 10089 10090 10091 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10092 PyObject *resultobj = 0; 10093 PLINT arg1 ; 10094 PLINT arg2 ; 10095 int val1 ; 10096 int ecode1 = 0 ; 10097 int val2 ; 10098 int ecode2 = 0 ; 10099 PyObject * obj0 = 0 ; 10100 PyObject * obj1 = 0 ; 10101 10102 if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail; 10103 ecode1 = SWIG_AsVal_int(obj0, &val1); 10104 if (!SWIG_IsOK(ecode1)) { 10105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'"); 10106 } 10107 arg1 = (PLINT)(val1); 10108 ecode2 = SWIG_AsVal_int(obj1, &val2); 10109 if (!SWIG_IsOK(ecode2)) { 10110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'"); 10111 } 10112 arg2 = (PLINT)(val2); 10113 plprec(arg1,arg2); 10114 resultobj = SWIG_Py_Void(); 10115 return resultobj; 10116 fail: 10117 return NULL; 10118 } 10119 10120 10121 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10122 PyObject *resultobj = 0; 10123 PLINT arg1 ; 10124 int val1 ; 10125 int ecode1 = 0 ; 10126 PyObject * obj0 = 0 ; 10127 10128 if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail; 10129 ecode1 = SWIG_AsVal_int(obj0, &val1); 10130 if (!SWIG_IsOK(ecode1)) { 10131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'"); 10132 } 10133 arg1 = (PLINT)(val1); 10134 plpsty(arg1); 10135 resultobj = SWIG_Py_Void(); 10136 return resultobj; 10137 fail: 10138 return NULL; 10139 } 10140 10141 10142 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10143 PyObject *resultobj = 0; 10144 PLFLT arg1 ; 10145 PLFLT arg2 ; 10146 PLFLT arg3 ; 10147 PLFLT arg4 ; 10148 PLFLT arg5 ; 10149 char *arg6 = (char *) 0 ; 10150 double val1 ; 10151 int ecode1 = 0 ; 10152 double val2 ; 10153 int ecode2 = 0 ; 10154 double val3 ; 10155 int ecode3 = 0 ; 10156 double val4 ; 10157 int ecode4 = 0 ; 10158 double val5 ; 10159 int ecode5 = 0 ; 10160 int res6 ; 10161 char *buf6 = 0 ; 10162 int alloc6 = 0 ; 10163 PyObject * obj0 = 0 ; 10164 PyObject * obj1 = 0 ; 10165 PyObject * obj2 = 0 ; 10166 PyObject * obj3 = 0 ; 10167 PyObject * obj4 = 0 ; 10168 PyObject * obj5 = 0 ; 10169 10170 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 10171 ecode1 = SWIG_AsVal_double(obj0, &val1); 10172 if (!SWIG_IsOK(ecode1)) { 10173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'"); 10174 } 10175 arg1 = (PLFLT)(val1); 10176 ecode2 = SWIG_AsVal_double(obj1, &val2); 10177 if (!SWIG_IsOK(ecode2)) { 10178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'"); 10179 } 10180 arg2 = (PLFLT)(val2); 10181 ecode3 = SWIG_AsVal_double(obj2, &val3); 10182 if (!SWIG_IsOK(ecode3)) { 10183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'"); 10184 } 10185 arg3 = (PLFLT)(val3); 10186 ecode4 = SWIG_AsVal_double(obj3, &val4); 10187 if (!SWIG_IsOK(ecode4)) { 10188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'"); 10189 } 10190 arg4 = (PLFLT)(val4); 10191 ecode5 = SWIG_AsVal_double(obj4, &val5); 10192 if (!SWIG_IsOK(ecode5)) { 10193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'"); 10194 } 10195 arg5 = (PLFLT)(val5); 10196 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6); 10197 if (!SWIG_IsOK(res6)) { 10198 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'"); 10199 } 10200 arg6 = (char *)(buf6); 10201 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 10202 resultobj = SWIG_Py_Void(); 10203 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 10204 return resultobj; 10205 fail: 10206 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6); 10207 return NULL; 10208 } 10209 10210 10211 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10212 PyObject *resultobj = 0; 10213 PLFLT arg1 ; 10214 PLFLT arg2 ; 10215 PLFLT arg3 ; 10216 PLFLT arg4 ; 10217 PLFLT arg5 ; 10218 PLFLT arg6 ; 10219 PLFLT arg7 ; 10220 PLFLT arg8 ; 10221 PLFLT arg9 ; 10222 PLFLT arg10 ; 10223 char *arg11 = (char *) 0 ; 10224 double val1 ; 10225 int ecode1 = 0 ; 10226 double val2 ; 10227 int ecode2 = 0 ; 10228 double val3 ; 10229 int ecode3 = 0 ; 10230 double val4 ; 10231 int ecode4 = 0 ; 10232 double val5 ; 10233 int ecode5 = 0 ; 10234 double val6 ; 10235 int ecode6 = 0 ; 10236 double val7 ; 10237 int ecode7 = 0 ; 10238 double val8 ; 10239 int ecode8 = 0 ; 10240 double val9 ; 10241 int ecode9 = 0 ; 10242 double val10 ; 10243 int ecode10 = 0 ; 10244 int res11 ; 10245 char *buf11 = 0 ; 10246 int alloc11 = 0 ; 10247 PyObject * obj0 = 0 ; 10248 PyObject * obj1 = 0 ; 10249 PyObject * obj2 = 0 ; 10250 PyObject * obj3 = 0 ; 10251 PyObject * obj4 = 0 ; 10252 PyObject * obj5 = 0 ; 10253 PyObject * obj6 = 0 ; 10254 PyObject * obj7 = 0 ; 10255 PyObject * obj8 = 0 ; 10256 PyObject * obj9 = 0 ; 10257 PyObject * obj10 = 0 ; 10258 10259 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; 10260 ecode1 = SWIG_AsVal_double(obj0, &val1); 10261 if (!SWIG_IsOK(ecode1)) { 10262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'"); 10263 } 10264 arg1 = (PLFLT)(val1); 10265 ecode2 = SWIG_AsVal_double(obj1, &val2); 10266 if (!SWIG_IsOK(ecode2)) { 10267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'"); 10268 } 10269 arg2 = (PLFLT)(val2); 10270 ecode3 = SWIG_AsVal_double(obj2, &val3); 10271 if (!SWIG_IsOK(ecode3)) { 10272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'"); 10273 } 10274 arg3 = (PLFLT)(val3); 10275 ecode4 = SWIG_AsVal_double(obj3, &val4); 10276 if (!SWIG_IsOK(ecode4)) { 10277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'"); 10278 } 10279 arg4 = (PLFLT)(val4); 10280 ecode5 = SWIG_AsVal_double(obj4, &val5); 10281 if (!SWIG_IsOK(ecode5)) { 10282 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'"); 10283 } 10284 arg5 = (PLFLT)(val5); 10285 ecode6 = SWIG_AsVal_double(obj5, &val6); 10286 if (!SWIG_IsOK(ecode6)) { 10287 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'"); 10288 } 10289 arg6 = (PLFLT)(val6); 10290 ecode7 = SWIG_AsVal_double(obj6, &val7); 10291 if (!SWIG_IsOK(ecode7)) { 10292 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'"); 10293 } 10294 arg7 = (PLFLT)(val7); 10295 ecode8 = SWIG_AsVal_double(obj7, &val8); 10296 if (!SWIG_IsOK(ecode8)) { 10297 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'"); 10298 } 10299 arg8 = (PLFLT)(val8); 10300 ecode9 = SWIG_AsVal_double(obj8, &val9); 10301 if (!SWIG_IsOK(ecode9)) { 10302 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'"); 10303 } 10304 arg9 = (PLFLT)(val9); 10305 ecode10 = SWIG_AsVal_double(obj9, &val10); 10306 if (!SWIG_IsOK(ecode10)) { 10307 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'"); 10308 } 10309 arg10 = (PLFLT)(val10); 10310 res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11); 10311 if (!SWIG_IsOK(res11)) { 10312 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'"); 10313 } 10314 arg11 = (char *)(buf11); 10315 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11); 10316 resultobj = SWIG_Py_Void(); 10317 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11); 10318 return resultobj; 10319 fail: 10320 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11); 10321 return NULL; 10322 } 10323 10324 10325 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10326 PyObject *resultobj = 0; 10327 PLFLT result; 10328 10329 if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail; 10330 result = (PLFLT)plrandd(); 10331 resultobj = SWIG_From_double((double)(result)); 10332 return resultobj; 10333 fail: 10334 return NULL; 10335 } 10336 10337 10338 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10339 PyObject *resultobj = 0; 10340 10341 if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail; 10342 plreplot(); 10343 resultobj = SWIG_Py_Void(); 10344 return resultobj; 10345 fail: 10346 return NULL; 10347 } 10348 10349 10350 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10351 PyObject *resultobj = 0; 10352 PLFLT arg1 ; 10353 PLFLT arg2 ; 10354 PLFLT arg3 ; 10355 PLFLT *arg4 = (PLFLT *) 0 ; 10356 PLFLT *arg5 = (PLFLT *) 0 ; 10357 PLFLT *arg6 = (PLFLT *) 0 ; 10358 double val1 ; 10359 int ecode1 = 0 ; 10360 double val2 ; 10361 int ecode2 = 0 ; 10362 double val3 ; 10363 int ecode3 = 0 ; 10364 PLFLT temp4 ; 10365 int res4 = SWIG_TMPOBJ ; 10366 PLFLT temp5 ; 10367 int res5 = SWIG_TMPOBJ ; 10368 PLFLT temp6 ; 10369 int res6 = SWIG_TMPOBJ ; 10370 PyObject * obj0 = 0 ; 10371 PyObject * obj1 = 0 ; 10372 PyObject * obj2 = 0 ; 10373 10374 arg4 = &temp4; 10375 arg5 = &temp5; 10376 arg6 = &temp6; 10377 if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail; 10378 ecode1 = SWIG_AsVal_double(obj0, &val1); 10379 if (!SWIG_IsOK(ecode1)) { 10380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'"); 10381 } 10382 arg1 = (PLFLT)(val1); 10383 ecode2 = SWIG_AsVal_double(obj1, &val2); 10384 if (!SWIG_IsOK(ecode2)) { 10385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'"); 10386 } 10387 arg2 = (PLFLT)(val2); 10388 ecode3 = SWIG_AsVal_double(obj2, &val3); 10389 if (!SWIG_IsOK(ecode3)) { 10390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'"); 10391 } 10392 arg3 = (PLFLT)(val3); 10393 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6); 10394 resultobj = SWIG_Py_Void(); 10395 if (SWIG_IsTmpObj(res4)) { 10396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 10397 } else { 10398 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 10399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 10400 } 10401 if (SWIG_IsTmpObj(res5)) { 10402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5))); 10403 } else { 10404 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 10405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags)); 10406 } 10407 if (SWIG_IsTmpObj(res6)) { 10408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6))); 10409 } else { 10410 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 10411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags)); 10412 } 10413 return resultobj; 10414 fail: 10415 return NULL; 10416 } 10417 10418 10419 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10420 PyObject *resultobj = 0; 10421 PLFLT arg1 ; 10422 PLFLT arg2 ; 10423 double val1 ; 10424 int ecode1 = 0 ; 10425 double val2 ; 10426 int ecode2 = 0 ; 10427 PyObject * obj0 = 0 ; 10428 PyObject * obj1 = 0 ; 10429 10430 if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail; 10431 ecode1 = SWIG_AsVal_double(obj0, &val1); 10432 if (!SWIG_IsOK(ecode1)) { 10433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'"); 10434 } 10435 arg1 = (PLFLT)(val1); 10436 ecode2 = SWIG_AsVal_double(obj1, &val2); 10437 if (!SWIG_IsOK(ecode2)) { 10438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'"); 10439 } 10440 arg2 = (PLFLT)(val2); 10441 plschr(arg1,arg2); 10442 resultobj = SWIG_Py_Void(); 10443 return resultobj; 10444 fail: 10445 return NULL; 10446 } 10447 10448 10449 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10450 PyObject *resultobj = 0; 10451 PLINT *arg1 = (PLINT *) 0 ; 10452 PLINT *arg2 = (PLINT *) 0 ; 10453 PLINT *arg3 = (PLINT *) 0 ; 10454 PLINT arg4 ; 10455 PyArrayObject *tmp1 = NULL ; 10456 PyArrayObject *tmp2 = NULL ; 10457 PyArrayObject *tmp3 = NULL ; 10458 PyObject * obj0 = 0 ; 10459 PyObject * obj1 = 0 ; 10460 PyObject * obj2 = 0 ; 10461 10462 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail; 10463 { 10464 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 10465 if ( tmp1 == NULL ) 10466 return NULL; 10467 Alen = PyArray_DIMS( tmp1 )[0]; 10468 arg1 = (PLINT *) PyArray_DATA( tmp1 ); 10469 } 10470 { 10471 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 10472 if ( tmp2 == NULL ) 10473 return NULL; 10474 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 10475 { 10476 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10477 return NULL; 10478 } 10479 arg2 = (PLINT *) PyArray_DATA( tmp2 ); 10480 } 10481 { 10482 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 ); 10483 if ( tmp3 == NULL ) 10484 return NULL; 10485 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 10486 { 10487 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10488 return NULL; 10489 } 10490 arg4 = PyArray_DIMS( tmp3 )[0]; 10491 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 10492 } 10493 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4); 10494 resultobj = SWIG_Py_Void(); 10495 { 10496 Py_CLEAR( tmp1 ); 10497 } 10498 { 10499 Py_CLEAR( tmp2 ); 10500 } 10501 { 10502 Py_CLEAR( tmp3 ); 10503 } 10504 return resultobj; 10505 fail: 10506 { 10507 Py_CLEAR( tmp1 ); 10508 } 10509 { 10510 Py_CLEAR( tmp2 ); 10511 } 10512 { 10513 Py_CLEAR( tmp3 ); 10514 } 10515 return NULL; 10516 } 10517 10518 10519 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10520 PyObject *resultobj = 0; 10521 PLINT *arg1 = (PLINT *) 0 ; 10522 PLINT *arg2 = (PLINT *) 0 ; 10523 PLINT *arg3 = (PLINT *) 0 ; 10524 PLFLT *arg4 = (PLFLT *) 0 ; 10525 PLINT arg5 ; 10526 PyArrayObject *tmp1 = NULL ; 10527 PyArrayObject *tmp2 = NULL ; 10528 PyArrayObject *tmp3 = NULL ; 10529 PyArrayObject *tmp4 = NULL ; 10530 PyObject * obj0 = 0 ; 10531 PyObject * obj1 = 0 ; 10532 PyObject * obj2 = 0 ; 10533 PyObject * obj3 = 0 ; 10534 10535 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 10536 { 10537 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 10538 if ( tmp1 == NULL ) 10539 return NULL; 10540 Alen = PyArray_DIMS( tmp1 )[0]; 10541 arg1 = (PLINT *) PyArray_DATA( tmp1 ); 10542 } 10543 { 10544 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 10545 if ( tmp2 == NULL ) 10546 return NULL; 10547 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 10548 { 10549 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10550 return NULL; 10551 } 10552 arg2 = (PLINT *) PyArray_DATA( tmp2 ); 10553 } 10554 { 10555 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 ); 10556 if ( tmp3 == NULL ) 10557 return NULL; 10558 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 10559 { 10560 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10561 return NULL; 10562 } 10563 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 10564 } 10565 { 10566 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 ); 10567 if ( tmp4 == NULL ) 10568 return NULL; 10569 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 10570 { 10571 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10572 return NULL; 10573 } 10574 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 10575 arg5 = PyArray_DIMS( tmp4 )[0]; 10576 } 10577 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5); 10578 resultobj = SWIG_Py_Void(); 10579 { 10580 Py_CLEAR( tmp1 ); 10581 } 10582 { 10583 Py_CLEAR( tmp2 ); 10584 } 10585 { 10586 Py_CLEAR( tmp3 ); 10587 } 10588 { 10589 Py_CLEAR( tmp4 ); 10590 } 10591 return resultobj; 10592 fail: 10593 { 10594 Py_CLEAR( tmp1 ); 10595 } 10596 { 10597 Py_CLEAR( tmp2 ); 10598 } 10599 { 10600 Py_CLEAR( tmp3 ); 10601 } 10602 { 10603 Py_CLEAR( tmp4 ); 10604 } 10605 return NULL; 10606 } 10607 10608 10609 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10610 PyObject *resultobj = 0; 10611 PLINT arg1 ; 10612 int val1 ; 10613 int ecode1 = 0 ; 10614 PyObject * obj0 = 0 ; 10615 10616 if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail; 10617 ecode1 = SWIG_AsVal_int(obj0, &val1); 10618 if (!SWIG_IsOK(ecode1)) { 10619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'"); 10620 } 10621 arg1 = (PLINT)(val1); 10622 plscmap0n(arg1); 10623 resultobj = SWIG_Py_Void(); 10624 return resultobj; 10625 fail: 10626 return NULL; 10627 } 10628 10629 10630 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10631 PyObject *resultobj = 0; 10632 PLINT *arg1 = (PLINT *) 0 ; 10633 PLINT *arg2 = (PLINT *) 0 ; 10634 PLINT *arg3 = (PLINT *) 0 ; 10635 PLINT arg4 ; 10636 PyArrayObject *tmp1 = NULL ; 10637 PyArrayObject *tmp2 = NULL ; 10638 PyArrayObject *tmp3 = NULL ; 10639 PyObject * obj0 = 0 ; 10640 PyObject * obj1 = 0 ; 10641 PyObject * obj2 = 0 ; 10642 10643 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail; 10644 { 10645 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 10646 if ( tmp1 == NULL ) 10647 return NULL; 10648 Alen = PyArray_DIMS( tmp1 )[0]; 10649 arg1 = (PLINT *) PyArray_DATA( tmp1 ); 10650 } 10651 { 10652 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 10653 if ( tmp2 == NULL ) 10654 return NULL; 10655 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 10656 { 10657 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10658 return NULL; 10659 } 10660 arg2 = (PLINT *) PyArray_DATA( tmp2 ); 10661 } 10662 { 10663 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 ); 10664 if ( tmp3 == NULL ) 10665 return NULL; 10666 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 10667 { 10668 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10669 return NULL; 10670 } 10671 arg4 = PyArray_DIMS( tmp3 )[0]; 10672 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 10673 } 10674 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4); 10675 resultobj = SWIG_Py_Void(); 10676 { 10677 Py_CLEAR( tmp1 ); 10678 } 10679 { 10680 Py_CLEAR( tmp2 ); 10681 } 10682 { 10683 Py_CLEAR( tmp3 ); 10684 } 10685 return resultobj; 10686 fail: 10687 { 10688 Py_CLEAR( tmp1 ); 10689 } 10690 { 10691 Py_CLEAR( tmp2 ); 10692 } 10693 { 10694 Py_CLEAR( tmp3 ); 10695 } 10696 return NULL; 10697 } 10698 10699 10700 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10701 PyObject *resultobj = 0; 10702 PLINT *arg1 = (PLINT *) 0 ; 10703 PLINT *arg2 = (PLINT *) 0 ; 10704 PLINT *arg3 = (PLINT *) 0 ; 10705 PLFLT *arg4 = (PLFLT *) 0 ; 10706 PLINT arg5 ; 10707 PyArrayObject *tmp1 = NULL ; 10708 PyArrayObject *tmp2 = NULL ; 10709 PyArrayObject *tmp3 = NULL ; 10710 PyArrayObject *tmp4 = NULL ; 10711 PyObject * obj0 = 0 ; 10712 PyObject * obj1 = 0 ; 10713 PyObject * obj2 = 0 ; 10714 PyObject * obj3 = 0 ; 10715 10716 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 10717 { 10718 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 10719 if ( tmp1 == NULL ) 10720 return NULL; 10721 Alen = PyArray_DIMS( tmp1 )[0]; 10722 arg1 = (PLINT *) PyArray_DATA( tmp1 ); 10723 } 10724 { 10725 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 10726 if ( tmp2 == NULL ) 10727 return NULL; 10728 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 10729 { 10730 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10731 return NULL; 10732 } 10733 arg2 = (PLINT *) PyArray_DATA( tmp2 ); 10734 } 10735 { 10736 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 ); 10737 if ( tmp3 == NULL ) 10738 return NULL; 10739 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 10740 { 10741 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10742 return NULL; 10743 } 10744 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 10745 } 10746 { 10747 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 ); 10748 if ( tmp4 == NULL ) 10749 return NULL; 10750 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 10751 { 10752 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10753 return NULL; 10754 } 10755 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 10756 arg5 = PyArray_DIMS( tmp4 )[0]; 10757 } 10758 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5); 10759 resultobj = SWIG_Py_Void(); 10760 { 10761 Py_CLEAR( tmp1 ); 10762 } 10763 { 10764 Py_CLEAR( tmp2 ); 10765 } 10766 { 10767 Py_CLEAR( tmp3 ); 10768 } 10769 { 10770 Py_CLEAR( tmp4 ); 10771 } 10772 return resultobj; 10773 fail: 10774 { 10775 Py_CLEAR( tmp1 ); 10776 } 10777 { 10778 Py_CLEAR( tmp2 ); 10779 } 10780 { 10781 Py_CLEAR( tmp3 ); 10782 } 10783 { 10784 Py_CLEAR( tmp4 ); 10785 } 10786 return NULL; 10787 } 10788 10789 10790 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10791 PyObject *resultobj = 0; 10792 PLBOOL arg1 ; 10793 PLINT arg2 ; 10794 PLFLT *arg3 = (PLFLT *) 0 ; 10795 PLFLT *arg4 = (PLFLT *) 0 ; 10796 PLFLT *arg5 = (PLFLT *) 0 ; 10797 PLFLT *arg6 = (PLFLT *) 0 ; 10798 PLBOOL *arg7 = (PLBOOL *) 0 ; 10799 int val1 ; 10800 int ecode1 = 0 ; 10801 PyArrayObject *tmp2 = NULL ; 10802 PyArrayObject *tmp4 = NULL ; 10803 PyArrayObject *tmp5 = NULL ; 10804 PyArrayObject *tmp6 = NULL ; 10805 PyArrayObject *tmp7 = NULL ; 10806 PyObject * obj0 = 0 ; 10807 PyObject * obj1 = 0 ; 10808 PyObject * obj2 = 0 ; 10809 PyObject * obj3 = 0 ; 10810 PyObject * obj4 = 0 ; 10811 PyObject * obj5 = 0 ; 10812 10813 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 10814 ecode1 = SWIG_AsVal_int(obj0, &val1); 10815 if (!SWIG_IsOK(ecode1)) { 10816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'"); 10817 } 10818 arg1 = (PLBOOL)(val1); 10819 { 10820 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 10821 if ( tmp2 == NULL ) 10822 return NULL; 10823 arg2 = Alen = PyArray_DIMS( tmp2 )[0]; 10824 arg3 = (PLFLT *) PyArray_DATA( tmp2 ); 10825 } 10826 { 10827 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 10828 if ( tmp4 == NULL ) 10829 return NULL; 10830 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 10831 { 10832 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10833 return NULL; 10834 } 10835 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 10836 } 10837 { 10838 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 ); 10839 if ( tmp5 == NULL ) 10840 return NULL; 10841 if ( PyArray_DIMS( tmp5 )[0] != Alen ) 10842 { 10843 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10844 return NULL; 10845 } 10846 arg5 = (PLFLT *) PyArray_DATA( tmp5 ); 10847 } 10848 { 10849 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 10850 if ( tmp6 == NULL ) 10851 return NULL; 10852 if ( PyArray_DIMS( tmp6 )[0] != Alen ) 10853 { 10854 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10855 return NULL; 10856 } 10857 arg6 = (PLFLT *) PyArray_DATA( tmp6 ); 10858 } 10859 { 10860 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 ); 10861 if ( tmp7 == NULL ) 10862 return NULL; 10863 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 ) 10864 { 10865 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." ); 10866 return NULL; 10867 } 10868 arg7 = (PLINT *) PyArray_DATA( tmp7 ); 10869 } 10870 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7); 10871 resultobj = SWIG_Py_Void(); 10872 { 10873 Py_CLEAR( tmp2 ); 10874 } 10875 { 10876 Py_CLEAR( tmp4 ); 10877 } 10878 { 10879 Py_CLEAR( tmp5 ); 10880 } 10881 { 10882 Py_CLEAR( tmp6 ); 10883 } 10884 { 10885 Py_CLEAR( tmp7 ); 10886 } 10887 return resultobj; 10888 fail: 10889 { 10890 Py_CLEAR( tmp2 ); 10891 } 10892 { 10893 Py_CLEAR( tmp4 ); 10894 } 10895 { 10896 Py_CLEAR( tmp5 ); 10897 } 10898 { 10899 Py_CLEAR( tmp6 ); 10900 } 10901 { 10902 Py_CLEAR( tmp7 ); 10903 } 10904 return NULL; 10905 } 10906 10907 10908 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10909 PyObject *resultobj = 0; 10910 PLBOOL arg1 ; 10911 PLINT arg2 ; 10912 PLFLT *arg3 = (PLFLT *) 0 ; 10913 PLFLT *arg4 = (PLFLT *) 0 ; 10914 PLFLT *arg5 = (PLFLT *) 0 ; 10915 PLFLT *arg6 = (PLFLT *) 0 ; 10916 PLFLT *arg7 = (PLFLT *) 0 ; 10917 PLBOOL *arg8 = (PLBOOL *) 0 ; 10918 int val1 ; 10919 int ecode1 = 0 ; 10920 PyArrayObject *tmp2 = NULL ; 10921 PyArrayObject *tmp4 = NULL ; 10922 PyArrayObject *tmp5 = NULL ; 10923 PyArrayObject *tmp6 = NULL ; 10924 PyArrayObject *tmp7 = NULL ; 10925 PyArrayObject *tmp8 = NULL ; 10926 PyObject * obj0 = 0 ; 10927 PyObject * obj1 = 0 ; 10928 PyObject * obj2 = 0 ; 10929 PyObject * obj3 = 0 ; 10930 PyObject * obj4 = 0 ; 10931 PyObject * obj5 = 0 ; 10932 PyObject * obj6 = 0 ; 10933 10934 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; 10935 ecode1 = SWIG_AsVal_int(obj0, &val1); 10936 if (!SWIG_IsOK(ecode1)) { 10937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'"); 10938 } 10939 arg1 = (PLBOOL)(val1); 10940 { 10941 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 10942 if ( tmp2 == NULL ) 10943 return NULL; 10944 arg2 = Alen = PyArray_DIMS( tmp2 )[0]; 10945 arg3 = (PLFLT *) PyArray_DATA( tmp2 ); 10946 } 10947 { 10948 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 10949 if ( tmp4 == NULL ) 10950 return NULL; 10951 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 10952 { 10953 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10954 return NULL; 10955 } 10956 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 10957 } 10958 { 10959 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 ); 10960 if ( tmp5 == NULL ) 10961 return NULL; 10962 if ( PyArray_DIMS( tmp5 )[0] != Alen ) 10963 { 10964 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10965 return NULL; 10966 } 10967 arg5 = (PLFLT *) PyArray_DATA( tmp5 ); 10968 } 10969 { 10970 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 ); 10971 if ( tmp6 == NULL ) 10972 return NULL; 10973 if ( PyArray_DIMS( tmp6 )[0] != Alen ) 10974 { 10975 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10976 return NULL; 10977 } 10978 arg6 = (PLFLT *) PyArray_DATA( tmp6 ); 10979 } 10980 { 10981 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 ); 10982 if ( tmp7 == NULL ) 10983 return NULL; 10984 if ( PyArray_DIMS( tmp7 )[0] != Alen ) 10985 { 10986 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 10987 return NULL; 10988 } 10989 arg7 = (PLFLT *) PyArray_DATA( tmp7 ); 10990 } 10991 { 10992 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 ); 10993 if ( tmp8 == NULL ) 10994 return NULL; 10995 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 ) 10996 { 10997 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." ); 10998 return NULL; 10999 } 11000 arg8 = (PLINT *) PyArray_DATA( tmp8 ); 11001 } 11002 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8); 11003 resultobj = SWIG_Py_Void(); 11004 { 11005 Py_CLEAR( tmp2 ); 11006 } 11007 { 11008 Py_CLEAR( tmp4 ); 11009 } 11010 { 11011 Py_CLEAR( tmp5 ); 11012 } 11013 { 11014 Py_CLEAR( tmp6 ); 11015 } 11016 { 11017 Py_CLEAR( tmp7 ); 11018 } 11019 { 11020 Py_CLEAR( tmp8 ); 11021 } 11022 return resultobj; 11023 fail: 11024 { 11025 Py_CLEAR( tmp2 ); 11026 } 11027 { 11028 Py_CLEAR( tmp4 ); 11029 } 11030 { 11031 Py_CLEAR( tmp5 ); 11032 } 11033 { 11034 Py_CLEAR( tmp6 ); 11035 } 11036 { 11037 Py_CLEAR( tmp7 ); 11038 } 11039 { 11040 Py_CLEAR( tmp8 ); 11041 } 11042 return NULL; 11043 } 11044 11045 11046 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11047 PyObject *resultobj = 0; 11048 PLINT arg1 ; 11049 int val1 ; 11050 int ecode1 = 0 ; 11051 PyObject * obj0 = 0 ; 11052 11053 if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail; 11054 ecode1 = SWIG_AsVal_int(obj0, &val1); 11055 if (!SWIG_IsOK(ecode1)) { 11056 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'"); 11057 } 11058 arg1 = (PLINT)(val1); 11059 plscmap1n(arg1); 11060 resultobj = SWIG_Py_Void(); 11061 return resultobj; 11062 fail: 11063 return NULL; 11064 } 11065 11066 11067 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11068 PyObject *resultobj = 0; 11069 PLFLT arg1 ; 11070 PLFLT arg2 ; 11071 double val1 ; 11072 int ecode1 = 0 ; 11073 double val2 ; 11074 int ecode2 = 0 ; 11075 PyObject * obj0 = 0 ; 11076 PyObject * obj1 = 0 ; 11077 11078 if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail; 11079 ecode1 = SWIG_AsVal_double(obj0, &val1); 11080 if (!SWIG_IsOK(ecode1)) { 11081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'"); 11082 } 11083 arg1 = (PLFLT)(val1); 11084 ecode2 = SWIG_AsVal_double(obj1, &val2); 11085 if (!SWIG_IsOK(ecode2)) { 11086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'"); 11087 } 11088 arg2 = (PLFLT)(val2); 11089 plscmap1_range(arg1,arg2); 11090 resultobj = SWIG_Py_Void(); 11091 return resultobj; 11092 fail: 11093 return NULL; 11094 } 11095 11096 11097 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11098 PyObject *resultobj = 0; 11099 PLFLT *arg1 = (PLFLT *) 0 ; 11100 PLFLT *arg2 = (PLFLT *) 0 ; 11101 PLFLT temp1 ; 11102 int res1 = SWIG_TMPOBJ ; 11103 PLFLT temp2 ; 11104 int res2 = SWIG_TMPOBJ ; 11105 11106 arg1 = &temp1; 11107 arg2 = &temp2; 11108 if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail; 11109 plgcmap1_range(arg1,arg2); 11110 resultobj = SWIG_Py_Void(); 11111 if (SWIG_IsTmpObj(res1)) { 11112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1))); 11113 } else { 11114 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 11115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags)); 11116 } 11117 if (SWIG_IsTmpObj(res2)) { 11118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2))); 11119 } else { 11120 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 11121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags)); 11122 } 11123 return resultobj; 11124 fail: 11125 return NULL; 11126 } 11127 11128 11129 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11130 PyObject *resultobj = 0; 11131 PLINT arg1 ; 11132 PLINT arg2 ; 11133 PLINT arg3 ; 11134 PLINT arg4 ; 11135 int val1 ; 11136 int ecode1 = 0 ; 11137 int val2 ; 11138 int ecode2 = 0 ; 11139 int val3 ; 11140 int ecode3 = 0 ; 11141 int val4 ; 11142 int ecode4 = 0 ; 11143 PyObject * obj0 = 0 ; 11144 PyObject * obj1 = 0 ; 11145 PyObject * obj2 = 0 ; 11146 PyObject * obj3 = 0 ; 11147 11148 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11149 ecode1 = SWIG_AsVal_int(obj0, &val1); 11150 if (!SWIG_IsOK(ecode1)) { 11151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'"); 11152 } 11153 arg1 = (PLINT)(val1); 11154 ecode2 = SWIG_AsVal_int(obj1, &val2); 11155 if (!SWIG_IsOK(ecode2)) { 11156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'"); 11157 } 11158 arg2 = (PLINT)(val2); 11159 ecode3 = SWIG_AsVal_int(obj2, &val3); 11160 if (!SWIG_IsOK(ecode3)) { 11161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'"); 11162 } 11163 arg3 = (PLINT)(val3); 11164 ecode4 = SWIG_AsVal_int(obj3, &val4); 11165 if (!SWIG_IsOK(ecode4)) { 11166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'"); 11167 } 11168 arg4 = (PLINT)(val4); 11169 plscol0(arg1,arg2,arg3,arg4); 11170 resultobj = SWIG_Py_Void(); 11171 return resultobj; 11172 fail: 11173 return NULL; 11174 } 11175 11176 11177 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11178 PyObject *resultobj = 0; 11179 PLINT arg1 ; 11180 PLINT arg2 ; 11181 PLINT arg3 ; 11182 PLINT arg4 ; 11183 PLFLT arg5 ; 11184 int val1 ; 11185 int ecode1 = 0 ; 11186 int val2 ; 11187 int ecode2 = 0 ; 11188 int val3 ; 11189 int ecode3 = 0 ; 11190 int val4 ; 11191 int ecode4 = 0 ; 11192 double val5 ; 11193 int ecode5 = 0 ; 11194 PyObject * obj0 = 0 ; 11195 PyObject * obj1 = 0 ; 11196 PyObject * obj2 = 0 ; 11197 PyObject * obj3 = 0 ; 11198 PyObject * obj4 = 0 ; 11199 11200 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 11201 ecode1 = SWIG_AsVal_int(obj0, &val1); 11202 if (!SWIG_IsOK(ecode1)) { 11203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'"); 11204 } 11205 arg1 = (PLINT)(val1); 11206 ecode2 = SWIG_AsVal_int(obj1, &val2); 11207 if (!SWIG_IsOK(ecode2)) { 11208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'"); 11209 } 11210 arg2 = (PLINT)(val2); 11211 ecode3 = SWIG_AsVal_int(obj2, &val3); 11212 if (!SWIG_IsOK(ecode3)) { 11213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'"); 11214 } 11215 arg3 = (PLINT)(val3); 11216 ecode4 = SWIG_AsVal_int(obj3, &val4); 11217 if (!SWIG_IsOK(ecode4)) { 11218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'"); 11219 } 11220 arg4 = (PLINT)(val4); 11221 ecode5 = SWIG_AsVal_double(obj4, &val5); 11222 if (!SWIG_IsOK(ecode5)) { 11223 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'"); 11224 } 11225 arg5 = (PLFLT)(val5); 11226 plscol0a(arg1,arg2,arg3,arg4,arg5); 11227 resultobj = SWIG_Py_Void(); 11228 return resultobj; 11229 fail: 11230 return NULL; 11231 } 11232 11233 11234 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11235 PyObject *resultobj = 0; 11236 PLINT arg1 ; 11237 PLINT arg2 ; 11238 PLINT arg3 ; 11239 int val1 ; 11240 int ecode1 = 0 ; 11241 int val2 ; 11242 int ecode2 = 0 ; 11243 int val3 ; 11244 int ecode3 = 0 ; 11245 PyObject * obj0 = 0 ; 11246 PyObject * obj1 = 0 ; 11247 PyObject * obj2 = 0 ; 11248 11249 if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail; 11250 ecode1 = SWIG_AsVal_int(obj0, &val1); 11251 if (!SWIG_IsOK(ecode1)) { 11252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'"); 11253 } 11254 arg1 = (PLINT)(val1); 11255 ecode2 = SWIG_AsVal_int(obj1, &val2); 11256 if (!SWIG_IsOK(ecode2)) { 11257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'"); 11258 } 11259 arg2 = (PLINT)(val2); 11260 ecode3 = SWIG_AsVal_int(obj2, &val3); 11261 if (!SWIG_IsOK(ecode3)) { 11262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'"); 11263 } 11264 arg3 = (PLINT)(val3); 11265 plscolbg(arg1,arg2,arg3); 11266 resultobj = SWIG_Py_Void(); 11267 return resultobj; 11268 fail: 11269 return NULL; 11270 } 11271 11272 11273 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11274 PyObject *resultobj = 0; 11275 PLINT arg1 ; 11276 PLINT arg2 ; 11277 PLINT arg3 ; 11278 PLFLT arg4 ; 11279 int val1 ; 11280 int ecode1 = 0 ; 11281 int val2 ; 11282 int ecode2 = 0 ; 11283 int val3 ; 11284 int ecode3 = 0 ; 11285 double val4 ; 11286 int ecode4 = 0 ; 11287 PyObject * obj0 = 0 ; 11288 PyObject * obj1 = 0 ; 11289 PyObject * obj2 = 0 ; 11290 PyObject * obj3 = 0 ; 11291 11292 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11293 ecode1 = SWIG_AsVal_int(obj0, &val1); 11294 if (!SWIG_IsOK(ecode1)) { 11295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'"); 11296 } 11297 arg1 = (PLINT)(val1); 11298 ecode2 = SWIG_AsVal_int(obj1, &val2); 11299 if (!SWIG_IsOK(ecode2)) { 11300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'"); 11301 } 11302 arg2 = (PLINT)(val2); 11303 ecode3 = SWIG_AsVal_int(obj2, &val3); 11304 if (!SWIG_IsOK(ecode3)) { 11305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'"); 11306 } 11307 arg3 = (PLINT)(val3); 11308 ecode4 = SWIG_AsVal_double(obj3, &val4); 11309 if (!SWIG_IsOK(ecode4)) { 11310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'"); 11311 } 11312 arg4 = (PLFLT)(val4); 11313 plscolbga(arg1,arg2,arg3,arg4); 11314 resultobj = SWIG_Py_Void(); 11315 return resultobj; 11316 fail: 11317 return NULL; 11318 } 11319 11320 11321 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11322 PyObject *resultobj = 0; 11323 PLINT arg1 ; 11324 int val1 ; 11325 int ecode1 = 0 ; 11326 PyObject * obj0 = 0 ; 11327 11328 if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail; 11329 ecode1 = SWIG_AsVal_int(obj0, &val1); 11330 if (!SWIG_IsOK(ecode1)) { 11331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'"); 11332 } 11333 arg1 = (PLINT)(val1); 11334 plscolor(arg1); 11335 resultobj = SWIG_Py_Void(); 11336 return resultobj; 11337 fail: 11338 return NULL; 11339 } 11340 11341 11342 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11343 PyObject *resultobj = 0; 11344 PLINT arg1 ; 11345 int val1 ; 11346 int ecode1 = 0 ; 11347 PyObject * obj0 = 0 ; 11348 11349 if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail; 11350 ecode1 = SWIG_AsVal_int(obj0, &val1); 11351 if (!SWIG_IsOK(ecode1)) { 11352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'"); 11353 } 11354 arg1 = (PLINT)(val1); 11355 plscompression(arg1); 11356 resultobj = SWIG_Py_Void(); 11357 return resultobj; 11358 fail: 11359 return NULL; 11360 } 11361 11362 11363 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11364 PyObject *resultobj = 0; 11365 char *arg1 = (char *) 0 ; 11366 int res1 ; 11367 char *buf1 = 0 ; 11368 int alloc1 = 0 ; 11369 PyObject * obj0 = 0 ; 11370 11371 if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail; 11372 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 11373 if (!SWIG_IsOK(res1)) { 11374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'"); 11375 } 11376 arg1 = (char *)(buf1); 11377 plsdev((char const *)arg1); 11378 resultobj = SWIG_Py_Void(); 11379 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11380 return resultobj; 11381 fail: 11382 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11383 return NULL; 11384 } 11385 11386 11387 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11388 PyObject *resultobj = 0; 11389 PLFLT arg1 ; 11390 PLFLT arg2 ; 11391 PLFLT arg3 ; 11392 PLFLT arg4 ; 11393 double val1 ; 11394 int ecode1 = 0 ; 11395 double val2 ; 11396 int ecode2 = 0 ; 11397 double val3 ; 11398 int ecode3 = 0 ; 11399 double val4 ; 11400 int ecode4 = 0 ; 11401 PyObject * obj0 = 0 ; 11402 PyObject * obj1 = 0 ; 11403 PyObject * obj2 = 0 ; 11404 PyObject * obj3 = 0 ; 11405 11406 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11407 ecode1 = SWIG_AsVal_double(obj0, &val1); 11408 if (!SWIG_IsOK(ecode1)) { 11409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'"); 11410 } 11411 arg1 = (PLFLT)(val1); 11412 ecode2 = SWIG_AsVal_double(obj1, &val2); 11413 if (!SWIG_IsOK(ecode2)) { 11414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'"); 11415 } 11416 arg2 = (PLFLT)(val2); 11417 ecode3 = SWIG_AsVal_double(obj2, &val3); 11418 if (!SWIG_IsOK(ecode3)) { 11419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'"); 11420 } 11421 arg3 = (PLFLT)(val3); 11422 ecode4 = SWIG_AsVal_double(obj3, &val4); 11423 if (!SWIG_IsOK(ecode4)) { 11424 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'"); 11425 } 11426 arg4 = (PLFLT)(val4); 11427 plsdidev(arg1,arg2,arg3,arg4); 11428 resultobj = SWIG_Py_Void(); 11429 return resultobj; 11430 fail: 11431 return NULL; 11432 } 11433 11434 11435 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11436 PyObject *resultobj = 0; 11437 PLINT arg1 ; 11438 PLINT arg2 ; 11439 PLINT arg3 ; 11440 PLINT arg4 ; 11441 PLFLT arg5 ; 11442 PLFLT arg6 ; 11443 int val1 ; 11444 int ecode1 = 0 ; 11445 int val2 ; 11446 int ecode2 = 0 ; 11447 int val3 ; 11448 int ecode3 = 0 ; 11449 int val4 ; 11450 int ecode4 = 0 ; 11451 double val5 ; 11452 int ecode5 = 0 ; 11453 double val6 ; 11454 int ecode6 = 0 ; 11455 PyObject * obj0 = 0 ; 11456 PyObject * obj1 = 0 ; 11457 PyObject * obj2 = 0 ; 11458 PyObject * obj3 = 0 ; 11459 PyObject * obj4 = 0 ; 11460 PyObject * obj5 = 0 ; 11461 11462 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 11463 ecode1 = SWIG_AsVal_int(obj0, &val1); 11464 if (!SWIG_IsOK(ecode1)) { 11465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'"); 11466 } 11467 arg1 = (PLINT)(val1); 11468 ecode2 = SWIG_AsVal_int(obj1, &val2); 11469 if (!SWIG_IsOK(ecode2)) { 11470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'"); 11471 } 11472 arg2 = (PLINT)(val2); 11473 ecode3 = SWIG_AsVal_int(obj2, &val3); 11474 if (!SWIG_IsOK(ecode3)) { 11475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'"); 11476 } 11477 arg3 = (PLINT)(val3); 11478 ecode4 = SWIG_AsVal_int(obj3, &val4); 11479 if (!SWIG_IsOK(ecode4)) { 11480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'"); 11481 } 11482 arg4 = (PLINT)(val4); 11483 ecode5 = SWIG_AsVal_double(obj4, &val5); 11484 if (!SWIG_IsOK(ecode5)) { 11485 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'"); 11486 } 11487 arg5 = (PLFLT)(val5); 11488 ecode6 = SWIG_AsVal_double(obj5, &val6); 11489 if (!SWIG_IsOK(ecode6)) { 11490 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'"); 11491 } 11492 arg6 = (PLFLT)(val6); 11493 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6); 11494 resultobj = SWIG_Py_Void(); 11495 return resultobj; 11496 fail: 11497 return NULL; 11498 } 11499 11500 11501 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11502 PyObject *resultobj = 0; 11503 PLFLT arg1 ; 11504 double val1 ; 11505 int ecode1 = 0 ; 11506 PyObject * obj0 = 0 ; 11507 11508 if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail; 11509 ecode1 = SWIG_AsVal_double(obj0, &val1); 11510 if (!SWIG_IsOK(ecode1)) { 11511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'"); 11512 } 11513 arg1 = (PLFLT)(val1); 11514 plsdiori(arg1); 11515 resultobj = SWIG_Py_Void(); 11516 return resultobj; 11517 fail: 11518 return NULL; 11519 } 11520 11521 11522 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11523 PyObject *resultobj = 0; 11524 PLFLT arg1 ; 11525 PLFLT arg2 ; 11526 PLFLT arg3 ; 11527 PLFLT arg4 ; 11528 double val1 ; 11529 int ecode1 = 0 ; 11530 double val2 ; 11531 int ecode2 = 0 ; 11532 double val3 ; 11533 int ecode3 = 0 ; 11534 double val4 ; 11535 int ecode4 = 0 ; 11536 PyObject * obj0 = 0 ; 11537 PyObject * obj1 = 0 ; 11538 PyObject * obj2 = 0 ; 11539 PyObject * obj3 = 0 ; 11540 11541 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11542 ecode1 = SWIG_AsVal_double(obj0, &val1); 11543 if (!SWIG_IsOK(ecode1)) { 11544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'"); 11545 } 11546 arg1 = (PLFLT)(val1); 11547 ecode2 = SWIG_AsVal_double(obj1, &val2); 11548 if (!SWIG_IsOK(ecode2)) { 11549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'"); 11550 } 11551 arg2 = (PLFLT)(val2); 11552 ecode3 = SWIG_AsVal_double(obj2, &val3); 11553 if (!SWIG_IsOK(ecode3)) { 11554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'"); 11555 } 11556 arg3 = (PLFLT)(val3); 11557 ecode4 = SWIG_AsVal_double(obj3, &val4); 11558 if (!SWIG_IsOK(ecode4)) { 11559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'"); 11560 } 11561 arg4 = (PLFLT)(val4); 11562 plsdiplt(arg1,arg2,arg3,arg4); 11563 resultobj = SWIG_Py_Void(); 11564 return resultobj; 11565 fail: 11566 return NULL; 11567 } 11568 11569 11570 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11571 PyObject *resultobj = 0; 11572 PLFLT arg1 ; 11573 PLFLT arg2 ; 11574 PLFLT arg3 ; 11575 PLFLT arg4 ; 11576 double val1 ; 11577 int ecode1 = 0 ; 11578 double val2 ; 11579 int ecode2 = 0 ; 11580 double val3 ; 11581 int ecode3 = 0 ; 11582 double val4 ; 11583 int ecode4 = 0 ; 11584 PyObject * obj0 = 0 ; 11585 PyObject * obj1 = 0 ; 11586 PyObject * obj2 = 0 ; 11587 PyObject * obj3 = 0 ; 11588 11589 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11590 ecode1 = SWIG_AsVal_double(obj0, &val1); 11591 if (!SWIG_IsOK(ecode1)) { 11592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'"); 11593 } 11594 arg1 = (PLFLT)(val1); 11595 ecode2 = SWIG_AsVal_double(obj1, &val2); 11596 if (!SWIG_IsOK(ecode2)) { 11597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'"); 11598 } 11599 arg2 = (PLFLT)(val2); 11600 ecode3 = SWIG_AsVal_double(obj2, &val3); 11601 if (!SWIG_IsOK(ecode3)) { 11602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'"); 11603 } 11604 arg3 = (PLFLT)(val3); 11605 ecode4 = SWIG_AsVal_double(obj3, &val4); 11606 if (!SWIG_IsOK(ecode4)) { 11607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'"); 11608 } 11609 arg4 = (PLFLT)(val4); 11610 plsdiplz(arg1,arg2,arg3,arg4); 11611 resultobj = SWIG_Py_Void(); 11612 return resultobj; 11613 fail: 11614 return NULL; 11615 } 11616 11617 11618 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11619 PyObject *resultobj = 0; 11620 unsigned int arg1 ; 11621 unsigned int val1 ; 11622 int ecode1 = 0 ; 11623 PyObject * obj0 = 0 ; 11624 11625 if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail; 11626 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); 11627 if (!SWIG_IsOK(ecode1)) { 11628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'"); 11629 } 11630 arg1 = (unsigned int)(val1); 11631 plseed(arg1); 11632 resultobj = SWIG_Py_Void(); 11633 return resultobj; 11634 fail: 11635 return NULL; 11636 } 11637 11638 11639 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11640 PyObject *resultobj = 0; 11641 char arg1 ; 11642 char val1 ; 11643 int ecode1 = 0 ; 11644 PyObject * obj0 = 0 ; 11645 11646 if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail; 11647 ecode1 = SWIG_AsVal_char(obj0, &val1); 11648 if (!SWIG_IsOK(ecode1)) { 11649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'"); 11650 } 11651 arg1 = (char)(val1); 11652 plsesc(arg1); 11653 resultobj = SWIG_Py_Void(); 11654 return resultobj; 11655 fail: 11656 return NULL; 11657 } 11658 11659 11660 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11661 PyObject *resultobj = 0; 11662 char *arg1 = (char *) 0 ; 11663 char *arg2 = (char *) 0 ; 11664 int res1 ; 11665 char *buf1 = 0 ; 11666 int alloc1 = 0 ; 11667 int res2 ; 11668 char *buf2 = 0 ; 11669 int alloc2 = 0 ; 11670 PyObject * obj0 = 0 ; 11671 PyObject * obj1 = 0 ; 11672 PLINT result; 11673 11674 if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail; 11675 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 11676 if (!SWIG_IsOK(res1)) { 11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'"); 11678 } 11679 arg1 = (char *)(buf1); 11680 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 11681 if (!SWIG_IsOK(res2)) { 11682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'"); 11683 } 11684 arg2 = (char *)(buf2); 11685 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2); 11686 resultobj = SWIG_From_int((int)(result)); 11687 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11688 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11689 return resultobj; 11690 fail: 11691 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11692 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11693 return NULL; 11694 } 11695 11696 11697 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11698 PyObject *resultobj = 0; 11699 PLINT arg1 ; 11700 PLINT arg2 ; 11701 PLINT arg3 ; 11702 int val1 ; 11703 int ecode1 = 0 ; 11704 int val2 ; 11705 int ecode2 = 0 ; 11706 int val3 ; 11707 int ecode3 = 0 ; 11708 PyObject * obj0 = 0 ; 11709 PyObject * obj1 = 0 ; 11710 PyObject * obj2 = 0 ; 11711 11712 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail; 11713 ecode1 = SWIG_AsVal_int(obj0, &val1); 11714 if (!SWIG_IsOK(ecode1)) { 11715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'"); 11716 } 11717 arg1 = (PLINT)(val1); 11718 ecode2 = SWIG_AsVal_int(obj1, &val2); 11719 if (!SWIG_IsOK(ecode2)) { 11720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'"); 11721 } 11722 arg2 = (PLINT)(val2); 11723 ecode3 = SWIG_AsVal_int(obj2, &val3); 11724 if (!SWIG_IsOK(ecode3)) { 11725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'"); 11726 } 11727 arg3 = (PLINT)(val3); 11728 plsfam(arg1,arg2,arg3); 11729 resultobj = SWIG_Py_Void(); 11730 return resultobj; 11731 fail: 11732 return NULL; 11733 } 11734 11735 11736 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11737 PyObject *resultobj = 0; 11738 PLUNICODE arg1 ; 11739 unsigned int val1 ; 11740 int ecode1 = 0 ; 11741 PyObject * obj0 = 0 ; 11742 11743 if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail; 11744 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); 11745 if (!SWIG_IsOK(ecode1)) { 11746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'"); 11747 } 11748 arg1 = (PLUNICODE)(val1); 11749 plsfci(arg1); 11750 resultobj = SWIG_Py_Void(); 11751 return resultobj; 11752 fail: 11753 return NULL; 11754 } 11755 11756 11757 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11758 PyObject *resultobj = 0; 11759 char *arg1 = (char *) 0 ; 11760 int res1 ; 11761 char *buf1 = 0 ; 11762 int alloc1 = 0 ; 11763 PyObject * obj0 = 0 ; 11764 11765 if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail; 11766 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 11767 if (!SWIG_IsOK(res1)) { 11768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'"); 11769 } 11770 arg1 = (char *)(buf1); 11771 plsfnam((char const *)arg1); 11772 resultobj = SWIG_Py_Void(); 11773 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11774 return resultobj; 11775 fail: 11776 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 11777 return NULL; 11778 } 11779 11780 11781 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11782 PyObject *resultobj = 0; 11783 PLINT arg1 ; 11784 PLINT arg2 ; 11785 PLINT arg3 ; 11786 int val1 ; 11787 int ecode1 = 0 ; 11788 int val2 ; 11789 int ecode2 = 0 ; 11790 int val3 ; 11791 int ecode3 = 0 ; 11792 PyObject * obj0 = 0 ; 11793 PyObject * obj1 = 0 ; 11794 PyObject * obj2 = 0 ; 11795 11796 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail; 11797 ecode1 = SWIG_AsVal_int(obj0, &val1); 11798 if (!SWIG_IsOK(ecode1)) { 11799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'"); 11800 } 11801 arg1 = (PLINT)(val1); 11802 ecode2 = SWIG_AsVal_int(obj1, &val2); 11803 if (!SWIG_IsOK(ecode2)) { 11804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'"); 11805 } 11806 arg2 = (PLINT)(val2); 11807 ecode3 = SWIG_AsVal_int(obj2, &val3); 11808 if (!SWIG_IsOK(ecode3)) { 11809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'"); 11810 } 11811 arg3 = (PLINT)(val3); 11812 plsfont(arg1,arg2,arg3); 11813 resultobj = SWIG_Py_Void(); 11814 return resultobj; 11815 fail: 11816 return NULL; 11817 } 11818 11819 11820 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11821 PyObject *resultobj = 0; 11822 PLFLT **arg1 = (PLFLT **) 0 ; 11823 PLINT arg2 ; 11824 PLINT arg3 ; 11825 defined_func arg4 = (defined_func) 0 ; 11826 PLFLT arg5 ; 11827 PLFLT arg6 ; 11828 PLFLT arg7 ; 11829 PLFLT arg8 ; 11830 PLFLT *arg9 = (PLFLT *) 0 ; 11831 PLINT arg10 ; 11832 PLFLT arg11 ; 11833 PLINT arg12 ; 11834 PLFLT arg13 ; 11835 fill_func arg14 = (fill_func) 0 ; 11836 PLBOOL arg15 ; 11837 pltr_func arg16 = (pltr_func) 0 ; 11838 PLPointer arg17 = (PLPointer) 0 ; 11839 PyArrayObject *tmp1 = NULL ; 11840 double val5 ; 11841 int ecode5 = 0 ; 11842 double val6 ; 11843 int ecode6 = 0 ; 11844 double val7 ; 11845 int ecode7 = 0 ; 11846 double val8 ; 11847 int ecode8 = 0 ; 11848 PyArrayObject *tmp9 = NULL ; 11849 double val11 ; 11850 int ecode11 = 0 ; 11851 int val12 ; 11852 int ecode12 = 0 ; 11853 double val13 ; 11854 int ecode13 = 0 ; 11855 int val15 ; 11856 int ecode15 = 0 ; 11857 PyObject * obj0 = 0 ; 11858 PyObject * obj1 = 0 ; 11859 PyObject * obj2 = 0 ; 11860 PyObject * obj3 = 0 ; 11861 PyObject * obj4 = 0 ; 11862 PyObject * obj5 = 0 ; 11863 PyObject * obj6 = 0 ; 11864 PyObject * obj7 = 0 ; 11865 PyObject * obj8 = 0 ; 11866 PyObject * obj9 = 0 ; 11867 PyObject * obj10 = 0 ; 11868 PyObject * obj11 = 0 ; 11869 11870 { 11871 python_pltr = 0; 11872 arg16 = NULL; 11873 } 11874 { 11875 arg17 = NULL; 11876 } 11877 { 11878 arg4 = NULL; 11879 } 11880 { 11881 arg14 = plfill; 11882 } 11883 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail; 11884 { 11885 int i, size; 11886 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 11887 if ( tmp1 == NULL ) 11888 return NULL; 11889 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 11890 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 11891 size = arg3; 11892 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 11893 for ( i = 0; i < arg2; i++ ) 11894 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 11895 } 11896 ecode5 = SWIG_AsVal_double(obj1, &val5); 11897 if (!SWIG_IsOK(ecode5)) { 11898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'"); 11899 } 11900 arg5 = (PLFLT)(val5); 11901 ecode6 = SWIG_AsVal_double(obj2, &val6); 11902 if (!SWIG_IsOK(ecode6)) { 11903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'"); 11904 } 11905 arg6 = (PLFLT)(val6); 11906 ecode7 = SWIG_AsVal_double(obj3, &val7); 11907 if (!SWIG_IsOK(ecode7)) { 11908 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'"); 11909 } 11910 arg7 = (PLFLT)(val7); 11911 ecode8 = SWIG_AsVal_double(obj4, &val8); 11912 if (!SWIG_IsOK(ecode8)) { 11913 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'"); 11914 } 11915 arg8 = (PLFLT)(val8); 11916 { 11917 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 ); 11918 if ( tmp9 == NULL ) 11919 return NULL; 11920 arg10 = PyArray_DIMS( tmp9 )[0]; 11921 arg9 = (PLFLT *) PyArray_DATA( tmp9 ); 11922 } 11923 ecode11 = SWIG_AsVal_double(obj6, &val11); 11924 if (!SWIG_IsOK(ecode11)) { 11925 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'"); 11926 } 11927 arg11 = (PLFLT)(val11); 11928 ecode12 = SWIG_AsVal_int(obj7, &val12); 11929 if (!SWIG_IsOK(ecode12)) { 11930 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'"); 11931 } 11932 arg12 = (PLINT)(val12); 11933 ecode13 = SWIG_AsVal_double(obj8, &val13); 11934 if (!SWIG_IsOK(ecode13)) { 11935 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'"); 11936 } 11937 arg13 = (PLFLT)(val13); 11938 ecode15 = SWIG_AsVal_int(obj9, &val15); 11939 if (!SWIG_IsOK(ecode15)) { 11940 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'"); 11941 } 11942 arg15 = (PLBOOL)(val15); 11943 if (obj10) { 11944 { 11945 // it must be a callable or None 11946 if ( obj10 == Py_None ) 11947 { 11948 arg16 = NULL; 11949 } 11950 else 11951 { 11952 if ( !PyCallable_Check( (PyObject *) obj10 ) ) 11953 { 11954 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" ); 11955 return NULL; 11956 } 11957 arg16 = marshal_pltr( obj10 ); 11958 } 11959 } 11960 } 11961 if (obj11) { 11962 { 11963 if ( obj11 == Py_None ) 11964 arg17 = NULL; 11965 else 11966 { 11967 arg17 = marshal_PLPointer( obj11, 0 ); 11968 } 11969 } 11970 } 11971 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); 11972 resultobj = SWIG_Py_Void(); 11973 { 11974 Py_CLEAR( tmp1 ); 11975 free( arg1 ); 11976 } 11977 { 11978 Py_CLEAR( tmp9 ); 11979 } 11980 { 11981 cleanup_pltr(); 11982 } 11983 { 11984 cleanup_PLPointer(); 11985 } 11986 return resultobj; 11987 fail: 11988 { 11989 Py_CLEAR( tmp1 ); 11990 free( arg1 ); 11991 } 11992 { 11993 Py_CLEAR( tmp9 ); 11994 } 11995 { 11996 cleanup_pltr(); 11997 } 11998 { 11999 cleanup_PLPointer(); 12000 } 12001 return NULL; 12002 } 12003 12004 12005 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12006 PyObject *resultobj = 0; 12007 PLFLT **arg1 = (PLFLT **) 0 ; 12008 PLINT arg2 ; 12009 PLINT arg3 ; 12010 defined_func arg4 = (defined_func) 0 ; 12011 PLFLT arg5 ; 12012 PLFLT arg6 ; 12013 PLFLT arg7 ; 12014 PLFLT arg8 ; 12015 PLFLT arg9 ; 12016 PLFLT arg10 ; 12017 PLINT arg11 ; 12018 PLFLT arg12 ; 12019 PLFLT arg13 ; 12020 PLINT arg14 ; 12021 PLFLT arg15 ; 12022 PLINT arg16 ; 12023 PLFLT arg17 ; 12024 fill_func arg18 = (fill_func) 0 ; 12025 PLBOOL arg19 ; 12026 pltr_func arg20 = (pltr_func) 0 ; 12027 PLPointer arg21 = (PLPointer) 0 ; 12028 PyArrayObject *tmp1 = NULL ; 12029 double val5 ; 12030 int ecode5 = 0 ; 12031 double val6 ; 12032 int ecode6 = 0 ; 12033 double val7 ; 12034 int ecode7 = 0 ; 12035 double val8 ; 12036 int ecode8 = 0 ; 12037 double val9 ; 12038 int ecode9 = 0 ; 12039 double val10 ; 12040 int ecode10 = 0 ; 12041 int val11 ; 12042 int ecode11 = 0 ; 12043 double val12 ; 12044 int ecode12 = 0 ; 12045 double val13 ; 12046 int ecode13 = 0 ; 12047 int val14 ; 12048 int ecode14 = 0 ; 12049 double val15 ; 12050 int ecode15 = 0 ; 12051 int val16 ; 12052 int ecode16 = 0 ; 12053 double val17 ; 12054 int ecode17 = 0 ; 12055 int val19 ; 12056 int ecode19 = 0 ; 12057 PyObject * obj0 = 0 ; 12058 PyObject * obj1 = 0 ; 12059 PyObject * obj2 = 0 ; 12060 PyObject * obj3 = 0 ; 12061 PyObject * obj4 = 0 ; 12062 PyObject * obj5 = 0 ; 12063 PyObject * obj6 = 0 ; 12064 PyObject * obj7 = 0 ; 12065 PyObject * obj8 = 0 ; 12066 PyObject * obj9 = 0 ; 12067 PyObject * obj10 = 0 ; 12068 PyObject * obj11 = 0 ; 12069 PyObject * obj12 = 0 ; 12070 PyObject * obj13 = 0 ; 12071 PyObject * obj14 = 0 ; 12072 PyObject * obj15 = 0 ; 12073 PyObject * obj16 = 0 ; 12074 12075 { 12076 python_pltr = 0; 12077 arg20 = NULL; 12078 } 12079 { 12080 arg21 = NULL; 12081 } 12082 { 12083 arg4 = NULL; 12084 } 12085 { 12086 arg18 = plfill; 12087 } 12088 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; 12089 { 12090 int i, size; 12091 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 12092 if ( tmp1 == NULL ) 12093 return NULL; 12094 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 12095 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 12096 size = arg3; 12097 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 12098 for ( i = 0; i < arg2; i++ ) 12099 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 12100 } 12101 ecode5 = SWIG_AsVal_double(obj1, &val5); 12102 if (!SWIG_IsOK(ecode5)) { 12103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'"); 12104 } 12105 arg5 = (PLFLT)(val5); 12106 ecode6 = SWIG_AsVal_double(obj2, &val6); 12107 if (!SWIG_IsOK(ecode6)) { 12108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'"); 12109 } 12110 arg6 = (PLFLT)(val6); 12111 ecode7 = SWIG_AsVal_double(obj3, &val7); 12112 if (!SWIG_IsOK(ecode7)) { 12113 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'"); 12114 } 12115 arg7 = (PLFLT)(val7); 12116 ecode8 = SWIG_AsVal_double(obj4, &val8); 12117 if (!SWIG_IsOK(ecode8)) { 12118 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'"); 12119 } 12120 arg8 = (PLFLT)(val8); 12121 ecode9 = SWIG_AsVal_double(obj5, &val9); 12122 if (!SWIG_IsOK(ecode9)) { 12123 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'"); 12124 } 12125 arg9 = (PLFLT)(val9); 12126 ecode10 = SWIG_AsVal_double(obj6, &val10); 12127 if (!SWIG_IsOK(ecode10)) { 12128 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'"); 12129 } 12130 arg10 = (PLFLT)(val10); 12131 ecode11 = SWIG_AsVal_int(obj7, &val11); 12132 if (!SWIG_IsOK(ecode11)) { 12133 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'"); 12134 } 12135 arg11 = (PLINT)(val11); 12136 ecode12 = SWIG_AsVal_double(obj8, &val12); 12137 if (!SWIG_IsOK(ecode12)) { 12138 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'"); 12139 } 12140 arg12 = (PLFLT)(val12); 12141 ecode13 = SWIG_AsVal_double(obj9, &val13); 12142 if (!SWIG_IsOK(ecode13)) { 12143 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'"); 12144 } 12145 arg13 = (PLFLT)(val13); 12146 ecode14 = SWIG_AsVal_int(obj10, &val14); 12147 if (!SWIG_IsOK(ecode14)) { 12148 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'"); 12149 } 12150 arg14 = (PLINT)(val14); 12151 ecode15 = SWIG_AsVal_double(obj11, &val15); 12152 if (!SWIG_IsOK(ecode15)) { 12153 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'"); 12154 } 12155 arg15 = (PLFLT)(val15); 12156 ecode16 = SWIG_AsVal_int(obj12, &val16); 12157 if (!SWIG_IsOK(ecode16)) { 12158 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'"); 12159 } 12160 arg16 = (PLINT)(val16); 12161 ecode17 = SWIG_AsVal_double(obj13, &val17); 12162 if (!SWIG_IsOK(ecode17)) { 12163 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'"); 12164 } 12165 arg17 = (PLFLT)(val17); 12166 ecode19 = SWIG_AsVal_int(obj14, &val19); 12167 if (!SWIG_IsOK(ecode19)) { 12168 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'"); 12169 } 12170 arg19 = (PLBOOL)(val19); 12171 if (obj15) { 12172 { 12173 // it must be a callable or None 12174 if ( obj15 == Py_None ) 12175 { 12176 arg20 = NULL; 12177 } 12178 else 12179 { 12180 if ( !PyCallable_Check( (PyObject *) obj15 ) ) 12181 { 12182 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" ); 12183 return NULL; 12184 } 12185 arg20 = marshal_pltr( obj15 ); 12186 } 12187 } 12188 } 12189 if (obj16) { 12190 { 12191 if ( obj16 == Py_None ) 12192 arg21 = NULL; 12193 else 12194 { 12195 arg21 = marshal_PLPointer( obj16, 0 ); 12196 } 12197 } 12198 } 12199 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21); 12200 resultobj = SWIG_Py_Void(); 12201 { 12202 Py_CLEAR( tmp1 ); 12203 free( arg1 ); 12204 } 12205 { 12206 cleanup_pltr(); 12207 } 12208 { 12209 cleanup_PLPointer(); 12210 } 12211 return resultobj; 12212 fail: 12213 { 12214 Py_CLEAR( tmp1 ); 12215 free( arg1 ); 12216 } 12217 { 12218 cleanup_pltr(); 12219 } 12220 { 12221 cleanup_PLPointer(); 12222 } 12223 return NULL; 12224 } 12225 12226 12227 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12228 PyObject *resultobj = 0; 12229 label_func arg1 = (label_func) 0 ; 12230 PLPointer arg2 = (PLPointer) 0 ; 12231 int res2 ; 12232 PyObject * obj0 = 0 ; 12233 PyObject * obj1 = 0 ; 12234 12235 if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail; 12236 { 12237 // Release reference to previous function if applicable 12238 if ( python_label ) 12239 { 12240 Py_CLEAR( python_label ); 12241 python_label = 0; 12242 } 12243 // it must be a callable or None 12244 if ( obj0 == Py_None ) 12245 { 12246 arg1 = NULL; 12247 } 12248 else 12249 { 12250 if ( !PyCallable_Check( (PyObject *) obj0 ) ) 12251 { 12252 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" ); 12253 return NULL; 12254 } 12255 // hold a reference to it 12256 Py_XINCREF( (PyObject *) obj0 ); 12257 python_label = (PyObject *) obj0; 12258 // this function handles calling the python function 12259 arg1 = do_label_callback; 12260 } 12261 } 12262 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); 12263 if (!SWIG_IsOK(res2)) { 12264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'"); 12265 } 12266 plslabelfunc(arg1,arg2); 12267 resultobj = SWIG_Py_Void(); 12268 return resultobj; 12269 fail: 12270 return NULL; 12271 } 12272 12273 12274 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12275 PyObject *resultobj = 0; 12276 PLFLT arg1 ; 12277 PLFLT arg2 ; 12278 double val1 ; 12279 int ecode1 = 0 ; 12280 double val2 ; 12281 int ecode2 = 0 ; 12282 PyObject * obj0 = 0 ; 12283 PyObject * obj1 = 0 ; 12284 12285 if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail; 12286 ecode1 = SWIG_AsVal_double(obj0, &val1); 12287 if (!SWIG_IsOK(ecode1)) { 12288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'"); 12289 } 12290 arg1 = (PLFLT)(val1); 12291 ecode2 = SWIG_AsVal_double(obj1, &val2); 12292 if (!SWIG_IsOK(ecode2)) { 12293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'"); 12294 } 12295 arg2 = (PLFLT)(val2); 12296 plsmaj(arg1,arg2); 12297 resultobj = SWIG_Py_Void(); 12298 return resultobj; 12299 fail: 12300 return NULL; 12301 } 12302 12303 12304 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12305 PyObject *resultobj = 0; 12306 PLINT arg1 ; 12307 PLINT arg2 ; 12308 void *arg3 = (void *) 0 ; 12309 int val1 ; 12310 int ecode1 = 0 ; 12311 int val2 ; 12312 int ecode2 = 0 ; 12313 int res3 ; 12314 Py_ssize_t size3 = 0 ; 12315 void *buf3 = 0 ; 12316 PyObject * obj0 = 0 ; 12317 PyObject * obj1 = 0 ; 12318 PyObject * obj2 = 0 ; 12319 12320 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail; 12321 ecode1 = SWIG_AsVal_int(obj0, &val1); 12322 if (!SWIG_IsOK(ecode1)) { 12323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'"); 12324 } 12325 arg1 = (PLINT)(val1); 12326 ecode2 = SWIG_AsVal_int(obj1, &val2); 12327 if (!SWIG_IsOK(ecode2)) { 12328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'"); 12329 } 12330 arg2 = (PLINT)(val2); 12331 { 12332 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3); 12333 if (res3<0) { 12334 PyErr_Clear(); 12335 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'"); 12336 } 12337 arg3 = (void *) buf3; 12338 } 12339 plsmem(arg1,arg2,arg3); 12340 resultobj = SWIG_Py_Void(); 12341 return resultobj; 12342 fail: 12343 return NULL; 12344 } 12345 12346 12347 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12348 PyObject *resultobj = 0; 12349 PLINT arg1 ; 12350 PLINT arg2 ; 12351 void *arg3 = (void *) 0 ; 12352 int val1 ; 12353 int ecode1 = 0 ; 12354 int val2 ; 12355 int ecode2 = 0 ; 12356 int res3 ; 12357 Py_ssize_t size3 = 0 ; 12358 void *buf3 = 0 ; 12359 PyObject * obj0 = 0 ; 12360 PyObject * obj1 = 0 ; 12361 PyObject * obj2 = 0 ; 12362 12363 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail; 12364 ecode1 = SWIG_AsVal_int(obj0, &val1); 12365 if (!SWIG_IsOK(ecode1)) { 12366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'"); 12367 } 12368 arg1 = (PLINT)(val1); 12369 ecode2 = SWIG_AsVal_int(obj1, &val2); 12370 if (!SWIG_IsOK(ecode2)) { 12371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'"); 12372 } 12373 arg2 = (PLINT)(val2); 12374 { 12375 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3); 12376 if (res3<0) { 12377 PyErr_Clear(); 12378 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'"); 12379 } 12380 arg3 = (void *) buf3; 12381 } 12382 plsmema(arg1,arg2,arg3); 12383 resultobj = SWIG_Py_Void(); 12384 return resultobj; 12385 fail: 12386 return NULL; 12387 } 12388 12389 12390 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12391 PyObject *resultobj = 0; 12392 PLFLT arg1 ; 12393 PLFLT arg2 ; 12394 double val1 ; 12395 int ecode1 = 0 ; 12396 double val2 ; 12397 int ecode2 = 0 ; 12398 PyObject * obj0 = 0 ; 12399 PyObject * obj1 = 0 ; 12400 12401 if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail; 12402 ecode1 = SWIG_AsVal_double(obj0, &val1); 12403 if (!SWIG_IsOK(ecode1)) { 12404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'"); 12405 } 12406 arg1 = (PLFLT)(val1); 12407 ecode2 = SWIG_AsVal_double(obj1, &val2); 12408 if (!SWIG_IsOK(ecode2)) { 12409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'"); 12410 } 12411 arg2 = (PLFLT)(val2); 12412 plsmin(arg1,arg2); 12413 resultobj = SWIG_Py_Void(); 12414 return resultobj; 12415 fail: 12416 return NULL; 12417 } 12418 12419 12420 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12421 PyObject *resultobj = 0; 12422 PLINT arg1 ; 12423 int val1 ; 12424 int ecode1 = 0 ; 12425 PyObject * obj0 = 0 ; 12426 12427 if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail; 12428 ecode1 = SWIG_AsVal_int(obj0, &val1); 12429 if (!SWIG_IsOK(ecode1)) { 12430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'"); 12431 } 12432 arg1 = (PLINT)(val1); 12433 plsori(arg1); 12434 resultobj = SWIG_Py_Void(); 12435 return resultobj; 12436 fail: 12437 return NULL; 12438 } 12439 12440 12441 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12442 PyObject *resultobj = 0; 12443 PLFLT arg1 ; 12444 PLFLT arg2 ; 12445 PLINT arg3 ; 12446 PLINT arg4 ; 12447 PLINT arg5 ; 12448 PLINT arg6 ; 12449 double val1 ; 12450 int ecode1 = 0 ; 12451 double val2 ; 12452 int ecode2 = 0 ; 12453 int val3 ; 12454 int ecode3 = 0 ; 12455 int val4 ; 12456 int ecode4 = 0 ; 12457 int val5 ; 12458 int ecode5 = 0 ; 12459 int val6 ; 12460 int ecode6 = 0 ; 12461 PyObject * obj0 = 0 ; 12462 PyObject * obj1 = 0 ; 12463 PyObject * obj2 = 0 ; 12464 PyObject * obj3 = 0 ; 12465 PyObject * obj4 = 0 ; 12466 PyObject * obj5 = 0 ; 12467 12468 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 12469 ecode1 = SWIG_AsVal_double(obj0, &val1); 12470 if (!SWIG_IsOK(ecode1)) { 12471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'"); 12472 } 12473 arg1 = (PLFLT)(val1); 12474 ecode2 = SWIG_AsVal_double(obj1, &val2); 12475 if (!SWIG_IsOK(ecode2)) { 12476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'"); 12477 } 12478 arg2 = (PLFLT)(val2); 12479 ecode3 = SWIG_AsVal_int(obj2, &val3); 12480 if (!SWIG_IsOK(ecode3)) { 12481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'"); 12482 } 12483 arg3 = (PLINT)(val3); 12484 ecode4 = SWIG_AsVal_int(obj3, &val4); 12485 if (!SWIG_IsOK(ecode4)) { 12486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'"); 12487 } 12488 arg4 = (PLINT)(val4); 12489 ecode5 = SWIG_AsVal_int(obj4, &val5); 12490 if (!SWIG_IsOK(ecode5)) { 12491 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'"); 12492 } 12493 arg5 = (PLINT)(val5); 12494 ecode6 = SWIG_AsVal_int(obj5, &val6); 12495 if (!SWIG_IsOK(ecode6)) { 12496 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'"); 12497 } 12498 arg6 = (PLINT)(val6); 12499 plspage(arg1,arg2,arg3,arg4,arg5,arg6); 12500 resultobj = SWIG_Py_Void(); 12501 return resultobj; 12502 fail: 12503 return NULL; 12504 } 12505 12506 12507 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12508 PyObject *resultobj = 0; 12509 char *arg1 = (char *) 0 ; 12510 int res1 ; 12511 char *buf1 = 0 ; 12512 int alloc1 = 0 ; 12513 PyObject * obj0 = 0 ; 12514 12515 if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail; 12516 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 12517 if (!SWIG_IsOK(res1)) { 12518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'"); 12519 } 12520 arg1 = (char *)(buf1); 12521 plspal0((char const *)arg1); 12522 resultobj = SWIG_Py_Void(); 12523 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12524 return resultobj; 12525 fail: 12526 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12527 return NULL; 12528 } 12529 12530 12531 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12532 PyObject *resultobj = 0; 12533 char *arg1 = (char *) 0 ; 12534 PLBOOL arg2 ; 12535 int res1 ; 12536 char *buf1 = 0 ; 12537 int alloc1 = 0 ; 12538 int val2 ; 12539 int ecode2 = 0 ; 12540 PyObject * obj0 = 0 ; 12541 PyObject * obj1 = 0 ; 12542 12543 if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail; 12544 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 12545 if (!SWIG_IsOK(res1)) { 12546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'"); 12547 } 12548 arg1 = (char *)(buf1); 12549 ecode2 = SWIG_AsVal_int(obj1, &val2); 12550 if (!SWIG_IsOK(ecode2)) { 12551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'"); 12552 } 12553 arg2 = (PLBOOL)(val2); 12554 plspal1((char const *)arg1,arg2); 12555 resultobj = SWIG_Py_Void(); 12556 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12557 return resultobj; 12558 fail: 12559 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12560 return NULL; 12561 } 12562 12563 12564 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12565 PyObject *resultobj = 0; 12566 PLBOOL arg1 ; 12567 int val1 ; 12568 int ecode1 = 0 ; 12569 PyObject * obj0 = 0 ; 12570 12571 if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail; 12572 ecode1 = SWIG_AsVal_int(obj0, &val1); 12573 if (!SWIG_IsOK(ecode1)) { 12574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'"); 12575 } 12576 arg1 = (PLBOOL)(val1); 12577 plspause(arg1); 12578 resultobj = SWIG_Py_Void(); 12579 return resultobj; 12580 fail: 12581 return NULL; 12582 } 12583 12584 12585 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12586 PyObject *resultobj = 0; 12587 PLINT arg1 ; 12588 int val1 ; 12589 int ecode1 = 0 ; 12590 PyObject * obj0 = 0 ; 12591 12592 if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail; 12593 ecode1 = SWIG_AsVal_int(obj0, &val1); 12594 if (!SWIG_IsOK(ecode1)) { 12595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'"); 12596 } 12597 arg1 = (PLINT)(val1); 12598 plsstrm(arg1); 12599 resultobj = SWIG_Py_Void(); 12600 return resultobj; 12601 fail: 12602 return NULL; 12603 } 12604 12605 12606 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12607 PyObject *resultobj = 0; 12608 PLINT arg1 ; 12609 PLINT arg2 ; 12610 int val1 ; 12611 int ecode1 = 0 ; 12612 int val2 ; 12613 int ecode2 = 0 ; 12614 PyObject * obj0 = 0 ; 12615 PyObject * obj1 = 0 ; 12616 12617 if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail; 12618 ecode1 = SWIG_AsVal_int(obj0, &val1); 12619 if (!SWIG_IsOK(ecode1)) { 12620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'"); 12621 } 12622 arg1 = (PLINT)(val1); 12623 ecode2 = SWIG_AsVal_int(obj1, &val2); 12624 if (!SWIG_IsOK(ecode2)) { 12625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'"); 12626 } 12627 arg2 = (PLINT)(val2); 12628 plssub(arg1,arg2); 12629 resultobj = SWIG_Py_Void(); 12630 return resultobj; 12631 fail: 12632 return NULL; 12633 } 12634 12635 12636 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12637 PyObject *resultobj = 0; 12638 PLFLT arg1 ; 12639 PLFLT arg2 ; 12640 double val1 ; 12641 int ecode1 = 0 ; 12642 double val2 ; 12643 int ecode2 = 0 ; 12644 PyObject * obj0 = 0 ; 12645 PyObject * obj1 = 0 ; 12646 12647 if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail; 12648 ecode1 = SWIG_AsVal_double(obj0, &val1); 12649 if (!SWIG_IsOK(ecode1)) { 12650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'"); 12651 } 12652 arg1 = (PLFLT)(val1); 12653 ecode2 = SWIG_AsVal_double(obj1, &val2); 12654 if (!SWIG_IsOK(ecode2)) { 12655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'"); 12656 } 12657 arg2 = (PLFLT)(val2); 12658 plssym(arg1,arg2); 12659 resultobj = SWIG_Py_Void(); 12660 return resultobj; 12661 fail: 12662 return NULL; 12663 } 12664 12665 12666 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12667 PyObject *resultobj = 0; 12668 PLINT arg1 ; 12669 PLINT arg2 ; 12670 int val1 ; 12671 int ecode1 = 0 ; 12672 int val2 ; 12673 int ecode2 = 0 ; 12674 PyObject * obj0 = 0 ; 12675 PyObject * obj1 = 0 ; 12676 12677 if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail; 12678 ecode1 = SWIG_AsVal_int(obj0, &val1); 12679 if (!SWIG_IsOK(ecode1)) { 12680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'"); 12681 } 12682 arg1 = (PLINT)(val1); 12683 ecode2 = SWIG_AsVal_int(obj1, &val2); 12684 if (!SWIG_IsOK(ecode2)) { 12685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'"); 12686 } 12687 arg2 = (PLINT)(val2); 12688 plstar(arg1,arg2); 12689 resultobj = SWIG_Py_Void(); 12690 return resultobj; 12691 fail: 12692 return NULL; 12693 } 12694 12695 12696 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12697 PyObject *resultobj = 0; 12698 char *arg1 = (char *) 0 ; 12699 PLINT arg2 ; 12700 PLINT arg3 ; 12701 int res1 ; 12702 char *buf1 = 0 ; 12703 int alloc1 = 0 ; 12704 int val2 ; 12705 int ecode2 = 0 ; 12706 int val3 ; 12707 int ecode3 = 0 ; 12708 PyObject * obj0 = 0 ; 12709 PyObject * obj1 = 0 ; 12710 PyObject * obj2 = 0 ; 12711 12712 if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail; 12713 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 12714 if (!SWIG_IsOK(res1)) { 12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'"); 12716 } 12717 arg1 = (char *)(buf1); 12718 ecode2 = SWIG_AsVal_int(obj1, &val2); 12719 if (!SWIG_IsOK(ecode2)) { 12720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'"); 12721 } 12722 arg2 = (PLINT)(val2); 12723 ecode3 = SWIG_AsVal_int(obj2, &val3); 12724 if (!SWIG_IsOK(ecode3)) { 12725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'"); 12726 } 12727 arg3 = (PLINT)(val3); 12728 plstart((char const *)arg1,arg2,arg3); 12729 resultobj = SWIG_Py_Void(); 12730 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12731 return resultobj; 12732 fail: 12733 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 12734 return NULL; 12735 } 12736 12737 12738 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12739 PyObject *resultobj = 0; 12740 ct_func arg1 = (ct_func) 0 ; 12741 PLPointer arg2 = (PLPointer) 0 ; 12742 int res2 ; 12743 PyObject * obj0 = 0 ; 12744 PyObject * obj1 = 0 ; 12745 12746 { 12747 python_ct = 0; 12748 arg1 = NULL; 12749 } 12750 if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail; 12751 if (obj0) { 12752 { 12753 if ( python_ct ) 12754 cleanup_ct(); 12755 // it must be a callable or none 12756 if ( obj0 == Py_None ) 12757 { 12758 arg1 = NULL; 12759 } 12760 else 12761 { 12762 if ( !PyCallable_Check( (PyObject *) obj0 ) ) 12763 { 12764 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" ); 12765 return NULL; 12766 } 12767 arg1 = marshal_ct( obj0 ); 12768 } 12769 } 12770 } 12771 if (obj1) { 12772 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); 12773 if (!SWIG_IsOK(res2)) { 12774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'"); 12775 } 12776 } 12777 plstransform(arg1,arg2); 12778 resultobj = SWIG_Py_Void(); 12779 return resultobj; 12780 fail: 12781 return NULL; 12782 } 12783 12784 12785 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12786 PyObject *resultobj = 0; 12787 PLINT arg1 ; 12788 PLFLT *arg2 = (PLFLT *) 0 ; 12789 PLFLT *arg3 = (PLFLT *) 0 ; 12790 char *arg4 = (char *) 0 ; 12791 PyArrayObject *tmp1 = NULL ; 12792 PyArrayObject *tmp3 = NULL ; 12793 int res4 ; 12794 char *buf4 = 0 ; 12795 int alloc4 = 0 ; 12796 PyObject * obj0 = 0 ; 12797 PyObject * obj1 = 0 ; 12798 PyObject * obj2 = 0 ; 12799 12800 if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail; 12801 { 12802 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 12803 if ( tmp1 == NULL ) 12804 return NULL; 12805 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 12806 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 12807 } 12808 { 12809 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 12810 if ( tmp3 == NULL ) 12811 return NULL; 12812 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 12813 { 12814 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 12815 return NULL; 12816 } 12817 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 12818 } 12819 res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4); 12820 if (!SWIG_IsOK(res4)) { 12821 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'"); 12822 } 12823 arg4 = (char *)(buf4); 12824 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4); 12825 resultobj = SWIG_Py_Void(); 12826 { 12827 Py_CLEAR( tmp1 ); 12828 } 12829 { 12830 Py_CLEAR( tmp3 ); 12831 } 12832 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 12833 return resultobj; 12834 fail: 12835 { 12836 Py_CLEAR( tmp1 ); 12837 } 12838 { 12839 Py_CLEAR( tmp3 ); 12840 } 12841 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 12842 return NULL; 12843 } 12844 12845 12846 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12847 PyObject *resultobj = 0; 12848 PLINT arg1 ; 12849 PLFLT *arg2 = (PLFLT *) 0 ; 12850 PLFLT *arg3 = (PLFLT *) 0 ; 12851 PLFLT *arg4 = (PLFLT *) 0 ; 12852 char *arg5 = (char *) 0 ; 12853 PyArrayObject *tmp1 = NULL ; 12854 PyArrayObject *tmp3 = NULL ; 12855 PyArrayObject *tmp4 = NULL ; 12856 int res5 ; 12857 char *buf5 = 0 ; 12858 int alloc5 = 0 ; 12859 PyObject * obj0 = 0 ; 12860 PyObject * obj1 = 0 ; 12861 PyObject * obj2 = 0 ; 12862 PyObject * obj3 = 0 ; 12863 12864 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 12865 { 12866 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 12867 if ( tmp1 == NULL ) 12868 return NULL; 12869 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 12870 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 12871 } 12872 { 12873 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 12874 if ( tmp3 == NULL ) 12875 return NULL; 12876 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 12877 { 12878 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 12879 return NULL; 12880 } 12881 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 12882 } 12883 { 12884 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 ); 12885 if ( tmp4 == NULL ) 12886 return NULL; 12887 if ( PyArray_DIMS( tmp4 )[0] != Alen ) 12888 { 12889 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 12890 return NULL; 12891 } 12892 arg4 = (PLFLT *) PyArray_DATA( tmp4 ); 12893 } 12894 res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5); 12895 if (!SWIG_IsOK(res5)) { 12896 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'"); 12897 } 12898 arg5 = (char *)(buf5); 12899 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5); 12900 resultobj = SWIG_Py_Void(); 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 resultobj; 12912 fail: 12913 { 12914 Py_CLEAR( tmp1 ); 12915 } 12916 { 12917 Py_CLEAR( tmp3 ); 12918 } 12919 { 12920 Py_CLEAR( tmp4 ); 12921 } 12922 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); 12923 return NULL; 12924 } 12925 12926 12927 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12928 PyObject *resultobj = 0; 12929 PLINT arg1 ; 12930 PLINT arg2 ; 12931 PLFLT arg3 ; 12932 PLFLT arg4 ; 12933 int val1 ; 12934 int ecode1 = 0 ; 12935 int val2 ; 12936 int ecode2 = 0 ; 12937 double val3 ; 12938 int ecode3 = 0 ; 12939 double val4 ; 12940 int ecode4 = 0 ; 12941 PyObject * obj0 = 0 ; 12942 PyObject * obj1 = 0 ; 12943 PyObject * obj2 = 0 ; 12944 PyObject * obj3 = 0 ; 12945 12946 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 12947 ecode1 = SWIG_AsVal_int(obj0, &val1); 12948 if (!SWIG_IsOK(ecode1)) { 12949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'"); 12950 } 12951 arg1 = (PLINT)(val1); 12952 ecode2 = SWIG_AsVal_int(obj1, &val2); 12953 if (!SWIG_IsOK(ecode2)) { 12954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'"); 12955 } 12956 arg2 = (PLINT)(val2); 12957 ecode3 = SWIG_AsVal_double(obj2, &val3); 12958 if (!SWIG_IsOK(ecode3)) { 12959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'"); 12960 } 12961 arg3 = (PLFLT)(val3); 12962 ecode4 = SWIG_AsVal_double(obj3, &val4); 12963 if (!SWIG_IsOK(ecode4)) { 12964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'"); 12965 } 12966 arg4 = (PLFLT)(val4); 12967 plstripa(arg1,arg2,arg3,arg4); 12968 resultobj = SWIG_Py_Void(); 12969 return resultobj; 12970 fail: 12971 return NULL; 12972 } 12973 12974 12975 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12976 PyObject *resultobj = 0; 12977 PLINT *arg1 = (PLINT *) 0 ; 12978 char *arg2 = (char *) 0 ; 12979 char *arg3 = (char *) 0 ; 12980 PLFLT arg4 ; 12981 PLFLT arg5 ; 12982 PLFLT arg6 ; 12983 PLFLT arg7 ; 12984 PLFLT arg8 ; 12985 PLFLT arg9 ; 12986 PLFLT arg10 ; 12987 PLBOOL arg11 ; 12988 PLBOOL arg12 ; 12989 PLINT arg13 ; 12990 PLINT arg14 ; 12991 PLINT *arg15 = (PLINT *) 0 ; 12992 PLINT *arg16 = (PLINT *) 0 ; 12993 char **arg17 ; 12994 char *arg18 = (char *) 0 ; 12995 char *arg19 = (char *) 0 ; 12996 char *arg20 = (char *) 0 ; 12997 PLINT temp1 ; 12998 int res1 = SWIG_TMPOBJ ; 12999 int res2 ; 13000 char *buf2 = 0 ; 13001 int alloc2 = 0 ; 13002 int res3 ; 13003 char *buf3 = 0 ; 13004 int alloc3 = 0 ; 13005 double val4 ; 13006 int ecode4 = 0 ; 13007 double val5 ; 13008 int ecode5 = 0 ; 13009 double val6 ; 13010 int ecode6 = 0 ; 13011 double val7 ; 13012 int ecode7 = 0 ; 13013 double val8 ; 13014 int ecode8 = 0 ; 13015 double val9 ; 13016 int ecode9 = 0 ; 13017 double val10 ; 13018 int ecode10 = 0 ; 13019 int val11 ; 13020 int ecode11 = 0 ; 13021 int val12 ; 13022 int ecode12 = 0 ; 13023 int val13 ; 13024 int ecode13 = 0 ; 13025 int val14 ; 13026 int ecode14 = 0 ; 13027 PyArrayObject *tmp15 = NULL ; 13028 PyArrayObject *tmp16 = NULL ; 13029 char **tmp17 = NULL ; 13030 int res18 ; 13031 char *buf18 = 0 ; 13032 int alloc18 = 0 ; 13033 int res19 ; 13034 char *buf19 = 0 ; 13035 int alloc19 = 0 ; 13036 int res20 ; 13037 char *buf20 = 0 ; 13038 int alloc20 = 0 ; 13039 PyObject * obj0 = 0 ; 13040 PyObject * obj1 = 0 ; 13041 PyObject * obj2 = 0 ; 13042 PyObject * obj3 = 0 ; 13043 PyObject * obj4 = 0 ; 13044 PyObject * obj5 = 0 ; 13045 PyObject * obj6 = 0 ; 13046 PyObject * obj7 = 0 ; 13047 PyObject * obj8 = 0 ; 13048 PyObject * obj9 = 0 ; 13049 PyObject * obj10 = 0 ; 13050 PyObject * obj11 = 0 ; 13051 PyObject * obj12 = 0 ; 13052 PyObject * obj13 = 0 ; 13053 PyObject * obj14 = 0 ; 13054 PyObject * obj15 = 0 ; 13055 PyObject * obj16 = 0 ; 13056 PyObject * obj17 = 0 ; 13057 PyObject * obj18 = 0 ; 13058 13059 arg1 = &temp1; 13060 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; 13061 res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2); 13062 if (!SWIG_IsOK(res2)) { 13063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'"); 13064 } 13065 arg2 = (char *)(buf2); 13066 res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3); 13067 if (!SWIG_IsOK(res3)) { 13068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'"); 13069 } 13070 arg3 = (char *)(buf3); 13071 ecode4 = SWIG_AsVal_double(obj2, &val4); 13072 if (!SWIG_IsOK(ecode4)) { 13073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'"); 13074 } 13075 arg4 = (PLFLT)(val4); 13076 ecode5 = SWIG_AsVal_double(obj3, &val5); 13077 if (!SWIG_IsOK(ecode5)) { 13078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'"); 13079 } 13080 arg5 = (PLFLT)(val5); 13081 ecode6 = SWIG_AsVal_double(obj4, &val6); 13082 if (!SWIG_IsOK(ecode6)) { 13083 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'"); 13084 } 13085 arg6 = (PLFLT)(val6); 13086 ecode7 = SWIG_AsVal_double(obj5, &val7); 13087 if (!SWIG_IsOK(ecode7)) { 13088 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'"); 13089 } 13090 arg7 = (PLFLT)(val7); 13091 ecode8 = SWIG_AsVal_double(obj6, &val8); 13092 if (!SWIG_IsOK(ecode8)) { 13093 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'"); 13094 } 13095 arg8 = (PLFLT)(val8); 13096 ecode9 = SWIG_AsVal_double(obj7, &val9); 13097 if (!SWIG_IsOK(ecode9)) { 13098 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'"); 13099 } 13100 arg9 = (PLFLT)(val9); 13101 ecode10 = SWIG_AsVal_double(obj8, &val10); 13102 if (!SWIG_IsOK(ecode10)) { 13103 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'"); 13104 } 13105 arg10 = (PLFLT)(val10); 13106 ecode11 = SWIG_AsVal_int(obj9, &val11); 13107 if (!SWIG_IsOK(ecode11)) { 13108 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'"); 13109 } 13110 arg11 = (PLBOOL)(val11); 13111 ecode12 = SWIG_AsVal_int(obj10, &val12); 13112 if (!SWIG_IsOK(ecode12)) { 13113 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'"); 13114 } 13115 arg12 = (PLBOOL)(val12); 13116 ecode13 = SWIG_AsVal_int(obj11, &val13); 13117 if (!SWIG_IsOK(ecode13)) { 13118 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'"); 13119 } 13120 arg13 = (PLINT)(val13); 13121 ecode14 = SWIG_AsVal_int(obj12, &val14); 13122 if (!SWIG_IsOK(ecode14)) { 13123 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'"); 13124 } 13125 arg14 = (PLINT)(val14); 13126 { 13127 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 ); 13128 if ( tmp15 == NULL ) 13129 return NULL; 13130 Alen = PyArray_DIMS( tmp15 )[0]; 13131 arg15 = (PLINT *) PyArray_DATA( tmp15 ); 13132 } 13133 { 13134 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 ); 13135 if ( tmp16 == NULL ) 13136 return NULL; 13137 if ( PyArray_DIMS( tmp16 )[0] != Alen ) 13138 { 13139 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 13140 return NULL; 13141 } 13142 arg16 = (PLINT *) PyArray_DATA( tmp16 ); 13143 } 13144 { 13145 int i; 13146 if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 ) 13147 { 13148 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." ); 13149 return NULL; 13150 } 13151 if ( Alen != 4 ) 13152 { 13153 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." ); 13154 return NULL; 13155 } 13156 tmp17 = (char **) malloc( sizeof ( char* ) * 4 ); 13157 if ( tmp17 == NULL ) 13158 return NULL; 13159 arg17 = tmp17; 13160 for ( i = 0; i < 4; i++ ) 13161 { 13162 arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) ); 13163 if ( arg17[i] == NULL ) 13164 { 13165 free( tmp17 ); 13166 return NULL; 13167 } 13168 } 13169 } 13170 res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18); 13171 if (!SWIG_IsOK(res18)) { 13172 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'"); 13173 } 13174 arg18 = (char *)(buf18); 13175 res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19); 13176 if (!SWIG_IsOK(res19)) { 13177 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'"); 13178 } 13179 arg19 = (char *)(buf19); 13180 res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20); 13181 if (!SWIG_IsOK(res20)) { 13182 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'"); 13183 } 13184 arg20 = (char *)(buf20); 13185 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); 13186 resultobj = SWIG_Py_Void(); 13187 if (SWIG_IsTmpObj(res1)) { 13188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); 13189 } else { 13190 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 13191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); 13192 } 13193 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 13194 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 13195 { 13196 Py_CLEAR( tmp15 ); 13197 } 13198 { 13199 Py_CLEAR( tmp16 ); 13200 } 13201 { 13202 free( tmp17 ); 13203 } 13204 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18); 13205 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19); 13206 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20); 13207 return resultobj; 13208 fail: 13209 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 13210 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 13211 { 13212 Py_CLEAR( tmp15 ); 13213 } 13214 { 13215 Py_CLEAR( tmp16 ); 13216 } 13217 { 13218 free( tmp17 ); 13219 } 13220 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18); 13221 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19); 13222 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20); 13223 return NULL; 13224 } 13225 13226 13227 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13228 PyObject *resultobj = 0; 13229 PLINT arg1 ; 13230 int val1 ; 13231 int ecode1 = 0 ; 13232 PyObject * obj0 = 0 ; 13233 13234 if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail; 13235 ecode1 = SWIG_AsVal_int(obj0, &val1); 13236 if (!SWIG_IsOK(ecode1)) { 13237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'"); 13238 } 13239 arg1 = (PLINT)(val1); 13240 plstripd(arg1); 13241 resultobj = SWIG_Py_Void(); 13242 return resultobj; 13243 fail: 13244 return NULL; 13245 } 13246 13247 13248 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13249 PyObject *resultobj = 0; 13250 PLINT arg1 ; 13251 PLINT *arg2 = (PLINT *) 0 ; 13252 PLINT *arg3 = (PLINT *) 0 ; 13253 PyArrayObject *tmp1 = NULL ; 13254 PyArrayObject *tmp3 = NULL ; 13255 PyObject * obj0 = 0 ; 13256 PyObject * obj1 = 0 ; 13257 13258 if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail; 13259 { 13260 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 ); 13261 if ( tmp1 == NULL ) 13262 return NULL; 13263 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 13264 arg2 = (PLINT *) PyArray_DATA( tmp1 ); 13265 } 13266 { 13267 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 ); 13268 if ( tmp3 == NULL ) 13269 return NULL; 13270 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 13271 { 13272 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 13273 return NULL; 13274 } 13275 arg3 = (PLINT *) PyArray_DATA( tmp3 ); 13276 } 13277 plstyl(arg1,(int const *)arg2,(int const *)arg3); 13278 resultobj = SWIG_Py_Void(); 13279 { 13280 Py_CLEAR( tmp1 ); 13281 } 13282 { 13283 Py_CLEAR( tmp3 ); 13284 } 13285 return resultobj; 13286 fail: 13287 { 13288 Py_CLEAR( tmp1 ); 13289 } 13290 { 13291 Py_CLEAR( tmp3 ); 13292 } 13293 return NULL; 13294 } 13295 13296 13297 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13298 PyObject *resultobj = 0; 13299 PLFLT *arg1 = (PLFLT *) 0 ; 13300 PLFLT *arg2 = (PLFLT *) 0 ; 13301 PLINT arg3 ; 13302 PLBOOL arg4 ; 13303 PyArrayObject *tmp1 = NULL ; 13304 PyArrayObject *tmp2 = NULL ; 13305 int val4 ; 13306 int ecode4 = 0 ; 13307 PyObject * obj0 = 0 ; 13308 PyObject * obj1 = 0 ; 13309 PyObject * obj2 = 0 ; 13310 13311 if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail; 13312 { 13313 if ( obj0 != Py_None ) 13314 { 13315 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 13316 if ( tmp1 == NULL ) 13317 return NULL; 13318 Alen = PyArray_DIMS( tmp1 )[0]; 13319 arg1 = (PLFLT *) PyArray_DATA( tmp1 ); 13320 } 13321 else 13322 { 13323 arg1 = NULL; 13324 Alen = 0; 13325 } 13326 } 13327 { 13328 if ( obj1 != Py_None ) 13329 { 13330 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 13331 if ( tmp2 == NULL ) 13332 return NULL; 13333 if ( PyArray_DIMS( tmp2 )[0] != Alen ) 13334 { 13335 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 13336 return NULL; 13337 } 13338 arg2 = (PLFLT *) PyArray_DATA( tmp2 ); 13339 arg3 = PyArray_DIMS( tmp2 )[0]; 13340 } 13341 else 13342 { 13343 arg2 = NULL; 13344 arg3 = 0; 13345 } 13346 } 13347 ecode4 = SWIG_AsVal_int(obj2, &val4); 13348 if (!SWIG_IsOK(ecode4)) { 13349 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'"); 13350 } 13351 arg4 = (PLBOOL)(val4); 13352 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4); 13353 resultobj = SWIG_Py_Void(); 13354 { 13355 Py_CLEAR( tmp1 ); 13356 } 13357 { 13358 Py_CLEAR( tmp2 ); 13359 } 13360 return resultobj; 13361 fail: 13362 { 13363 Py_CLEAR( tmp1 ); 13364 } 13365 { 13366 Py_CLEAR( tmp2 ); 13367 } 13368 return NULL; 13369 } 13370 13371 13372 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13373 PyObject *resultobj = 0; 13374 PLFLT arg1 ; 13375 PLFLT arg2 ; 13376 PLFLT arg3 ; 13377 PLFLT arg4 ; 13378 double val1 ; 13379 int ecode1 = 0 ; 13380 double val2 ; 13381 int ecode2 = 0 ; 13382 double val3 ; 13383 int ecode3 = 0 ; 13384 double val4 ; 13385 int ecode4 = 0 ; 13386 PyObject * obj0 = 0 ; 13387 PyObject * obj1 = 0 ; 13388 PyObject * obj2 = 0 ; 13389 PyObject * obj3 = 0 ; 13390 13391 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 13392 ecode1 = SWIG_AsVal_double(obj0, &val1); 13393 if (!SWIG_IsOK(ecode1)) { 13394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'"); 13395 } 13396 arg1 = (PLFLT)(val1); 13397 ecode2 = SWIG_AsVal_double(obj1, &val2); 13398 if (!SWIG_IsOK(ecode2)) { 13399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'"); 13400 } 13401 arg2 = (PLFLT)(val2); 13402 ecode3 = SWIG_AsVal_double(obj2, &val3); 13403 if (!SWIG_IsOK(ecode3)) { 13404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'"); 13405 } 13406 arg3 = (PLFLT)(val3); 13407 ecode4 = SWIG_AsVal_double(obj3, &val4); 13408 if (!SWIG_IsOK(ecode4)) { 13409 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'"); 13410 } 13411 arg4 = (PLFLT)(val4); 13412 plsvpa(arg1,arg2,arg3,arg4); 13413 resultobj = SWIG_Py_Void(); 13414 return resultobj; 13415 fail: 13416 return NULL; 13417 } 13418 13419 13420 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13421 PyObject *resultobj = 0; 13422 PLINT arg1 ; 13423 PLINT arg2 ; 13424 int val1 ; 13425 int ecode1 = 0 ; 13426 int val2 ; 13427 int ecode2 = 0 ; 13428 PyObject * obj0 = 0 ; 13429 PyObject * obj1 = 0 ; 13430 13431 if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail; 13432 ecode1 = SWIG_AsVal_int(obj0, &val1); 13433 if (!SWIG_IsOK(ecode1)) { 13434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'"); 13435 } 13436 arg1 = (PLINT)(val1); 13437 ecode2 = SWIG_AsVal_int(obj1, &val2); 13438 if (!SWIG_IsOK(ecode2)) { 13439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'"); 13440 } 13441 arg2 = (PLINT)(val2); 13442 plsxax(arg1,arg2); 13443 resultobj = SWIG_Py_Void(); 13444 return resultobj; 13445 fail: 13446 return NULL; 13447 } 13448 13449 13450 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13451 PyObject *resultobj = 0; 13452 PLINT arg1 ; 13453 PLINT arg2 ; 13454 int val1 ; 13455 int ecode1 = 0 ; 13456 int val2 ; 13457 int ecode2 = 0 ; 13458 PyObject * obj0 = 0 ; 13459 PyObject * obj1 = 0 ; 13460 13461 if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail; 13462 ecode1 = SWIG_AsVal_int(obj0, &val1); 13463 if (!SWIG_IsOK(ecode1)) { 13464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'"); 13465 } 13466 arg1 = (PLINT)(val1); 13467 ecode2 = SWIG_AsVal_int(obj1, &val2); 13468 if (!SWIG_IsOK(ecode2)) { 13469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'"); 13470 } 13471 arg2 = (PLINT)(val2); 13472 plsyax(arg1,arg2); 13473 resultobj = SWIG_Py_Void(); 13474 return resultobj; 13475 fail: 13476 return NULL; 13477 } 13478 13479 13480 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13481 PyObject *resultobj = 0; 13482 PLINT arg1 ; 13483 PLFLT *arg2 = (PLFLT *) 0 ; 13484 PLFLT *arg3 = (PLFLT *) 0 ; 13485 PLINT arg4 ; 13486 PyArrayObject *tmp1 = NULL ; 13487 PyArrayObject *tmp3 = NULL ; 13488 int val4 ; 13489 int ecode4 = 0 ; 13490 PyObject * obj0 = 0 ; 13491 PyObject * obj1 = 0 ; 13492 PyObject * obj2 = 0 ; 13493 13494 if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail; 13495 { 13496 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 ); 13497 if ( tmp1 == NULL ) 13498 return NULL; 13499 arg1 = Alen = PyArray_DIMS( tmp1 )[0]; 13500 arg2 = (PLFLT *) PyArray_DATA( tmp1 ); 13501 } 13502 { 13503 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 ); 13504 if ( tmp3 == NULL ) 13505 return NULL; 13506 if ( PyArray_DIMS( tmp3 )[0] != Alen ) 13507 { 13508 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." ); 13509 return NULL; 13510 } 13511 arg3 = (PLFLT *) PyArray_DATA( tmp3 ); 13512 } 13513 ecode4 = SWIG_AsVal_int(obj2, &val4); 13514 if (!SWIG_IsOK(ecode4)) { 13515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'"); 13516 } 13517 arg4 = (PLINT)(val4); 13518 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4); 13519 resultobj = SWIG_Py_Void(); 13520 { 13521 Py_CLEAR( tmp1 ); 13522 } 13523 { 13524 Py_CLEAR( tmp3 ); 13525 } 13526 return resultobj; 13527 fail: 13528 { 13529 Py_CLEAR( tmp1 ); 13530 } 13531 { 13532 Py_CLEAR( tmp3 ); 13533 } 13534 return NULL; 13535 } 13536 13537 13538 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13539 PyObject *resultobj = 0; 13540 PLINT arg1 ; 13541 PLINT arg2 ; 13542 int val1 ; 13543 int ecode1 = 0 ; 13544 int val2 ; 13545 int ecode2 = 0 ; 13546 PyObject * obj0 = 0 ; 13547 PyObject * obj1 = 0 ; 13548 13549 if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail; 13550 ecode1 = SWIG_AsVal_int(obj0, &val1); 13551 if (!SWIG_IsOK(ecode1)) { 13552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'"); 13553 } 13554 arg1 = (PLINT)(val1); 13555 ecode2 = SWIG_AsVal_int(obj1, &val2); 13556 if (!SWIG_IsOK(ecode2)) { 13557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'"); 13558 } 13559 arg2 = (PLINT)(val2); 13560 plszax(arg1,arg2); 13561 resultobj = SWIG_Py_Void(); 13562 return resultobj; 13563 fail: 13564 return NULL; 13565 } 13566 13567 13568 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13569 PyObject *resultobj = 0; 13570 13571 if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail; 13572 pltext(); 13573 resultobj = SWIG_Py_Void(); 13574 return resultobj; 13575 fail: 13576 return NULL; 13577 } 13578 13579 13580 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13581 PyObject *resultobj = 0; 13582 char *arg1 = (char *) 0 ; 13583 int res1 ; 13584 char *buf1 = 0 ; 13585 int alloc1 = 0 ; 13586 PyObject * obj0 = 0 ; 13587 13588 if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail; 13589 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 13590 if (!SWIG_IsOK(res1)) { 13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'"); 13592 } 13593 arg1 = (char *)(buf1); 13594 pltimefmt((char const *)arg1); 13595 resultobj = SWIG_Py_Void(); 13596 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 13597 return resultobj; 13598 fail: 13599 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 13600 return NULL; 13601 } 13602 13603 13604 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13605 PyObject *resultobj = 0; 13606 PLFLT arg1 ; 13607 double val1 ; 13608 int ecode1 = 0 ; 13609 PyObject * obj0 = 0 ; 13610 13611 if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail; 13612 ecode1 = SWIG_AsVal_double(obj0, &val1); 13613 if (!SWIG_IsOK(ecode1)) { 13614 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'"); 13615 } 13616 arg1 = (PLFLT)(val1); 13617 plvasp(arg1); 13618 resultobj = SWIG_Py_Void(); 13619 return resultobj; 13620 fail: 13621 return NULL; 13622 } 13623 13624 13625 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13626 PyObject *resultobj = 0; 13627 PLFLT **arg1 = (PLFLT **) 0 ; 13628 PLFLT **arg2 = (PLFLT **) 0 ; 13629 PLINT arg3 ; 13630 PLINT arg4 ; 13631 PLFLT arg5 ; 13632 pltr_func arg6 = (pltr_func) 0 ; 13633 PLPointer arg7 = (PLPointer) 0 ; 13634 PyArrayObject *tmp1 = NULL ; 13635 PyArrayObject *tmp2 = NULL ; 13636 double val5 ; 13637 int ecode5 = 0 ; 13638 PyObject * obj0 = 0 ; 13639 PyObject * obj1 = 0 ; 13640 PyObject * obj2 = 0 ; 13641 PyObject * obj3 = 0 ; 13642 PyObject * obj4 = 0 ; 13643 13644 { 13645 python_pltr = 0; 13646 arg6 = NULL; 13647 } 13648 { 13649 arg7 = NULL; 13650 } 13651 if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 13652 { 13653 int i, size; 13654 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 13655 if ( tmp1 == NULL ) 13656 return NULL; 13657 Xlen = PyArray_DIMS( tmp1 )[0]; 13658 Ylen = PyArray_DIMS( tmp1 )[1]; 13659 size = Ylen; 13660 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen ); 13661 for ( i = 0; i < Xlen; i++ ) 13662 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 13663 } 13664 { 13665 int i, size; 13666 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 ); 13667 if ( tmp2 == NULL ) 13668 return NULL; 13669 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] ) 13670 { 13671 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." ); 13672 return NULL; 13673 } 13674 arg3 = PyArray_DIMS( tmp2 )[0]; 13675 arg4 = PyArray_DIMS( tmp2 )[1]; 13676 size = arg4; 13677 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 ); 13678 for ( i = 0; i < arg3; i++ ) 13679 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size ); 13680 } 13681 ecode5 = SWIG_AsVal_double(obj2, &val5); 13682 if (!SWIG_IsOK(ecode5)) { 13683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'"); 13684 } 13685 arg5 = (PLFLT)(val5); 13686 if (obj3) { 13687 { 13688 // it must be a callable or None 13689 if ( obj3 == Py_None ) 13690 { 13691 arg6 = NULL; 13692 } 13693 else 13694 { 13695 if ( !PyCallable_Check( (PyObject *) obj3 ) ) 13696 { 13697 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" ); 13698 return NULL; 13699 } 13700 arg6 = marshal_pltr( obj3 ); 13701 } 13702 } 13703 } 13704 if (obj4) { 13705 { 13706 if ( obj4 == Py_None ) 13707 arg7 = NULL; 13708 else 13709 { 13710 arg7 = marshal_PLPointer( obj4, 0 ); 13711 } 13712 } 13713 } 13714 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7); 13715 resultobj = SWIG_Py_Void(); 13716 { 13717 Py_CLEAR( tmp1 ); 13718 free( arg1 ); 13719 } 13720 { 13721 Py_CLEAR( tmp2 ); 13722 free( arg2 ); 13723 } 13724 { 13725 cleanup_pltr(); 13726 } 13727 { 13728 cleanup_PLPointer(); 13729 } 13730 return resultobj; 13731 fail: 13732 { 13733 Py_CLEAR( tmp1 ); 13734 free( arg1 ); 13735 } 13736 { 13737 Py_CLEAR( tmp2 ); 13738 free( arg2 ); 13739 } 13740 { 13741 cleanup_pltr(); 13742 } 13743 { 13744 cleanup_PLPointer(); 13745 } 13746 return NULL; 13747 } 13748 13749 13750 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13751 PyObject *resultobj = 0; 13752 PLFLT arg1 ; 13753 PLFLT arg2 ; 13754 PLFLT arg3 ; 13755 PLFLT arg4 ; 13756 PLFLT arg5 ; 13757 double val1 ; 13758 int ecode1 = 0 ; 13759 double val2 ; 13760 int ecode2 = 0 ; 13761 double val3 ; 13762 int ecode3 = 0 ; 13763 double val4 ; 13764 int ecode4 = 0 ; 13765 double val5 ; 13766 int ecode5 = 0 ; 13767 PyObject * obj0 = 0 ; 13768 PyObject * obj1 = 0 ; 13769 PyObject * obj2 = 0 ; 13770 PyObject * obj3 = 0 ; 13771 PyObject * obj4 = 0 ; 13772 13773 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; 13774 ecode1 = SWIG_AsVal_double(obj0, &val1); 13775 if (!SWIG_IsOK(ecode1)) { 13776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'"); 13777 } 13778 arg1 = (PLFLT)(val1); 13779 ecode2 = SWIG_AsVal_double(obj1, &val2); 13780 if (!SWIG_IsOK(ecode2)) { 13781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'"); 13782 } 13783 arg2 = (PLFLT)(val2); 13784 ecode3 = SWIG_AsVal_double(obj2, &val3); 13785 if (!SWIG_IsOK(ecode3)) { 13786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'"); 13787 } 13788 arg3 = (PLFLT)(val3); 13789 ecode4 = SWIG_AsVal_double(obj3, &val4); 13790 if (!SWIG_IsOK(ecode4)) { 13791 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'"); 13792 } 13793 arg4 = (PLFLT)(val4); 13794 ecode5 = SWIG_AsVal_double(obj4, &val5); 13795 if (!SWIG_IsOK(ecode5)) { 13796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'"); 13797 } 13798 arg5 = (PLFLT)(val5); 13799 plvpas(arg1,arg2,arg3,arg4,arg5); 13800 resultobj = SWIG_Py_Void(); 13801 return resultobj; 13802 fail: 13803 return NULL; 13804 } 13805 13806 13807 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13808 PyObject *resultobj = 0; 13809 PLFLT arg1 ; 13810 PLFLT arg2 ; 13811 PLFLT arg3 ; 13812 PLFLT arg4 ; 13813 double val1 ; 13814 int ecode1 = 0 ; 13815 double val2 ; 13816 int ecode2 = 0 ; 13817 double val3 ; 13818 int ecode3 = 0 ; 13819 double val4 ; 13820 int ecode4 = 0 ; 13821 PyObject * obj0 = 0 ; 13822 PyObject * obj1 = 0 ; 13823 PyObject * obj2 = 0 ; 13824 PyObject * obj3 = 0 ; 13825 13826 if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 13827 ecode1 = SWIG_AsVal_double(obj0, &val1); 13828 if (!SWIG_IsOK(ecode1)) { 13829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'"); 13830 } 13831 arg1 = (PLFLT)(val1); 13832 ecode2 = SWIG_AsVal_double(obj1, &val2); 13833 if (!SWIG_IsOK(ecode2)) { 13834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'"); 13835 } 13836 arg2 = (PLFLT)(val2); 13837 ecode3 = SWIG_AsVal_double(obj2, &val3); 13838 if (!SWIG_IsOK(ecode3)) { 13839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'"); 13840 } 13841 arg3 = (PLFLT)(val3); 13842 ecode4 = SWIG_AsVal_double(obj3, &val4); 13843 if (!SWIG_IsOK(ecode4)) { 13844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'"); 13845 } 13846 arg4 = (PLFLT)(val4); 13847 plvpor(arg1,arg2,arg3,arg4); 13848 resultobj = SWIG_Py_Void(); 13849 return resultobj; 13850 fail: 13851 return NULL; 13852 } 13853 13854 13855 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13856 PyObject *resultobj = 0; 13857 13858 if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail; 13859 plvsta(); 13860 resultobj = SWIG_Py_Void(); 13861 return resultobj; 13862 fail: 13863 return NULL; 13864 } 13865 13866 13867 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13868 PyObject *resultobj = 0; 13869 PLFLT arg1 ; 13870 PLFLT arg2 ; 13871 PLFLT arg3 ; 13872 PLFLT arg4 ; 13873 PLFLT arg5 ; 13874 PLFLT arg6 ; 13875 PLFLT arg7 ; 13876 PLFLT arg8 ; 13877 PLFLT arg9 ; 13878 PLFLT arg10 ; 13879 PLFLT arg11 ; 13880 double val1 ; 13881 int ecode1 = 0 ; 13882 double val2 ; 13883 int ecode2 = 0 ; 13884 double val3 ; 13885 int ecode3 = 0 ; 13886 double val4 ; 13887 int ecode4 = 0 ; 13888 double val5 ; 13889 int ecode5 = 0 ; 13890 double val6 ; 13891 int ecode6 = 0 ; 13892 double val7 ; 13893 int ecode7 = 0 ; 13894 double val8 ; 13895 int ecode8 = 0 ; 13896 double val9 ; 13897 int ecode9 = 0 ; 13898 double val10 ; 13899 int ecode10 = 0 ; 13900 double val11 ; 13901 int ecode11 = 0 ; 13902 PyObject * obj0 = 0 ; 13903 PyObject * obj1 = 0 ; 13904 PyObject * obj2 = 0 ; 13905 PyObject * obj3 = 0 ; 13906 PyObject * obj4 = 0 ; 13907 PyObject * obj5 = 0 ; 13908 PyObject * obj6 = 0 ; 13909 PyObject * obj7 = 0 ; 13910 PyObject * obj8 = 0 ; 13911 PyObject * obj9 = 0 ; 13912 PyObject * obj10 = 0 ; 13913 13914 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; 13915 ecode1 = SWIG_AsVal_double(obj0, &val1); 13916 if (!SWIG_IsOK(ecode1)) { 13917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'"); 13918 } 13919 arg1 = (PLFLT)(val1); 13920 ecode2 = SWIG_AsVal_double(obj1, &val2); 13921 if (!SWIG_IsOK(ecode2)) { 13922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'"); 13923 } 13924 arg2 = (PLFLT)(val2); 13925 ecode3 = SWIG_AsVal_double(obj2, &val3); 13926 if (!SWIG_IsOK(ecode3)) { 13927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'"); 13928 } 13929 arg3 = (PLFLT)(val3); 13930 ecode4 = SWIG_AsVal_double(obj3, &val4); 13931 if (!SWIG_IsOK(ecode4)) { 13932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'"); 13933 } 13934 arg4 = (PLFLT)(val4); 13935 ecode5 = SWIG_AsVal_double(obj4, &val5); 13936 if (!SWIG_IsOK(ecode5)) { 13937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'"); 13938 } 13939 arg5 = (PLFLT)(val5); 13940 ecode6 = SWIG_AsVal_double(obj5, &val6); 13941 if (!SWIG_IsOK(ecode6)) { 13942 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'"); 13943 } 13944 arg6 = (PLFLT)(val6); 13945 ecode7 = SWIG_AsVal_double(obj6, &val7); 13946 if (!SWIG_IsOK(ecode7)) { 13947 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'"); 13948 } 13949 arg7 = (PLFLT)(val7); 13950 ecode8 = SWIG_AsVal_double(obj7, &val8); 13951 if (!SWIG_IsOK(ecode8)) { 13952 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'"); 13953 } 13954 arg8 = (PLFLT)(val8); 13955 ecode9 = SWIG_AsVal_double(obj8, &val9); 13956 if (!SWIG_IsOK(ecode9)) { 13957 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'"); 13958 } 13959 arg9 = (PLFLT)(val9); 13960 ecode10 = SWIG_AsVal_double(obj9, &val10); 13961 if (!SWIG_IsOK(ecode10)) { 13962 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'"); 13963 } 13964 arg10 = (PLFLT)(val10); 13965 ecode11 = SWIG_AsVal_double(obj10, &val11); 13966 if (!SWIG_IsOK(ecode11)) { 13967 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'"); 13968 } 13969 arg11 = (PLFLT)(val11); 13970 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); 13971 resultobj = SWIG_Py_Void(); 13972 return resultobj; 13973 fail: 13974 return NULL; 13975 } 13976 13977 13978 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13979 PyObject *resultobj = 0; 13980 PLFLT arg1 ; 13981 double val1 ; 13982 int ecode1 = 0 ; 13983 PyObject * obj0 = 0 ; 13984 13985 if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail; 13986 ecode1 = SWIG_AsVal_double(obj0, &val1); 13987 if (!SWIG_IsOK(ecode1)) { 13988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'"); 13989 } 13990 arg1 = (PLFLT)(val1); 13991 plwidth(arg1); 13992 resultobj = SWIG_Py_Void(); 13993 return resultobj; 13994 fail: 13995 return NULL; 13996 } 13997 13998 13999 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14000 PyObject *resultobj = 0; 14001 PLFLT arg1 ; 14002 PLFLT arg2 ; 14003 PLFLT arg3 ; 14004 PLFLT arg4 ; 14005 double val1 ; 14006 int ecode1 = 0 ; 14007 double val2 ; 14008 int ecode2 = 0 ; 14009 double val3 ; 14010 int ecode3 = 0 ; 14011 double val4 ; 14012 int ecode4 = 0 ; 14013 PyObject * obj0 = 0 ; 14014 PyObject * obj1 = 0 ; 14015 PyObject * obj2 = 0 ; 14016 PyObject * obj3 = 0 ; 14017 14018 if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 14019 ecode1 = SWIG_AsVal_double(obj0, &val1); 14020 if (!SWIG_IsOK(ecode1)) { 14021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'"); 14022 } 14023 arg1 = (PLFLT)(val1); 14024 ecode2 = SWIG_AsVal_double(obj1, &val2); 14025 if (!SWIG_IsOK(ecode2)) { 14026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'"); 14027 } 14028 arg2 = (PLFLT)(val2); 14029 ecode3 = SWIG_AsVal_double(obj2, &val3); 14030 if (!SWIG_IsOK(ecode3)) { 14031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'"); 14032 } 14033 arg3 = (PLFLT)(val3); 14034 ecode4 = SWIG_AsVal_double(obj3, &val4); 14035 if (!SWIG_IsOK(ecode4)) { 14036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'"); 14037 } 14038 arg4 = (PLFLT)(val4); 14039 plwind(arg1,arg2,arg3,arg4); 14040 resultobj = SWIG_Py_Void(); 14041 return resultobj; 14042 fail: 14043 return NULL; 14044 } 14045 14046 14047 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14048 PyObject *resultobj = 0; 14049 PLBOOL arg1 ; 14050 PLBOOL *arg2 = (PLBOOL *) 0 ; 14051 int val1 ; 14052 int ecode1 = 0 ; 14053 PLBOOL temp2 ; 14054 int res2 = SWIG_TMPOBJ ; 14055 PyObject * obj0 = 0 ; 14056 14057 arg2 = &temp2; 14058 if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail; 14059 ecode1 = SWIG_AsVal_int(obj0, &val1); 14060 if (!SWIG_IsOK(ecode1)) { 14061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'"); 14062 } 14063 arg1 = (PLBOOL)(val1); 14064 plxormod(arg1,arg2); 14065 resultobj = SWIG_Py_Void(); 14066 if (SWIG_IsTmpObj(res2)) { 14067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); 14068 } else { 14069 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 14070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags)); 14071 } 14072 return resultobj; 14073 fail: 14074 return NULL; 14075 } 14076 14077 14078 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14079 PyObject *resultobj = 0; 14080 mapform_func arg1 = (mapform_func) 0 ; 14081 char *arg2 = (char *) 0 ; 14082 PLFLT arg3 ; 14083 PLFLT arg4 ; 14084 PLFLT arg5 ; 14085 PLFLT arg6 ; 14086 int res2 ; 14087 char *buf2 = 0 ; 14088 int alloc2 = 0 ; 14089 double val3 ; 14090 int ecode3 = 0 ; 14091 double val4 ; 14092 int ecode4 = 0 ; 14093 double val5 ; 14094 int ecode5 = 0 ; 14095 double val6 ; 14096 int ecode6 = 0 ; 14097 PyObject * obj0 = 0 ; 14098 PyObject * obj1 = 0 ; 14099 PyObject * obj2 = 0 ; 14100 PyObject * obj3 = 0 ; 14101 PyObject * obj4 = 0 ; 14102 PyObject * obj5 = 0 ; 14103 14104 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; 14105 { 14106 // it must be a callable or none 14107 if ( obj0 == Py_None ) 14108 { 14109 arg1 = NULL; 14110 } 14111 else 14112 { 14113 if ( !PyCallable_Check( (PyObject *) obj0 ) ) 14114 { 14115 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" ); 14116 return NULL; 14117 } 14118 arg1 = marshal_mapform( obj0 ); 14119 } 14120 } 14121 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 14122 if (!SWIG_IsOK(res2)) { 14123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'"); 14124 } 14125 arg2 = (char *)(buf2); 14126 ecode3 = SWIG_AsVal_double(obj2, &val3); 14127 if (!SWIG_IsOK(ecode3)) { 14128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'"); 14129 } 14130 arg3 = (PLFLT)(val3); 14131 ecode4 = SWIG_AsVal_double(obj3, &val4); 14132 if (!SWIG_IsOK(ecode4)) { 14133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'"); 14134 } 14135 arg4 = (PLFLT)(val4); 14136 ecode5 = SWIG_AsVal_double(obj4, &val5); 14137 if (!SWIG_IsOK(ecode5)) { 14138 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'"); 14139 } 14140 arg5 = (PLFLT)(val5); 14141 ecode6 = SWIG_AsVal_double(obj5, &val6); 14142 if (!SWIG_IsOK(ecode6)) { 14143 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'"); 14144 } 14145 arg6 = (PLFLT)(val6); 14146 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); 14147 resultobj = SWIG_Py_Void(); 14148 { 14149 cleanup_mapform(); 14150 } 14151 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 14152 return resultobj; 14153 fail: 14154 { 14155 cleanup_mapform(); 14156 } 14157 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 14158 return NULL; 14159 } 14160 14161 14162 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14163 PyObject *resultobj = 0; 14164 mapform_func arg1 = (mapform_func) 0 ; 14165 PLFLT arg2 ; 14166 PLFLT arg3 ; 14167 PLFLT arg4 ; 14168 PLFLT arg5 ; 14169 PLFLT arg6 ; 14170 PLFLT arg7 ; 14171 double val2 ; 14172 int ecode2 = 0 ; 14173 double val3 ; 14174 int ecode3 = 0 ; 14175 double val4 ; 14176 int ecode4 = 0 ; 14177 double val5 ; 14178 int ecode5 = 0 ; 14179 double val6 ; 14180 int ecode6 = 0 ; 14181 double val7 ; 14182 int ecode7 = 0 ; 14183 PyObject * obj0 = 0 ; 14184 PyObject * obj1 = 0 ; 14185 PyObject * obj2 = 0 ; 14186 PyObject * obj3 = 0 ; 14187 PyObject * obj4 = 0 ; 14188 PyObject * obj5 = 0 ; 14189 PyObject * obj6 = 0 ; 14190 14191 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; 14192 { 14193 // it must be a callable or none 14194 if ( obj0 == Py_None ) 14195 { 14196 arg1 = NULL; 14197 } 14198 else 14199 { 14200 if ( !PyCallable_Check( (PyObject *) obj0 ) ) 14201 { 14202 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" ); 14203 return NULL; 14204 } 14205 arg1 = marshal_mapform( obj0 ); 14206 } 14207 } 14208 ecode2 = SWIG_AsVal_double(obj1, &val2); 14209 if (!SWIG_IsOK(ecode2)) { 14210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'"); 14211 } 14212 arg2 = (PLFLT)(val2); 14213 ecode3 = SWIG_AsVal_double(obj2, &val3); 14214 if (!SWIG_IsOK(ecode3)) { 14215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'"); 14216 } 14217 arg3 = (PLFLT)(val3); 14218 ecode4 = SWIG_AsVal_double(obj3, &val4); 14219 if (!SWIG_IsOK(ecode4)) { 14220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'"); 14221 } 14222 arg4 = (PLFLT)(val4); 14223 ecode5 = SWIG_AsVal_double(obj4, &val5); 14224 if (!SWIG_IsOK(ecode5)) { 14225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'"); 14226 } 14227 arg5 = (PLFLT)(val5); 14228 ecode6 = SWIG_AsVal_double(obj5, &val6); 14229 if (!SWIG_IsOK(ecode6)) { 14230 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'"); 14231 } 14232 arg6 = (PLFLT)(val6); 14233 ecode7 = SWIG_AsVal_double(obj6, &val7); 14234 if (!SWIG_IsOK(ecode7)) { 14235 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'"); 14236 } 14237 arg7 = (PLFLT)(val7); 14238 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 14239 resultobj = SWIG_Py_Void(); 14240 { 14241 cleanup_mapform(); 14242 } 14243 return resultobj; 14244 fail: 14245 { 14246 cleanup_mapform(); 14247 } 14248 return NULL; 14249 } 14250 14251 14252 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14253 PyObject *resultobj = 0; 14254 PLFLT **arg1 = (PLFLT **) 0 ; 14255 PLINT arg2 ; 14256 PLINT arg3 ; 14257 PLFLT arg4 ; 14258 PLFLT arg5 ; 14259 PLFLT arg6 ; 14260 PLFLT arg7 ; 14261 PLFLT arg8 ; 14262 PLFLT arg9 ; 14263 PLFLT arg10 ; 14264 PLFLT arg11 ; 14265 PLFLT arg12 ; 14266 PLFLT arg13 ; 14267 PyArrayObject *tmp1 = NULL ; 14268 double val4 ; 14269 int ecode4 = 0 ; 14270 double val5 ; 14271 int ecode5 = 0 ; 14272 double val6 ; 14273 int ecode6 = 0 ; 14274 double val7 ; 14275 int ecode7 = 0 ; 14276 double val8 ; 14277 int ecode8 = 0 ; 14278 double val9 ; 14279 int ecode9 = 0 ; 14280 double val10 ; 14281 int ecode10 = 0 ; 14282 double val11 ; 14283 int ecode11 = 0 ; 14284 double val12 ; 14285 int ecode12 = 0 ; 14286 double val13 ; 14287 int ecode13 = 0 ; 14288 PyObject * obj0 = 0 ; 14289 PyObject * obj1 = 0 ; 14290 PyObject * obj2 = 0 ; 14291 PyObject * obj3 = 0 ; 14292 PyObject * obj4 = 0 ; 14293 PyObject * obj5 = 0 ; 14294 PyObject * obj6 = 0 ; 14295 PyObject * obj7 = 0 ; 14296 PyObject * obj8 = 0 ; 14297 PyObject * obj9 = 0 ; 14298 PyObject * obj10 = 0 ; 14299 14300 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; 14301 { 14302 int i, size; 14303 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 14304 if ( tmp1 == NULL ) 14305 return NULL; 14306 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 14307 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 14308 size = arg3; 14309 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 14310 for ( i = 0; i < arg2; i++ ) 14311 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 14312 } 14313 ecode4 = SWIG_AsVal_double(obj1, &val4); 14314 if (!SWIG_IsOK(ecode4)) { 14315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'"); 14316 } 14317 arg4 = (PLFLT)(val4); 14318 ecode5 = SWIG_AsVal_double(obj2, &val5); 14319 if (!SWIG_IsOK(ecode5)) { 14320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'"); 14321 } 14322 arg5 = (PLFLT)(val5); 14323 ecode6 = SWIG_AsVal_double(obj3, &val6); 14324 if (!SWIG_IsOK(ecode6)) { 14325 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'"); 14326 } 14327 arg6 = (PLFLT)(val6); 14328 ecode7 = SWIG_AsVal_double(obj4, &val7); 14329 if (!SWIG_IsOK(ecode7)) { 14330 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'"); 14331 } 14332 arg7 = (PLFLT)(val7); 14333 ecode8 = SWIG_AsVal_double(obj5, &val8); 14334 if (!SWIG_IsOK(ecode8)) { 14335 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'"); 14336 } 14337 arg8 = (PLFLT)(val8); 14338 ecode9 = SWIG_AsVal_double(obj6, &val9); 14339 if (!SWIG_IsOK(ecode9)) { 14340 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'"); 14341 } 14342 arg9 = (PLFLT)(val9); 14343 ecode10 = SWIG_AsVal_double(obj7, &val10); 14344 if (!SWIG_IsOK(ecode10)) { 14345 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'"); 14346 } 14347 arg10 = (PLFLT)(val10); 14348 ecode11 = SWIG_AsVal_double(obj8, &val11); 14349 if (!SWIG_IsOK(ecode11)) { 14350 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'"); 14351 } 14352 arg11 = (PLFLT)(val11); 14353 ecode12 = SWIG_AsVal_double(obj9, &val12); 14354 if (!SWIG_IsOK(ecode12)) { 14355 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'"); 14356 } 14357 arg12 = (PLFLT)(val12); 14358 ecode13 = SWIG_AsVal_double(obj10, &val13); 14359 if (!SWIG_IsOK(ecode13)) { 14360 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'"); 14361 } 14362 arg13 = (PLFLT)(val13); 14363 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13); 14364 resultobj = SWIG_Py_Void(); 14365 { 14366 Py_CLEAR( tmp1 ); 14367 free( arg1 ); 14368 } 14369 return resultobj; 14370 fail: 14371 { 14372 Py_CLEAR( tmp1 ); 14373 free( arg1 ); 14374 } 14375 return NULL; 14376 } 14377 14378 14379 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14380 PyObject *resultobj = 0; 14381 PLFLT **arg1 = (PLFLT **) 0 ; 14382 PLINT arg2 ; 14383 PLINT arg3 ; 14384 PLFLT arg4 ; 14385 PLFLT arg5 ; 14386 PLFLT arg6 ; 14387 PLFLT arg7 ; 14388 PLFLT arg8 ; 14389 PLFLT arg9 ; 14390 PLFLT arg10 ; 14391 PLFLT arg11 ; 14392 pltr_func arg12 = (pltr_func) 0 ; 14393 PLPointer arg13 = (PLPointer) 0 ; 14394 PyArrayObject *tmp1 = NULL ; 14395 double val4 ; 14396 int ecode4 = 0 ; 14397 double val5 ; 14398 int ecode5 = 0 ; 14399 double val6 ; 14400 int ecode6 = 0 ; 14401 double val7 ; 14402 int ecode7 = 0 ; 14403 double val8 ; 14404 int ecode8 = 0 ; 14405 double val9 ; 14406 int ecode9 = 0 ; 14407 double val10 ; 14408 int ecode10 = 0 ; 14409 double val11 ; 14410 int ecode11 = 0 ; 14411 PyObject * obj0 = 0 ; 14412 PyObject * obj1 = 0 ; 14413 PyObject * obj2 = 0 ; 14414 PyObject * obj3 = 0 ; 14415 PyObject * obj4 = 0 ; 14416 PyObject * obj5 = 0 ; 14417 PyObject * obj6 = 0 ; 14418 PyObject * obj7 = 0 ; 14419 PyObject * obj8 = 0 ; 14420 PyObject * obj9 = 0 ; 14421 PyObject * obj10 = 0 ; 14422 14423 { 14424 python_pltr = 0; 14425 arg12 = NULL; 14426 } 14427 { 14428 arg13 = NULL; 14429 } 14430 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; 14431 { 14432 int i, size; 14433 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 14434 if ( tmp1 == NULL ) 14435 return NULL; 14436 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 14437 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 14438 size = arg3; 14439 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 14440 for ( i = 0; i < arg2; i++ ) 14441 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 14442 } 14443 ecode4 = SWIG_AsVal_double(obj1, &val4); 14444 if (!SWIG_IsOK(ecode4)) { 14445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'"); 14446 } 14447 arg4 = (PLFLT)(val4); 14448 ecode5 = SWIG_AsVal_double(obj2, &val5); 14449 if (!SWIG_IsOK(ecode5)) { 14450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'"); 14451 } 14452 arg5 = (PLFLT)(val5); 14453 ecode6 = SWIG_AsVal_double(obj3, &val6); 14454 if (!SWIG_IsOK(ecode6)) { 14455 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'"); 14456 } 14457 arg6 = (PLFLT)(val6); 14458 ecode7 = SWIG_AsVal_double(obj4, &val7); 14459 if (!SWIG_IsOK(ecode7)) { 14460 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'"); 14461 } 14462 arg7 = (PLFLT)(val7); 14463 ecode8 = SWIG_AsVal_double(obj5, &val8); 14464 if (!SWIG_IsOK(ecode8)) { 14465 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'"); 14466 } 14467 arg8 = (PLFLT)(val8); 14468 ecode9 = SWIG_AsVal_double(obj6, &val9); 14469 if (!SWIG_IsOK(ecode9)) { 14470 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'"); 14471 } 14472 arg9 = (PLFLT)(val9); 14473 ecode10 = SWIG_AsVal_double(obj7, &val10); 14474 if (!SWIG_IsOK(ecode10)) { 14475 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'"); 14476 } 14477 arg10 = (PLFLT)(val10); 14478 ecode11 = SWIG_AsVal_double(obj8, &val11); 14479 if (!SWIG_IsOK(ecode11)) { 14480 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'"); 14481 } 14482 arg11 = (PLFLT)(val11); 14483 if (obj9) { 14484 { 14485 // it must be a callable or None 14486 if ( obj9 == Py_None ) 14487 { 14488 arg12 = NULL; 14489 } 14490 else 14491 { 14492 if ( !PyCallable_Check( (PyObject *) obj9 ) ) 14493 { 14494 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" ); 14495 return NULL; 14496 } 14497 arg12 = marshal_pltr( obj9 ); 14498 } 14499 } 14500 } 14501 if (obj10) { 14502 { 14503 if ( obj10 == Py_None ) 14504 arg13 = NULL; 14505 else 14506 { 14507 arg13 = marshal_PLPointer( obj10, 1 ); 14508 } 14509 } 14510 } 14511 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13); 14512 resultobj = SWIG_Py_Void(); 14513 { 14514 Py_CLEAR( tmp1 ); 14515 free( arg1 ); 14516 } 14517 { 14518 cleanup_pltr(); 14519 } 14520 { 14521 cleanup_PLPointer(); 14522 } 14523 return resultobj; 14524 fail: 14525 { 14526 Py_CLEAR( tmp1 ); 14527 free( arg1 ); 14528 } 14529 { 14530 cleanup_pltr(); 14531 } 14532 { 14533 cleanup_PLPointer(); 14534 } 14535 return NULL; 14536 } 14537 14538 14539 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14540 PyObject *resultobj = 0; 14541 14542 if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail; 14543 plClearOpts(); 14544 resultobj = SWIG_Py_Void(); 14545 return resultobj; 14546 fail: 14547 return NULL; 14548 } 14549 14550 14551 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14552 PyObject *resultobj = 0; 14553 14554 if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail; 14555 plResetOpts(); 14556 resultobj = SWIG_Py_Void(); 14557 return resultobj; 14558 fail: 14559 return NULL; 14560 } 14561 14562 14563 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14564 PyObject *resultobj = 0; 14565 char *arg1 = (char *) 0 ; 14566 char *arg2 = (char *) 0 ; 14567 int res1 ; 14568 char *buf1 = 0 ; 14569 int alloc1 = 0 ; 14570 int res2 ; 14571 char *buf2 = 0 ; 14572 int alloc2 = 0 ; 14573 PyObject * obj0 = 0 ; 14574 PyObject * obj1 = 0 ; 14575 14576 if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail; 14577 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 14578 if (!SWIG_IsOK(res1)) { 14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'"); 14580 } 14581 arg1 = (char *)(buf1); 14582 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 14583 if (!SWIG_IsOK(res2)) { 14584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'"); 14585 } 14586 arg2 = (char *)(buf2); 14587 plSetUsage((char const *)arg1,(char const *)arg2); 14588 resultobj = SWIG_Py_Void(); 14589 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 14590 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 14591 return resultobj; 14592 fail: 14593 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 14594 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 14595 return NULL; 14596 } 14597 14598 14599 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14600 PyObject *resultobj = 0; 14601 14602 if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail; 14603 plOptUsage(); 14604 resultobj = SWIG_Py_Void(); 14605 return resultobj; 14606 fail: 14607 return NULL; 14608 } 14609 14610 14611 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14612 PyObject *resultobj = 0; 14613 PLFLT **arg1 = (PLFLT **) 0 ; 14614 PLINT arg2 ; 14615 PLINT arg3 ; 14616 PLFLT *arg4 = (PLFLT *) 0 ; 14617 PLFLT *arg5 = (PLFLT *) 0 ; 14618 PyArrayObject *tmp1 = NULL ; 14619 PLFLT temp4 ; 14620 int res4 = SWIG_TMPOBJ ; 14621 PLFLT temp5 ; 14622 int res5 = SWIG_TMPOBJ ; 14623 PyObject * obj0 = 0 ; 14624 14625 arg4 = &temp4; 14626 arg5 = &temp5; 14627 if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail; 14628 { 14629 int i, size; 14630 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 ); 14631 if ( tmp1 == NULL ) 14632 return NULL; 14633 Xlen = arg2 = PyArray_DIMS( tmp1 )[0]; 14634 Ylen = arg3 = PyArray_DIMS( tmp1 )[1]; 14635 size = arg3; 14636 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 ); 14637 for ( i = 0; i < arg2; i++ ) 14638 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size ); 14639 } 14640 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5); 14641 resultobj = SWIG_Py_Void(); 14642 if (SWIG_IsTmpObj(res4)) { 14643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4))); 14644 } else { 14645 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 14646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags)); 14647 } 14648 if (SWIG_IsTmpObj(res5)) { 14649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5))); 14650 } else { 14651 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ; 14652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags)); 14653 } 14654 { 14655 Py_CLEAR( tmp1 ); 14656 free( arg1 ); 14657 } 14658 return resultobj; 14659 fail: 14660 { 14661 Py_CLEAR( tmp1 ); 14662 free( arg1 ); 14663 } 14664 return NULL; 14665 } 14666 14667 14668 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14669 PyObject *resultobj = 0; 14670 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ; 14671 void *argp1 = 0 ; 14672 int res1 = 0 ; 14673 PyObject * obj0 = 0 ; 14674 PLINT result; 14675 14676 if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail; 14677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 ); 14678 if (!SWIG_IsOK(res1)) { 14679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 14680 } 14681 arg1 = (PLGraphicsIn *)(argp1); 14682 result = (PLINT)plGetCursor(arg1); 14683 resultobj = SWIG_From_int((int)(result)); 14684 return resultobj; 14685 fail: 14686 return NULL; 14687 } 14688 14689 14690 static PyMethodDef SwigMethods[] = { 14691 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, 14692 { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL}, 14693 { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL}, 14694 { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL}, 14695 { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL}, 14696 { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL}, 14697 { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL}, 14698 { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL}, 14699 { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL}, 14700 { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL}, 14701 { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL}, 14702 { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL}, 14703 { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL}, 14704 { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL}, 14705 { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL}, 14706 { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL}, 14707 { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL}, 14708 { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL}, 14709 { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL}, 14710 { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL}, 14711 { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL}, 14712 { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL}, 14713 { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL}, 14714 { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL}, 14715 { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL}, 14716 { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL}, 14717 { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL}, 14718 { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL}, 14719 { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL}, 14720 { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL}, 14721 { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL}, 14722 { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL}, 14723 { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n" 14724 "Set format of numerical label for contours\n" 14725 "\n" 14726 "DESCRIPTION:\n" 14727 "\n" 14728 " Set format of numerical label for contours. \n" 14729 "\n" 14730 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n" 14731 "\n" 14732 " This function is used example 9. \n" 14733 "\n" 14734 "\n" 14735 "\n" 14736 "SYNOPSIS:\n" 14737 "\n" 14738 "pl_setcontlabelformat(lexp, sigdig)\n" 14739 "\n" 14740 "ARGUMENTS:\n" 14741 "\n" 14742 " lexp (PLINT, input) : If the contour numerical label is greater\n" 14743 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n" 14744 " format is used. Default value of lexp is 4. \n" 14745 "\n" 14746 " sigdig (PLINT, input) : Number of significant digits. Default\n" 14747 " value is 2. \n" 14748 "\n" 14749 ""}, 14750 { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n" 14751 "Set parameters of contour labelling other than format of numerical label\n" 14752 "\n" 14753 "DESCRIPTION:\n" 14754 "\n" 14755 " Set parameters of contour labelling other than those handled by\n" 14756 " pl_setcontlabelformat. \n" 14757 "\n" 14758 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n" 14759 "\n" 14760 " This function is used in example 9. \n" 14761 "\n" 14762 "\n" 14763 "\n" 14764 "SYNOPSIS:\n" 14765 "\n" 14766 "pl_setcontlabelparam(offset, size, spacing, active)\n" 14767 "\n" 14768 "ARGUMENTS:\n" 14769 "\n" 14770 " offset (PLFLT, input) : Offset of label from contour line (if set\n" 14771 " to 0.0, labels are printed on the lines). Default value is 0.006. \n" 14772 "\n" 14773 " size (PLFLT, input) : Font height for contour labels (normalized). \n" 14774 " Default value is 0.3. \n" 14775 "\n" 14776 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n" 14777 " Default value is 0.1. \n" 14778 "\n" 14779 " active (PLINT, input) : Activate labels. Set to 1 if you want\n" 14780 " contour labels on. Default is off (0). \n" 14781 "\n" 14782 ""}, 14783 { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n" 14784 "Advance the (sub-)page\n" 14785 "\n" 14786 "DESCRIPTION:\n" 14787 "\n" 14788 " Advances to the next subpage if sub=0, performing a page advance if\n" 14789 " there are no remaining subpages on the current page. If subpages\n" 14790 " aren't being used, pladv(0) will always advance the page. If page>0,\n" 14791 " PLplot switches to the specified subpage. Note that this allows you\n" 14792 " to overwrite a plot on the specified subpage; if this is not what you\n" 14793 " intended, use pleop followed by plbop to first advance the page. This\n" 14794 " routine is called automatically (with page=0) by plenv, but if plenv\n" 14795 " is not used, pladv must be called after initializing PLplot but before\n" 14796 " defining the viewport. \n" 14797 "\n" 14798 " Redacted form: pladv(page)\n" 14799 "\n" 14800 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n" 14801 "\n" 14802 "\n" 14803 "\n" 14804 "SYNOPSIS:\n" 14805 "\n" 14806 "pladv(page)\n" 14807 "\n" 14808 "ARGUMENTS:\n" 14809 "\n" 14810 " page (PLINT, input) : Specifies the subpage number (starting from 1\n" 14811 " in the top left corner and increasing along the rows) to which to\n" 14812 " advance. Set to zero to advance to the next subpage (or to the\n" 14813 " next page if subpages are not being used). \n" 14814 "\n" 14815 ""}, 14816 { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n" 14817 "Draw a circular or elliptical arc \n" 14818 "\n" 14819 "DESCRIPTION:\n" 14820 "\n" 14821 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n" 14822 " semiminor axis b, starting at angle1 and ending at angle2. \n" 14823 "\n" 14824 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n" 14825 " fill)\n" 14826 "\n" 14827 "\n" 14828 " This function is used in examples 3 and 27. \n" 14829 "\n" 14830 "\n" 14831 "\n" 14832 "SYNOPSIS:\n" 14833 "\n" 14834 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n" 14835 "\n" 14836 "ARGUMENTS:\n" 14837 "\n" 14838 " x (PLFLT, input) : X coordinate of arc center. \n" 14839 "\n" 14840 " y (PLFLT, input) : Y coordinate of arc center. \n" 14841 "\n" 14842 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n" 14843 "\n" 14844 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n" 14845 "\n" 14846 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n" 14847 " semimajor axis. \n" 14848 "\n" 14849 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n" 14850 " semimajor axis. \n" 14851 "\n" 14852 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n" 14853 " X-axis. \n" 14854 "\n" 14855 " fill (PLBOOL, input) : Draw a filled arc. \n" 14856 "\n" 14857 ""}, 14858 { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n" 14859 "Draw a box with axes, etc. with arbitrary origin \n" 14860 "\n" 14861 "DESCRIPTION:\n" 14862 "\n" 14863 " Draws a box around the currently defined viewport with arbitrary\n" 14864 " world-coordinate origin specified by x0 and y0 and labels it with\n" 14865 " world coordinate values appropriate to the window. Thus plaxes should\n" 14866 " only be called after defining both viewport and window. The character\n" 14867 " strings xopt and yopt specify how the box should be drawn as described\n" 14868 " below. If ticks and/or subticks are to be drawn for a particular\n" 14869 " axis, the tick intervals and number of subintervals may be specified\n" 14870 " explicitly, or they may be defaulted by setting the appropriate\n" 14871 " arguments to zero. \n" 14872 "\n" 14873 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n" 14874 " ytick, nysub)\n" 14875 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n" 14876 " yopt)\n" 14877 "\n" 14878 "\n" 14879 " This function is not used in any examples. \n" 14880 "\n" 14881 "\n" 14882 "\n" 14883 "SYNOPSIS:\n" 14884 "\n" 14885 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n" 14886 "\n" 14887 "ARGUMENTS:\n" 14888 "\n" 14889 " x0 (PLFLT, input) : World X coordinate of origin. \n" 14890 "\n" 14891 " y0 (PLFLT, input) : World Y coordinate of origin. \n" 14892 "\n" 14893 " xopt (const char *, input) : Pointer to character string specifying\n" 14894 " options for horizontal axis. The string can include any\n" 14895 " combination of the following letters (upper or lower case) in any\n" 14896 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n" 14897 " is vertical line (x=0). \n" 14898 " b: Draws bottom (X) or left (Y) edge of frame. \n" 14899 " c: Draws top (X) or right (Y) edge of frame. \n" 14900 " d: Plot labels as date / time. Values are assumed to be\n" 14901 " seconds since the epoch (as used by gmtime). \n" 14902 " f: Always use fixed point numeric labels. \n" 14903 " g: Draws a grid at the major tick interval. \n" 14904 " h: Draws a grid at the minor tick interval. \n" 14905 " i: Inverts tick marks, so they are drawn outwards, rather than\n" 14906 " inwards. \n" 14907 " l: Labels axis logarithmically. This only affects the labels,\n" 14908 " not the data, and so it is necessary to compute the logarithms\n" 14909 " of data points before passing them to any of the drawing\n" 14910 " routines. \n" 14911 " m: Writes numeric labels at major tick intervals in the\n" 14912 " unconventional location (above box for X, right of box for Y). \n" 14913 " n: Writes numeric labels at major tick intervals in the\n" 14914 " conventional location (below box for X, left of box for Y). \n" 14915 " o: Use custom labelling function to generate axis label text. \n" 14916 " The custom labelling function can be defined with the\n" 14917 " plslabelfunc command. \n" 14918 " s: Enables subticks between major ticks, only valid if t is\n" 14919 " also specified. \n" 14920 " t: Draws major ticks. \n" 14921 " u: Exactly like \"b\" except don't draw edge line. \n" 14922 " w: Exactly like \"c\" except don't draw edge line. \n" 14923 " x: Exactly like \"t\" (including the side effect of the\n" 14924 " numerical labels for the major ticks) except exclude drawing\n" 14925 " the major and minor tick marks. \n" 14926 "\n" 14927 "\n" 14928 " xtick (PLFLT, input) : World coordinate interval between major\n" 14929 " ticks on the x axis. If it is set to zero, PLplot automatically\n" 14930 " generates a suitable tick interval. \n" 14931 "\n" 14932 " nxsub (PLINT, input) : Number of subintervals between major x axis\n" 14933 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 14934 " generates a suitable minor tick interval. \n" 14935 "\n" 14936 " yopt (const char *, input) : Pointer to character string specifying\n" 14937 " options for vertical axis. The string can include any combination\n" 14938 " of the letters defined above for xopt, and in addition may\n" 14939 " contain: v: Write numeric labels for vertical axis parallel to the\n" 14940 " base of the graph, rather than parallel to the axis. \n" 14941 "\n" 14942 "\n" 14943 " ytick (PLFLT, input) : World coordinate interval between major\n" 14944 " ticks on the y axis. If it is set to zero, PLplot automatically\n" 14945 " generates a suitable tick interval. \n" 14946 "\n" 14947 " nysub (PLINT, input) : Number of subintervals between major y axis\n" 14948 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 14949 " generates a suitable minor tick interval. \n" 14950 "\n" 14951 ""}, 14952 { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n" 14953 "Plot a histogram from binned data \n" 14954 "\n" 14955 "DESCRIPTION:\n" 14956 "\n" 14957 " Plots a histogram consisting of nbin bins. The value associated with\n" 14958 " the i'th bin is placed in x[i], and the number of points in the bin is\n" 14959 " placed in y[i]. For proper operation, the values in x[i] must form a\n" 14960 " strictly increasing sequence. By default, x[i] is the left-hand edge\n" 14961 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n" 14962 " placed midway between the values in the x array. Also see plhist for\n" 14963 " drawing histograms from unbinned data. \n" 14964 "\n" 14965 " Redacted form: General: plbin(x, y, opt)\n" 14966 " Perl/PDL: plbin(nbin, x, y, opt)\n" 14967 " Python: plbin(nbin, x, y, opt)\n" 14968 "\n" 14969 "\n" 14970 " This function is not used in any examples. \n" 14971 "\n" 14972 "\n" 14973 "\n" 14974 "SYNOPSIS:\n" 14975 "\n" 14976 "plbin(nbin, x, y, opt)\n" 14977 "\n" 14978 "ARGUMENTS:\n" 14979 "\n" 14980 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n" 14981 " and y arrays.) \n" 14982 "\n" 14983 " x (const PLFLT *, input) : Pointer to array containing values\n" 14984 " associated with bins. These must form a strictly increasing\n" 14985 " sequence. \n" 14986 "\n" 14987 " y (const PLFLT *, input) : Pointer to array containing number of\n" 14988 " points in bin. This is a PLFLT (instead of PLINT) array so as to\n" 14989 " allow histograms of probabilities, etc. \n" 14990 "\n" 14991 " opt (PLINT, input) : Is a combination of several flags:\n" 14992 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n" 14993 " outer bins are expanded to fill up the entire x-axis and bins of\n" 14994 " zero height are simply drawn. \n" 14995 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n" 14996 " between the x values. If the values in x are equally spaced,\n" 14997 " the values are the center values of the bins. \n" 14998 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n" 14999 " size as the ones inside. \n" 15000 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n" 15001 " (there is a gap for such bins). \n" 15002 "\n" 15003 ""}, 15004 { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n" 15005 "Calculate broken-down time from continuous time for the current stream \n" 15006 "\n" 15007 "DESCRIPTION:\n" 15008 "\n" 15009 " Calculate broken-down time; year, month, day, hour, min, sec; from\n" 15010 " continuous time, ctime for the current stream. This function is the\n" 15011 " inverse of plctime. \n" 15012 "\n" 15013 " The PLplot definition of broken-down time is a calendar time that\n" 15014 " completely ignores all time zone offsets, i.e., it is the user's\n" 15015 " responsibility to apply those offsets (if so desired) before using the\n" 15016 " PLplot time API. By default broken-down time is defined using the\n" 15017 " proleptic Gregorian calendar without the insertion of leap seconds and\n" 15018 " continuous time is defined as the number of seconds since the Unix\n" 15019 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n" 15020 " broken-down and continuous time are possible, see plconfigtime. \n" 15021 "\n" 15022 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n" 15023 " ctime)\n" 15024 " Perl/PDL: Not available? \n" 15025 "\n" 15026 "\n" 15027 " This function is used in example 29. \n" 15028 "\n" 15029 "\n" 15030 "\n" 15031 "SYNOPSIS:\n" 15032 "\n" 15033 "plbtime(year, month, day, hour, min, sec, ctime)\n" 15034 "\n" 15035 "ARGUMENTS:\n" 15036 "\n" 15037 " year (PLINT *, output) : Output year. \n" 15038 "\n" 15039 " month (PLINT *, output) : Output month in range from 0 (January) to\n" 15040 " 11 (December). \n" 15041 "\n" 15042 " day (PLINT *, output) : Output day in range from 1 to 31. \n" 15043 "\n" 15044 " hour (PLINT *, output) : Output hour in range from 0 to 23. \n" 15045 "\n" 15046 " min (PLINT *, output) : Output minute in range from 0 to 59 \n" 15047 "\n" 15048 " sec (PLFLT *, output) : Output second in floating range from 0. to\n" 15049 " 60. \n" 15050 "\n" 15051 " ctime (PLFLT, input) : Continous time from which the broken-down\n" 15052 " time is calculated. \n" 15053 "\n" 15054 ""}, 15055 { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n" 15056 "Begin a new page\n" 15057 "\n" 15058 "DESCRIPTION:\n" 15059 "\n" 15060 " Begins a new page. For a file driver, the output file is opened if\n" 15061 " necessary. Advancing the page via pleop and plbop is useful when a\n" 15062 " page break is desired at a particular point when plotting to subpages.\n" 15063 " Another use for pleop and plbop is when plotting pages to different\n" 15064 " files, since you can manually set the file name by calling plsfnam\n" 15065 " after the call to pleop. (In fact some drivers may only support a\n" 15066 " single page per file, making this a necessity.) One way to handle\n" 15067 " this case automatically is to page advance via pladv, but enable\n" 15068 " familying (see plsfam) with a small limit on the file size so that a\n" 15069 " new family member file will be created on each page break. \n" 15070 "\n" 15071 " Redacted form: plbop()\n" 15072 "\n" 15073 " This function is used in examples 2,20. \n" 15074 "\n" 15075 "\n" 15076 "\n" 15077 "SYNOPSIS:\n" 15078 "\n" 15079 "plbop()\n" 15080 "\n" 15081 ""}, 15082 { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n" 15083 "Draw a box with axes, etc\n" 15084 "\n" 15085 "DESCRIPTION:\n" 15086 "\n" 15087 " Draws a box around the currently defined viewport, and labels it with\n" 15088 " world coordinate values appropriate to the window. Thus plbox should\n" 15089 " only be called after defining both viewport and window. The character\n" 15090 " strings xopt and yopt specify how the box should be drawn as described\n" 15091 " below. If ticks and/or subticks are to be drawn for a particular\n" 15092 " axis, the tick intervals and number of subintervals may be specified\n" 15093 " explicitly, or they may be defaulted by setting the appropriate\n" 15094 " arguments to zero. \n" 15095 "\n" 15096 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n" 15097 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n" 15098 "\n" 15099 "\n" 15100 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n" 15101 "\n" 15102 "\n" 15103 "\n" 15104 "SYNOPSIS:\n" 15105 "\n" 15106 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n" 15107 "\n" 15108 "ARGUMENTS:\n" 15109 "\n" 15110 " xopt (const char *, input) : Pointer to character string specifying\n" 15111 " options for horizontal axis. The string can include any\n" 15112 " combination of the following letters (upper or lower case) in any\n" 15113 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n" 15114 " is vertical line (x=0). \n" 15115 " b: Draws bottom (X) or left (Y) edge of frame. \n" 15116 " c: Draws top (X) or right (Y) edge of frame. \n" 15117 " d: Plot labels as date / time. Values are assumed to be\n" 15118 " seconds since the epoch (as used by gmtime). \n" 15119 " f: Always use fixed point numeric labels. \n" 15120 " g: Draws a grid at the major tick interval. \n" 15121 " h: Draws a grid at the minor tick interval. \n" 15122 " i: Inverts tick marks, so they are drawn outwards, rather than\n" 15123 " inwards. \n" 15124 " l: Labels axis logarithmically. This only affects the labels,\n" 15125 " not the data, and so it is necessary to compute the logarithms\n" 15126 " of data points before passing them to any of the drawing\n" 15127 " routines. \n" 15128 " m: Writes numeric labels at major tick intervals in the\n" 15129 " unconventional location (above box for X, right of box for Y). \n" 15130 " n: Writes numeric labels at major tick intervals in the\n" 15131 " conventional location (below box for X, left of box for Y). \n" 15132 " o: Use custom labelling function to generate axis label text. \n" 15133 " The custom labelling function can be defined with the\n" 15134 " plslabelfunc command. \n" 15135 " s: Enables subticks between major ticks, only valid if t is\n" 15136 " also specified. \n" 15137 " t: Draws major ticks. \n" 15138 " u: Exactly like \"b\" except don't draw edge line. \n" 15139 " w: Exactly like \"c\" except don't draw edge line. \n" 15140 " x: Exactly like \"t\" (including the side effect of the\n" 15141 " numerical labels for the major ticks) except exclude drawing\n" 15142 " the major and minor tick marks. \n" 15143 "\n" 15144 "\n" 15145 " xtick (PLFLT, input) : World coordinate interval between major\n" 15146 " ticks on the x axis. If it is set to zero, PLplot automatically\n" 15147 " generates a suitable tick interval. \n" 15148 "\n" 15149 " nxsub (PLINT, input) : Number of subintervals between major x axis\n" 15150 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 15151 " generates a suitable minor tick interval. \n" 15152 "\n" 15153 " yopt (const char *, input) : Pointer to character string specifying\n" 15154 " options for vertical axis. The string can include any combination\n" 15155 " of the letters defined above for xopt, and in addition may\n" 15156 " contain: v: Write numeric labels for vertical axis parallel to the\n" 15157 " base of the graph, rather than parallel to the axis. \n" 15158 "\n" 15159 "\n" 15160 " ytick (PLFLT, input) : World coordinate interval between major\n" 15161 " ticks on the y axis. If it is set to zero, PLplot automatically\n" 15162 " generates a suitable tick interval. \n" 15163 "\n" 15164 " nysub (PLINT, input) : Number of subintervals between major y axis\n" 15165 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 15166 " generates a suitable minor tick interval. \n" 15167 "\n" 15168 ""}, 15169 { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n" 15170 "Draw a box with axes, etc, in 3-d \n" 15171 "\n" 15172 "DESCRIPTION:\n" 15173 "\n" 15174 " Draws axes, numeric and text labels for a three-dimensional surface\n" 15175 " plot. For a more complete description of three-dimensional plotting\n" 15176 " see the PLplot documentation. \n" 15177 "\n" 15178 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n" 15179 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n" 15180 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n" 15181 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n" 15182 "\n" 15183 "\n" 15184 " This function is used in examples 8,11,18,21. \n" 15185 "\n" 15186 "\n" 15187 "\n" 15188 "SYNOPSIS:\n" 15189 "\n" 15190 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n" 15191 "\n" 15192 "ARGUMENTS:\n" 15193 "\n" 15194 " xopt (const char *, input) : Pointer to character string specifying\n" 15195 " options for the x axis. The string can include any combination of\n" 15196 " the following letters (upper or lower case) in any order: b: Draws\n" 15197 " axis at base, at height z=\n" 15198 " zmin where zmin is defined by call to plw3d. This character must be\n" 15199 " specified in order to use any of the other options. \n" 15200 " f: Always use fixed point numeric labels. \n" 15201 " i: Inverts tick marks, so they are drawn downwards, rather\n" 15202 " than upwards. \n" 15203 " l: Labels axis logarithmically. This only affects the labels,\n" 15204 " not the data, and so it is necessary to compute the logarithms\n" 15205 " of data points before passing them to any of the drawing\n" 15206 " routines. \n" 15207 " n: Writes numeric labels at major tick intervals. \n" 15208 " o: Use custom labelling function to generate axis label text. \n" 15209 " The custom labelling function can be defined with the\n" 15210 " plslabelfunc command. \n" 15211 " s: Enables subticks between major ticks, only valid if t is\n" 15212 " also specified. \n" 15213 " t: Draws major ticks. \n" 15214 " u: If this is specified, the text label for the axis is\n" 15215 " written under the axis. \n" 15216 "\n" 15217 "\n" 15218 " xlabel (const char *, input) : Pointer to character string\n" 15219 " specifying text label for the x axis. It is only drawn if u is in\n" 15220 " the xopt string. \n" 15221 "\n" 15222 " xtick (PLFLT, input) : World coordinate interval between major\n" 15223 " ticks on the x axis. If it is set to zero, PLplot automatically\n" 15224 " generates a suitable tick interval. \n" 15225 "\n" 15226 " nxsub (PLINT, input) : Number of subintervals between major x axis\n" 15227 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 15228 " generates a suitable minor tick interval. \n" 15229 "\n" 15230 " yopt (const char *, input) : Pointer to character string specifying\n" 15231 " options for the y axis. The string is interpreted in the same way\n" 15232 " as xopt. \n" 15233 "\n" 15234 " ylabel (const char *, input) : Pointer to character string\n" 15235 " specifying text label for the y axis. It is only drawn if u is in\n" 15236 " the yopt string. \n" 15237 "\n" 15238 " ytick (PLFLT, input) : World coordinate interval between major\n" 15239 " ticks on the y axis. If it is set to zero, PLplot automatically\n" 15240 " generates a suitable tick interval. \n" 15241 "\n" 15242 " nysub (PLINT, input) : Number of subintervals between major y axis\n" 15243 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 15244 " generates a suitable minor tick interval. \n" 15245 "\n" 15246 " zopt (const char *, input) : Pointer to character string specifying\n" 15247 " options for the z axis. The string can include any combination of\n" 15248 " the following letters (upper or lower case) in any order: b: Draws\n" 15249 " z axis to the left of the surface plot. \n" 15250 " c: Draws z axis to the right of the surface plot. \n" 15251 " d: Draws grid lines parallel to the x-y plane behind the\n" 15252 " figure. These lines are not drawn until after plot3d or\n" 15253 " plmesh are called because of the need for hidden line removal. \n" 15254 " f: Always use fixed point numeric labels. \n" 15255 " i: Inverts tick marks, so they are drawn away from the center. \n" 15256 " l: Labels axis logarithmically. This only affects the labels,\n" 15257 " not the data, and so it is necessary to compute the logarithms\n" 15258 " of data points before passing them to any of the drawing\n" 15259 " routines. \n" 15260 " m: Writes numeric labels at major tick intervals on the\n" 15261 " right-hand vertical axis. \n" 15262 " n: Writes numeric labels at major tick intervals on the\n" 15263 " left-hand vertical axis. \n" 15264 " o: Use custom labelling function to generate axis label text. \n" 15265 " The custom labelling function can be defined with the\n" 15266 " plslabelfunc command. \n" 15267 " s: Enables subticks between major ticks, only valid if t is\n" 15268 " also specified. \n" 15269 " t: Draws major ticks. \n" 15270 " u: If this is specified, the text label is written beside the\n" 15271 " left-hand axis. \n" 15272 " v: If this is specified, the text label is written beside the\n" 15273 " right-hand axis. \n" 15274 "\n" 15275 "\n" 15276 " zlabel (const char *, input) : Pointer to character string\n" 15277 " specifying text label for the z axis. It is only drawn if u or v\n" 15278 " are in the zopt string. \n" 15279 "\n" 15280 " ztick (PLFLT, input) : World coordinate interval between major\n" 15281 " ticks on the z axis. If it is set to zero, PLplot automatically\n" 15282 " generates a suitable tick interval. \n" 15283 "\n" 15284 " nzsub (PLINT, input) : Number of subintervals between major z axis\n" 15285 " ticks for minor ticks. If it is set to zero, PLplot automatically\n" 15286 " generates a suitable minor tick interval. \n" 15287 "\n" 15288 ""}, 15289 { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n" 15290 "Calculate world coordinates and corresponding window index from relative device coordinates \n" 15291 "\n" 15292 "DESCRIPTION:\n" 15293 "\n" 15294 " Calculate world coordinates, wx and wy, and corresponding window index\n" 15295 " from relative device coordinates, rx and ry. \n" 15296 "\n" 15297 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n" 15298 " Perl/PDL: Not available? \n" 15299 "\n" 15300 "\n" 15301 " This function is used in example 31. \n" 15302 "\n" 15303 "\n" 15304 "\n" 15305 "SYNOPSIS:\n" 15306 "\n" 15307 "plcalc_world(rx, ry, wx, wy, window)\n" 15308 "\n" 15309 "ARGUMENTS:\n" 15310 "\n" 15311 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n" 15312 " 0. to 1.) for the x coordinate. \n" 15313 "\n" 15314 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n" 15315 " 0. to 1.) for the y coordinate. \n" 15316 "\n" 15317 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n" 15318 " x corresponding to the relative device coordinates rx and ry. \n" 15319 "\n" 15320 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n" 15321 " y corresponding to the relative device coordinates rx and ry. \n" 15322 "\n" 15323 " window (PLINT *, output) : Pointer to the returned last defined\n" 15324 " window index that corresponds to the input relative device\n" 15325 " coordinates (and the returned world coordinates). To give some\n" 15326 " background on the window index, for each page the initial window\n" 15327 " index is set to zero, and each time plwind is called within the\n" 15328 " page, world and device coordinates are stored for the window and\n" 15329 " the window index is incremented. Thus, for a simple page layout\n" 15330 " with non-overlapping viewports and one window per viewport, window\n" 15331 " corresponds to the viewport index (in the order which the\n" 15332 " viewport/windows were created) of the only viewport/window\n" 15333 " corresponding to rx and ry. However, for more complicated layouts\n" 15334 " with potentially overlapping viewports and possibly more than one\n" 15335 " window (set of world coordinates) per viewport, window and the\n" 15336 " corresponding output world coordinates corresponds to the last\n" 15337 " window created that fulfills the criterion that the relative\n" 15338 " device coordinates are inside it. Finally, in all cases where the\n" 15339 " input relative device coordinates are not inside any\n" 15340 " viewport/window, then window is set to -1. \n" 15341 "\n" 15342 ""}, 15343 { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n" 15344 "Clear current (sub)page \n" 15345 "\n" 15346 "DESCRIPTION:\n" 15347 "\n" 15348 " Clears the current page, effectively erasing everything that have been\n" 15349 " drawn. This command only works with interactive drivers; if the\n" 15350 " driver does not support this, the page is filled with the background\n" 15351 " color in use. If the current page is divided into subpages, only the\n" 15352 " current subpage is erased. The nth subpage can be selected with\n" 15353 " pladv(n). \n" 15354 "\n" 15355 " Redacted form: General: plclear()\n" 15356 " Perl/PDL: Not available? \n" 15357 "\n" 15358 "\n" 15359 " This function is not used in any examples. \n" 15360 "\n" 15361 "\n" 15362 "\n" 15363 "SYNOPSIS:\n" 15364 "\n" 15365 "plclear()\n" 15366 "\n" 15367 ""}, 15368 { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n" 15369 "Set color, cmap0 \n" 15370 "\n" 15371 "DESCRIPTION:\n" 15372 "\n" 15373 " Sets the color index for cmap0 (see the PLplot documentation). \n" 15374 "\n" 15375 " Redacted form: plcol0(icol0)\n" 15376 "\n" 15377 " This function is used in examples 1-9,11-16,18-27,29. \n" 15378 "\n" 15379 "\n" 15380 "\n" 15381 "SYNOPSIS:\n" 15382 "\n" 15383 "plcol0(icol0)\n" 15384 "\n" 15385 "ARGUMENTS:\n" 15386 "\n" 15387 " icol0 (PLINT, input) : Integer representing the color. The\n" 15388 " defaults at present are (these may change): \n" 15389 " 0 black (default background) \n" 15390 " 1 red (default foreground) \n" 15391 " 2 yellow \n" 15392 " 3 green \n" 15393 " 4 aquamarine \n" 15394 " 5 pink \n" 15395 " 6 wheat \n" 15396 " 7 grey \n" 15397 " 8 brown \n" 15398 " 9 blue \n" 15399 " 10 BlueViolet \n" 15400 " 11 cyan \n" 15401 " 12 turquoise \n" 15402 " 13 magenta \n" 15403 " 14 salmon \n" 15404 " 15 white \n" 15405 "\n" 15406 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n" 15407 " change an individual color in the map0 color palette. \n" 15408 "\n" 15409 ""}, 15410 { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n" 15411 "Set color, cmap1 \n" 15412 "\n" 15413 "DESCRIPTION:\n" 15414 "\n" 15415 " Sets the color for cmap1 (see the PLplot documentation). \n" 15416 "\n" 15417 " Redacted form: plcol1(col1)\n" 15418 "\n" 15419 " This function is used in examples 12 and 21. \n" 15420 "\n" 15421 "\n" 15422 "\n" 15423 "SYNOPSIS:\n" 15424 "\n" 15425 "plcol1(col1)\n" 15426 "\n" 15427 "ARGUMENTS:\n" 15428 "\n" 15429 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n" 15430 " and is mapped to color using the continuous map1 color palette\n" 15431 " which by default ranges from blue to the background color to red. \n" 15432 " The map1 palette can also be straightforwardly changed by the user\n" 15433 " with plscmap1 or plscmap1l. \n" 15434 "\n" 15435 ""}, 15436 { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n" 15437 "Configure the transformation between continuous and broken-down time for the current stream \n" 15438 "\n" 15439 "DESCRIPTION:\n" 15440 "\n" 15441 " Configure the transformation between continuous and broken-down time\n" 15442 " for the current stream. This transformation is used by both plbtime\n" 15443 " and plctime. \n" 15444 "\n" 15445 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n" 15446 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n" 15447 " Perl/PDL: Not available? \n" 15448 "\n" 15449 "\n" 15450 " This function is used in example 29. \n" 15451 "\n" 15452 "\n" 15453 "\n" 15454 "SYNOPSIS:\n" 15455 "\n" 15456 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n" 15457 "\n" 15458 "ARGUMENTS:\n" 15459 "\n" 15460 " scale (PLFLT, input) : The number of days per continuous time unit.\n" 15461 " As a special case, if \n" 15462 " scale is 0., then all other arguments are ignored, and the result (the\n" 15463 " default used by PLplot) is the equivalent of a call to\n" 15464 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n" 15465 " That is, for this special case broken-down time is calculated with\n" 15466 " the proleptic Gregorian calendar with no leap seconds inserted,\n" 15467 " and the continuous time is defined as the number of seconds since\n" 15468 " the Unix epoch of 1970-01-01T00:00:00Z. \n" 15469 "\n" 15470 " offset1 (PLFLT, input) : If \n" 15471 " ifbtime_offset is true, the parameters \n" 15472 " offset1 and \n" 15473 " offset2 are completely ignored. Otherwise, the sum of these parameters\n" 15474 " (with units in days) specify the epoch of the continuous time\n" 15475 " relative to the MJD epoch corresponding to the Gregorian calendar\n" 15476 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n" 15477 " are used to specify the origin to allow users (by specifying \n" 15478 " offset1 as an integer that can be exactly represented by a\n" 15479 " floating-point variable and specifying \n" 15480 " offset2 as a number in the range from 0. to 1) the chance to minimize\n" 15481 " the numerical errors of the continuous time representation. \n" 15482 "\n" 15483 " offset2 (PLFLT, input) : See documentation of \n" 15484 " offset1. \n" 15485 "\n" 15486 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n" 15487 " transformation. If the 0x1 bit is set, then the proleptic Julian\n" 15488 " calendar is used for broken-down time rather than the proleptic\n" 15489 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n" 15490 " have been historically used to define UTC are inserted into the\n" 15491 " broken-down time. Other possibilities for additional control bits\n" 15492 " for ccontrol exist such as making the historical time corrections\n" 15493 " in the broken-down time corresponding to ET (ephemeris time) or\n" 15494 " making the (slightly non-constant) corrections from international\n" 15495 " atomic time (TAI) to what astronomers define as terrestrial time\n" 15496 " (TT). But those additional possibilities have not been\n" 15497 " implemented yet in the qsastime library (one of the PLplot utility\n" 15498 " libraries). \n" 15499 "\n" 15500 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n" 15501 " epoch of the continuous time scale is specified by the user. If \n" 15502 " ifbtime_offset is false, then \n" 15503 " offset1 and \n" 15504 " offset2 are used to specify the epoch, and the following broken-down\n" 15505 " time parameters are completely ignored. If \n" 15506 " ifbtime_offset is true, then \n" 15507 " offset1 and \n" 15508 " offset2 are completely ignored, and the following broken-down time\n" 15509 " parameters are used to specify the epoch. \n" 15510 "\n" 15511 " year (PLINT, input) : Year of epoch. \n" 15512 "\n" 15513 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n" 15514 " 11 (December). \n" 15515 "\n" 15516 " day (PLINT, input) : Day of epoch in range from 1 to 31. \n" 15517 "\n" 15518 " hour (PLINT, input) : Hour of epoch in range from 0 to 23 \n" 15519 "\n" 15520 " min (PLINT, input) : Minute of epoch in range from 0 to 59. \n" 15521 "\n" 15522 " sec (PLFLT, input) : Second of epoch in floating range from 0. to\n" 15523 " 60. \n" 15524 "\n" 15525 ""}, 15526 { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n" 15527 "Contour plot \n" 15528 "\n" 15529 "DESCRIPTION:\n" 15530 "\n" 15531 " Draws a contour plot of the data in f[\n" 15532 " nx][\n" 15533 " ny], using the nlevel contour levels specified by clevel. Only the\n" 15534 " region of the array from kx to lx and from ky to ly is plotted out. A\n" 15535 " transformation routine pointed to by pltr with a pointer pltr_data for\n" 15536 " additional data required by the transformation routine is used to map\n" 15537 " indices within the array to the world coordinates. See the following\n" 15538 " discussion of the arguments and the PLplot documentation for more\n" 15539 " information. \n" 15540 "\n" 15541 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n" 15542 " plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n" 15543 " clevel, xgrid, ygrid)\n" 15544 " Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n" 15545 " Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n" 15546 " Python: plcont2(f, kx, lx, ky, ly, clevel)\n" 15547 "\n" 15548 "\n" 15549 " This function is used in examples 9,14,16,22. \n" 15550 "\n" 15551 "\n" 15552 "\n" 15553 "SYNOPSIS:\n" 15554 "\n" 15555 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n" 15556 "\n" 15557 "ARGUMENTS:\n" 15558 "\n" 15559 " f (const PLFLT * const *, input) : Pointer to a vectored\n" 15560 " two-dimensional array containing data to be contoured. \n" 15561 "\n" 15562 " nx, ny (PLINT, input) : Physical dimensions of array f. \n" 15563 "\n" 15564 " kx, lx (PLINT, input) : Range of x indices to consider. \n" 15565 "\n" 15566 " ky, ly (PLINT, input) : Range of y indices to consider. \n" 15567 "\n" 15568 " clevel (const PLFLT *, input) : Pointer to array specifying levels\n" 15569 " at which to draw contours. \n" 15570 "\n" 15571 " nlevel (PLINT, input) : Number of contour levels to draw. \n" 15572 "\n" 15573 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n" 15574 " Pointer to function that defines transformation between indices\n" 15575 " in array f and the world coordinates (C only). Transformation\n" 15576 " functions are provided in the PLplot library: pltr0 for identity\n" 15577 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n" 15578 " defined by one- and two-dimensional arrays. In addition,\n" 15579 " user-supplied routines for the transformation can be used as well.\n" 15580 " Examples of all of these approaches are given in the PLplot\n" 15581 " documentation. The transformation function should have the form\n" 15582 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n" 15583 " and similar PLplot functions which have a pltr argument, plcont\n" 15584 " requires that a transformation function be provided in the C\n" 15585 " interface. Leaving pltr NULL will result in an error. \n" 15586 "\n" 15587 " pltr_data (PLPointer, input) : Extra parameter to help pass\n" 15588 " information to pltr0, pltr1, pltr2, or whatever routine that is\n" 15589 " externally supplied. \n" 15590 "\n" 15591 ""}, 15592 { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n" 15593 "Calculate continuous time from broken-down time for the current stream \n" 15594 "\n" 15595 "DESCRIPTION:\n" 15596 "\n" 15597 " Calculate continuous time, ctime, from broken-down time for the\n" 15598 " current stream. The broken-down\n" 15599 " time is specified by the following parameters: year, month, day, hour,\n" 15600 " min, and sec. This function is the inverse of plbtime. \n" 15601 "\n" 15602 " The PLplot definition of broken-down time is a calendar time that\n" 15603 " completely ignores all time zone offsets, i.e., it is the user's\n" 15604 " responsibility to apply those offsets (if so desired) before using the\n" 15605 " PLplot time API. By default broken-down time is defined using the\n" 15606 " proleptic Gregorian calendar without the insertion of leap seconds and\n" 15607 " continuous time is defined as the number of seconds since the Unix\n" 15608 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n" 15609 " broken-down and continuous time are possible, see plconfigtime which\n" 15610 " specifies that transformation for the current stream. \n" 15611 "\n" 15612 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n" 15613 " ctime)\n" 15614 " Perl/PDL: Not available? \n" 15615 "\n" 15616 "\n" 15617 " This function is used in example 29. \n" 15618 "\n" 15619 "\n" 15620 "\n" 15621 "SYNOPSIS:\n" 15622 "\n" 15623 "plctime(year, month, day, hour, min, sec, ctime)\n" 15624 "\n" 15625 "ARGUMENTS:\n" 15626 "\n" 15627 " year (PLINT, input) : Input year. \n" 15628 "\n" 15629 " month (PLINT, input) : Input month in range from 0 (January) to 11\n" 15630 " (December). \n" 15631 "\n" 15632 " day (PLINT, input) : Input day in range from 1 to 31. \n" 15633 "\n" 15634 " hour (PLINT, input) : Input hour in range from 0 to 23 \n" 15635 "\n" 15636 " min (PLINT, input) : Input minute in range from 0 to 59. \n" 15637 "\n" 15638 " sec (PLFLT, input) : Input second in floating range from 0. to 60. \n" 15639 "\n" 15640 " ctime (PLFLT *, output) : Continous time calculated from the\n" 15641 " broken-down time specified by the previous parameters. \n" 15642 "\n" 15643 ""}, 15644 { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n" 15645 "Copy state parameters from the reference stream to the current stream \n" 15646 "\n" 15647 "DESCRIPTION:\n" 15648 "\n" 15649 " Copies state parameters from the reference stream to the current\n" 15650 " stream. Tell driver interface to map device coordinates unless flags\n" 15651 " == 1. \n" 15652 "\n" 15653 " This function is used for making save files of selected plots (e.g.\n" 15654 " from the TK driver). After initializing, you can get a copy of the\n" 15655 " current plot to the specified device by switching to this stream and\n" 15656 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n" 15657 " appropriate. The plot buffer must have previously been enabled (done\n" 15658 " automatically by some display drivers, such as X). \n" 15659 "\n" 15660 " Redacted form: plcpstrm(iplsr, flags)\n" 15661 "\n" 15662 " This function is used in example 1,20. \n" 15663 "\n" 15664 "\n" 15665 "\n" 15666 "SYNOPSIS:\n" 15667 "\n" 15668 "plcpstrm(iplsr, flags)\n" 15669 "\n" 15670 "ARGUMENTS:\n" 15671 "\n" 15672 " iplsr (PLINT, input) : Number of reference stream. \n" 15673 "\n" 15674 " flags (PLBOOL, input) : If flags is set to true the device\n" 15675 " coordinates are not copied from the reference to current stream. \n" 15676 "\n" 15677 ""}, 15678 { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n" 15679 "End plotting session \n" 15680 "\n" 15681 "DESCRIPTION:\n" 15682 "\n" 15683 " Ends a plotting session, tidies up all the output files, switches\n" 15684 " interactive devices back into text mode and frees up any memory that\n" 15685 " was allocated. Must be called before end of program. \n" 15686 "\n" 15687 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n" 15688 " wait state after a call to plend or other functions which trigger the\n" 15689 " end of a plot page. To avoid this, use the plspause function. \n" 15690 "\n" 15691 " Redacted form: plend()\n" 15692 "\n" 15693 " This function is used in all of the examples. \n" 15694 "\n" 15695 "\n" 15696 "\n" 15697 "SYNOPSIS:\n" 15698 "\n" 15699 "plend()\n" 15700 "\n" 15701 ""}, 15702 { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n" 15703 "End plotting session for current stream \n" 15704 "\n" 15705 "DESCRIPTION:\n" 15706 "\n" 15707 " Ends a plotting session for the current output stream only. See\n" 15708 " plsstrm for more info. \n" 15709 "\n" 15710 " Redacted form: plend1()\n" 15711 "\n" 15712 " This function is used in examples 1,20. \n" 15713 "\n" 15714 "\n" 15715 "\n" 15716 "SYNOPSIS:\n" 15717 "\n" 15718 "plend1()\n" 15719 "\n" 15720 ""}, 15721 { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n" 15722 "Set up standard window and draw box \n" 15723 "\n" 15724 "DESCRIPTION:\n" 15725 "\n" 15726 " Sets up plotter environment for simple graphs by calling pladv and\n" 15727 " setting up viewport and window to sensible default values. plenv\n" 15728 " leaves enough room around most graphs for axis labels and a title.\n" 15729 " When these defaults are not suitable, use the individual routines\n" 15730 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n" 15731 " defining the window, and plbox for drawing the box. \n" 15732 "\n" 15733 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n" 15734 "\n" 15735 " This function is used in example 1,3,9,13,14,19-22,29. \n" 15736 "\n" 15737 "\n" 15738 "\n" 15739 "SYNOPSIS:\n" 15740 "\n" 15741 "plenv(xmin, xmax, ymin, ymax, just, axis)\n" 15742 "\n" 15743 "ARGUMENTS:\n" 15744 "\n" 15745 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n" 15746 " world coordinates). \n" 15747 "\n" 15748 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n" 15749 " world coordinates). \n" 15750 "\n" 15751 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n" 15752 " coordinates). \n" 15753 "\n" 15754 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n" 15755 " coordinates). \n" 15756 "\n" 15757 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n" 15758 " scales will not be set, the user must set up the scale before\n" 15759 " calling plenv using plsvpa, plvasp or other. \n" 15760 " 0: the x and y axes are scaled independently to use as much of\n" 15761 " the screen as possible. \n" 15762 " 1: the scales of the x and y axes are made equal. \n" 15763 " 2: the axis of the x and y axes are made equal, and the plot\n" 15764 " box will be square. \n" 15765 "\n" 15766 "\n" 15767 " axis (PLINT, input) : Controls drawing of the box around the plot:\n" 15768 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n" 15769 " -1: draw box only. \n" 15770 " 0: draw box, ticks, and numeric tick labels. \n" 15771 " 1: also draw coordinate axes at x=0 and y=0. \n" 15772 " 2: also draw a grid at major tick positions in both\n" 15773 " coordinates. \n" 15774 " 3: also draw a grid at minor tick positions in both\n" 15775 " coordinates. \n" 15776 " 10: same as 0 except logarithmic x tick marks. (The x data\n" 15777 " have to be converted to logarithms separately.) \n" 15778 " 11: same as 1 except logarithmic x tick marks. (The x data\n" 15779 " have to be converted to logarithms separately.) \n" 15780 " 12: same as 2 except logarithmic x tick marks. (The x data\n" 15781 " have to be converted to logarithms separately.) \n" 15782 " 13: same as 3 except logarithmic x tick marks. (The x data\n" 15783 " have to be converted to logarithms separately.) \n" 15784 " 20: same as 0 except logarithmic y tick marks. (The y data\n" 15785 " have to be converted to logarithms separately.) \n" 15786 " 21: same as 1 except logarithmic y tick marks. (The y data\n" 15787 " have to be converted to logarithms separately.) \n" 15788 " 22: same as 2 except logarithmic y tick marks. (The y data\n" 15789 " have to be converted to logarithms separately.) \n" 15790 " 23: same as 3 except logarithmic y tick marks. (The y data\n" 15791 " have to be converted to logarithms separately.) \n" 15792 " 30: same as 0 except logarithmic x and y tick marks. (The x\n" 15793 " and y data have to be converted to logarithms separately.) \n" 15794 " 31: same as 1 except logarithmic x and y tick marks. (The x\n" 15795 " and y data have to be converted to logarithms separately.) \n" 15796 " 32: same as 2 except logarithmic x and y tick marks. (The x\n" 15797 " and y data have to be converted to logarithms separately.) \n" 15798 " 33: same as 3 except logarithmic x and y tick marks. (The x\n" 15799 " and y data have to be converted to logarithms separately.) \n" 15800 " 40: same as 0 except date / time x labels. \n" 15801 " 41: same as 1 except date / time x labels. \n" 15802 " 42: same as 2 except date / time x labels. \n" 15803 " 43: same as 3 except date / time x labels. \n" 15804 " 50: same as 0 except date / time y labels. \n" 15805 " 51: same as 1 except date / time y labels. \n" 15806 " 52: same as 2 except date / time y labels. \n" 15807 " 53: same as 3 except date / time y labels. \n" 15808 " 60: same as 0 except date / time x and y labels. \n" 15809 " 61: same as 1 except date / time x and y labels. \n" 15810 " 62: same as 2 except date / time x and y labels. \n" 15811 " 63: same as 3 except date / time x and y labels. \n" 15812 " 70: same as 0 except custom x and y labels. \n" 15813 " 71: same as 1 except custom x and y labels. \n" 15814 " 72: same as 2 except custom x and y labels. \n" 15815 " 73: same as 3 except custom x and y labels. \n" 15816 "\n" 15817 ""}, 15818 { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n" 15819 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n" 15820 "\n" 15821 "DESCRIPTION:\n" 15822 "\n" 15823 " Sets up plotter environment for simple graphs by calling pladv and\n" 15824 " setting up viewport and window to sensible default values. plenv0\n" 15825 " leaves enough room around most graphs for axis labels and a title.\n" 15826 " When these defaults are not suitable, use the individual routines\n" 15827 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n" 15828 " defining the window, and plbox for drawing the box. \n" 15829 "\n" 15830 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n" 15831 "\n" 15832 " This function is used in example 21. \n" 15833 "\n" 15834 "\n" 15835 "\n" 15836 "SYNOPSIS:\n" 15837 "\n" 15838 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n" 15839 "\n" 15840 "ARGUMENTS:\n" 15841 "\n" 15842 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n" 15843 " world coordinates). \n" 15844 "\n" 15845 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n" 15846 " world coordinates). \n" 15847 "\n" 15848 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n" 15849 " coordinates). \n" 15850 "\n" 15851 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n" 15852 " coordinates). \n" 15853 "\n" 15854 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n" 15855 " scales will not be set, the user must set up the scale before\n" 15856 " calling plenv0 using plsvpa, plvasp or other. \n" 15857 " 0: the x and y axes are scaled independently to use as much of\n" 15858 " the screen as possible. \n" 15859 " 1: the scales of the x and y axes are made equal. \n" 15860 " 2: the axis of the x and y axes are made equal, and the plot\n" 15861 " box will be square. \n" 15862 "\n" 15863 "\n" 15864 " axis (PLINT, input) : Controls drawing of the box around the plot:\n" 15865 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n" 15866 " -1: draw box only. \n" 15867 " 0: draw box, ticks, and numeric tick labels. \n" 15868 " 1: also draw coordinate axes at x=0 and y=0. \n" 15869 " 2: also draw a grid at major tick positions in both\n" 15870 " coordinates. \n" 15871 " 3: also draw a grid at minor tick positions in both\n" 15872 " coordinates. \n" 15873 " 10: same as 0 except logarithmic x tick marks. (The x data\n" 15874 " have to be converted to logarithms separately.) \n" 15875 " 11: same as 1 except logarithmic x tick marks. (The x data\n" 15876 " have to be converted to logarithms separately.) \n" 15877 " 12: same as 2 except logarithmic x tick marks. (The x data\n" 15878 " have to be converted to logarithms separately.) \n" 15879 " 13: same as 3 except logarithmic x tick marks. (The x data\n" 15880 " have to be converted to logarithms separately.) \n" 15881 " 20: same as 0 except logarithmic y tick marks. (The y data\n" 15882 " have to be converted to logarithms separately.) \n" 15883 " 21: same as 1 except logarithmic y tick marks. (The y data\n" 15884 " have to be converted to logarithms separately.) \n" 15885 " 22: same as 2 except logarithmic y tick marks. (The y data\n" 15886 " have to be converted to logarithms separately.) \n" 15887 " 23: same as 3 except logarithmic y tick marks. (The y data\n" 15888 " have to be converted to logarithms separately.) \n" 15889 " 30: same as 0 except logarithmic x and y tick marks. (The x\n" 15890 " and y data have to be converted to logarithms separately.) \n" 15891 " 31: same as 1 except logarithmic x and y tick marks. (The x\n" 15892 " and y data have to be converted to logarithms separately.) \n" 15893 " 32: same as 2 except logarithmic x and y tick marks. (The x\n" 15894 " and y data have to be converted to logarithms separately.) \n" 15895 " 33: same as 3 except logarithmic x and y tick marks. (The x\n" 15896 " and y data have to be converted to logarithms separately.) \n" 15897 " 40: same as 0 except date / time x labels. \n" 15898 " 41: same as 1 except date / time x labels. \n" 15899 " 42: same as 2 except date / time x labels. \n" 15900 " 43: same as 3 except date / time x labels. \n" 15901 " 50: same as 0 except date / time y labels. \n" 15902 " 51: same as 1 except date / time y labels. \n" 15903 " 52: same as 2 except date / time y labels. \n" 15904 " 53: same as 3 except date / time y labels. \n" 15905 " 60: same as 0 except date / time x and y labels. \n" 15906 " 61: same as 1 except date / time x and y labels. \n" 15907 " 62: same as 2 except date / time x and y labels. \n" 15908 " 63: same as 3 except date / time x and y labels. \n" 15909 " 70: same as 0 except custom x and y labels. \n" 15910 " 71: same as 1 except custom x and y labels. \n" 15911 " 72: same as 2 except custom x and y labels. \n" 15912 " 73: same as 3 except custom x and y labels. \n" 15913 "\n" 15914 ""}, 15915 { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n" 15916 "Eject current page \n" 15917 "\n" 15918 "DESCRIPTION:\n" 15919 "\n" 15920 " Clears the graphics screen of an interactive device, or ejects a page\n" 15921 " on a plotter. See plbop for more information. \n" 15922 "\n" 15923 " Redacted form: pleop()\n" 15924 "\n" 15925 " This function is used in example 2,14. \n" 15926 "\n" 15927 "\n" 15928 "\n" 15929 "SYNOPSIS:\n" 15930 "\n" 15931 "pleop()\n" 15932 "\n" 15933 ""}, 15934 { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n" 15935 "Draw x error bar \n" 15936 "\n" 15937 "DESCRIPTION:\n" 15938 "\n" 15939 " Draws a set of n horizontal error bars, the i'th error bar extending\n" 15940 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n" 15941 " error bar are of length equal to the minor tick length (settable using\n" 15942 " plsmin). \n" 15943 "\n" 15944 " Redacted form: General: plerrx(xmin, ymax, y)\n" 15945 " Perl/PDL: plerrx(n, xmin, xmax, y)\n" 15946 "\n" 15947 "\n" 15948 " This function is used in example 29. \n" 15949 "\n" 15950 "\n" 15951 "\n" 15952 "SYNOPSIS:\n" 15953 "\n" 15954 "plerrx(n, xmin, xmax, y)\n" 15955 "\n" 15956 "ARGUMENTS:\n" 15957 "\n" 15958 " n (PLINT, input) : Number of error bars to draw. \n" 15959 "\n" 15960 " xmin (const PLFLT *, input) : Pointer to array with x coordinates\n" 15961 " of left-hand endpoint of error bars. \n" 15962 "\n" 15963 " xmax (const PLFLT *, input) : Pointer to array with x coordinates\n" 15964 " of right-hand endpoint of error bars. \n" 15965 "\n" 15966 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 15967 " error bar. \n" 15968 "\n" 15969 ""}, 15970 { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n" 15971 "Draw y error bar \n" 15972 "\n" 15973 "DESCRIPTION:\n" 15974 "\n" 15975 " Draws a set of n vertical error bars, the i'th error bar extending\n" 15976 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n" 15977 " error bar are of length equal to the minor tick length (settable using\n" 15978 " plsmin). \n" 15979 "\n" 15980 " Redacted form: General: plerry(x, ymin, ymax)\n" 15981 " Perl/PDL: plerry(n, x, ymin, ymax)\n" 15982 "\n" 15983 "\n" 15984 " This function is used in example 29. \n" 15985 "\n" 15986 "\n" 15987 "\n" 15988 "SYNOPSIS:\n" 15989 "\n" 15990 "plerry(n, x, ymin, ymax)\n" 15991 "\n" 15992 "ARGUMENTS:\n" 15993 "\n" 15994 " n (PLINT, input) : Number of error bars to draw. \n" 15995 "\n" 15996 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 15997 " error bars. \n" 15998 "\n" 15999 " ymin (const PLFLT *, input) : Pointer to array with y coordinates\n" 16000 " of lower endpoint of error bars. \n" 16001 "\n" 16002 " ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n" 16003 " upper endpoint of error bar. \n" 16004 "\n" 16005 ""}, 16006 { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n" 16007 "Advance to the next family file on the next new page \n" 16008 "\n" 16009 "DESCRIPTION:\n" 16010 "\n" 16011 " Advance to the next family file on the next new page. \n" 16012 "\n" 16013 " Redacted form: plfamadv()\n" 16014 "\n" 16015 " This function is not used in any examples. \n" 16016 "\n" 16017 "\n" 16018 "\n" 16019 "SYNOPSIS:\n" 16020 "\n" 16021 "plfamadv()\n" 16022 "\n" 16023 ""}, 16024 { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n" 16025 "Draw filled polygon \n" 16026 "\n" 16027 "DESCRIPTION:\n" 16028 "\n" 16029 " Fills the polygon defined by the n points (\n" 16030 " x[i], \n" 16031 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n" 16032 " style is a solid fill. The routine will automatically close the\n" 16033 " polygon between the last and first vertices. If multiple closed\n" 16034 " polygons are passed in x and y then plfill will fill in between them. \n" 16035 "\n" 16036 " Redacted form: plfill(x,y)\n" 16037 "\n" 16038 " This function is used in examples 12,13,15,16,21,24,25. \n" 16039 "\n" 16040 "\n" 16041 "\n" 16042 "SYNOPSIS:\n" 16043 "\n" 16044 "plfill(n, x, y)\n" 16045 "\n" 16046 "ARGUMENTS:\n" 16047 "\n" 16048 " n (PLINT, input) : Number of vertices in polygon. \n" 16049 "\n" 16050 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 16051 " vertices. \n" 16052 "\n" 16053 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 16054 " vertices. \n" 16055 "\n" 16056 ""}, 16057 { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n" 16058 "Draw filled polygon in 3D \n" 16059 "\n" 16060 "DESCRIPTION:\n" 16061 "\n" 16062 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n" 16063 " using the pattern defined by plpsty or plpat. The routine will\n" 16064 " automatically close the polygon between the last and first vertices. \n" 16065 " If multiple closed polygons are passed in x, y, and z then plfill3\n" 16066 " will fill in between them. \n" 16067 "\n" 16068 " Redacted form: General: plfill3(x, y, z)\n" 16069 " Perl/PDL: plfill3(n, x, y, z)\n" 16070 "\n" 16071 "\n" 16072 " This function is used in example 15. \n" 16073 "\n" 16074 "\n" 16075 "\n" 16076 "SYNOPSIS:\n" 16077 "\n" 16078 "plfill3(n, x, y, z)\n" 16079 "\n" 16080 "ARGUMENTS:\n" 16081 "\n" 16082 " n (PLINT, input) : Number of vertices in polygon. \n" 16083 "\n" 16084 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 16085 " vertices. \n" 16086 "\n" 16087 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 16088 " vertices. \n" 16089 "\n" 16090 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n" 16091 " vertices. \n" 16092 "\n" 16093 ""}, 16094 { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n" 16095 "Draw linear gradient inside polygon \n" 16096 "\n" 16097 "DESCRIPTION:\n" 16098 "\n" 16099 " Draw a linear gradient using colour map 1 inside the polygon defined\n" 16100 " by the n points (\n" 16101 " x[i], \n" 16102 " y[i]). Interpretation of the polygon is the same as for plfill. The\n" 16103 " polygon coordinates and the gradient angle are all expressed in world\n" 16104 " coordinates. The angle from the x axis for both the rotated\n" 16105 " coordinate system and the gradient vector is specified by angle. The\n" 16106 " magnitude of the gradient vector is the difference between the maximum\n" 16107 " and minimum values of x for the vertices in the rotated coordinate\n" 16108 " system. The origin of the gradient vector can be interpreted as being\n" 16109 " anywhere on the line corresponding to the minimum x value for the\n" 16110 " vertices in the rotated coordinate system. The distance along the\n" 16111 " gradient vector is linearly transformed to the independent variable of\n" 16112 " colour map 1 which ranges from 0. at the tail of the gradient vector\n" 16113 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n" 16114 " colour corresponding to the independent variable of colour map 1. For\n" 16115 " more information about colour map 1 (see the PLplot documentation). \n" 16116 "\n" 16117 " Redacted form: plgradient(x,y,angle)\n" 16118 "\n" 16119 " This function is used in examples 25,30. \n" 16120 "\n" 16121 "\n" 16122 "\n" 16123 "SYNOPSIS:\n" 16124 "\n" 16125 "plgradient(n, x, y, angle)\n" 16126 "\n" 16127 "ARGUMENTS:\n" 16128 "\n" 16129 " n (PLINT, input) : Number of vertices in polygon. \n" 16130 "\n" 16131 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 16132 " vertices. \n" 16133 "\n" 16134 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 16135 " vertices. \n" 16136 "\n" 16137 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n" 16138 " axis. \n" 16139 "\n" 16140 ""}, 16141 { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n" 16142 "Flushes the output stream \n" 16143 "\n" 16144 "DESCRIPTION:\n" 16145 "\n" 16146 " Flushes the output stream. Use sparingly, if at all. \n" 16147 "\n" 16148 " Redacted form: plflush()\n" 16149 "\n" 16150 " This function is used in examples 1,14. \n" 16151 "\n" 16152 "\n" 16153 "\n" 16154 "SYNOPSIS:\n" 16155 "\n" 16156 "plflush()\n" 16157 "\n" 16158 ""}, 16159 { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n" 16160 "Set character font \n" 16161 "\n" 16162 "DESCRIPTION:\n" 16163 "\n" 16164 " Sets the default character font for subsequent character drawing. Also\n" 16165 " affects symbols produced by plpoin. This routine has no effect unless\n" 16166 " the extended character set is loaded (see plfontld). \n" 16167 "\n" 16168 " Redacted form: plfont(ifont)\n" 16169 "\n" 16170 " This function is used in examples 1,2,4,7,13,24,26. \n" 16171 "\n" 16172 "\n" 16173 "\n" 16174 "SYNOPSIS:\n" 16175 "\n" 16176 "plfont(ifont)\n" 16177 "\n" 16178 "ARGUMENTS:\n" 16179 "\n" 16180 " ifont (PLINT, input) : Specifies the font: 1: Normal font (simplest\n" 16181 " and fastest) \n" 16182 " 2: Roman font \n" 16183 " 3: Italic font \n" 16184 " 4: Script font \n" 16185 "\n" 16186 ""}, 16187 { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n" 16188 "Load character font \n" 16189 "\n" 16190 "DESCRIPTION:\n" 16191 "\n" 16192 " Sets the character set to use for subsequent character drawing. May\n" 16193 " be called before initializing PLplot. \n" 16194 "\n" 16195 " Redacted form: plfontld(fnt)\n" 16196 "\n" 16197 " This function is used in examples 1,7. \n" 16198 "\n" 16199 "\n" 16200 "\n" 16201 "SYNOPSIS:\n" 16202 "\n" 16203 "plfontld(fnt)\n" 16204 "\n" 16205 "ARGUMENTS:\n" 16206 "\n" 16207 " fnt (PLINT, input) : Specifies the character set to load: 0:\n" 16208 " Standard character set \n" 16209 " 1: Extended character set \n" 16210 "\n" 16211 ""}, 16212 { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n" 16213 "Get character default height and current (scaled) height \n" 16214 "\n" 16215 "DESCRIPTION:\n" 16216 "\n" 16217 " Get character default height and current (scaled) height. \n" 16218 "\n" 16219 " Redacted form: plgchr(p_def, p_ht)\n" 16220 "\n" 16221 " This function is used in example 23. \n" 16222 "\n" 16223 "\n" 16224 "\n" 16225 "SYNOPSIS:\n" 16226 "\n" 16227 "plgchr(p_def, p_ht)\n" 16228 "\n" 16229 "ARGUMENTS:\n" 16230 "\n" 16231 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n" 16232 "\n" 16233 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n" 16234 " height (mm). \n" 16235 "\n" 16236 ""}, 16237 { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n" 16238 "Returns 8-bit RGB values for given color index from cmap0 \n" 16239 "\n" 16240 "DESCRIPTION:\n" 16241 "\n" 16242 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n" 16243 " PLplot documentation). Values are negative if an invalid color id is\n" 16244 " given. \n" 16245 "\n" 16246 " Redacted form: plgcol0(icol0, r, g, b)\n" 16247 "\n" 16248 " This function is used in example 2. \n" 16249 "\n" 16250 "\n" 16251 "\n" 16252 "SYNOPSIS:\n" 16253 "\n" 16254 "plgcol0(icol0, r, g, b)\n" 16255 "\n" 16256 "ARGUMENTS:\n" 16257 "\n" 16258 " icol0 (PLINT, input) : Index of desired cmap0 color. \n" 16259 "\n" 16260 " r (PLINT *, output) : Pointer to 8-bit red value. \n" 16261 "\n" 16262 " g (PLINT *, output) : Pointer to 8-bit green value. \n" 16263 "\n" 16264 " b (PLINT *, output) : Pointer to 8-bit blue value. \n" 16265 "\n" 16266 ""}, 16267 { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n" 16268 "Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n" 16269 "\n" 16270 "DESCRIPTION:\n" 16271 "\n" 16272 " Returns 8-bit RGB values (0-255) and double alpha transparency value\n" 16273 " (0.0 - 1.0) for given color from cmap0 (see the PLplot\n" 16274 " documentation). Values are negative if an invalid color id is given. \n" 16275 "\n" 16276 " This function is used in example 30. \n" 16277 "\n" 16278 "\n" 16279 "\n" 16280 "SYNOPSIS:\n" 16281 "\n" 16282 "plgcol0a(icol0, r, g, b, alpha)\n" 16283 "\n" 16284 "ARGUMENTS:\n" 16285 "\n" 16286 " icol0 (PLINT, input) : Index of desired cmap0 color. \n" 16287 "\n" 16288 " r (PLINT *, output) : Pointer to 8-bit red value. \n" 16289 "\n" 16290 " g (PLINT *, output) : Pointer to 8-bit green value. \n" 16291 "\n" 16292 " b (PLINT *, output) : Pointer to 8-bit blue value. \n" 16293 "\n" 16294 " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n" 16295 " value. \n" 16296 "\n" 16297 ""}, 16298 { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n" 16299 "Returns the background color (cmap0[0]) by 8-bit RGB value \n" 16300 "\n" 16301 "ESCRIPTION:\n" 16302 "\n" 16303 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n" 16304 "\n" 16305 " Redacted form: plgcolbg(r, g, b)\n" 16306 "\n" 16307 " This function is used in example 31. \n" 16308 "\n" 16309 "\n" 16310 "\n" 16311 "YNOPSIS:\n" 16312 "\n" 16313 "lgcolbg(r, g, b)\n" 16314 "\n" 16315 "RGUMENTS:\n" 16316 "\n" 16317 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16318 " representing the degree of red in the color. \n" 16319 "\n" 16320 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16321 " representing the degree of green in the color. \n" 16322 "\n" 16323 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16324 " representing the degree of blue in the color. \n" 16325 "\n" 16326 ""}, 16327 { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n" 16328 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n" 16329 "\n" 16330 "ESCRIPTION:\n" 16331 "\n" 16332 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n" 16333 " alpha transparency value. \n" 16334 "\n" 16335 " This function is used in example 31. \n" 16336 "\n" 16337 "\n" 16338 "\n" 16339 "YNOPSIS:\n" 16340 "\n" 16341 "lgcolbga(r, g, b, alpha)\n" 16342 "\n" 16343 "RGUMENTS:\n" 16344 "\n" 16345 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16346 " representing the degree of red in the color. \n" 16347 "\n" 16348 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16349 " representing the degree of green in the color. \n" 16350 "\n" 16351 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n" 16352 " representing the degree of blue in the color. \n" 16353 "\n" 16354 " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n" 16355 " value. \n" 16356 "\n" 16357 ""}, 16358 { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n" 16359 "Get the current device-compression setting \n" 16360 "\n" 16361 "DESCRIPTION:\n" 16362 "\n" 16363 " Get the current device-compression setting. This parameter is only\n" 16364 " used for drivers that provide compression. \n" 16365 "\n" 16366 " Redacted form: plgcompression(compression)\n" 16367 "\n" 16368 " This function is used in example 31. \n" 16369 "\n" 16370 "\n" 16371 "\n" 16372 "SYNOPSIS:\n" 16373 "\n" 16374 "plgcompression(compression)\n" 16375 "\n" 16376 "ARGUMENTS:\n" 16377 "\n" 16378 " compression (PLINT *, output) : Pointer to a variable to be filled\n" 16379 " with the current device-compression setting. \n" 16380 "\n" 16381 ""}, 16382 { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n" 16383 "Get the current device (keyword) name \n" 16384 "\n" 16385 "DESCRIPTION:\n" 16386 "\n" 16387 " Get the current device (keyword) name. Note: you must have allocated\n" 16388 " space for this (80 characters is safe). \n" 16389 "\n" 16390 " Redacted form: plgdev(p_dev)\n" 16391 "\n" 16392 " This function is used in example 14. \n" 16393 "\n" 16394 "\n" 16395 "\n" 16396 "SYNOPSIS:\n" 16397 "\n" 16398 "plgdev(p_dev)\n" 16399 "\n" 16400 "ARGUMENTS:\n" 16401 "\n" 16402 " p_dev (char *, output) : Pointer to device (keyword) name string. \n" 16403 "\n" 16404 ""}, 16405 { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n" 16406 "Get parameters that define current device-space window \n" 16407 "\n" 16408 "DESCRIPTION:\n" 16409 "\n" 16410 " Get relative margin width, aspect ratio, and relative justification\n" 16411 " that define current device-space window. If plsdidev has not been\n" 16412 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n" 16413 " p_jy will all be 0. \n" 16414 "\n" 16415 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n" 16416 "\n" 16417 " This function is used in example 31. \n" 16418 "\n" 16419 "\n" 16420 "\n" 16421 "SYNOPSIS:\n" 16422 "\n" 16423 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n" 16424 "\n" 16425 "ARGUMENTS:\n" 16426 "\n" 16427 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n" 16428 "\n" 16429 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n" 16430 "\n" 16431 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n" 16432 "\n" 16433 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n" 16434 "\n" 16435 ""}, 16436 { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n" 16437 "Get plot orientation \n" 16438 "\n" 16439 "DESCRIPTION:\n" 16440 "\n" 16441 " Get plot orientation parameter which is multiplied by 90 degrees to\n" 16442 " obtain the angle of rotation. Note, arbitrary rotation parameters\n" 16443 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n" 16444 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n" 16445 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n" 16446 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n" 16447 " not been called the default value pointed to by p_rot will be 0. \n" 16448 "\n" 16449 " Redacted form: plgdiori(p_rot)\n" 16450 "\n" 16451 " This function is not used in any examples. \n" 16452 "\n" 16453 "\n" 16454 "\n" 16455 "SYNOPSIS:\n" 16456 "\n" 16457 "plgdiori(p_rot)\n" 16458 "\n" 16459 "ARGUMENTS:\n" 16460 "\n" 16461 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n" 16462 "\n" 16463 ""}, 16464 { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n" 16465 "Get parameters that define current plot-space window \n" 16466 "\n" 16467 "DESCRIPTION:\n" 16468 "\n" 16469 " Get relative minima and maxima that define current plot-space window.\n" 16470 " If plsdiplt has not been called the default values pointed to by\n" 16471 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n" 16472 "\n" 16473 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n" 16474 "\n" 16475 " This function is used in example 31. \n" 16476 "\n" 16477 "\n" 16478 "\n" 16479 "SYNOPSIS:\n" 16480 "\n" 16481 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n" 16482 "\n" 16483 "ARGUMENTS:\n" 16484 "\n" 16485 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n" 16486 "\n" 16487 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n" 16488 "\n" 16489 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n" 16490 "\n" 16491 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n" 16492 "\n" 16493 ""}, 16494 { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n" 16495 "Get family file parameters \n" 16496 "\n" 16497 "DESCRIPTION:\n" 16498 "\n" 16499 " Gets information about current family file, if familying is enabled. \n" 16500 " See the PLplot documentation for more information. \n" 16501 "\n" 16502 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n" 16503 "\n" 16504 " This function is used in examples 14,31. \n" 16505 "\n" 16506 "\n" 16507 "\n" 16508 "SYNOPSIS:\n" 16509 "\n" 16510 "plgfam(p_fam, p_num, p_bmax)\n" 16511 "\n" 16512 "ARGUMENTS:\n" 16513 "\n" 16514 " p_fam (PLINT *, output) : Pointer to variable with the Boolean\n" 16515 " family flag value. If nonzero, familying is enabled. \n" 16516 "\n" 16517 " p_num (PLINT *, output) : Pointer to variable with the current\n" 16518 " family file number. \n" 16519 "\n" 16520 " p_bmax (PLINT *, output) : Pointer to variable with the maximum\n" 16521 " file size (in bytes) for a family file. \n" 16522 "\n" 16523 ""}, 16524 { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n" 16525 "Get FCI (font characterization integer) \n" 16526 "\n" 16527 "DESCRIPTION:\n" 16528 "\n" 16529 " Gets information about the current font using the FCI approach. See\n" 16530 " the PLplot documentation for more information. \n" 16531 "\n" 16532 " Redacted form: plgfci(p_fci)\n" 16533 "\n" 16534 " This function is used in example 23. \n" 16535 "\n" 16536 "\n" 16537 "\n" 16538 "SYNOPSIS:\n" 16539 "\n" 16540 "plgfci(p_fci)\n" 16541 "\n" 16542 "ARGUMENTS:\n" 16543 "\n" 16544 " p_fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n" 16545 " integer) variable which is updated with current FCI value. \n" 16546 "\n" 16547 ""}, 16548 { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n" 16549 "Get output file name \n" 16550 "\n" 16551 "DESCRIPTION:\n" 16552 "\n" 16553 " Gets the current output file name, if applicable. \n" 16554 "\n" 16555 " Redacted form: plgfnam(fnam)\n" 16556 "\n" 16557 " This function is used in example 31. \n" 16558 "\n" 16559 "\n" 16560 "\n" 16561 "SYNOPSIS:\n" 16562 "\n" 16563 "plgfnam(fnam)\n" 16564 "\n" 16565 "ARGUMENTS:\n" 16566 "\n" 16567 " fnam (char *, output) : Pointer to file name string (a preallocated\n" 16568 " string of 80 characters or more). \n" 16569 "\n" 16570 ""}, 16571 { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n" 16572 "Get family, style and weight of the current font \n" 16573 "\n" 16574 "DESCRIPTION:\n" 16575 "\n" 16576 " Gets information about current font. See the PLplot documentation for\n" 16577 " more information on font selection. \n" 16578 "\n" 16579 " Redacted form: plgfont(p_family, p_style, p_weight)\n" 16580 "\n" 16581 " This function is used in example 23. \n" 16582 "\n" 16583 "\n" 16584 "\n" 16585 "SYNOPSIS:\n" 16586 "\n" 16587 "plgfont(p_family, p_style, p_weight)\n" 16588 "\n" 16589 "ARGUMENTS:\n" 16590 "\n" 16591 " p_family (PLINT *, output) : Pointer to variable with the current\n" 16592 " font family. The available values are given by the PL_FCI_*\n" 16593 " constants in plplot.h. Current options are PL_FCI_SANS,\n" 16594 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n" 16595 " p_family is NULL then the font family is not returned. \n" 16596 "\n" 16597 " p_style (PLINT *, output) : Pointer to variable with the current\n" 16598 " font style. The available values are given by the PL_FCI_*\n" 16599 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n" 16600 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n" 16601 " font style is not returned. \n" 16602 "\n" 16603 " p_weight (PLINT *, output) : Pointer to variable with the current\n" 16604 " font weight. The available values are given by the PL_FCI_*\n" 16605 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n" 16606 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n" 16607 " returned. \n" 16608 "\n" 16609 ""}, 16610 { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n" 16611 "Get the (current) run level \n" 16612 "\n" 16613 "DESCRIPTION:\n" 16614 "\n" 16615 " Get the (current) run level. Valid settings are: 0, uninitialized \n" 16616 " 1, initialized \n" 16617 " 2, viewport defined \n" 16618 " 3, world coordinates defined \n" 16619 "\n" 16620 "\n" 16621 " Redacted form: plglevel(p_level)\n" 16622 "\n" 16623 " This function is used in example 31. \n" 16624 "\n" 16625 "\n" 16626 "\n" 16627 "SYNOPSIS:\n" 16628 "\n" 16629 "plglevel(p_level)\n" 16630 "\n" 16631 "ARGUMENTS:\n" 16632 "\n" 16633 " p_level (PLINT *, output) : Pointer to the run level. \n" 16634 "\n" 16635 ""}, 16636 { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n" 16637 "Get page parameters \n" 16638 "\n" 16639 "DESCRIPTION:\n" 16640 "\n" 16641 " Gets the current page configuration. The length and offset values are\n" 16642 " expressed in units that are specific to the current driver. For\n" 16643 " instance: screen drivers will usually interpret them as number of\n" 16644 " pixels, whereas printer drivers will usually use mm. \n" 16645 "\n" 16646 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n" 16647 "\n" 16648 " This function is used in examples 14 and 31. \n" 16649 "\n" 16650 "\n" 16651 "\n" 16652 "SYNOPSIS:\n" 16653 "\n" 16654 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n" 16655 "\n" 16656 "ARGUMENTS:\n" 16657 "\n" 16658 " p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n" 16659 "\n" 16660 " p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n" 16661 " y. \n" 16662 "\n" 16663 " p_xleng (PLINT *, output) : Pointer to x page length value. \n" 16664 "\n" 16665 " p_yleng (PLINT *, output) : Pointer to y page length value. \n" 16666 "\n" 16667 " p_xoff (PLINT *, output) : Pointer to x page offset. \n" 16668 "\n" 16669 " p_yoff (PLINT *, output) : Pointer to y page offset. \n" 16670 "\n" 16671 ""}, 16672 { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n" 16673 "Switch to graphics screen \n" 16674 "\n" 16675 "DESCRIPTION:\n" 16676 "\n" 16677 " Sets an interactive device to graphics mode, used in conjunction with\n" 16678 " pltext to allow graphics and text to be interspersed. On a device\n" 16679 " which supports separate text and graphics windows, this command causes\n" 16680 " control to be switched to the graphics window. If already in graphics\n" 16681 " mode, this command is ignored. It is also ignored on devices which\n" 16682 " only support a single window or use a different method for shifting\n" 16683 " focus. See also pltext. \n" 16684 "\n" 16685 " Redacted form: plgra()\n" 16686 "\n" 16687 " This function is used in example 1. \n" 16688 "\n" 16689 "\n" 16690 "\n" 16691 "SYNOPSIS:\n" 16692 "\n" 16693 "plgra()\n" 16694 "\n" 16695 ""}, 16696 { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n" 16697 "Grid data from irregularly sampled data \n" 16698 "\n" 16699 "DESCRIPTION:\n" 16700 "\n" 16701 " Real world data is frequently irregularly sampled, but all PLplot 3D\n" 16702 " plots require data placed in a uniform grid. This function takes\n" 16703 " irregularly sampled data from three input arrays x[npts], y[npts], and\n" 16704 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n" 16705 " and yg[nptsy], and returns the gridded data into output array\n" 16706 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n" 16707 " with the argument type which can have one parameter specified in\n" 16708 " argument data. \n" 16709 "\n" 16710 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n" 16711 " Perl/PDL: Not available? \n" 16712 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n" 16713 "\n" 16714 "\n" 16715 " This function is used in example 21. \n" 16716 "\n" 16717 "\n" 16718 "\n" 16719 "SYNOPSIS:\n" 16720 "\n" 16721 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n" 16722 "\n" 16723 "ARGUMENTS:\n" 16724 "\n" 16725 " x (const PLFLT *, input) : The input x array. \n" 16726 "\n" 16727 " y (const PLFLT *, input) : The input y array. \n" 16728 "\n" 16729 " z (const PLFLT *, input) : The input z array. Each triple x[i],\n" 16730 " y[i], z[i] represents one data sample coordinate. \n" 16731 "\n" 16732 " npts (PLINT, input) : The number of data samples in the x, y and z\n" 16733 " arrays. \n" 16734 "\n" 16735 " xg (const PLFLT *, input) : The input array that specifies the grid\n" 16736 " spacing in the x direction. Usually xg has nptsx equally spaced\n" 16737 " values from the minimum to the maximum values of the x input\n" 16738 " array. \n" 16739 "\n" 16740 " nptsx (PLINT, input) : The number of points in the xg array. \n" 16741 "\n" 16742 " yg (const PLFLT *, input) : The input array that specifies the grid\n" 16743 " spacing in the y direction. Similar to the xg parameter. \n" 16744 "\n" 16745 " nptsy (PLINT, input) : The number of points in the yg array. \n" 16746 "\n" 16747 " zg (PLFLT **, output) : The output array, where data lies in the\n" 16748 " regular grid specified by xg and yg. the zg array must exist or be\n" 16749 " allocated by the user prior to the call, and must have dimension\n" 16750 " zg[nptsx][nptsy]. \n" 16751 "\n" 16752 " type (PLINT, input) : The type of gridding algorithm to use, which\n" 16753 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n" 16754 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n" 16755 " GRID_NNI: Natural Neighbors Interpolation \n" 16756 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n" 16757 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n" 16758 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n" 16759 " Weighted \n" 16760 " For details of the algorithms read the source file plgridd.c. \n" 16761 "\n" 16762 " data (PLFLT, input) : Some gridding algorithms require extra data,\n" 16763 " which can be specified through this argument. Currently, for\n" 16764 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n" 16765 " use, the lower the value, the noisier (more local) the\n" 16766 " approximation is. \n" 16767 " GRID_NNLI, data specifies what a thin triangle is, in the\n" 16768 " range [1. .. 2.]. High values enable the usage of very thin\n" 16769 " triangles for interpolation, possibly resulting in error in\n" 16770 " the approximation. \n" 16771 " GRID_NNI, only weights greater than data will be accepted. If\n" 16772 " 0, all weights will be accepted. \n" 16773 "\n" 16774 ""}, 16775 { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n" 16776 "Get current subpage parameters \n" 16777 "\n" 16778 "DESCRIPTION:\n" 16779 "\n" 16780 " Gets the size of the current subpage in millimeters measured from the\n" 16781 " bottom left hand corner of the output device page or screen. Can be\n" 16782 " used in conjunction with plsvpa for setting the size of a viewport in\n" 16783 " absolute coordinates (millimeters). \n" 16784 "\n" 16785 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n" 16786 "\n" 16787 " This function is used in example 23. \n" 16788 "\n" 16789 "\n" 16790 "\n" 16791 "SYNOPSIS:\n" 16792 "\n" 16793 "plgspa(xmin, xmax, ymin, ymax)\n" 16794 "\n" 16795 "ARGUMENTS:\n" 16796 "\n" 16797 " xmin (PLFLT *, output) : Pointer to variable with position of left\n" 16798 " hand edge of subpage in millimeters. \n" 16799 "\n" 16800 " xmax (PLFLT *, output) : Pointer to variable with position of right\n" 16801 " hand edge of subpage in millimeters. \n" 16802 "\n" 16803 " ymin (PLFLT *, output) : Pointer to variable with position of\n" 16804 " bottom edge of subpage in millimeters. \n" 16805 "\n" 16806 " ymax (PLFLT *, output) : Pointer to variable with position of top\n" 16807 " edge of subpage in millimeters. \n" 16808 "\n" 16809 ""}, 16810 { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n" 16811 "Get current stream number \n" 16812 "\n" 16813 "DESCRIPTION:\n" 16814 "\n" 16815 " Gets the number of the current output stream. See also plsstrm. \n" 16816 "\n" 16817 " Redacted form: plgstrm(p_strm)\n" 16818 "\n" 16819 " This function is used in example 1,20. \n" 16820 "\n" 16821 "\n" 16822 "\n" 16823 "SYNOPSIS:\n" 16824 "\n" 16825 "plgstrm(p_strm)\n" 16826 "\n" 16827 "ARGUMENTS:\n" 16828 "\n" 16829 " p_strm (PLINT *, output) : Pointer to current stream value. \n" 16830 "\n" 16831 ""}, 16832 { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n" 16833 "Get the current library version number \n" 16834 "\n" 16835 "DESCRIPTION:\n" 16836 "\n" 16837 " Get the current library version number. Note: you must have allocated\n" 16838 " space for this (80 characters is safe). \n" 16839 "\n" 16840 " Redacted form: plgver(p_ver)\n" 16841 "\n" 16842 " This function is used in example 1. \n" 16843 "\n" 16844 "\n" 16845 "\n" 16846 "SYNOPSIS:\n" 16847 "\n" 16848 "plgver(p_ver)\n" 16849 "\n" 16850 "ARGUMENTS:\n" 16851 "\n" 16852 " p_ver (char *, output) : Pointer to the current library version\n" 16853 " number. \n" 16854 "\n" 16855 ""}, 16856 { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n" 16857 "Get viewport limits in normalized device coordinates \n" 16858 "\n" 16859 "DESCRIPTION:\n" 16860 "\n" 16861 " Get viewport limits in normalized device coordinates. \n" 16862 "\n" 16863 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n" 16864 " Perl/PDL: Not available? \n" 16865 "\n" 16866 "\n" 16867 " This function is used in example 31. \n" 16868 "\n" 16869 "\n" 16870 "\n" 16871 "SYNOPSIS:\n" 16872 "\n" 16873 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n" 16874 "\n" 16875 "ARGUMENTS:\n" 16876 "\n" 16877 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n" 16878 " device coordinate in x. \n" 16879 "\n" 16880 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n" 16881 " device coordinate in x. \n" 16882 "\n" 16883 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n" 16884 " device coordinate in y. \n" 16885 "\n" 16886 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n" 16887 " device coordinate in y. \n" 16888 "\n" 16889 ""}, 16890 { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n" 16891 "Get viewport limits in world coordinates \n" 16892 "\n" 16893 "DESCRIPTION:\n" 16894 "\n" 16895 " Get viewport limits in world coordinates. \n" 16896 "\n" 16897 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n" 16898 " Perl/PDL: Not available? \n" 16899 "\n" 16900 "\n" 16901 " This function is used in example 31. \n" 16902 "\n" 16903 "\n" 16904 "\n" 16905 "SYNOPSIS:\n" 16906 "\n" 16907 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n" 16908 "\n" 16909 "ARGUMENTS:\n" 16910 "\n" 16911 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n" 16912 " coordinate in x. \n" 16913 "\n" 16914 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n" 16915 " coordinate in x. \n" 16916 "\n" 16917 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n" 16918 " coordinate in y. \n" 16919 "\n" 16920 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n" 16921 " coordinate in y. \n" 16922 "\n" 16923 ""}, 16924 { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n" 16925 "Get x axis parameters \n" 16926 "\n" 16927 "DESCRIPTION:\n" 16928 "\n" 16929 " Returns current values of the p_digmax and p_digits flags for the x\n" 16930 " axis. p_digits is updated after the plot is drawn, so this routine\n" 16931 " should only be called after the call to plbox (or plbox3) is complete.\n" 16932 " See the PLplot documentation for more information. \n" 16933 "\n" 16934 " Redacted form: plgxax(p_digmax, p_digits)\n" 16935 "\n" 16936 " This function is used in example 31. \n" 16937 "\n" 16938 "\n" 16939 "\n" 16940 "SYNOPSIS:\n" 16941 "\n" 16942 "plgxax(p_digmax, p_digits)\n" 16943 "\n" 16944 "ARGUMENTS:\n" 16945 "\n" 16946 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n" 16947 " number of digits for the x axis. If nonzero, the printed label\n" 16948 " has been switched to a floating point representation when the\n" 16949 " number of digits exceeds p_digmax. \n" 16950 "\n" 16951 " p_digits (PLINT *, output) : Pointer to variable with the actual\n" 16952 " number of digits for the numeric labels (x axis) from the last\n" 16953 " plot. \n" 16954 "\n" 16955 ""}, 16956 { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n" 16957 "Get y axis parameters \n" 16958 "\n" 16959 "DESCRIPTION:\n" 16960 "\n" 16961 " Identical to plgxax, except that arguments are flags for y axis. See\n" 16962 " the description of plgxax for more detail. \n" 16963 "\n" 16964 " Redacted form: plgyax(p_digmax, p_digits)\n" 16965 "\n" 16966 " This function is used in example 31. \n" 16967 "\n" 16968 "\n" 16969 "\n" 16970 "SYNOPSIS:\n" 16971 "\n" 16972 "plgyax(p_digmax, p_digits)\n" 16973 "\n" 16974 "ARGUMENTS:\n" 16975 "\n" 16976 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n" 16977 " number of digits for the y axis. If nonzero, the printed label\n" 16978 " has been switched to a floating point representation when the\n" 16979 " number of digits exceeds p_digmax. \n" 16980 "\n" 16981 " p_digits (PLINT *, output) : Pointer to variable with the actual\n" 16982 " number of digits for the numeric labels (y axis) from the last\n" 16983 " plot. \n" 16984 "\n" 16985 ""}, 16986 { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n" 16987 "Get z axis parameters \n" 16988 "\n" 16989 "DESCRIPTION:\n" 16990 "\n" 16991 " Identical to plgxax, except that arguments are flags for z axis. See\n" 16992 " the description of plgxax for more detail. \n" 16993 "\n" 16994 " Redacted form: plgzax(p_digmax, p_digits)\n" 16995 "\n" 16996 " This function is used in example 31. \n" 16997 "\n" 16998 "\n" 16999 "\n" 17000 "SYNOPSIS:\n" 17001 "\n" 17002 "plgzax(p_digmax, p_digits)\n" 17003 "\n" 17004 "ARGUMENTS:\n" 17005 "\n" 17006 " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n" 17007 " number of digits for the z axis. If nonzero, the printed label\n" 17008 " has been switched to a floating point representation when the\n" 17009 " number of digits exceeds p_digmax. \n" 17010 "\n" 17011 " p_digits (PLINT *, output) : Pointer to variable with the actual\n" 17012 " number of digits for the numeric labels (z axis) from the last\n" 17013 " plot. \n" 17014 "\n" 17015 ""}, 17016 { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n" 17017 "Plot a histogram from unbinned data \n" 17018 "\n" 17019 "DESCRIPTION:\n" 17020 "\n" 17021 " Plots a histogram from n data points stored in the array data. This\n" 17022 " routine bins the data into nbin bins equally spaced between datmin and\n" 17023 " datmax, and calls plbin to draw the resulting histogram. Parameter\n" 17024 " opt allows, among other things, the histogram either to be plotted in\n" 17025 " an existing window or causes plhist to call plenv with suitable limits\n" 17026 " before plotting the histogram. \n" 17027 "\n" 17028 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n" 17029 "\n" 17030 " This function is used in example 5. \n" 17031 "\n" 17032 "\n" 17033 "\n" 17034 "SYNOPSIS:\n" 17035 "\n" 17036 "plhist(n, data, datmin, datmax, nbin, opt)\n" 17037 "\n" 17038 "ARGUMENTS:\n" 17039 "\n" 17040 " n (PLINT, input) : Number of data points. \n" 17041 "\n" 17042 " data (const PLFLT *, input) : Pointer to array with values of the n\n" 17043 " data points. \n" 17044 "\n" 17045 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n" 17046 "\n" 17047 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n" 17048 "\n" 17049 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n" 17050 " divide the interval xmin to xmax. \n" 17051 "\n" 17052 " opt (PLINT, input) : Is a combination of several flags:\n" 17053 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n" 17054 " the histogram data, the outer bins are expanded to fill up the\n" 17055 " entire x-axis, data outside the given extremes are assigned to the\n" 17056 " outer bins and bins of zero height are simply drawn. \n" 17057 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n" 17058 " to fit the histogram data, without this flag, plenv is called\n" 17059 " to set the world coordinates. \n" 17060 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n" 17061 " extremes are not taken into account. This option should\n" 17062 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n" 17063 " properly present the data. \n" 17064 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n" 17065 " size as the ones inside. \n" 17066 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n" 17067 " (there is a gap for such bins). \n" 17068 "\n" 17069 ""}, 17070 { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n" 17071 "Convert HLS color to RGB \n" 17072 "\n" 17073 "DESCRIPTION:\n" 17074 "\n" 17075 " Convert HLS color coordinates to RGB. \n" 17076 "\n" 17077 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n" 17078 " Perl/PDL: Not available? Implemented as plhls? \n" 17079 "\n" 17080 "\n" 17081 " This function is used in example 2. \n" 17082 "\n" 17083 "\n" 17084 "\n" 17085 "SYNOPSIS:\n" 17086 "\n" 17087 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n" 17088 "\n" 17089 "ARGUMENTS:\n" 17090 "\n" 17091 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n" 17092 "\n" 17093 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n" 17094 " of the colour cone (0.0-1.0) \n" 17095 "\n" 17096 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n" 17097 " radius of the colour cone (0.0-1.0) \n" 17098 "\n" 17099 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n" 17100 " colour \n" 17101 "\n" 17102 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n" 17103 " colour \n" 17104 "\n" 17105 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n" 17106 " colour \n" 17107 "\n" 17108 ""}, 17109 { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n" 17110 "Initialize PLplot \n" 17111 "\n" 17112 "DESCRIPTION:\n" 17113 "\n" 17114 " Initializing the plotting package. The program prompts for the device\n" 17115 " keyword or number of the desired output device. Hitting a RETURN in\n" 17116 " response to the prompt is the same as selecting the first device. \n" 17117 " plinit will issue no prompt if either the device was specified\n" 17118 " previously (via command line flag, the plsetopt function, or the\n" 17119 " plsdev function), or if only one device is enabled when PLplot is\n" 17120 " installed. If subpages have been specified, the output device is\n" 17121 " divided into nx by ny subpages, each of which may be used\n" 17122 " independently. If plinit is called again during a program, the\n" 17123 " previously opened file will be closed. The subroutine pladv is used\n" 17124 " to advance from one subpage to the next. \n" 17125 "\n" 17126 " Redacted form: plinit()\n" 17127 "\n" 17128 " This function is used in all of the examples. \n" 17129 "\n" 17130 "\n" 17131 "\n" 17132 "SYNOPSIS:\n" 17133 "\n" 17134 "plinit()\n" 17135 "\n" 17136 ""}, 17137 { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n" 17138 "Draw a line between two points \n" 17139 "\n" 17140 "DESCRIPTION:\n" 17141 "\n" 17142 " Joins the point (\n" 17143 " x1, \n" 17144 " y1) to (\n" 17145 " x2, \n" 17146 " y2). \n" 17147 "\n" 17148 " Redacted form: pljoin(x1,y1,x2,y2)\n" 17149 "\n" 17150 " This function is used in examples 3,14. \n" 17151 "\n" 17152 "\n" 17153 "\n" 17154 "SYNOPSIS:\n" 17155 "\n" 17156 "pljoin(x1, y1, x2, y2)\n" 17157 "\n" 17158 "ARGUMENTS:\n" 17159 "\n" 17160 " x1 (PLFLT, input) : x coordinate of first point. \n" 17161 "\n" 17162 " y1 (PLFLT, input) : y coordinate of first point. \n" 17163 "\n" 17164 " x2 (PLFLT, input) : x coordinate of second point. \n" 17165 "\n" 17166 " y2 (PLFLT, input) : y coordinate of second point. \n" 17167 "\n" 17168 ""}, 17169 { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n" 17170 "Simple routine to write labels \n" 17171 "\n" 17172 "DESCRIPTION:\n" 17173 "\n" 17174 " Routine for writing simple labels. Use plmtex for more complex labels. \n" 17175 "\n" 17176 " Redacted form: pllab(xlabel, ylabel, tlabel)\n" 17177 "\n" 17178 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n" 17179 "\n" 17180 "\n" 17181 "\n" 17182 "SYNOPSIS:\n" 17183 "\n" 17184 "pllab(xlabel, ylabel, tlabel)\n" 17185 "\n" 17186 "ARGUMENTS:\n" 17187 "\n" 17188 " xlabel (const char *, input) : Label for horizontal axis. \n" 17189 "\n" 17190 " ylabel (const char *, input) : Label for vertical axis. \n" 17191 "\n" 17192 " tlabel (const char *, input) : Title of graph. \n" 17193 "\n" 17194 ""}, 17195 { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n" 17196 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n" 17197 "\n" 17198 "DESCRIPTION:\n" 17199 "\n" 17200 " Routine for creating a discrete plot legend with a plotted filled box,\n" 17201 " line, and/or line of symbols for each annotated legend entry. (See\n" 17202 " plcolorbar for similar functionality for creating continuous color\n" 17203 " bars.) The arguments of pllegend provide control over the location\n" 17204 " and size of the legend as well as the location and characteristics of\n" 17205 " the elements (most of which are optional) within that legend. The\n" 17206 " resulting legend is clipped at the boundaries of the current subpage. \n" 17207 " (N.B. the adopted coordinate system used for some of the parameters is\n" 17208 " defined in the documentation of the position parameter.) \n" 17209 "\n" 17210 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n" 17211 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n" 17212 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n" 17213 " test_justification, text_colors, text, box_colors, box_patterns,\n" 17214 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n" 17215 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n" 17216 "\n" 17217 " This function is used in examples 4, 26, and 33. \n" 17218 "\n" 17219 "\n" 17220 "\n" 17221 "SYNOPSIS:\n" 17222 "\n" 17223 "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" 17224 "\n" 17225 "ARGUMENTS:\n" 17226 "\n" 17227 " p_legend_width (PLFLT *, output) : Pointer to a location which\n" 17228 " contains (after the call) the legend width in adopted coordinates.\n" 17229 " This quantity is calculated from plot_width, text_offset, ncolumn\n" 17230 " (possibly modified inside the routine depending on nlegend and\n" 17231 " nrow), and the length (calculated internally) of the longest text\n" 17232 " string. \n" 17233 "\n" 17234 " p_legend_height (PLFLT *, output) : Pointer to a location which\n" 17235 " contains (after the call) the legend height in adopted\n" 17236 " coordinates. This quantity is calculated from text_scale,\n" 17237 " text_spacing, and nrow (possibly modified inside the routine\n" 17238 " depending on nlegend and nrow). \n" 17239 "\n" 17240 " opt (PLINT, input) : opt contains bits controlling the overall\n" 17241 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n" 17242 " on the left of the legend and the plotted area on the right.\n" 17243 " Otherwise, put the text area on the right of the legend and the\n" 17244 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n" 17245 " plot a (semi-transparent) background for the legend. If the\n" 17246 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n" 17247 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n" 17248 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n" 17249 " plot the resulting array of legend entries in row-major order.\n" 17250 " Otherwise, plot the legend entries in column-major order. \n" 17251 "\n" 17252 " position (PLINT, input) : position contains bits which control the\n" 17253 " overall position of the legend and the definition of the adopted\n" 17254 " coordinates used for positions just like what is done for the\n" 17255 " position argument for plcolorbar. However, note that the defaults\n" 17256 " for the position bits (see below) are different than the\n" 17257 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n" 17258 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n" 17259 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n" 17260 " the 16 possible standard positions (the 4 corners and centers of\n" 17261 " the 4 sides for both the inside and outside cases) of the legend\n" 17262 " relative to the adopted coordinate system. The corner positions\n" 17263 " are specified by the appropriate combination of two of the\n" 17264 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n" 17265 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n" 17266 " value of one of those bits. The adopted coordinates are\n" 17267 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n" 17268 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n" 17269 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n" 17270 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n" 17271 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n" 17272 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n" 17273 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n" 17274 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n" 17275 "\n" 17276 " x (PLFLT, input) : X offset of the legend position in adopted\n" 17277 " coordinates from the specified standard position of the legend.\n" 17278 " For positive x, the direction of motion away from the standard\n" 17279 " position is inward/outward from the standard corner positions or\n" 17280 " standard left or right positions if the\n" 17281 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n" 17282 " For the standard top or bottom positions, the direction of motion\n" 17283 " is toward positive X. \n" 17284 "\n" 17285 " y (PLFLT, input) : Y offset of the legend position in adopted\n" 17286 " coordinates from the specified standard position of the legend.\n" 17287 " For positive y, the direction of motion away from the standard\n" 17288 " position is inward/outward from the standard corner positions or\n" 17289 " standard top or bottom positions if the\n" 17290 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n" 17291 " For the standard left or right positions, the direction of motion\n" 17292 " is toward positive Y. \n" 17293 "\n" 17294 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n" 17295 " of the plot area (where the colored boxes, lines, and/or lines of\n" 17296 " symbols are drawn) of the legend. \n" 17297 "\n" 17298 " bg_color (PLINT, input) : The cmap0 color of the background for the\n" 17299 " legend (PL_LEGEND_BACKGROUND). \n" 17300 "\n" 17301 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n" 17302 " for the legend (PL_LEGEND_BOUNDING_BOX). \n" 17303 "\n" 17304 " bb_style (PLINT, input) : The pllsty style number for the\n" 17305 " bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n" 17306 "\n" 17307 " nrow (PLINT, input) : The cmap0 index of the background color for\n" 17308 " the legend (PL_LEGEND_BACKGROUND). \n" 17309 "\n" 17310 " ncolumn (PLINT, input) : The cmap0 index of the background color\n" 17311 " for the legend (PL_LEGEND_BACKGROUND). \n" 17312 "\n" 17313 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n" 17314 " vertical height of the legend in adopted coordinates is calculated\n" 17315 " internally from nlegend, text_scale (see below), and text_spacing\n" 17316 " (see below). \n" 17317 "\n" 17318 " opt_array (const PLINT *, input) : Array of nlegend values of\n" 17319 " options to control each individual plotted area corresponding to a\n" 17320 " legend entry. If the \n" 17321 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n" 17322 " area. If the \n" 17323 " PL_LEGEND_COLOR_BOX, \n" 17324 " PL_LEGEND_LINE, and/or \n" 17325 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n" 17326 " entry is plotted with a colored box; a line; and/or a line of\n" 17327 " symbols. \n" 17328 "\n" 17329 " text_offset (PLFLT, input) : Offset of the text area from the plot\n" 17330 " area in units of character width. N.B. The total horizontal\n" 17331 " width of the legend in adopted coordinates is calculated\n" 17332 " internally from \n" 17333 " plot_width (see above), \n" 17334 " text_offset, and length (calculated internally) of the longest text\n" 17335 " string. \n" 17336 "\n" 17337 " text_scale (PLFLT, input) : Character height scale for text\n" 17338 " annotations. N.B. The total vertical height of the legend in\n" 17339 " adopted coordinates is calculated internally from \n" 17340 " nlegend (see above), \n" 17341 " text_scale, and \n" 17342 " text_spacing (see below). \n" 17343 "\n" 17344 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n" 17345 " character height from one legend entry to the next. N.B. The\n" 17346 " total vertical height of the legend in adopted coordinates is\n" 17347 " calculated internally from \n" 17348 " nlegend (see above), \n" 17349 " text_scale (see above), and \n" 17350 " text_spacing. \n" 17351 "\n" 17352 " text_justification (PLFLT, input) : Justification parameter used\n" 17353 " for text justification. The most common values of\n" 17354 " text_justification are 0., 0.5, or 1. corresponding to a text that\n" 17355 " is left justified, centred, or right justified within the text\n" 17356 " area, but other values are allowed as well. \n" 17357 "\n" 17358 " text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n" 17359 " colors. \n" 17360 "\n" 17361 " text (const char * const *, input) : Array of nlegend text string\n" 17362 " annotations. \n" 17363 "\n" 17364 " box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n" 17365 " for the discrete colored boxes (\n" 17366 " PL_LEGEND_COLOR_BOX). \n" 17367 "\n" 17368 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n" 17369 " (plpsty indices) for the discrete colored boxes (\n" 17370 " PL_LEGEND_COLOR_BOX). \n" 17371 "\n" 17372 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n" 17373 " of fraction of character height) for the height of the discrete\n" 17374 " colored boxes (\n" 17375 " PL_LEGEND_COLOR_BOX). \n" 17376 "\n" 17377 " box_line_widths (const PLFLT *, input) : Array of nlegend line\n" 17378 " widths for the patterns specified by box_patterns (\n" 17379 " PL_LEGEND_COLOR_BOX). \n" 17380 "\n" 17381 " line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n" 17382 " colors (\n" 17383 " PL_LEGEND_LINE). \n" 17384 "\n" 17385 " line_styles (const PLINT *, input) : Array of nlegend line styles\n" 17386 " (plsty indices) (\n" 17387 " PL_LEGEND_LINE). \n" 17388 "\n" 17389 " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n" 17390 " PL_LEGEND_LINE). \n" 17391 "\n" 17392 " symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n" 17393 " symbol colors (\n" 17394 " PL_LEGEND_SYMBOL). \n" 17395 "\n" 17396 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n" 17397 " values for the symbol height (\n" 17398 " PL_LEGEND_SYMBOL). \n" 17399 "\n" 17400 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n" 17401 " symbols to be drawn across the width of the plotted area (\n" 17402 " PL_LEGEND_SYMBOL). \n" 17403 "\n" 17404 " symbols (const char * const *, input) : Array of nlegend symbols\n" 17405 " (plpoin indices) (\n" 17406 " PL_LEGEND_SYMBOL). \n" 17407 "\n" 17408 ""}, 17409 { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n" 17410 "Plot color bar for image, shade or gradient plots \n" 17411 "\n" 17412 "DESCRIPTION:\n" 17413 "\n" 17414 " Routine for creating a continuous color bar for image, shade, or\n" 17415 " gradient plots. (See pllegend for similar functionality for creating\n" 17416 " legends with discrete elements). The arguments of plcolorbar provide\n" 17417 " control over the location and size of the color bar as well as the\n" 17418 " location and characteristics of the elements (most of which are\n" 17419 " optional) within that color bar. The resulting color bar is clipped\n" 17420 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n" 17421 " system used for some of the parameters is defined in the documentation\n" 17422 " of the position parameter.) \n" 17423 "\n" 17424 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n" 17425 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n" 17426 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n" 17427 " labels, axis_opts, ticks, sub_ticks, values)\n" 17428 "\n" 17429 " This function is used in examples 16 and 33. \n" 17430 "\n" 17431 "\n" 17432 "\n" 17433 "SYNOPSIS:\n" 17434 "\n" 17435 "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" 17436 "\n" 17437 "ARGUMENTS:\n" 17438 "\n" 17439 " p_colorbar_width (PLFLT *, output) : Pointer to a location which\n" 17440 " contains (after the call) the labelled and decorated color bar\n" 17441 " width in adopted coordinates. \n" 17442 "\n" 17443 " p_colorbar_height (PLFLT *, output) : Pointer to a location which\n" 17444 " contains (after the call) the labelled and decorated color bar\n" 17445 " height in adopted coordinates. \n" 17446 "\n" 17447 " opt (PLINT, input) : opt contains bits controlling the overall\n" 17448 " color bar. The orientation (direction of the maximum value) of\n" 17449 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n" 17450 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n" 17451 " specified, the default orientation is toward the top if the\n" 17452 " colorbar is placed on the left or right of the viewport or toward\n" 17453 " the right if the colorbar is placed on the top or bottom of the\n" 17454 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n" 17455 " (semi-transparent) background for the color bar. If the\n" 17456 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n" 17457 " color bar. The type of color bar must be specified with one of\n" 17458 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n" 17459 " more than one of those bits is set only the first one in the above\n" 17460 " list is honored. The position of the (optional) label/title can be\n" 17461 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n" 17462 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n" 17463 " will be drawn. If more than one of this list of bits is specified,\n" 17464 " only the first one on the list is honored. End-caps for the color\n" 17465 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n" 17466 " If a particular color bar cap option is not specified then no cap\n" 17467 " will be drawn for that end. As a special case for\n" 17468 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n" 17469 " specified. If this option is provided then any tick marks and tick\n" 17470 " labels will be placed at the breaks between shaded segments. TODO:\n" 17471 " This should be expanded to support custom placement of tick marks\n" 17472 " and tick labels at custom value locations for any color bar type. \n" 17473 "\n" 17474 " position (PLINT, input) : position contains bits which control the\n" 17475 " overall position of the color bar and the definition of the\n" 17476 " adopted coordinates used for positions just like what is done for\n" 17477 " the position argument for pllegend. However, note that the\n" 17478 " defaults for the position bits (see below) are different than the\n" 17479 " pllegend case. The combination of the PL_POSITION_LEFT,\n" 17480 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n" 17481 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n" 17482 " the 16 possible standard positions (the 4 corners and centers of\n" 17483 " the 4 sides for both the inside and outside cases) of the color\n" 17484 " bar relative to the adopted coordinate system. The corner\n" 17485 " positions are specified by the appropriate combination of two of\n" 17486 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n" 17487 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n" 17488 " value of one of those bits. The adopted coordinates are\n" 17489 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n" 17490 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n" 17491 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n" 17492 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n" 17493 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n" 17494 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n" 17495 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n" 17496 " PL_POSITION_VIEWPORT. \n" 17497 "\n" 17498 " x (PLFLT, input) : X offset of the color bar position in adopted\n" 17499 " coordinates from the specified standard position of the color bar.\n" 17500 " For positive x, the direction of motion away from the standard\n" 17501 " position is inward/outward from the standard corner positions or\n" 17502 " standard left or right positions if the\n" 17503 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n" 17504 " For the standard top or bottom positions, the direction of motion\n" 17505 " is toward positive X. \n" 17506 "\n" 17507 " y (PLFLT, input) : Y offset of the color bar position in adopted\n" 17508 " coordinates from the specified standard position of the color bar.\n" 17509 " For positive y, the direction of motion away from the standard\n" 17510 " position is inward/outward from the standard corner positions or\n" 17511 " standard top or bottom positions if the\n" 17512 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n" 17513 " For the standard left or right positions, the direction of motion\n" 17514 " is toward positive Y. \n" 17515 "\n" 17516 " x_length (PLFLT, input) : Length of the body of the color bar in\n" 17517 " the X direction in adopted coordinates. \n" 17518 "\n" 17519 " y_length (PLFLT, input) : Length of the body of the color bar in\n" 17520 " the Y direction in adopted coordinates. \n" 17521 "\n" 17522 " bg_color (PLINT, input) : The cmap0 color of the background for the\n" 17523 " color bar (PL_COLORBAR_BACKGROUND). \n" 17524 "\n" 17525 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n" 17526 " for the color bar (PL_COLORBAR_BOUNDING_BOX). \n" 17527 "\n" 17528 " bb_style (PLINT, input) : The pllsty style number for the\n" 17529 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n" 17530 "\n" 17531 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n" 17532 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n" 17533 "\n" 17534 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n" 17535 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n" 17536 "\n" 17537 " cont_color (PLINT, input) : The cmap0 contour color for\n" 17538 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n" 17539 " it will be interpreted according to the design of plshades. \n" 17540 "\n" 17541 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n" 17542 " plots. This is passed directly to plshades, so it will be\n" 17543 " interpreted according to the design of plshades. \n" 17544 "\n" 17545 " n_labels (PLINT, input) : Number of labels to place around the\n" 17546 " color bar. \n" 17547 "\n" 17548 " label_opts (const PLINT *, input) : Options for each of \n" 17549 " n_labels labels. \n" 17550 "\n" 17551 " labels (const char * const *, input) : n_labels text labels for the\n" 17552 " color bar. No label is drawn if no label position is specified\n" 17553 " with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n" 17554 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n" 17555 " corresponding label_opts field. \n" 17556 "\n" 17557 " n_axes (PLINT, input) : Number of axis definitions provided. This\n" 17558 " value must be greater than 0. It is typically 1 (numerical axis\n" 17559 " labels are provided for one of the long edges of the color bar),\n" 17560 " but it can be larger if multiple numerical axis labels for the\n" 17561 " long edges of the color bar are desired. \n" 17562 "\n" 17563 " axis_opts (const char * const *, input) : An array of n_axes axis\n" 17564 " options (interpreted as for plbox) for the color bar's axis\n" 17565 " definitions. \n" 17566 "\n" 17567 " ticks (const PLFLT *, input) : An array of n_axes values of the\n" 17568 " spacing of the major tick marks (interpreted as for plbox) for the\n" 17569 " color bar's axis definitions. \n" 17570 "\n" 17571 " sub_ticks (const PLINT *, input) : An array of n_axes values of the\n" 17572 " number of subticks (interpreted as for plbox) for the color bar's\n" 17573 " axis definitions. \n" 17574 "\n" 17575 " n_values (const PLINT *, input) : An array containing the number of\n" 17576 " elements in each of the n_axes rows of the two-dimensional values\n" 17577 " array. \n" 17578 "\n" 17579 " values (const PLFLT * const *, input) : A two-dimensional array\n" 17580 " containing the numeric values for the data range represented by\n" 17581 " the color bar. For a row index of i_axis (where 0 < i_axis <\n" 17582 " n_axes), the number of elements in the row is specified by\n" 17583 " n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n" 17584 " the number of elements is 2, and the corresponding row elements of\n" 17585 " the values array are the minimum and maximum value represented by\n" 17586 " the colorbar. For PL_COLORBAR_SHADE, the number and values of the\n" 17587 " elements of a row of the values array is interpreted the same as\n" 17588 " the nlevel and clevel arguments of plshades. \n" 17589 "\n" 17590 ""}, 17591 { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n" 17592 "Sets the 3D position of the light source \n" 17593 "\n" 17594 "DESCRIPTION:\n" 17595 "\n" 17596 " Sets the 3D position of the light source for use with plsurf3d. \n" 17597 "\n" 17598 " Redacted form: pllightsource(x, y, z)\n" 17599 "\n" 17600 " This function is used in example 8. \n" 17601 "\n" 17602 "\n" 17603 "\n" 17604 "SYNOPSIS:\n" 17605 "\n" 17606 "pllightsource(x, y, z)\n" 17607 "\n" 17608 "ARGUMENTS:\n" 17609 "\n" 17610 " x (PLFLT, input) : X-coordinate of the light source. \n" 17611 "\n" 17612 " y (PLFLT, input) : Y-coordinate of the light source. \n" 17613 "\n" 17614 " z (PLFLT, input) : Z-coordinate of the light source. \n" 17615 "\n" 17616 ""}, 17617 { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n" 17618 "Draw a line \n" 17619 "\n" 17620 "DESCRIPTION:\n" 17621 "\n" 17622 " Draws line defined by n points in x and y. \n" 17623 "\n" 17624 " Redacted form: plline(x, y)\n" 17625 "\n" 17626 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n" 17627 "\n" 17628 "\n" 17629 "\n" 17630 "SYNOPSIS:\n" 17631 "\n" 17632 "plline(n, x, y)\n" 17633 "\n" 17634 "ARGUMENTS:\n" 17635 "\n" 17636 " n (PLINT, input) : Number of points defining line. \n" 17637 "\n" 17638 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 17639 " points. \n" 17640 "\n" 17641 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 17642 " points. \n" 17643 "\n" 17644 ""}, 17645 { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n" 17646 "Draw a line in 3 space \n" 17647 "\n" 17648 "DESCRIPTION:\n" 17649 "\n" 17650 " Draws line in 3 space defined by n points in x, y, and z. You must\n" 17651 " first set up the viewport, the 2d viewing window (in world\n" 17652 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n" 17653 " more info. \n" 17654 "\n" 17655 " Redacted form: plline3(x, y, z)\n" 17656 "\n" 17657 " This function is used in example 18. \n" 17658 "\n" 17659 "\n" 17660 "\n" 17661 "SYNOPSIS:\n" 17662 "\n" 17663 "plline3(n, x, y, z)\n" 17664 "\n" 17665 "ARGUMENTS:\n" 17666 "\n" 17667 " n (PLINT, input) : Number of points defining line. \n" 17668 "\n" 17669 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 17670 " points. \n" 17671 "\n" 17672 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 17673 " points. \n" 17674 "\n" 17675 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n" 17676 " points. \n" 17677 "\n" 17678 ""}, 17679 { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n" 17680 "Select line style \n" 17681 "\n" 17682 "DESCRIPTION:\n" 17683 "\n" 17684 " This sets the line style according to one of eight predefined patterns\n" 17685 " (also see plstyl). \n" 17686 "\n" 17687 " Redacted form: pllsty(lin)\n" 17688 "\n" 17689 " This function is used in examples 9,12,22,25. \n" 17690 "\n" 17691 "\n" 17692 "\n" 17693 "SYNOPSIS:\n" 17694 "\n" 17695 "pllsty(lin)\n" 17696 "\n" 17697 "ARGUMENTS:\n" 17698 "\n" 17699 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n" 17700 " a continuous line, line style 2 is a line with short dashes and\n" 17701 " gaps, line style 3 is a line with long dashes and gaps, line style\n" 17702 " 4 has long dashes and short gaps and so on. \n" 17703 "\n" 17704 ""}, 17705 { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n" 17706 "Plot surface mesh \n" 17707 "\n" 17708 "DESCRIPTION:\n" 17709 "\n" 17710 " Plots a surface mesh within the environment set up by plw3d. The\n" 17711 " surface is defined by the two-dimensional array z[\n" 17712 " nx][\n" 17713 " ny], the point z[i][j] being the value of the function at (\n" 17714 " x[i], \n" 17715 " y[j]). Note that the points in arrays x and y do not need to be\n" 17716 " equally spaced, but must be stored in ascending order. The parameter\n" 17717 " opt controls the way in which the surface is displayed. For further\n" 17718 " details see the PLplot documentation. \n" 17719 "\n" 17720 " Redacted form: plmesh(x, y, z, opt)\n" 17721 "\n" 17722 " This function is used in example 11. \n" 17723 "\n" 17724 "\n" 17725 "\n" 17726 "SYNOPSIS:\n" 17727 "\n" 17728 "plmesh(x, y, z, nx, ny, opt)\n" 17729 "\n" 17730 "ARGUMENTS:\n" 17731 "\n" 17732 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 17733 " which the function is evaluated. \n" 17734 "\n" 17735 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 17736 " which the function is evaluated. \n" 17737 "\n" 17738 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 17739 " two-dimensional array with set of function values. \n" 17740 "\n" 17741 " nx (PLINT, input) : Number of x values at which function is\n" 17742 " evaluated. \n" 17743 "\n" 17744 " ny (PLINT, input) : Number of y values at which function is\n" 17745 " evaluated. \n" 17746 "\n" 17747 " opt (PLINT, input) : Determines the way in which the surface is\n" 17748 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n" 17749 " function of x for each value of y[j]. \n" 17750 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n" 17751 " for each value of x[i]. \n" 17752 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n" 17753 " at which function is defined. \n" 17754 "\n" 17755 ""}, 17756 { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n" 17757 "Magnitude colored plot surface mesh with contour \n" 17758 "\n" 17759 "DESCRIPTION:\n" 17760 "\n" 17761 " A more powerful form of plmesh: the surface mesh can be colored\n" 17762 " accordingly to the current z value being plotted, a contour plot can\n" 17763 " be drawn at the base XY plane, and a curtain can be drawn between the\n" 17764 " plotted function border and the base XY plane. \n" 17765 "\n" 17766 " Redacted form: plmeshc(x, y, z, opt, clevel)\n" 17767 "\n" 17768 " This function is used in example 11. \n" 17769 "\n" 17770 "\n" 17771 "\n" 17772 "SYNOPSIS:\n" 17773 "\n" 17774 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n" 17775 "\n" 17776 "ARGUMENTS:\n" 17777 "\n" 17778 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 17779 " which the function is evaluated. \n" 17780 "\n" 17781 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 17782 " which the function is evaluated. \n" 17783 "\n" 17784 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 17785 " two-dimensional array with set of function values. \n" 17786 "\n" 17787 " nx (PLINT, input) : Number of x values at which function is\n" 17788 " evaluated. \n" 17789 "\n" 17790 " ny (PLINT, input) : Number of y values at which function is\n" 17791 " evaluated. \n" 17792 "\n" 17793 " opt (PLINT, input) : Determines the way in which the surface is\n" 17794 " represented. To specify more than one option just add the options,\n" 17795 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n" 17796 " showing z as a function of x for each value of y[j]. \n" 17797 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n" 17798 " for each value of x[i]. \n" 17799 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n" 17800 " at which function is defined. \n" 17801 " opt=MAG_COLOR: Each line in the mesh is colored according to\n" 17802 " the z value being plotted. The color is used from the current\n" 17803 " color map 1. \n" 17804 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n" 17805 " using parameters \n" 17806 " nlevel and \n" 17807 " clevel. \n" 17808 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n" 17809 " the borders of the plotted function. \n" 17810 "\n" 17811 "\n" 17812 " clevel (const PLFLT *, input) : Pointer to the array that defines\n" 17813 " the contour level spacing. \n" 17814 "\n" 17815 " nlevel (PLINT, input) : Number of elements in the clevel array. \n" 17816 "\n" 17817 ""}, 17818 { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n" 17819 "Creates a new stream and makes it the default \n" 17820 "\n" 17821 "DESCRIPTION:\n" 17822 "\n" 17823 " Creates a new stream and makes it the default. Differs from using\n" 17824 " plsstrm, in that a free stream number is found, and returned.\n" 17825 " Unfortunately, I have to start at stream 1 and work upward, since\n" 17826 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n" 17827 " that no initial, library-opening call is required. So stream 0 must\n" 17828 " be preallocated, and there is no simple way of determining whether it\n" 17829 " is already in use or not. \n" 17830 "\n" 17831 " Redacted form: plmkstrm(p_strm)\n" 17832 "\n" 17833 " This function is used in examples 1,20. \n" 17834 "\n" 17835 "\n" 17836 "\n" 17837 "SYNOPSIS:\n" 17838 "\n" 17839 "plmkstrm(p_strm)\n" 17840 "\n" 17841 "ARGUMENTS:\n" 17842 "\n" 17843 " p_strm (PLINT *, output) : Pointer to stream number of the created\n" 17844 " stream. \n" 17845 "\n" 17846 ""}, 17847 { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n" 17848 "Write text relative to viewport boundaries \n" 17849 "\n" 17850 "DESCRIPTION:\n" 17851 "\n" 17852 " Writes text at a specified position relative to the viewport\n" 17853 " boundaries. Text may be written inside or outside the viewport, but\n" 17854 " is clipped at the subpage boundaries. The reference point of a string\n" 17855 " lies along a line passing through the string at half the height of a\n" 17856 " capital letter. The position of the reference point along this line\n" 17857 " is determined by just, and the position of the reference point\n" 17858 " relative to the viewport is set by disp and pos. \n" 17859 "\n" 17860 " Redacted form: General: plmtex(side, disp, pos, just, text)\n" 17861 " Perl/PDL: plmtex(disp, pos, just, side, text)\n" 17862 "\n" 17863 "\n" 17864 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n" 17865 "\n" 17866 "\n" 17867 "\n" 17868 "SYNOPSIS:\n" 17869 "\n" 17870 "plmtex(side, disp, pos, just, text)\n" 17871 "\n" 17872 "ARGUMENTS:\n" 17873 "\n" 17874 " side (const char *, input) : Specifies the side of the viewport\n" 17875 " along which the text is to be written. The string must be one of:\n" 17876 " b: Bottom of viewport, text written parallel to edge. \n" 17877 " bv: Bottom of viewport, text written at right angles to edge. \n" 17878 " l: Left of viewport, text written parallel to edge. \n" 17879 " lv: Left of viewport, text written at right angles to edge. \n" 17880 " r: Right of viewport, text written parallel to edge. \n" 17881 " rv: Right of viewport, text written at right angles to edge. \n" 17882 " t: Top of viewport, text written parallel to edge. \n" 17883 " tv: Top of viewport, text written at right angles to edge. \n" 17884 "\n" 17885 "\n" 17886 " disp (PLFLT, input) : Position of the reference point of string,\n" 17887 " measured outwards from the specified viewport edge in units of the\n" 17888 " current character height. Use negative disp to write within the\n" 17889 " viewport. \n" 17890 "\n" 17891 " pos (PLFLT, input) : Position of the reference point of string\n" 17892 " along the specified edge, expressed as a fraction of the length of\n" 17893 " the edge. \n" 17894 "\n" 17895 " just (PLFLT, input) : Specifies the position of the string relative\n" 17896 " to its reference point. If just=0., the reference point is at the\n" 17897 " left and if just=1., it is at the right of the string. Other\n" 17898 " values of just give intermediate justifications. \n" 17899 "\n" 17900 " text (const char *, input) : The string to be written out. \n" 17901 "\n" 17902 ""}, 17903 { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n" 17904 "Write text relative to viewport boundaries in 3D plots \n" 17905 "\n" 17906 "DESCRIPTION:\n" 17907 "\n" 17908 " Writes text at a specified position relative to the viewport\n" 17909 " boundaries. Text may be written inside or outside the viewport, but\n" 17910 " is clipped at the subpage boundaries. The reference point of a string\n" 17911 " lies along a line passing through the string at half the height of a\n" 17912 " capital letter. The position of the reference point along this line\n" 17913 " is determined by just, and the position of the reference point\n" 17914 " relative to the viewport is set by disp and pos. \n" 17915 "\n" 17916 " Redacted form: plmtex3(side, disp, pos, just, text)\n" 17917 "\n" 17918 " This function is used in example 28. \n" 17919 "\n" 17920 "\n" 17921 "\n" 17922 "SYNOPSIS:\n" 17923 "\n" 17924 "plmtex3(side, disp, pos, just, text)\n" 17925 "\n" 17926 "ARGUMENTS:\n" 17927 "\n" 17928 " side (const char *, input) : Specifies the side of the viewport\n" 17929 " along which the text is to be written. The string should contain\n" 17930 " one or more of the following characters: [xyz][ps][v]. Only one\n" 17931 " label is drawn at a time, i.e. xyp will only label the X axis, not\n" 17932 " both the X and Y axes. x: Label the X axis. \n" 17933 " y: Label the Y axis. \n" 17934 " z: Label the Z axis. \n" 17935 " p: Label the primary axis. For Z this is the leftmost Z axis.\n" 17936 " For X it is the axis that starts at y-min. For Y it is the\n" 17937 " axis that starts at x-min. \n" 17938 " s: Label the secondary axis. \n" 17939 " v: Draw the text perpendicular to the axis. \n" 17940 "\n" 17941 "\n" 17942 " disp (PLFLT, input) : Position of the reference point of string,\n" 17943 " measured outwards from the specified viewport edge in units of the\n" 17944 " current character height. Use negative disp to write within the\n" 17945 " viewport. \n" 17946 "\n" 17947 " pos (PLFLT, input) : Position of the reference point of string\n" 17948 " along the specified edge, expressed as a fraction of the length of\n" 17949 " the edge. \n" 17950 "\n" 17951 " just (PLFLT, input) : Specifies the position of the string relative\n" 17952 " to its reference point. If just=0., the reference point is at the\n" 17953 " left and if just=1., it is at the right of the string. Other\n" 17954 " values of just give intermediate justifications. \n" 17955 "\n" 17956 " text (const char *, input) : The string to be written out. \n" 17957 "\n" 17958 ""}, 17959 { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n" 17960 "Plot 3-d surface plot \n" 17961 "\n" 17962 "DESCRIPTION:\n" 17963 "\n" 17964 " Plots a three dimensional surface plot within the environment set up\n" 17965 " by plw3d. The surface is defined by the two-dimensional array z[\n" 17966 " nx][\n" 17967 " ny], the point z[i][j] being the value of the function at (\n" 17968 " x[i], \n" 17969 " y[j]). Note that the points in arrays x and y do not need to be\n" 17970 " equally spaced, but must be stored in ascending order. The parameter\n" 17971 " opt controls the way in which the surface is displayed. For further\n" 17972 " details see the PLplot documentation. The only difference between\n" 17973 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n" 17974 " while plot3d only draws the surface as viewed from the top. \n" 17975 "\n" 17976 " Redacted form: plot3d(x, y, z, opt, side)\n" 17977 "\n" 17978 " This function is used in examples 11,21. \n" 17979 "\n" 17980 "\n" 17981 "\n" 17982 "SYNOPSIS:\n" 17983 "\n" 17984 "plot3d(x, y, z, nx, ny, opt, side)\n" 17985 "\n" 17986 "ARGUMENTS:\n" 17987 "\n" 17988 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 17989 " which the function is evaluated. \n" 17990 "\n" 17991 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 17992 " which the function is evaluated. \n" 17993 "\n" 17994 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 17995 " two-dimensional array with set of function values. \n" 17996 "\n" 17997 " nx (PLINT, input) : Number of x values at which function is\n" 17998 " evaluated. \n" 17999 "\n" 18000 " ny (PLINT, input) : Number of y values at which function is\n" 18001 " evaluated. \n" 18002 "\n" 18003 " opt (PLINT, input) : Determines the way in which the surface is\n" 18004 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n" 18005 " function of x for each value of y[j]. \n" 18006 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n" 18007 " for each value of x[i]. \n" 18008 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n" 18009 " at which function is defined. \n" 18010 "\n" 18011 "\n" 18012 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n" 18013 " should be draw on the figure. If side is true sides are drawn,\n" 18014 " otherwise no sides are drawn. \n" 18015 "\n" 18016 ""}, 18017 { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n" 18018 "Magnitude colored plot surface with contour \n" 18019 "\n" 18020 "DESCRIPTION:\n" 18021 "\n" 18022 " Aside from dropping the \n" 18023 " side functionality this is a more powerful form of plot3d: the surface\n" 18024 " mesh can be colored accordingly to the current z value being plotted,\n" 18025 " a contour plot can be drawn at the base XY plane, and a curtain can be\n" 18026 " drawn between the plotted function border and the base XY plane. The\n" 18027 " arguments are identical to those of plmeshc. The only difference\n" 18028 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n" 18029 " the surface, while plot3dc only draws the surface as viewed from the\n" 18030 " top. \n" 18031 "\n" 18032 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n" 18033 " Perl/PDL: Not available? \n" 18034 "\n" 18035 "\n" 18036 " This function is used in example 21. \n" 18037 "\n" 18038 "\n" 18039 "\n" 18040 "SYNOPSIS:\n" 18041 "\n" 18042 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n" 18043 "\n" 18044 "ARGUMENTS:\n" 18045 "\n" 18046 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 18047 " which the function is evaluated. \n" 18048 "\n" 18049 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 18050 " which the function is evaluated. \n" 18051 "\n" 18052 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 18053 " two-dimensional array with set of function values. \n" 18054 "\n" 18055 " nx (PLINT, input) : Number of x values at which function is\n" 18056 " evaluated. \n" 18057 "\n" 18058 " ny (PLINT, input) : Number of y values at which function is\n" 18059 " evaluated. \n" 18060 "\n" 18061 " opt (PLINT, input) : Determines the way in which the surface is\n" 18062 " represented. To specify more than one option just add the options,\n" 18063 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n" 18064 " showing z as a function of x for each value of y[j]. \n" 18065 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n" 18066 " for each value of x[i]. \n" 18067 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n" 18068 " at which function is defined. \n" 18069 " opt=MAG_COLOR: Each line in the mesh is colored according to\n" 18070 " the z value being plotted. The color is used from the current\n" 18071 " color map 1. \n" 18072 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n" 18073 " using parameters \n" 18074 " nlevel and \n" 18075 " clevel. \n" 18076 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n" 18077 " the borders of the plotted function. \n" 18078 "\n" 18079 "\n" 18080 " clevel (const PLFLT *, input) : Pointer to the array that defines\n" 18081 " the contour level spacing. \n" 18082 "\n" 18083 " nlevel (PLINT, input) : Number of elements in the clevel array. \n" 18084 "\n" 18085 ""}, 18086 { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n" 18087 "Magnitude colored plot surface with contour for z[x][y] with y index limits \n" 18088 "\n" 18089 "DESCRIPTION:\n" 18090 "\n" 18091 " When the implementation is completed this variant of plot3dc (see that\n" 18092 " function's documentation for more details) should be suitable for the\n" 18093 " case where the area of the x, y coordinate grid where z is defined can\n" 18094 " be non-rectangular. The implementation is incomplete so the last 4\n" 18095 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n" 18096 " indexymax; are currently ignored and the functionality is otherwise\n" 18097 " identical to that of plot3dc. \n" 18098 "\n" 18099 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n" 18100 " indexymin, indexymax)\n" 18101 " Perl/PDL: Not available? \n" 18102 "\n" 18103 "\n" 18104 " This function is not used in any example. \n" 18105 "\n" 18106 "\n" 18107 "\n" 18108 "SYNOPSIS:\n" 18109 "\n" 18110 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n" 18111 "\n" 18112 "ARGUMENTS:\n" 18113 "\n" 18114 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 18115 " which the function is evaluated. \n" 18116 "\n" 18117 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 18118 " which the function is evaluated. \n" 18119 "\n" 18120 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 18121 " two-dimensional array with set of function values. \n" 18122 "\n" 18123 " nx (PLINT, input) : Number of x values at which the function is\n" 18124 " evaluated. \n" 18125 "\n" 18126 " ny (PLINT, input) : Number of y values at which the function is\n" 18127 " evaluated. \n" 18128 "\n" 18129 " opt (PLINT, input) : Determines the way in which the surface is\n" 18130 " represented. To specify more than one option just add the options,\n" 18131 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n" 18132 " showing z as a function of x for each value of y[j]. \n" 18133 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n" 18134 " for each value of x[i]. \n" 18135 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n" 18136 " at which function is defined. \n" 18137 " opt=MAG_COLOR: Each line in the mesh is colored according to\n" 18138 " the z value being plotted. The color is used from the current\n" 18139 " color map 1. \n" 18140 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n" 18141 " using parameters \n" 18142 " nlevel and \n" 18143 " clevel. \n" 18144 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n" 18145 " the borders of the plotted function. \n" 18146 "\n" 18147 "\n" 18148 " clevel (const PLFLT *, input) : Pointer to the array that defines\n" 18149 " the contour level spacing. \n" 18150 "\n" 18151 " nlevel (PLINT, input) : Number of elements in the clevel array. \n" 18152 "\n" 18153 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n" 18154 " corresponds to the first x index where z is defined. \n" 18155 "\n" 18156 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n" 18157 " which corresponds (by convention) to one more than the last x\n" 18158 " index value where z is defined. \n" 18159 "\n" 18160 " indexymin (const PLINT *, input) : Array of y index values which\n" 18161 " all must be ≥ 0. These values are the first y index where z is\n" 18162 " defined for a particular x index in the range from indexxmin to\n" 18163 " indexxmax - 1. The dimension of indexymin is indexxmax. \n" 18164 "\n" 18165 " indexymax (const PLINT *, input) : Array of y index values which\n" 18166 " all must be ≤ ny. These values correspond (by convention) to one\n" 18167 " more than the last y index where z is defined for a particular x\n" 18168 " index in the range from indexxmin to indexxmax - 1. The dimension\n" 18169 " of indexymax is indexxmax. \n" 18170 "\n" 18171 ""}, 18172 { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n" 18173 "Plot shaded 3-d surface plot \n" 18174 "\n" 18175 "DESCRIPTION:\n" 18176 "\n" 18177 " Plots a three dimensional shaded surface plot within the environment\n" 18178 " set up by plw3d. The surface is defined by the two-dimensional array\n" 18179 " z[\n" 18180 " nx][\n" 18181 " ny], the point z[i][j] being the value of the function at (\n" 18182 " x[i], \n" 18183 " y[j]). Note that the points in arrays x and y do not need to be\n" 18184 " equally spaced, but must be stored in ascending order. For further\n" 18185 " details see the PLplot documentation. \n" 18186 "\n" 18187 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n" 18188 "\n" 18189 " This function is not used in any examples. \n" 18190 "\n" 18191 "\n" 18192 "\n" 18193 "SYNOPSIS:\n" 18194 "\n" 18195 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n" 18196 "\n" 18197 "ARGUMENTS:\n" 18198 "\n" 18199 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 18200 " which the function is evaluated. \n" 18201 "\n" 18202 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 18203 " which the function is evaluated. \n" 18204 "\n" 18205 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 18206 " two-dimensional array with set of function values. \n" 18207 "\n" 18208 " nx (PLINT, input) : Number of x values at which function is\n" 18209 " evaluated. \n" 18210 "\n" 18211 " ny (PLINT, input) : Number of y values at which function is\n" 18212 " evaluated. \n" 18213 "\n" 18214 " opt (PLINT, input) : Determines the way in which the surface is\n" 18215 " represented. To specify more than one option just add the options,\n" 18216 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n" 18217 " connecting points at which function is defined. \n" 18218 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n" 18219 " using parameters \n" 18220 " nlevel and \n" 18221 " clevel. \n" 18222 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n" 18223 " using parameters \n" 18224 " nlevel and \n" 18225 " clevel. \n" 18226 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n" 18227 " the borders of the plotted function. \n" 18228 " opt=MAG_COLOR: the surface is colored according to the value\n" 18229 " of Z; if MAG_COLOR is not used, then the default the surface\n" 18230 " is colored according to the intensity of the reflected light\n" 18231 " in the surface from a light source whose position is set using\n" 18232 " pllightsource. \n" 18233 "\n" 18234 "\n" 18235 " clevel (const PLFLT *, input) : Pointer to the array that defines\n" 18236 " the contour level spacing. \n" 18237 "\n" 18238 " nlevel (PLINT, input) : Number of elements in the clevel array. \n" 18239 "\n" 18240 ""}, 18241 { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n" 18242 "Plot shaded 3-d surface plot for z[x][y] with y index limits \n" 18243 "\n" 18244 "DESCRIPTION:\n" 18245 "\n" 18246 " This variant of plsurf3d (see that function's documentation for more\n" 18247 " details) should be suitable for the case where the area of the x, y\n" 18248 " coordinate grid where z is defined can be non-rectangular. The limits\n" 18249 " of that grid are provided by the parameters indexxmin, indexxmax,\n" 18250 " indexymin, and indexymax. \n" 18251 "\n" 18252 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n" 18253 " indexymax)\n" 18254 "\n" 18255 " This function is not used in any examples. \n" 18256 "\n" 18257 "\n" 18258 "\n" 18259 "SYNOPSIS:\n" 18260 "\n" 18261 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n" 18262 "\n" 18263 "ARGUMENTS:\n" 18264 "\n" 18265 " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n" 18266 " which the function is evaluated. \n" 18267 "\n" 18268 " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n" 18269 " which the function is evaluated. \n" 18270 "\n" 18271 " z (const PLFLT * const *, input) : Pointer to a vectored\n" 18272 " two-dimensional array with set of function values. \n" 18273 "\n" 18274 " nx (PLINT, input) : Number of x values at which function is\n" 18275 " evaluated. \n" 18276 "\n" 18277 " ny (PLINT, input) : Number of y values at which function is\n" 18278 " evaluated. \n" 18279 "\n" 18280 " opt (PLINT, input) : Determines the way in which the surface is\n" 18281 " represented. To specify more than one option just add the options,\n" 18282 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n" 18283 " connecting points at which function is defined. \n" 18284 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n" 18285 " using parameters \n" 18286 " nlevel and \n" 18287 " clevel. \n" 18288 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n" 18289 " using parameters \n" 18290 " nlevel and \n" 18291 " clevel. \n" 18292 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n" 18293 " the borders of the plotted function. \n" 18294 " opt=MAG_COLOR: the surface is colored according to the value\n" 18295 " of Z; if MAG_COLOR is not used, then the default the surface\n" 18296 " is colored according to the intensity of the reflected light\n" 18297 " in the surface from a light source whose position is set using\n" 18298 " pllightsource. \n" 18299 "\n" 18300 "\n" 18301 " clevel (const PLFLT *, input) : Pointer to the array that defines\n" 18302 " the contour level spacing. \n" 18303 "\n" 18304 " nlevel (PLINT, input) : Number of elements in the clevel array. \n" 18305 "\n" 18306 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n" 18307 " corresponds to the first x index where z is defined. \n" 18308 "\n" 18309 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n" 18310 " which corresponds (by convention) to one more than the last x\n" 18311 " index value where z is defined. \n" 18312 "\n" 18313 " indexymin (const PLINT *, input) : Array of y index values which\n" 18314 " all must be ≥ 0. These values are the first y index where z is\n" 18315 " defined for a particular x index in the range from indexxmin to\n" 18316 " indexxmax - 1. The dimension of indexymin is indexxmax. \n" 18317 "\n" 18318 " indexymax (const PLINT *, input) : Array of y index values which\n" 18319 " all must be ≤ ny. These values correspond (by convention) to one\n" 18320 " more than the last y index where z is defined for a particular x\n" 18321 " index in the range from indexxmin to indexxmax - 1. The dimension\n" 18322 " of indexymax is indexxmax. \n" 18323 "\n" 18324 ""}, 18325 { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n" 18326 "Parse command-line arguments \n" 18327 "\n" 18328 "DESCRIPTION:\n" 18329 "\n" 18330 " Parse command-line arguments. \n" 18331 "\n" 18332 " plparseopts removes all recognized flags (decreasing argc\n" 18333 " accordingly), so that invalid input may be readily detected. It can\n" 18334 " also be used to process user command line flags. The user can merge\n" 18335 " an option table of type PLOptionTable into the internal option table\n" 18336 " info structure using plMergeOpts. Or, the user can specify that ONLY\n" 18337 " the external table(s) be parsed by calling plClearOpts before\n" 18338 " plMergeOpts. \n" 18339 "\n" 18340 " The default action taken by plparseopts is as follows: \n" 18341 " Returns with an error if an unrecognized option or badly formed\n" 18342 " option-value pair are encountered. \n" 18343 " Returns immediately (return code 0) when the first non-option command\n" 18344 " line argument is found. \n" 18345 " Returns with the return code of the option handler, if one was called.\n" 18346 " \n" 18347 " Deletes command line arguments from argv list as they are found, and\n" 18348 " decrements argc accordingly. \n" 18349 " Does not show \"invisible\" options in usage or help messages. \n" 18350 " Assumes the program name is contained in argv[0]. \n" 18351 "\n" 18352 " These behaviors may be controlled through the \n" 18353 " mode argument. \n" 18354 "\n" 18355 " Redacted form: General: plparseopts(argv, mode)\n" 18356 " Perl/PDL: Not available? \n" 18357 "\n" 18358 "\n" 18359 " This function is used in all of the examples. \n" 18360 "\n" 18361 "\n" 18362 "\n" 18363 "SYNOPSIS:\n" 18364 "\n" 18365 "int plparseopts(p_argc, argv, mode)\n" 18366 "\n" 18367 "ARGUMENTS:\n" 18368 "\n" 18369 " p_argc (int *, input) : pointer to number of arguments. \n" 18370 "\n" 18371 " argv (const char **, input) : Pointer to character array containing\n" 18372 " *p_argc command-line arguments. \n" 18373 "\n" 18374 " mode (PLINT, input) : Parsing mode with the following\n" 18375 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n" 18376 " and all error messages enabled, including program exit when an\n" 18377 " error occurs. Anything on the command line that isn't recognized\n" 18378 " as a valid option or option argument is flagged as an error. \n" 18379 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n" 18380 " of errors. \n" 18381 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n" 18382 " arguments. \n" 18383 " PL_PARSE_SHOWALL (8) -- Show invisible options \n" 18384 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n" 18385 " pointer to the program name. \n" 18386 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n" 18387 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n" 18388 " unrecognized arguments. \n" 18389 "\n" 18390 ""}, 18391 { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n" 18392 "Set area fill pattern \n" 18393 "\n" 18394 "DESCRIPTION:\n" 18395 "\n" 18396 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n" 18397 " parallel lines with specified inclinations and spacings. The\n" 18398 " arguments to this routine are the number of sets to use (1 or 2)\n" 18399 " followed by two pointers to integer arrays (of 1 or 2 elements)\n" 18400 " specifying the inclinations in tenths of a degree and the spacing in\n" 18401 " micrometers. (also see plpsty) \n" 18402 "\n" 18403 " Redacted form: General: plpat(inc, del)\n" 18404 " Perl/PDL: plpat(nlin, inc, del)\n" 18405 "\n" 18406 "\n" 18407 " This function is used in example 15. \n" 18408 "\n" 18409 "\n" 18410 "\n" 18411 "SYNOPSIS:\n" 18412 "\n" 18413 "plpat(nlin, inc, del)\n" 18414 "\n" 18415 "ARGUMENTS:\n" 18416 "\n" 18417 " nlin (PLINT, input) : Number of sets of lines making up the\n" 18418 " pattern, either 1 or 2. \n" 18419 "\n" 18420 " inc (const PLINT *, input) : Pointer to array with nlin elements.\n" 18421 " Specifies the line inclination in tenths of a degree. (Should be\n" 18422 " between -900 and 900). \n" 18423 "\n" 18424 " del (const PLINT *, input) : Pointer to array with nlin elements.\n" 18425 " Specifies the spacing in micrometers between the lines making up\n" 18426 " the pattern. \n" 18427 "\n" 18428 ""}, 18429 { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n" 18430 "Draw a line between two points, accounting for coordinate transforms \n" 18431 "\n" 18432 "DESCRIPTION:\n" 18433 "\n" 18434 " Joins the point (\n" 18435 " x1, \n" 18436 " y1) to (\n" 18437 " x2, \n" 18438 " y2). If a global coordinate transform is defined then the line is\n" 18439 " broken in to n segments to approximate the path. If no transform is\n" 18440 " defined then this simply acts like a call to pljoin. \n" 18441 "\n" 18442 " Redacted form: plpath(n,x1,y1,x2,y2)\n" 18443 "\n" 18444 " This function is used in example 22. \n" 18445 "\n" 18446 "\n" 18447 "\n" 18448 "SYNOPSIS:\n" 18449 "\n" 18450 "plpath(n, x1, y1, x2, y2)\n" 18451 "\n" 18452 "ARGUMENTS:\n" 18453 "\n" 18454 " n (PLINT, input) : number of points to use to approximate the path. \n" 18455 "\n" 18456 " x1 (PLFLT, input) : x coordinate of first point. \n" 18457 "\n" 18458 " y1 (PLFLT, input) : y coordinate of first point. \n" 18459 "\n" 18460 " x2 (PLFLT, input) : x coordinate of second point. \n" 18461 "\n" 18462 " y2 (PLFLT, input) : y coordinate of second point. \n" 18463 "\n" 18464 ""}, 18465 { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n" 18466 "Plot a glyph at the specified points \n" 18467 "\n" 18468 "DESCRIPTION:\n" 18469 "\n" 18470 " Plot a glyph at the specified points. (This function is largely\n" 18471 " superseded by plstring which gives access to many[!] more glyphs.)\n" 18472 " code=-1 means try to just draw a point. Right now it's just a move\n" 18473 " and a draw at the same place. Not ideal, since a sufficiently\n" 18474 " intelligent output device may optimize it away, or there may be faster\n" 18475 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n" 18476 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n" 18477 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n" 18478 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n" 18479 " code <= 127 the corresponding printable ASCII character is plotted. \n" 18480 "\n" 18481 " Redacted form: plpoin(x, y, code)\n" 18482 "\n" 18483 " This function is used in examples 1,6,14,29. \n" 18484 "\n" 18485 "\n" 18486 "\n" 18487 "SYNOPSIS:\n" 18488 "\n" 18489 "plpoin(n, x, y, code)\n" 18490 "\n" 18491 "ARGUMENTS:\n" 18492 "\n" 18493 " n (PLINT, input) : Number of points in the x and y arrays. \n" 18494 "\n" 18495 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n" 18496 " of points. \n" 18497 "\n" 18498 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n" 18499 " of points. \n" 18500 "\n" 18501 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n" 18502 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n" 18503 " each of the n points. \n" 18504 "\n" 18505 ""}, 18506 { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n" 18507 "Plot a glyph at the specified 3D points \n" 18508 "\n" 18509 "DESCRIPTION:\n" 18510 "\n" 18511 " Plot a glyph at the specified 3D points. (This function is largely\n" 18512 " superseded by plstring3 which gives access to many[!] more glyphs.)\n" 18513 " Set up the call to this function similar to what is done for plline3.\n" 18514 " code=-1 means try to just draw a point. Right now it's just a move\n" 18515 " and a draw at the same place. Not ideal, since a sufficiently\n" 18516 " intelligent output device may optimize it away, or there may be faster\n" 18517 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n" 18518 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n" 18519 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n" 18520 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n" 18521 " code <= 127 the corresponding printable ASCII character is plotted. \n" 18522 "\n" 18523 " Redacted form: plpoin3(x, y, z, code)\n" 18524 "\n" 18525 " This function is not used in any example. \n" 18526 "\n" 18527 "\n" 18528 "\n" 18529 "SYNOPSIS:\n" 18530 "\n" 18531 "plpoin3(n, x, y, z, code)\n" 18532 "\n" 18533 "ARGUMENTS:\n" 18534 "\n" 18535 " n (PLINT, input) : Number of points in the x and y arrays. \n" 18536 "\n" 18537 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n" 18538 " of points. \n" 18539 "\n" 18540 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n" 18541 " of points. \n" 18542 "\n" 18543 " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n" 18544 " of points. \n" 18545 "\n" 18546 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n" 18547 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n" 18548 " each of the n points. \n" 18549 "\n" 18550 ""}, 18551 { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n" 18552 "Draw a polygon in 3 space \n" 18553 "\n" 18554 "DESCRIPTION:\n" 18555 "\n" 18556 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n" 18557 " like plline3, but differs from that function in that plpoly3 attempts\n" 18558 " to determine if the polygon is viewable depending on the order of the\n" 18559 " points within the arrays and the value of ifcc. If the back of\n" 18560 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n" 18561 " you want, then use plline3 instead. \n" 18562 "\n" 18563 " The points are assumed to be in a plane, and the directionality of the\n" 18564 " plane is determined from the first three points. Additional points do\n" 18565 " not have to lie on the plane defined by the first three, but if they\n" 18566 " do not, then the determination of visibility obviously can't be 100%\n" 18567 " accurate... So if you're 3 space polygons are too far from planar,\n" 18568 " consider breaking them into smaller polygons. 3 points define a plane\n" 18569 " :-). \n" 18570 "\n" 18571 " Bugs: If one of the first two segments is of zero length, or if they\n" 18572 " are co-linear, the calculation of visibility has a 50/50 chance of\n" 18573 " being correct. Avoid such situations :-). See x18c.c for an example\n" 18574 " of this problem. (Search for 20.1). \n" 18575 "\n" 18576 " Redacted form: plpoly3(x, y, z, code)\n" 18577 "\n" 18578 " This function is used in example 18. \n" 18579 "\n" 18580 "\n" 18581 "\n" 18582 "SYNOPSIS:\n" 18583 "\n" 18584 "plpoly3(n, x, y, z, draw, ifcc)\n" 18585 "\n" 18586 "ARGUMENTS:\n" 18587 "\n" 18588 " n (PLINT, input) : Number of points defining line. \n" 18589 "\n" 18590 " x (const PLFLT *, input) : Pointer to array with x coordinates of\n" 18591 " points. \n" 18592 "\n" 18593 " y (const PLFLT *, input) : Pointer to array with y coordinates of\n" 18594 " points. \n" 18595 "\n" 18596 " z (const PLFLT *, input) : Pointer to array with z coordinates of\n" 18597 " points. \n" 18598 "\n" 18599 " draw (const PLBOOL *, input) : Pointer to array which controls\n" 18600 " drawing the segments of the polygon. If draw[i] is true, then the\n" 18601 " polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n" 18602 "\n" 18603 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n" 18604 " polygon is determined by assuming the points are laid out in a\n" 18605 " counter-clockwise order. Otherwise, the directionality of the\n" 18606 " polygon is determined by assuming the points are laid out in a\n" 18607 " clockwise order. \n" 18608 "\n" 18609 ""}, 18610 { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n" 18611 "Set precision in numeric labels \n" 18612 "\n" 18613 "DESCRIPTION:\n" 18614 "\n" 18615 " Sets the number of places after the decimal point in numeric labels. \n" 18616 "\n" 18617 " Redacted form: plprec(setp, prec)\n" 18618 "\n" 18619 " This function is used in example 29. \n" 18620 "\n" 18621 "\n" 18622 "\n" 18623 "SYNOPSIS:\n" 18624 "\n" 18625 "plprec(setp, prec)\n" 18626 "\n" 18627 "ARGUMENTS:\n" 18628 "\n" 18629 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n" 18630 " automatically determines the number of places to use after the\n" 18631 " decimal point in numeric labels (like those used to label axes). \n" 18632 " If setp is 1 then prec sets the number of places. \n" 18633 "\n" 18634 " prec (PLINT, input) : The number of characters to draw after the\n" 18635 " decimal point in numeric labels. \n" 18636 "\n" 18637 ""}, 18638 { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n" 18639 "Select area fill pattern \n" 18640 "\n" 18641 "DESCRIPTION:\n" 18642 "\n" 18643 " Select one of eight predefined area fill patterns to use (also see\n" 18644 " plpat). Setting the fill style to 0 gives a solid fill. \n" 18645 "\n" 18646 " Redacted form: plpsty(patt)\n" 18647 "\n" 18648 " This function is used in examples 12,13,15,16,25. \n" 18649 "\n" 18650 "\n" 18651 "\n" 18652 "SYNOPSIS:\n" 18653 "\n" 18654 "plpsty(patt)\n" 18655 "\n" 18656 "ARGUMENTS:\n" 18657 "\n" 18658 " patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n" 18659 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n" 18660 " consists of lines at 45 degrees angle (upward), and so on. \n" 18661 "\n" 18662 ""}, 18663 { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n" 18664 "Write text inside the viewport \n" 18665 "\n" 18666 "DESCRIPTION:\n" 18667 "\n" 18668 " Writes text at a specified position and inclination within the\n" 18669 " viewport. Text is clipped at the viewport boundaries. The reference\n" 18670 " point of a string lies along a line passing through the string at half\n" 18671 " the height of a capital letter. The position of the reference point\n" 18672 " along this line is determined by just, the reference point is placed\n" 18673 " at world coordinates (\n" 18674 " x, \n" 18675 " y) within the viewport. The inclination of the string is specified in\n" 18676 " terms of differences of world coordinates making it easy to write text\n" 18677 " parallel to a line in a graph. \n" 18678 "\n" 18679 " Redacted form: plptex(x, y, dx, dy, just, text)\n" 18680 "\n" 18681 " This function is used in example 2-4,10,12-14,20,23,24,26. \n" 18682 "\n" 18683 "\n" 18684 "\n" 18685 "SYNOPSIS:\n" 18686 "\n" 18687 "plptex(x, y, dx, dy, just, text)\n" 18688 "\n" 18689 "ARGUMENTS:\n" 18690 "\n" 18691 " x (PLFLT, input) : x coordinate of reference point of string. \n" 18692 "\n" 18693 " y (PLFLT, input) : y coordinate of reference point of string. \n" 18694 "\n" 18695 " dx (PLFLT, input) : Together with dy, this specifies the\n" 18696 " inclination of the string. The baseline of the string is parallel\n" 18697 " to a line joining (\n" 18698 " x, \n" 18699 " y) to (\n" 18700 " x+\n" 18701 " dx, \n" 18702 " y+\n" 18703 " dy). \n" 18704 "\n" 18705 " dy (PLFLT, input) : Together with dx, this specifies the\n" 18706 " inclination of the string. \n" 18707 "\n" 18708 " just (PLFLT, input) : Specifies the position of the string relative\n" 18709 " to its reference point. If just=0., the reference point is at the\n" 18710 " left and if just=1., it is at the right of the string. Other\n" 18711 " values of just give intermediate justifications. \n" 18712 "\n" 18713 " text (const char *, input) : The string to be written out. \n" 18714 "\n" 18715 ""}, 18716 { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n" 18717 "Write text inside the viewport of a 3D plot \n" 18718 "\n" 18719 "DESCRIPTION:\n" 18720 "\n" 18721 " Writes text at a specified position and inclination and with a\n" 18722 " specified shear within the viewport. Text is clipped at the viewport\n" 18723 " boundaries. The reference point of a string lies along a line passing\n" 18724 " through the string at half the height of a capital letter. The\n" 18725 " position of the reference point along this line is determined by just,\n" 18726 " and the reference point is placed at world coordinates (\n" 18727 " wx, \n" 18728 " wy, \n" 18729 " wz) within the viewport. The inclination and shear of the string is\n" 18730 " specified in terms of differences of world coordinates making it easy\n" 18731 " to write text parallel to a line in a graph. \n" 18732 "\n" 18733 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n" 18734 "\n" 18735 " This function is used in example 28. \n" 18736 "\n" 18737 "\n" 18738 "\n" 18739 "SYNOPSIS:\n" 18740 "\n" 18741 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n" 18742 "\n" 18743 "ARGUMENTS:\n" 18744 "\n" 18745 " wx (PLFLT, input) : x world coordinate of reference point of\n" 18746 " string. \n" 18747 "\n" 18748 " wy (PLFLT, input) : y world coordinate of reference point of\n" 18749 " string. \n" 18750 "\n" 18751 " wz (PLFLT, input) : z world coordinate of reference point of\n" 18752 " string. \n" 18753 "\n" 18754 " dx (PLFLT, input) : Together with dy and \n" 18755 " dz, this specifies the inclination of the string. The baseline of\n" 18756 " the string is parallel to a line joining (\n" 18757 " x, \n" 18758 " y, \n" 18759 " z) to (\n" 18760 " x+\n" 18761 " dx, \n" 18762 " y+\n" 18763 " dy, \n" 18764 " z+\n" 18765 " dz). \n" 18766 "\n" 18767 " dy (PLFLT, input) : Together with dx and \n" 18768 " dz, this specifies the inclination of the string. \n" 18769 "\n" 18770 " dz (PLFLT, input) : Together with dx and \n" 18771 " dy, this specifies the inclination of the string. \n" 18772 "\n" 18773 " sx (PLFLT, input) : Together with sy and \n" 18774 " sz, this specifies the shear of the string. The string is sheared so\n" 18775 " that the characters are vertically parallel to a line joining (\n" 18776 " x, \n" 18777 " y, \n" 18778 " z) to (\n" 18779 " x+\n" 18780 " sx, \n" 18781 " y+\n" 18782 " sy, \n" 18783 " z+\n" 18784 " sz). If sx = \n" 18785 " sy = \n" 18786 " sz = 0.) then the text is not sheared. \n" 18787 "\n" 18788 " sy (PLFLT, input) : Together with sx and \n" 18789 " sz, this specifies shear of the string. \n" 18790 "\n" 18791 " sz (PLFLT, input) : Together with sx and \n" 18792 " sy, this specifies shear of the string. \n" 18793 "\n" 18794 " just (PLFLT, input) : Specifies the position of the string relative\n" 18795 " to its reference point. If just=0., the reference point is at the\n" 18796 " left and if just=1., it is at the right of the string. Other\n" 18797 " values of just give intermediate justifications. \n" 18798 "\n" 18799 " text (const char *, input) : The string to be written out. \n" 18800 "\n" 18801 ""}, 18802 { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n" 18803 "Random number generator returning a real random number in the range [0,1] \n" 18804 "\n" 18805 "DESCRIPTION:\n" 18806 "\n" 18807 " Random number generator returning a real random number in the range\n" 18808 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n" 18809 " / compilers provide their own random number generator, and so this is\n" 18810 " provided purely for convenience and to give a consistent random number\n" 18811 " generator across all languages supported by PLplot. This is\n" 18812 " particularly useful for comparing results from the test suite of\n" 18813 " examples. \n" 18814 "\n" 18815 " Redacted form: plrandd()\n" 18816 "\n" 18817 " This function is used in examples 17,21. \n" 18818 "\n" 18819 "\n" 18820 "\n" 18821 "SYNOPSIS:\n" 18822 "\n" 18823 "plrandd()\n" 18824 "\n" 18825 ""}, 18826 { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n" 18827 "Replays contents of plot buffer to current device/file \n" 18828 "\n" 18829 "DESCRIPTION:\n" 18830 "\n" 18831 " Replays contents of plot buffer to current device/file. \n" 18832 "\n" 18833 " Redacted form: plreplot()\n" 18834 "\n" 18835 " This function is used in example 1,20. \n" 18836 "\n" 18837 "\n" 18838 "\n" 18839 "SYNOPSIS:\n" 18840 "\n" 18841 "plreplot()\n" 18842 "\n" 18843 ""}, 18844 { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n" 18845 "Convert RGB color to HLS \n" 18846 "\n" 18847 "DESCRIPTION:\n" 18848 "\n" 18849 " Convert RGB color coordinates to HLS \n" 18850 "\n" 18851 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n" 18852 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n" 18853 "\n" 18854 "\n" 18855 " This function is used in example 2. \n" 18856 "\n" 18857 "\n" 18858 "\n" 18859 "SYNOPSIS:\n" 18860 "\n" 18861 "plrgbhls(r, g, b, p_h, p_l, p_s)\n" 18862 "\n" 18863 "ARGUMENTS:\n" 18864 "\n" 18865 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n" 18866 "\n" 18867 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n" 18868 "\n" 18869 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n" 18870 "\n" 18871 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n" 18872 " cone (0.0-360.0) \n" 18873 "\n" 18874 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n" 18875 " fraction of the axis of the colour cone (0.0-1.0) \n" 18876 "\n" 18877 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n" 18878 " fraction of the radius of the colour cone (0.0-1.0) \n" 18879 "\n" 18880 ""}, 18881 { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n" 18882 "Set character size \n" 18883 "\n" 18884 "DESCRIPTION:\n" 18885 "\n" 18886 " This sets up the size of all subsequent characters drawn. The actual\n" 18887 " height of a character is the product of the default character size and\n" 18888 " a scaling factor. \n" 18889 "\n" 18890 " Redacted form: plschr(def, scale)\n" 18891 "\n" 18892 " This function is used in example 2,13,23,24. \n" 18893 "\n" 18894 "\n" 18895 "\n" 18896 "SYNOPSIS:\n" 18897 "\n" 18898 "plschr(def, scale)\n" 18899 "\n" 18900 "ARGUMENTS:\n" 18901 "\n" 18902 " def (PLFLT, input) : The default height of a character in\n" 18903 " millimeters, should be set to zero if the default height is to\n" 18904 " remain unchanged. \n" 18905 "\n" 18906 " scale (PLFLT, input) : Scale factor to be applied to default to get\n" 18907 " actual character height. \n" 18908 "\n" 18909 ""}, 18910 { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n" 18911 "Set cmap0 colors by 8-bit RGB values \n" 18912 "\n" 18913 "DESCRIPTION:\n" 18914 "\n" 18915 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n" 18916 " documentation). This sets the entire color map -- only as many colors\n" 18917 " as specified will be allocated. \n" 18918 "\n" 18919 " Redacted form: plscmap0(r, g, b)\n" 18920 "\n" 18921 " This function is used in examples 2,24. \n" 18922 "\n" 18923 "\n" 18924 "\n" 18925 "SYNOPSIS:\n" 18926 "\n" 18927 "plscmap0(r, g, b, ncol0)\n" 18928 "\n" 18929 "ARGUMENTS:\n" 18930 "\n" 18931 " r (const PLINT *, input) : Pointer to array with set of unsigned\n" 18932 " 8-bit integers (0-255) representing the degree of red in the\n" 18933 " color. \n" 18934 "\n" 18935 " g (const PLINT *, input) : Pointer to array with set of unsigned\n" 18936 " 8-bit integers (0-255) representing the degree of green in the\n" 18937 " color. \n" 18938 "\n" 18939 " b (const PLINT *, input) : Pointer to array with set of unsigned\n" 18940 " 8-bit integers (0-255) representing the degree of blue in the\n" 18941 " color. \n" 18942 "\n" 18943 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n" 18944 "\n" 18945 ""}, 18946 { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n" 18947 "Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n" 18948 "\n" 18949 "DESCRIPTION:\n" 18950 "\n" 18951 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n" 18952 " and floating point alpha transparency value. This sets the entire\n" 18953 " color map -- only as many colors as specified will be allocated. \n" 18954 "\n" 18955 " Redacted form: plscmap0a(r, g, b, alpha)\n" 18956 "\n" 18957 " This function is used in examples 30. \n" 18958 "\n" 18959 "\n" 18960 "\n" 18961 "SYNOPSIS:\n" 18962 "\n" 18963 "plscmap0a(r, g, b, alpha, ncol0)\n" 18964 "\n" 18965 "ARGUMENTS:\n" 18966 "\n" 18967 " r (const PLINT *, input) : Pointer to array with set of unsigned\n" 18968 " 8-bit integers (0-255) representing the degree of red in the\n" 18969 " color. \n" 18970 "\n" 18971 " g (const PLINT *, input) : Pointer to array with set of unsigned\n" 18972 " 8-bit integers (0-255) representing the degree of green in the\n" 18973 " color. \n" 18974 "\n" 18975 " b (const PLINT *, input) : Pointer to array with set of unsigned\n" 18976 " 8-bit integers (0-255) representing the degree of blue in the\n" 18977 " color. \n" 18978 "\n" 18979 " alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n" 18980 " values (0.0 - 1.0) representing the alpha transparency of the\n" 18981 " color. \n" 18982 "\n" 18983 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n" 18984 " arrays. \n" 18985 "\n" 18986 ""}, 18987 { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n" 18988 "Set number of colors in cmap0 \n" 18989 "\n" 18990 "DESCRIPTION:\n" 18991 "\n" 18992 " Set number of colors in color map0 (see the PLplot documentation).\n" 18993 " Allocate (or reallocate) color map0, and fill with default values for\n" 18994 " those colors not previously allocated. The first 16 default colors are\n" 18995 " given in the plcol0 documentation. For larger indices the default\n" 18996 " color is red. \n" 18997 "\n" 18998 " The drivers are not guaranteed to support more than 16 colors. \n" 18999 "\n" 19000 " Redacted form: plscmap0n(ncol0)\n" 19001 "\n" 19002 " This function is used in examples 15,16,24. \n" 19003 "\n" 19004 "\n" 19005 "\n" 19006 "SYNOPSIS:\n" 19007 "\n" 19008 "plscmap0n(ncol0)\n" 19009 "\n" 19010 "ARGUMENTS:\n" 19011 "\n" 19012 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n" 19013 " the map0 palette. If this number is zero or less, then the value\n" 19014 " from the previous call to plscmap0n is used and if there is no\n" 19015 " previous call, then a default value is used. \n" 19016 "\n" 19017 ""}, 19018 { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n" 19019 "Set cmap1 colors using 8-bit RGB values \n" 19020 "\n" 19021 "DESCRIPTION:\n" 19022 "\n" 19023 " Set cmap1 colors using 8-bit RGB values (see the PLplot\n" 19024 " documentation). This also sets the number of colors. \n" 19025 "\n" 19026 " Redacted form: plscmap1(r, g, b)\n" 19027 "\n" 19028 " This function is used in example 31. \n" 19029 "\n" 19030 "\n" 19031 "\n" 19032 "SYNOPSIS:\n" 19033 "\n" 19034 "plscmap1(r, g, b, ncol1)\n" 19035 "\n" 19036 "ARGUMENTS:\n" 19037 "\n" 19038 " r (const PLINT *, input) : Pointer to array with set of unsigned\n" 19039 " 8-bit integers (0-255) representing the degree of red in the\n" 19040 " color. \n" 19041 "\n" 19042 " g (const PLINT *, input) : Pointer to array with set of unsigned\n" 19043 " 8-bit integers (0-255) representing the degree of green in the\n" 19044 " color. \n" 19045 "\n" 19046 " b (const PLINT *, input) : Pointer to array with set of unsigned\n" 19047 " 8-bit integers (0-255) representing the degree of blue in the\n" 19048 " color. \n" 19049 "\n" 19050 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n" 19051 "\n" 19052 ""}, 19053 { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n" 19054 "Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n" 19055 "\n" 19056 "DESCRIPTION:\n" 19057 "\n" 19058 " Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n" 19059 " and double alpha transparency values. This also sets the number of\n" 19060 " colors.\n" 19061 "\n" 19062 " Redacted form: plscmap1a(r, g, b, alpha)\n" 19063 "\n" 19064 " This function is used in example 31. \n" 19065 "\n" 19066 "\n" 19067 "\n" 19068 "SYNOPSIS:\n" 19069 "\n" 19070 "plscmap1a(r, g, b, alpha, ncol1)\n" 19071 "\n" 19072 "ARGUMENTS:\n" 19073 "\n" 19074 " r (const PLINT *, input) : Pointer to array with set of unsigned\n" 19075 " 8-bit integers (0-255) representing the degree of red in the\n" 19076 " color. \n" 19077 "\n" 19078 " g (const PLINT *, input) : Pointer to array with set of unsigned\n" 19079 " 8-bit integers (0-255) representing the degree of green in the\n" 19080 " color. \n" 19081 "\n" 19082 " b (const PLINT *, input) : Pointer to array with set of unsigned\n" 19083 " 8-bit integers (0-255) representing the degree of blue in the\n" 19084 " color. \n" 19085 "\n" 19086 " alpha (const PLFLT *, input) : Pointer to array with set of double\n" 19087 " values (0.0-1.0) representing the alpha transparency value of the\n" 19088 " color. \n" 19089 "\n" 19090 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n" 19091 " arrays. \n" 19092 "\n" 19093 ""}, 19094 { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n" 19095 "Set cmap1 colors using a piece-wise linear relationship \n" 19096 "\n" 19097 "DESCRIPTION:\n" 19098 "\n" 19099 " Set cmap1 colors using a piece-wise linear relationship between\n" 19100 " intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n" 19101 " color space (see the PLplot documentation). May be called at any\n" 19102 " time. \n" 19103 "\n" 19104 " The idea here is to specify a number of control points that define the\n" 19105 " mapping between input cmap1 intensity indices and HLS (or RGB). \n" 19106 " Between these points, linear interpolation is used which gives a\n" 19107 " smooth variation of color with intensity index. Any number of control\n" 19108 " points may be specified, located at arbitrary positions, although\n" 19109 " typically 2 - 4 are enough. Another way of stating this is that we are\n" 19110 " traversing a given number of lines through HLS (or RGB) space as we\n" 19111 " move through cmap1 intensity indices. The control points at the\n" 19112 " minimum and maximum position (0 and 1) must always be specified. By\n" 19113 " adding more control points you can get more variation. One good\n" 19114 " technique for plotting functions that vary about some expected average\n" 19115 " is to use an additional 2 control points in the center (position ~=\n" 19116 " 0.5) that are the same lightness as the background (typically white\n" 19117 " for paper output, black for crt), and same hue as the boundary control\n" 19118 " points. This allows the highs and lows to be very easily\n" 19119 " distinguished. \n" 19120 "\n" 19121 " Each control point must specify the cmap1 intensity index and the\n" 19122 " associated three coordinates in HLS or RGB space. The first point\n" 19123 " must correspond to position = 0, and the last to position = 1. \n" 19124 "\n" 19125 " The default behaviour is for the hue to be linearly interpolated \n" 19126 " between the control points. Since the hue lies in the range [0, 360]\n" 19127 " this corresponds to interpolation around the \"front\" of the color\n" 19128 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n" 19129 " alternative interpolation is used between control points i and i+1. If\n" 19130 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n" 19131 " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n" 19132 " consider this as interpolation around the \"back\" or \"reverse\" of the\n" 19133 " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n" 19134 " alt_hue_path[] = false for every control point. \n" 19135 "\n" 19136 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n" 19137 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n" 19138 " 240]truegreen-yellow-red-magenta-blue[240\n" 19139 " 120]trueblue-magenta-red-yellow-green\n" 19140 "\n" 19141 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n" 19142 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n" 19143 " 1]magnitudeHLSsaturation[0, 1]magnitude\n" 19144 "\n" 19145 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n" 19146 " alt_hue_path)\n" 19147 "\n" 19148 " This function is used in examples 8,11,12,15,20,21. \n" 19149 "\n" 19150 "\n" 19151 "\n" 19152 "SYNOPSIS:\n" 19153 "\n" 19154 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n" 19155 "\n" 19156 "ARGUMENTS:\n" 19157 "\n" 19158 " itype (PLBOOL, input) : true: RGB, false: HLS. \n" 19159 "\n" 19160 " npts (PLINT, input) : number of control points \n" 19161 "\n" 19162 " intensity (const PLFLT *, input) : intensity index for each control\n" 19163 " point (between 0.0 and 1.0, in ascending order) \n" 19164 "\n" 19165 " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n" 19166 " control point \n" 19167 "\n" 19168 " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n" 19169 " control point \n" 19170 "\n" 19171 " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n" 19172 " control point \n" 19173 "\n" 19174 " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n" 19175 " method flag for each control point. (alt_hue_path[i] refers to\n" 19176 " the interpolation interval between the i and i + 1 control\n" 19177 " points). \n" 19178 "\n" 19179 ""}, 19180 { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n" 19181 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n" 19182 "\n" 19183 "DESCRIPTION:\n" 19184 "\n" 19185 " This is a variant of plscmap1l that supports alpha channel\n" 19186 " transparency. It sets cmap1 colors using a piece-wise linear\n" 19187 " relationship between cmap1 intensity index (from 0. to 1.) and\n" 19188 " position in HLS or RGB color space (see the PLplot documentation) with\n" 19189 " alpha transparency value (0.0 - 1.0). It may be called at any time. \n" 19190 "\n" 19191 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n" 19192 " alpha, alt_hue_path)\n" 19193 "\n" 19194 " This function is used in example 30. \n" 19195 "\n" 19196 "\n" 19197 "\n" 19198 "SYNOPSIS:\n" 19199 "\n" 19200 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n" 19201 "\n" 19202 "ARGUMENTS:\n" 19203 "\n" 19204 " itype (PLBOOL, input) : true: RGB, false: HLS. \n" 19205 "\n" 19206 " npts (PLINT, input) : number of control points \n" 19207 "\n" 19208 " intensity (const PLFLT *, input) : position for each control point\n" 19209 " (between 0.0 and 1.0, in ascending order) \n" 19210 "\n" 19211 " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n" 19212 " control point \n" 19213 "\n" 19214 " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n" 19215 " control point \n" 19216 "\n" 19217 " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n" 19218 " control point \n" 19219 "\n" 19220 " alpha (const PLFLT *, input) : the alpha transparency value for\n" 19221 " each control point \n" 19222 "\n" 19223 " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n" 19224 " method flag for each control point. (alt_hue_path[i] refers to\n" 19225 " the interpolation interval between the i and i + 1 control\n" 19226 " points). \n" 19227 "\n" 19228 ""}, 19229 { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n" 19230 "Set number of colors in cmap1 \n" 19231 "\n" 19232 "DESCRIPTION:\n" 19233 "\n" 19234 " Set number of colors in cmap1, (re-)allocate color map1, and set\n" 19235 " default values if this is the first allocation (see the PLplot\n" 19236 " documentation). \n" 19237 "\n" 19238 " Redacted form: plscmap1n(ncol1)\n" 19239 "\n" 19240 " This function is used in examples 8,11,20,21. \n" 19241 "\n" 19242 "\n" 19243 "\n" 19244 "SYNOPSIS:\n" 19245 "\n" 19246 "plscmap1n(ncol1)\n" 19247 "\n" 19248 "ARGUMENTS:\n" 19249 "\n" 19250 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n" 19251 " the map1 palette. If this number is zero or less, then the value\n" 19252 " from the previous call to plscmap1n is used and if there is no\n" 19253 " previous call, then a default value is used. \n" 19254 "\n" 19255 ""}, 19256 { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n" 19257 "Set the cmap1 argument range for continuous color plots \n" 19258 "\n" 19259 "DESCRIPTION:\n" 19260 "\n" 19261 " Set the cmap1 argument range for continuous color plots. If \n" 19262 " min_color is greater than \n" 19263 " max_color or \n" 19264 " max_color is greater than 1.0 or \n" 19265 " min_color is less than 0.0 then no change is made. (Use\n" 19266 " plgcmap1_range to get the cmap1 argument range.) \n" 19267 "\n" 19268 " Redacted form: plscmap1_range(min_color, max_color)\n" 19269 "\n" 19270 " This function is currently used in example 33. \n" 19271 "\n" 19272 "\n" 19273 "\n" 19274 "SYNOPSIS:\n" 19275 "\n" 19276 "plscmap1_range(min_color, max_color)\n" 19277 "\n" 19278 "ARGUMENTS:\n" 19279 "\n" 19280 " min_color (PLFLT, input) : The minimum cmap1 floating point\n" 19281 " argument. \n" 19282 "\n" 19283 " max_color (PLFLT, input) : The maximum cmap1 floating point\n" 19284 " argument. \n" 19285 "\n" 19286 ""}, 19287 { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n" 19288 "Get the cmap1 argument range for continuous color plots \n" 19289 "\n" 19290 "DESCRIPTION:\n" 19291 "\n" 19292 " Get the cmap1 argument range for continuous color plots. (Use\n" 19293 " plgsmap1_range to set the cmap1 argument range.) \n" 19294 "\n" 19295 " Redacted form: plgcmap1_range(min_color, max_color)\n" 19296 "\n" 19297 " This function is currently not used in any example. \n" 19298 "\n" 19299 "\n" 19300 "\n" 19301 "SYNOPSIS:\n" 19302 "\n" 19303 "plgcmap1_range(min_color, max_color)\n" 19304 "\n" 19305 "ARGUMENTS:\n" 19306 "\n" 19307 " min_color (PLFLT *, output) : Pointer to the current minimum cmap1\n" 19308 " floating point argument. \n" 19309 "\n" 19310 " max_color (PLFLT *, output) : Pointer to the current maximum cmap1\n" 19311 " floating point argument. \n" 19312 "\n" 19313 ""}, 19314 { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n" 19315 "Set 8-bit RGB values for given cmap0 color index \n" 19316 "\n" 19317 "ESCRIPTION:\n" 19318 "\n" 19319 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n" 19320 " index. Overwrites the previous color value for the given index and,\n" 19321 " thus, does not result in any additional allocation of space for\n" 19322 " colors. \n" 19323 "\n" 19324 " Redacted form: plscol0(icol0, r, g, b)\n" 19325 "\n" 19326 " This function is used in any example 31. \n" 19327 "\n" 19328 "\n" 19329 "\n" 19330 "YNOPSIS:\n" 19331 "\n" 19332 "lscol0(icol0, r, g, b)\n" 19333 "\n" 19334 "RGUMENTS:\n" 19335 "\n" 19336 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n" 19337 " number of colors (which is set by default, by plscmap0n, or even\n" 19338 " by plscmap0). \n" 19339 "\n" 19340 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19341 " degree of red in the color. \n" 19342 "\n" 19343 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19344 " degree of green in the color. \n" 19345 "\n" 19346 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19347 " degree of blue in the color. \n" 19348 "\n" 19349 ""}, 19350 { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n" 19351 "Set 8-bit RGB values and double alpha transparency value for given cmap0 color index \n" 19352 "\n" 19353 "ESCRIPTION:\n" 19354 "\n" 19355 " Set 8-bit RGB value and double alpha transparency value for given\n" 19356 " cmap0 (see the PLplot documentation) index. Overwrites the previous\n" 19357 " color value for the given index and, thus, does not result in any\n" 19358 " additional allocation of space for colors. \n" 19359 "\n" 19360 " This function is used in example 30. \n" 19361 "\n" 19362 "\n" 19363 "\n" 19364 "YNOPSIS:\n" 19365 "\n" 19366 "lscol0a(icol0, r, g, b, alpha)\n" 19367 "\n" 19368 "RGUMENTS:\n" 19369 "\n" 19370 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n" 19371 " number of colors (which is set by default, by plscmap0n, or even\n" 19372 " by plscmap0). \n" 19373 "\n" 19374 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19375 " degree of red in the color. \n" 19376 "\n" 19377 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19378 " degree of green in the color. \n" 19379 "\n" 19380 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19381 " degree of blue in the color. \n" 19382 "\n" 19383 " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n" 19384 " alpha transparency value of the color. \n" 19385 "\n" 19386 ""}, 19387 { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n" 19388 "Set the background color by 8-bit RGB value \n" 19389 "\n" 19390 "DESCRIPTION:\n" 19391 "\n" 19392 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n" 19393 " (see the PLplot documentation). \n" 19394 "\n" 19395 " Redacted form: plscolbg(r, g, b)\n" 19396 "\n" 19397 " This function is used in examples 15,31. \n" 19398 "\n" 19399 "\n" 19400 "\n" 19401 "SYNOPSIS:\n" 19402 "\n" 19403 "plscolbg(r, g, b)\n" 19404 "\n" 19405 "ARGUMENTS:\n" 19406 "\n" 19407 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19408 " degree of red in the color. \n" 19409 "\n" 19410 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19411 " degree of green in the color. \n" 19412 "\n" 19413 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19414 " degree of blue in the color. \n" 19415 "\n" 19416 ""}, 19417 { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n" 19418 "Set the background color by 8-bit RGB value and double alpha transparency value. \n" 19419 "\n" 19420 "DESCRIPTION:\n" 19421 "\n" 19422 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n" 19423 " (see the PLplot documentation) and double alpha transparency value. \n" 19424 "\n" 19425 " This function is used in example 31. \n" 19426 "\n" 19427 "\n" 19428 "\n" 19429 "SYNOPSIS:\n" 19430 "\n" 19431 "plscolbga(r, g, b, alpha)\n" 19432 "\n" 19433 "ARGUMENTS:\n" 19434 "\n" 19435 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19436 " degree of red in the color. \n" 19437 "\n" 19438 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19439 " degree of green in the color. \n" 19440 "\n" 19441 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n" 19442 " degree of blue in the color. \n" 19443 "\n" 19444 " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n" 19445 " alpha transparency value of the color. \n" 19446 "\n" 19447 ""}, 19448 { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n" 19449 "Used to globally turn color output on/off \n" 19450 "\n" 19451 "DESCRIPTION:\n" 19452 "\n" 19453 " Used to globally turn color output on/off for those drivers/devices\n" 19454 " that support it. \n" 19455 "\n" 19456 " Redacted form: plscolor(color)\n" 19457 "\n" 19458 " This function is used in example 31. \n" 19459 "\n" 19460 "\n" 19461 "\n" 19462 "SYNOPSIS:\n" 19463 "\n" 19464 "plscolor(color)\n" 19465 "\n" 19466 "ARGUMENTS:\n" 19467 "\n" 19468 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n" 19469 " turned off. If non-zero, color is turned on. \n" 19470 "\n" 19471 ""}, 19472 { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n" 19473 "Set device-compression level \n" 19474 "\n" 19475 "DESCRIPTION:\n" 19476 "\n" 19477 " Set device-compression level. Only used for drivers that provide\n" 19478 " compression. This function, if used, should be invoked before a call\n" 19479 " to plinit. \n" 19480 "\n" 19481 " Redacted form: plscompression(compression)\n" 19482 "\n" 19483 " This function is used in example 31. \n" 19484 "\n" 19485 "\n" 19486 "\n" 19487 "SYNOPSIS:\n" 19488 "\n" 19489 "plscompression(compression)\n" 19490 "\n" 19491 "ARGUMENTS:\n" 19492 "\n" 19493 " compression (PLINT, input) : The desired compression level. This is\n" 19494 " a device-dependent value. Currently only the jpeg and png devices\n" 19495 " use these values. For jpeg value is the jpeg quality which should\n" 19496 " normally be in the range 0-95. Higher values denote higher quality\n" 19497 " and hence larger image sizes. For png values are in the range -1\n" 19498 " to 99. Values of 0-9 are taken as the compression level for zlib.\n" 19499 " A value of -1 denotes the default zlib compression level. Values\n" 19500 " in the range 10-99 are divided by 10 and then used as the zlib\n" 19501 " compression level. Higher compression levels correspond to greater\n" 19502 " compression and small file sizes at the expense of more\n" 19503 " computation. \n" 19504 "\n" 19505 ""}, 19506 { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n" 19507 "Set the device (keyword) name \n" 19508 "\n" 19509 "DESCRIPTION:\n" 19510 "\n" 19511 " Set the device (keyword) name. \n" 19512 "\n" 19513 " Redacted form: plsdev(devname)\n" 19514 "\n" 19515 " This function is used in examples 1,14,20. \n" 19516 "\n" 19517 "\n" 19518 "\n" 19519 "SYNOPSIS:\n" 19520 "\n" 19521 "plsdev(devname)\n" 19522 "\n" 19523 "ARGUMENTS:\n" 19524 "\n" 19525 " devname (const char *, input) : Pointer to device (keyword) name\n" 19526 " string. \n" 19527 "\n" 19528 ""}, 19529 { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n" 19530 "Set parameters that define current device-space window \n" 19531 "\n" 19532 "DESCRIPTION:\n" 19533 "\n" 19534 " Set relative margin width, aspect ratio, and relative justification\n" 19535 " that define current device-space window. If you want to just use the\n" 19536 " previous value for any of these, just pass in the magic value\n" 19537 " PL_NOTSET. It is unlikely that one should ever need to change the\n" 19538 " aspect ratio but it's in there for completeness. If plsdidev is not\n" 19539 " called the default values of mar, jx, and jy are all 0. aspect is set\n" 19540 " to a device-specific value. \n" 19541 "\n" 19542 " Redacted form: plsdidev(mar, aspect, jx, jy)\n" 19543 "\n" 19544 " This function is used in example 31. \n" 19545 "\n" 19546 "\n" 19547 "\n" 19548 "SYNOPSIS:\n" 19549 "\n" 19550 "plsdidev(mar, aspect, jx, jy)\n" 19551 "\n" 19552 "ARGUMENTS:\n" 19553 "\n" 19554 " mar (PLFLT, input) : Relative margin width. \n" 19555 "\n" 19556 " aspect (PLFLT, input) : Aspect ratio. \n" 19557 "\n" 19558 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n" 19559 " the range -0.5 to 0.5. \n" 19560 "\n" 19561 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n" 19562 " the range -0.5 to 0.5. \n" 19563 "\n" 19564 ""}, 19565 { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n" 19566 "Set up transformation from metafile coordinates \n" 19567 "\n" 19568 "DESCRIPTION:\n" 19569 "\n" 19570 " Set up transformation from metafile coordinates. The size of the plot\n" 19571 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n" 19572 " general-purpose facility just yet (not sure why the user would need\n" 19573 " it, for one). \n" 19574 "\n" 19575 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n" 19576 " dimypmm)\n" 19577 "\n" 19578 " This function is not used in any examples. \n" 19579 "\n" 19580 "\n" 19581 "\n" 19582 "SYNOPSIS:\n" 19583 "\n" 19584 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n" 19585 "\n" 19586 "ARGUMENTS:\n" 19587 "\n" 19588 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n" 19589 "\n" 19590 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n" 19591 "\n" 19592 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n" 19593 "\n" 19594 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n" 19595 "\n" 19596 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n" 19597 "\n" 19598 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n" 19599 "\n" 19600 ""}, 19601 { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n" 19602 "Set plot orientation \n" 19603 "\n" 19604 "DESCRIPTION:\n" 19605 "\n" 19606 " Set plot orientation parameter which is multiplied by 90 degrees to\n" 19607 " obtain the angle of rotation. Note, arbitrary rotation parameters\n" 19608 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n" 19609 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n" 19610 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n" 19611 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n" 19612 " not called the default value of rot is 0. \n" 19613 "\n" 19614 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n" 19615 " probably want to change the aspect ratio to a value suitable for the\n" 19616 " plot orientation using a call to plsdidev or the command-line options\n" 19617 " -a or -freeaspect. For more documentation of those options see the\n" 19618 " PLplot documentation. Such command-line options can be set internally\n" 19619 " using plsetopt or set directly using the command line and parsed using\n" 19620 " a call to plparseopts. \n" 19621 "\n" 19622 " Redacted form: plsdiori(rot)\n" 19623 "\n" 19624 " This function is not used in any examples. \n" 19625 "\n" 19626 "\n" 19627 "\n" 19628 "SYNOPSIS:\n" 19629 "\n" 19630 "plsdiori(rot)\n" 19631 "\n" 19632 "ARGUMENTS:\n" 19633 "\n" 19634 " rot (PLFLT, input) : Plot orientation parameter. \n" 19635 "\n" 19636 ""}, 19637 { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n" 19638 "Set parameters that define current plot-space window \n" 19639 "\n" 19640 "DESCRIPTION:\n" 19641 "\n" 19642 " Set relative minima and maxima that define the current plot-space\n" 19643 " window. If plsdiplt is not called the default values of xmin, ymin,\n" 19644 " xmax, and ymax are 0., 0., 1., and 1. \n" 19645 "\n" 19646 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n" 19647 "\n" 19648 " This function is used in example 31. \n" 19649 "\n" 19650 "\n" 19651 "\n" 19652 "SYNOPSIS:\n" 19653 "\n" 19654 "plsdiplt(xmin, ymin, xmax, ymax)\n" 19655 "\n" 19656 "ARGUMENTS:\n" 19657 "\n" 19658 " xmin (PLFLT, input) : Relative minimum in x. \n" 19659 "\n" 19660 " ymin (PLFLT, input) : Relative minimum in y. \n" 19661 "\n" 19662 " xmax (PLFLT, input) : Relative maximum in x. \n" 19663 "\n" 19664 " ymax (PLFLT, input) : Relative maximum in y. \n" 19665 "\n" 19666 ""}, 19667 { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n" 19668 "Set parameters incrementally (zoom mode) that define current plot-space window \n" 19669 "\n" 19670 "DESCRIPTION:\n" 19671 "\n" 19672 " Set relative minima and maxima incrementally (zoom mode) that define\n" 19673 " the current plot-space window. This function has the same effect as\n" 19674 " plsdiplt if that function has not been previously called. Otherwise,\n" 19675 " this function implements zoom mode using the transformation min_used =\n" 19676 " old_min + old_length*min and max_used = old_min + old_length*max for\n" 19677 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n" 19678 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n" 19679 "\n" 19680 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n" 19681 "\n" 19682 " This function is used in example 31. \n" 19683 "\n" 19684 "\n" 19685 "\n" 19686 "SYNOPSIS:\n" 19687 "\n" 19688 "plsdiplz(xmin, ymin, xmax, ymax)\n" 19689 "\n" 19690 "ARGUMENTS:\n" 19691 "\n" 19692 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n" 19693 "\n" 19694 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n" 19695 "\n" 19696 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n" 19697 "\n" 19698 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n" 19699 "\n" 19700 ""}, 19701 { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n" 19702 "Set seed for internal random number generator. \n" 19703 "\n" 19704 "DESCRIPTION:\n" 19705 "\n" 19706 " Set the seed for the internal random number generator. See plrandd for\n" 19707 " further details. \n" 19708 "\n" 19709 " Redacted form: plseed(seed)\n" 19710 "\n" 19711 " This function is used in example 21. \n" 19712 "\n" 19713 "\n" 19714 "\n" 19715 "SYNOPSIS:\n" 19716 "\n" 19717 "plseed(seed)\n" 19718 "\n" 19719 "ARGUMENTS:\n" 19720 "\n" 19721 " seed (unsigned int, input) : Seed for random number generator. \n" 19722 "\n" 19723 ""}, 19724 { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n" 19725 "Set the escape character for text strings \n" 19726 "\n" 19727 "DESCRIPTION:\n" 19728 "\n" 19729 " Set the escape character for text strings. From C (in contrast to\n" 19730 " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n" 19731 " selected characters are allowed to prevent the user from shooting\n" 19732 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n" 19733 " with C's use of backslash as a character escape). Here are the\n" 19734 " allowed escape characters and their corresponding decimal ASCII\n" 19735 " values: !, ASCII 33 \n" 19736 " #, ASCII 35 \n" 19737 " $, ASCII 36 \n" 19738 " %, ASCII 37 \n" 19739 " &, ASCII 38 \n" 19740 " *, ASCII 42 \n" 19741 " @, ASCII 64 \n" 19742 " ^, ASCII 94 \n" 19743 " ~, ASCII 126 \n" 19744 "\n" 19745 "\n" 19746 " Redacted form: General: plsesc(esc)\n" 19747 " Perl/PDL: Not available? \n" 19748 "\n" 19749 "\n" 19750 " This function is used in example 29. \n" 19751 "\n" 19752 "\n" 19753 "\n" 19754 "SYNOPSIS:\n" 19755 "\n" 19756 "plsesc(esc)\n" 19757 "\n" 19758 "ARGUMENTS:\n" 19759 "\n" 19760 " esc (char, input) : Escape character. \n" 19761 "\n" 19762 ""}, 19763 { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n" 19764 "Set any command-line option \n" 19765 "\n" 19766 "DESCRIPTION:\n" 19767 "\n" 19768 " Set any command-line option internally from a program before it\n" 19769 " invokes plinit. opt is the name of the command-line option and optarg\n" 19770 " is the corresponding command-line option argument. \n" 19771 "\n" 19772 " This function returns 0 on success. \n" 19773 "\n" 19774 " Redacted form: plsetopt(opt, optarg)\n" 19775 "\n" 19776 " This function is used in example 14. \n" 19777 "\n" 19778 "\n" 19779 "\n" 19780 "SYNOPSIS:\n" 19781 "\n" 19782 "int plsetopt(opt, optarg)\n" 19783 "\n" 19784 "ARGUMENTS:\n" 19785 "\n" 19786 " opt (const char *, input) : Pointer to string containing the\n" 19787 " command-line option. \n" 19788 "\n" 19789 " optarg (const char *, input) : Pointer to string containing the\n" 19790 " argument of the command-line option. \n" 19791 "\n" 19792 ""}, 19793 { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n" 19794 "Set family file parameters \n" 19795 "\n" 19796 "DESCRIPTION:\n" 19797 "\n" 19798 " Sets variables dealing with output file familying. Does nothing if\n" 19799 " familying not supported by the driver. This routine, if used, must be\n" 19800 " called before initializing PLplot. See the PLplot documentation for\n" 19801 " more information. \n" 19802 "\n" 19803 " Redacted form: plsfam(fam, num, bmax)\n" 19804 "\n" 19805 " This function is used in examples 14,31. \n" 19806 "\n" 19807 "\n" 19808 "\n" 19809 "SYNOPSIS:\n" 19810 "\n" 19811 "plsfam(fam, num, bmax)\n" 19812 "\n" 19813 "ARGUMENTS:\n" 19814 "\n" 19815 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n" 19816 " is enabled. \n" 19817 "\n" 19818 " num (PLINT, input) : Current family file number. \n" 19819 "\n" 19820 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n" 19821 " file. \n" 19822 "\n" 19823 ""}, 19824 { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n" 19825 "Set FCI (font characterization integer) \n" 19826 "\n" 19827 "DESCRIPTION:\n" 19828 "\n" 19829 " Sets font characteristics to be used at the start of the next string\n" 19830 " using the FCI approach. See the PLplot documentation for more\n" 19831 " information. \n" 19832 "\n" 19833 " Redacted form: General: plsfci(fci)\n" 19834 " Perl/PDL: Not available? \n" 19835 "\n" 19836 "\n" 19837 " This function is used in example 23. \n" 19838 "\n" 19839 "\n" 19840 "\n" 19841 "SYNOPSIS:\n" 19842 "\n" 19843 "plsfci(fci)\n" 19844 "\n" 19845 "ARGUMENTS:\n" 19846 "\n" 19847 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n" 19848 " of FCI. \n" 19849 "\n" 19850 ""}, 19851 { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n" 19852 "Set output file name \n" 19853 "\n" 19854 "DESCRIPTION:\n" 19855 "\n" 19856 " Sets the current output file name, if applicable. If the file name\n" 19857 " has not been specified and is required by the driver, the user will be\n" 19858 " prompted for it. If using the X-windows output driver, this sets the\n" 19859 " display name. This routine, if used, must be called before\n" 19860 " initializing PLplot. \n" 19861 "\n" 19862 " Redacted form: plsfnam(fnam)\n" 19863 "\n" 19864 " This function is used in examples 1,20. \n" 19865 "\n" 19866 "\n" 19867 "\n" 19868 "SYNOPSIS:\n" 19869 "\n" 19870 "plsfnam(fnam)\n" 19871 "\n" 19872 "ARGUMENTS:\n" 19873 "\n" 19874 " fnam (const char *, input) : Pointer to file name string. \n" 19875 "\n" 19876 ""}, 19877 { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n" 19878 "Set family, style and weight of the current font \n" 19879 "\n" 19880 "DESCRIPTION:\n" 19881 "\n" 19882 " Sets the current font. See the PLplot documentation for more\n" 19883 " information on font selection. \n" 19884 "\n" 19885 " Redacted form: plsfont(family, style, weight)\n" 19886 "\n" 19887 " This function is used in example 23. \n" 19888 "\n" 19889 "\n" 19890 "\n" 19891 "SYNOPSIS:\n" 19892 "\n" 19893 "plsfont(family, style, weight)\n" 19894 "\n" 19895 "ARGUMENTS:\n" 19896 "\n" 19897 " family (PLINT, input) : Font family to select for the current font.\n" 19898 " The available values are given by the PL_FCI_* constants in\n" 19899 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n" 19900 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n" 19901 " signifies that the font family should not be altered. \n" 19902 "\n" 19903 " style (PLINT, input) : Font style to select for the current font.\n" 19904 " The available values are given by the PL_FCI_* constants in\n" 19905 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n" 19906 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n" 19907 " should not be altered. \n" 19908 "\n" 19909 " weight (PLINT, input) : Font weight to select for the current font.\n" 19910 " The available values are given by the PL_FCI_* constants in\n" 19911 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n" 19912 " negative value signifies that the font weight should not be\n" 19913 " altered. \n" 19914 "\n" 19915 ""}, 19916 { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n" 19917 "Shade regions on the basis of value \n" 19918 "\n" 19919 "DESCRIPTION:\n" 19920 "\n" 19921 " Shade regions on the basis of value. This is the high-level routine\n" 19922 " for making continuous color shaded plots with cmap1 while plshade (or\n" 19923 " plshade1) are used for individual shaded regions using either cmap0 or\n" 19924 " cmap1. examples/c/x16c.c shows a number of examples for using this\n" 19925 " function. See the following discussion of the arguments and the PLplot\n" 19926 " documentation for more information. \n" 19927 "\n" 19928 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n" 19929 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n" 19930 " pltr_data)\n" 19931 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n" 19932 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n" 19933 " pltr_data)\n" 19934 "\n" 19935 "\n" 19936 " This function is used in examples 16,21. \n" 19937 "\n" 19938 "\n" 19939 "\n" 19940 "SYNOPSIS:\n" 19941 "\n" 19942 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n" 19943 "\n" 19944 "ARGUMENTS:\n" 19945 "\n" 19946 " a (const PLFLT * const *, input) : Contains ** pointer to array to\n" 19947 " be plotted. The array must have been declared as PLFLT a[nx][ny]. \n" 19948 "\n" 19949 " nx (PLINT, input) : First dimension of array \"a\". \n" 19950 "\n" 19951 " ny (PLINT, input) : Second dimension of array \"a\". \n" 19952 "\n" 19953 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n" 19954 " specifying regions excluded from the shading plot. This function\n" 19955 " accepts x and y coordinates as input arguments and must return 0\n" 19956 " if the point is in the excluded region or 1 otherwise. This\n" 19957 " argument can be NULL if all the values are valid. \n" 19958 "\n" 19959 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n" 19960 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n" 19961 " at (xmax,ymin) and so on. \n" 19962 "\n" 19963 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n" 19964 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n" 19965 " at (xmax,ymin) and so on. \n" 19966 "\n" 19967 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n" 19968 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n" 19969 " at (xmax,ymin) and so on. \n" 19970 "\n" 19971 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n" 19972 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n" 19973 " at (xmax,ymin) and so on. \n" 19974 "\n" 19975 " clevel (const PLFLT *, input) : Pointer to array containing the\n" 19976 " data levels corresponding to the edges of each shaded region that\n" 19977 " will be plotted by this function. To work properly the levels\n" 19978 " should be monotonic. \n" 19979 "\n" 19980 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n" 19981 " of shade edge values in clevel). \n" 19982 "\n" 19983 " fill_width (PLFLT, input) : Defines line width used by the fill\n" 19984 " pattern. \n" 19985 "\n" 19986 " cont_color (PLINT, input) : Defines pen color used for contours\n" 19987 " defining edges of shaded regions. The pen color is only temporary\n" 19988 " set for the contour drawing. Set this value to zero or less if no\n" 19989 " shade edge contours are wanted. \n" 19990 "\n" 19991 " cont_width (PLFLT, input) : Defines line width used for contours\n" 19992 " defining edges of shaded regions. This value may not be honored\n" 19993 " by all drivers. The pen width is only temporary set for the\n" 19994 " contour drawing. Set this value to zero or less if no shade edge\n" 19995 " contours are wanted. \n" 19996 "\n" 19997 " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n" 19998 " Routine used to fill the region. Use plfill. Future version of\n" 19999 " PLplot may have other fill routines. \n" 20000 "\n" 20001 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n" 20002 " map to rectangles after coordinate transformation with pltrl. \n" 20003 " Otherwise, set rectangular to false. If rectangular is set to\n" 20004 " true, plshade tries to save time by filling large rectangles. \n" 20005 " This optimization fails if the coordinate transformation distorts\n" 20006 " the shape of rectangles. For example a plot in polar coordinates\n" 20007 " has to have rectangular set to false. \n" 20008 "\n" 20009 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n" 20010 " Pointer to function that defines transformation between indices\n" 20011 " in array z and the world coordinates (C only). Transformation\n" 20012 " functions are provided in the PLplot library: pltr0 for identity\n" 20013 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n" 20014 " defined by one- and two-dimensional arrays. In addition,\n" 20015 " user-supplied routines for the transformation can be used as well.\n" 20016 " Examples of all of these approaches are given in the PLplot\n" 20017 " documentation. The transformation function should have the form\n" 20018 " given by any of pltr0, pltr1, or pltr2. \n" 20019 "\n" 20020 " pltr_data (PLPointer, input) : Extra parameter to help pass\n" 20021 " information to pltr0, pltr1, pltr2, or whatever routine that is\n" 20022 " externally supplied. \n" 20023 "\n" 20024 ""}, 20025 { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n" 20026 "Shade individual region on the basis of value \n" 20027 "\n" 20028 "ESCRIPTION:\n" 20029 "\n" 20030 " Shade individual region on the basis of value. Use plshades if you\n" 20031 " want to shade a number of regions using continuous colors. plshade is\n" 20032 " identical to plshade1 except for the type of the first parameter. See\n" 20033 " plshade1 for further discussion. \n" 20034 "\n" 20035 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n" 20036 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n" 20037 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n" 20038 " Perl/PDL: Not available? \n" 20039 "\n" 20040 "\n" 20041 " This function is used in example 15. \n" 20042 "\n" 20043 "\n" 20044 "\n" 20045 "YNOPSIS:\n" 20046 "\n" 20047 "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" 20048 "\n" 20049 "RGUMENTS:\n" 20050 "\n" 20051 " a (const PLFLT * const *, input) : \n" 20052 "\n" 20053 " nx (PLINT, input) : \n" 20054 "\n" 20055 " ny (PLINT, input) : \n" 20056 "\n" 20057 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n" 20058 "\n" 20059 " xmin (PLFLT, input) : \n" 20060 "\n" 20061 " xmax (PLFLT, input) : \n" 20062 "\n" 20063 " ymin (PLFLT, input) : \n" 20064 "\n" 20065 " ymax (PLFLT, input) : \n" 20066 "\n" 20067 " shade_min (PLFLT, input) : \n" 20068 "\n" 20069 " shade_max (PLFLT, input) : \n" 20070 "\n" 20071 " sh_cmap (PLINT, input) : \n" 20072 "\n" 20073 " sh_color (PLFLT, input) : \n" 20074 "\n" 20075 " sh_width (PLFLT, input) : \n" 20076 "\n" 20077 " min_color (PLINT, input) : \n" 20078 "\n" 20079 " min_width (PLFLT, input) : \n" 20080 "\n" 20081 " max_color (PLINT, input) : \n" 20082 "\n" 20083 " max_width (PLFLT, input) : \n" 20084 "\n" 20085 " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n" 20086 "\n" 20087 " rectangular (PLBOOL, input) : \n" 20088 "\n" 20089 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n" 20090 "\n" 20091 " pltr_data (PLPointer, input) : \n" 20092 "\n" 20093 ""}, 20094 { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n" 20095 "Assign a function to use for generating custom axis labels \n" 20096 "\n" 20097 "DESCRIPTION:\n" 20098 "\n" 20099 " This function allows a user to provide their own function to provide\n" 20100 " axis label text. The user function is given the numeric value for a\n" 20101 " point on an axis and returns a string label to correspond with that\n" 20102 " value. Custom axis labels can be enabled by passing appropriate\n" 20103 " arguments to plenv, plbox, plbox3 and similar functions. \n" 20104 "\n" 20105 " This function is used in example 19. \n" 20106 "\n" 20107 "\n" 20108 "\n" 20109 "SYNOPSIS:\n" 20110 "\n" 20111 "plslabelfunc(label_func, label_data)\n" 20112 "\n" 20113 "ARGUMENTS:\n" 20114 "\n" 20115 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n" 20116 " : This is the custom label function. In order to reset to the\n" 20117 " default labelling, set this to NULL. The labelling function\n" 20118 " parameters are, in order: axis: This indicates which axis a\n" 20119 " label is being requested for. The value will be one of PL_X_AXIS,\n" 20120 " PL_Y_AXIS or PL_Z_AXIS. \n" 20121 "\n" 20122 " value: This is the value along the axis which is being labelled. \n" 20123 "\n" 20124 " label_text: The string representation of the label value. \n" 20125 "\n" 20126 " length: The maximum length in characters allowed for label_text. \n" 20127 "\n" 20128 "\n" 20129 " label_data (PLPointer, input) : This parameter may be used to pass\n" 20130 " data to the label_func function. \n" 20131 "\n" 20132 ""}, 20133 { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n" 20134 "Set length of major ticks \n" 20135 "\n" 20136 "DESCRIPTION:\n" 20137 "\n" 20138 " This sets up the length of the major ticks. The actual length is the\n" 20139 " product of the default length and a scaling factor as for character\n" 20140 " height. \n" 20141 "\n" 20142 " Redacted form: plsmaj(def, scale)\n" 20143 "\n" 20144 " This function is used in example 29. \n" 20145 "\n" 20146 "\n" 20147 "\n" 20148 "SYNOPSIS:\n" 20149 "\n" 20150 "plsmaj(def, scale)\n" 20151 "\n" 20152 "ARGUMENTS:\n" 20153 "\n" 20154 " def (PLFLT, input) : The default length of a major tick in\n" 20155 " millimeters, should be set to zero if the default length is to\n" 20156 " remain unchanged. \n" 20157 "\n" 20158 " scale (PLFLT, input) : Scale factor to be applied to default to get\n" 20159 " actual tick length. \n" 20160 "\n" 20161 ""}, 20162 { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n" 20163 "Set the memory area to be plotted (RGB) \n" 20164 "\n" 20165 "DESCRIPTION:\n" 20166 "\n" 20167 " Set the memory area to be plotted (with the mem or memcairo driver) as\n" 20168 " the dev member of the stream structure. Also set the number of pixels\n" 20169 " in the memory passed in \n" 20170 " plotmem, which is a block of memory \n" 20171 " maxy by \n" 20172 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n" 20173 "\n" 20174 " This memory will have to be freed by the user! \n" 20175 "\n" 20176 " Redacted form: plsmem(maxx, maxy, plotmem)\n" 20177 "\n" 20178 " This function is not used in any examples. \n" 20179 "\n" 20180 "\n" 20181 "\n" 20182 "SYNOPSIS:\n" 20183 "\n" 20184 "plsmem(maxx, maxy, plotmem)\n" 20185 "\n" 20186 "ARGUMENTS:\n" 20187 "\n" 20188 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n" 20189 "\n" 20190 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n" 20191 "\n" 20192 " plotmem (void *, input) : Pointer to the beginning of the\n" 20193 " user-supplied memory area. \n" 20194 "\n" 20195 ""}, 20196 { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n" 20197 "Set the memory area to be plotted (RGBA) \n" 20198 "\n" 20199 "DESCRIPTION:\n" 20200 "\n" 20201 " Set the memory area to be plotted (with the memcairo driver) as the\n" 20202 " dev member of the stream structure. Also set the number of pixels in\n" 20203 " the memory passed in \n" 20204 " plotmem, which is a block of memory \n" 20205 " maxy by \n" 20206 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n" 20207 "\n" 20208 " This memory will have to be freed by the user! \n" 20209 "\n" 20210 " Redacted form: plsmema(maxx, maxy, plotmem)\n" 20211 "\n" 20212 " This function is not used in any examples. \n" 20213 "\n" 20214 "\n" 20215 "\n" 20216 "SYNOPSIS:\n" 20217 "\n" 20218 "plsmema(maxx, maxy, plotmem)\n" 20219 "\n" 20220 "ARGUMENTS:\n" 20221 "\n" 20222 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n" 20223 "\n" 20224 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n" 20225 "\n" 20226 " plotmem (void *, input) : Pointer to the beginning of the\n" 20227 " user-supplied memory area. \n" 20228 "\n" 20229 ""}, 20230 { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n" 20231 "Set length of minor ticks \n" 20232 "\n" 20233 "DESCRIPTION:\n" 20234 "\n" 20235 " This sets up the length of the minor ticks and the length of the\n" 20236 " terminals on error bars. The actual length is the product of the\n" 20237 " default length and a scaling factor as for character height. \n" 20238 "\n" 20239 " Redacted form: plsmin(def, scale)\n" 20240 "\n" 20241 " This function is used in example 29. \n" 20242 "\n" 20243 "\n" 20244 "\n" 20245 "SYNOPSIS:\n" 20246 "\n" 20247 "plsmin(def, scale)\n" 20248 "\n" 20249 "ARGUMENTS:\n" 20250 "\n" 20251 " def (PLFLT, input) : The default length of a minor tick in\n" 20252 " millimeters, should be set to zero if the default length is to\n" 20253 " remain unchanged. \n" 20254 "\n" 20255 " scale (PLFLT, input) : Scale factor to be applied to default to get\n" 20256 " actual tick length. \n" 20257 "\n" 20258 ""}, 20259 { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n" 20260 "Set orientation \n" 20261 "\n" 20262 "DESCRIPTION:\n" 20263 "\n" 20264 " Set integer plot orientation parameter. This function is identical to\n" 20265 " plsdiori except for the type of the argument, and should be used in\n" 20266 " the same way. See the PLplot documentation for details. \n" 20267 "\n" 20268 " Redacted form: plsori(ori)\n" 20269 "\n" 20270 " This function is used in example 3. \n" 20271 "\n" 20272 "\n" 20273 "\n" 20274 "SYNOPSIS:\n" 20275 "\n" 20276 "plsori(ori)\n" 20277 "\n" 20278 "ARGUMENTS:\n" 20279 "\n" 20280 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n" 20281 " portrait, etc.) The value is multiplied by 90 degrees to get the\n" 20282 " angle. \n" 20283 "\n" 20284 ""}, 20285 { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n" 20286 "Set page parameters \n" 20287 "\n" 20288 "DESCRIPTION:\n" 20289 "\n" 20290 " Sets the page configuration (optional). If an individual parameter is\n" 20291 " zero then that parameter value is not updated. Not all parameters are\n" 20292 " recognized by all drivers and the interpretation is device-dependent.\n" 20293 " The X-window driver uses the length and offset parameters to determine\n" 20294 " the window size and location. The length and offset values are\n" 20295 " expressed in units that are specific to the current driver. For\n" 20296 " instance: screen drivers will usually interpret them as number of\n" 20297 " pixels, whereas printer drivers will usually use mm. This routine, if\n" 20298 " used, must be called before initializing PLplot. \n" 20299 "\n" 20300 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n" 20301 "\n" 20302 " This function is used in examples 14 and 31. \n" 20303 "\n" 20304 "\n" 20305 "\n" 20306 "SYNOPSIS:\n" 20307 "\n" 20308 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n" 20309 "\n" 20310 "ARGUMENTS:\n" 20311 "\n" 20312 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n" 20313 "\n" 20314 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n" 20315 "\n" 20316 " xleng (PLINT , input) : Page length, x. \n" 20317 "\n" 20318 " yleng (PLINT, input) : Page length, y. \n" 20319 "\n" 20320 " xoff (PLINT, input) : Page offset, x. \n" 20321 "\n" 20322 " yoff (PLINT, input) : Page offset, y. \n" 20323 "\n" 20324 ""}, 20325 { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n" 20326 "Set the colors for color table 0 from a cmap0 file \n" 20327 "\n" 20328 "DESCRIPTION:\n" 20329 "\n" 20330 " Set the colors for color table 0 from a cmap0 file \n" 20331 "\n" 20332 " Redacted form: plspal0(filename)\n" 20333 "\n" 20334 " This function is in example 16. \n" 20335 "\n" 20336 "\n" 20337 "\n" 20338 "SYNOPSIS:\n" 20339 "\n" 20340 "plspal0(filename)\n" 20341 "\n" 20342 "ARGUMENTS:\n" 20343 "\n" 20344 " filename (const char *, input) : The name of the cmap0 file, or a\n" 20345 " empty to string to specify the default cmap0 file. \n" 20346 "\n" 20347 ""}, 20348 { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n" 20349 "Set the palette for cmap1 using the specified cmap1*.pal format file \n" 20350 "\n" 20351 "DESCRIPTION:\n" 20352 "\n" 20353 " Set the palette for cmap1 using the specified cmap1*.pal format file. \n" 20354 "\n" 20355 " Redacted form: plspal1(filename, interpolate)\n" 20356 "\n" 20357 " This function is used in example 16. \n" 20358 "\n" 20359 "\n" 20360 "\n" 20361 "SYNOPSIS:\n" 20362 "\n" 20363 "plspal1(filename, interpolate)\n" 20364 "\n" 20365 "ARGUMENTS:\n" 20366 "\n" 20367 " filename (const char *, input) : The name of the cmap1*.pal file,\n" 20368 " or an empty string to specify the default cmap1.pal file. \n" 20369 "\n" 20370 " interpolate (PLBOOL, input) : If this parameter is true, the\n" 20371 " columns containing the intensity index, r, g, b, alpha and\n" 20372 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n" 20373 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n" 20374 " a flag which controls whether the r, g, b data sent to plscmap1la\n" 20375 " are interpreted as HLS or RGB.) If this parameter is false, the\n" 20376 " intensity index and alt_hue_path columns are ignored and the r, g,\n" 20377 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n" 20378 " are used instead to set the cmap1 palette directly with a call to\n" 20379 " plscmap1a. \n" 20380 "\n" 20381 ""}, 20382 { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n" 20383 "Set the pause (on end-of-page) status \n" 20384 "\n" 20385 "DESCRIPTION:\n" 20386 "\n" 20387 " Set the pause (on end-of-page) status. \n" 20388 "\n" 20389 " Redacted form: plspause(pause)\n" 20390 "\n" 20391 " This function is in examples 14,20. \n" 20392 "\n" 20393 "\n" 20394 "\n" 20395 "SYNOPSIS:\n" 20396 "\n" 20397 "plspause(pause)\n" 20398 "\n" 20399 "ARGUMENTS:\n" 20400 "\n" 20401 " pause (PLBOOL, input) : If pause is true there will be a pause on\n" 20402 " end-of-page for those drivers which support this. Otherwise there\n" 20403 " is no pause. \n" 20404 "\n" 20405 ""}, 20406 { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n" 20407 "Set current output stream \n" 20408 "\n" 20409 "DESCRIPTION:\n" 20410 "\n" 20411 " Sets the number of the current output stream. The stream number\n" 20412 " defaults to 0 unless changed by this routine. The first use of this\n" 20413 " routine must be followed by a call initializing PLplot (e.g. plstar). \n" 20414 "\n" 20415 " Redacted form: plsstrm(strm)\n" 20416 "\n" 20417 " This function is examples 1,14,20. \n" 20418 "\n" 20419 "\n" 20420 "\n" 20421 "SYNOPSIS:\n" 20422 "\n" 20423 "plsstrm(strm)\n" 20424 "\n" 20425 "ARGUMENTS:\n" 20426 "\n" 20427 " strm (PLINT, input) : The current stream number. \n" 20428 "\n" 20429 ""}, 20430 { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n" 20431 "Set the number of subpages in x and y \n" 20432 "\n" 20433 "DESCRIPTION:\n" 20434 "\n" 20435 " Set the number of subpages in x and y. \n" 20436 "\n" 20437 " Redacted form: plssub(nx, ny)\n" 20438 "\n" 20439 " This function is examples 1,2,14,21,25,27. \n" 20440 "\n" 20441 "\n" 20442 "\n" 20443 "SYNOPSIS:\n" 20444 "\n" 20445 "plssub(nx, ny)\n" 20446 "\n" 20447 "ARGUMENTS:\n" 20448 "\n" 20449 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n" 20450 " of window columns). \n" 20451 "\n" 20452 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n" 20453 " of window rows). \n" 20454 "\n" 20455 ""}, 20456 { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n" 20457 "Set symbol size \n" 20458 "\n" 20459 "DESCRIPTION:\n" 20460 "\n" 20461 " This sets up the size of all subsequent symbols drawn by plpoin and\n" 20462 " plsym. The actual height of a symbol is the product of the default\n" 20463 " symbol size and a scaling factor as for the character height. \n" 20464 "\n" 20465 " Redacted form: plssym(def, scale)\n" 20466 "\n" 20467 " This function is used in example 29. \n" 20468 "\n" 20469 "\n" 20470 "\n" 20471 "SYNOPSIS:\n" 20472 "\n" 20473 "plssym(def, scale)\n" 20474 "\n" 20475 "ARGUMENTS:\n" 20476 "\n" 20477 " def (PLFLT, input) : The default height of a symbol in millimeters,\n" 20478 " should be set to zero if the default height is to remain\n" 20479 " unchanged. \n" 20480 "\n" 20481 " scale (PLFLT, input) : Scale factor to be applied to default to get\n" 20482 " actual symbol height. \n" 20483 "\n" 20484 ""}, 20485 { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n" 20486 "Initialization \n" 20487 "\n" 20488 "DESCRIPTION:\n" 20489 "\n" 20490 " Initializing the plotting package. The program prompts for the device\n" 20491 " keyword or number of the desired output device. Hitting a RETURN in\n" 20492 " response to the prompt is the same as selecting the first device. If\n" 20493 " only one device is enabled when PLplot is installed, plstar will issue\n" 20494 " no prompt. The output device is divided into nx by ny subpages, each\n" 20495 " of which may be used independently. The subroutine pladv is used to\n" 20496 " advance from one subpage to the next. \n" 20497 "\n" 20498 " Redacted form: plstar(nx, ny)\n" 20499 "\n" 20500 " This function is used in example 1. \n" 20501 "\n" 20502 "\n" 20503 "\n" 20504 "SYNOPSIS:\n" 20505 "\n" 20506 "plstar(nx, ny)\n" 20507 "\n" 20508 "ARGUMENTS:\n" 20509 "\n" 20510 " nx (PLINT, input) : Number of subpages to divide output page in the\n" 20511 " horizontal direction. \n" 20512 "\n" 20513 " ny (PLINT, input) : Number of subpages to divide output page in the\n" 20514 " vertical direction. \n" 20515 "\n" 20516 ""}, 20517 { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n" 20518 "Initialization \n" 20519 "\n" 20520 "DESCRIPTION:\n" 20521 "\n" 20522 " Alternative to plstar for initializing the plotting package. The\n" 20523 " device name keyword for the desired output device must be supplied as\n" 20524 " an argument. These keywords are the same as those printed out by\n" 20525 " plstar. If the requested device is not available, or if the input\n" 20526 " string is empty or begins with ``?'', the prompted start up of plstar\n" 20527 " is used. This routine also divides the output device page into nx by\n" 20528 " ny subpages, each of which may be used independently. The subroutine\n" 20529 " pladv is used to advance from one subpage to the next. \n" 20530 "\n" 20531 " Redacted form: General: plstart(devname, nx, ny)\n" 20532 " Perl/PDL: plstart(nx, ny, devname)\n" 20533 "\n" 20534 "\n" 20535 " This function is not used in any examples. \n" 20536 "\n" 20537 "\n" 20538 "\n" 20539 "SYNOPSIS:\n" 20540 "\n" 20541 "plstart(devname, nx, ny)\n" 20542 "\n" 20543 "ARGUMENTS:\n" 20544 "\n" 20545 " devname (const char *, input) : Device name keyword of the required\n" 20546 " output device. If NULL or if the first character is a ``?'', the\n" 20547 " normal (prompted) start up is used. \n" 20548 "\n" 20549 " nx (PLINT, input) : Number of subpages to divide output page in the\n" 20550 " horizontal direction. \n" 20551 "\n" 20552 " ny (PLINT, input) : Number of subpages to divide output page in the\n" 20553 " vertical direction. \n" 20554 "\n" 20555 ""}, 20556 { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n" 20557 "Set a global coordinate transform function \n" 20558 "\n" 20559 "DESCRIPTION:\n" 20560 "\n" 20561 " This function can be used to define a coordinate transformation which\n" 20562 " affects all elements drawn within the current plot window. The\n" 20563 " coordinate_transform function is similar to that provided for the\n" 20564 " plmap and plmeridians functions. The coordinate_transform_data\n" 20565 " parameter may be used to pass extra data to coordinate_transform. \n" 20566 "\n" 20567 " Redacted form: General: plstransform(coordinate_transform,\n" 20568 " coordinate_transform_data)\n" 20569 "\n" 20570 "\n" 20571 " This function is used in examples 19 and 22. \n" 20572 "\n" 20573 "\n" 20574 "\n" 20575 "SYNOPSIS:\n" 20576 "\n" 20577 "plstransform(coordinate_transform, coordinate_transform_data)\n" 20578 "\n" 20579 "ARGUMENTS:\n" 20580 "\n" 20581 " coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n" 20582 " PLPointer) , input) : Pointer to a function that defines a\n" 20583 " transformation from the input (x, y) coordinate to a new plot\n" 20584 " world coordinate. A NULL pointer means that no transform is\n" 20585 " applied. \n" 20586 "\n" 20587 " coordinate_transform_data (PLPointer, input) : Optional extra data\n" 20588 " for \n" 20589 " coordinate_transform. \n" 20590 "\n" 20591 ""}, 20592 { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n" 20593 "Plot a glyph at the specified points \n" 20594 "\n" 20595 "DESCRIPTION:\n" 20596 "\n" 20597 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n" 20598 " because many[!] more glyphs are accessible with plstring.) The glyph\n" 20599 " is specified with a PLplot user string. Note that the user string is\n" 20600 " not actually limited to one glyph so it is possible (but not normally\n" 20601 " useful) to plot more than one glyph at the specified points with this\n" 20602 " function. As with plmtex and plptex, the user string can contain FCI\n" 20603 " escapes to determine the font, UTF-8 code to determine the glyph or\n" 20604 " else PLplot escapes for Hershey or unicode text to determine the\n" 20605 " glyph. \n" 20606 "\n" 20607 " Redacted form: plstring(x, y, string)\n" 20608 "\n" 20609 " This function is used in examples 4, 21 and 26. \n" 20610 "\n" 20611 "\n" 20612 "\n" 20613 "SYNOPSIS:\n" 20614 "\n" 20615 "plstring(n, x, y, string)\n" 20616 "\n" 20617 "ARGUMENTS:\n" 20618 "\n" 20619 " n (PLINT, input) : Number of points in the x and y arrays. \n" 20620 "\n" 20621 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n" 20622 " of points. \n" 20623 "\n" 20624 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n" 20625 " of points. \n" 20626 "\n" 20627 " string (const char *, input) : PLplot user string corresponding to\n" 20628 " the glyph to be plotted at each of the n points. \n" 20629 "\n" 20630 ""}, 20631 { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n" 20632 "Plot a glyph at the specified 3D points \n" 20633 "\n" 20634 "DESCRIPTION:\n" 20635 "\n" 20636 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n" 20637 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n" 20638 " this function similar to what is done for plline3. The glyph is\n" 20639 " specified with a PLplot user string. Note that the user string is not\n" 20640 " actually limited to one glyph so it is possible (but not normally\n" 20641 " useful) to plot more than one glyph at the specified points with this\n" 20642 " function. As with plmtex and plptex, the user string can contain FCI\n" 20643 " escapes to determine the font, UTF-8 code to determine the glyph or\n" 20644 " else PLplot escapes for Hershey or unicode text to determine the\n" 20645 " glyph. \n" 20646 "\n" 20647 " Redacted form: plstring3(x, y, z, string)\n" 20648 "\n" 20649 " This function is used in example 18. \n" 20650 "\n" 20651 "\n" 20652 "\n" 20653 "SYNOPSIS:\n" 20654 "\n" 20655 "plstring3(n, x, y, z, string)\n" 20656 "\n" 20657 "ARGUMENTS:\n" 20658 "\n" 20659 " n (PLINT, input) : Number of points in the x, y, and z arrays. \n" 20660 "\n" 20661 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n" 20662 " of points. \n" 20663 "\n" 20664 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n" 20665 " of points. \n" 20666 "\n" 20667 " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n" 20668 " of points. \n" 20669 "\n" 20670 " string (const char *, input) : PLplot user string corresponding to\n" 20671 " the glyph to be plotted at each of the n points. \n" 20672 "\n" 20673 ""}, 20674 { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n" 20675 "Add a point to a strip chart \n" 20676 "\n" 20677 "DESCRIPTION:\n" 20678 "\n" 20679 " Add a point to a given pen of a given strip chart. There is no need\n" 20680 " for all pens to have the same number of points or to be equally\n" 20681 " sampled in the x coordinate. Allocates memory and rescales as\n" 20682 " necessary. \n" 20683 "\n" 20684 " Redacted form: plstripa(id, pen, x, y)\n" 20685 "\n" 20686 " This function is used in example 17. \n" 20687 "\n" 20688 "\n" 20689 "\n" 20690 "SYNOPSIS:\n" 20691 "\n" 20692 "plstripa(id, pen, x, y)\n" 20693 "\n" 20694 "ARGUMENTS:\n" 20695 "\n" 20696 " id (PLINT, input) : Identification number of the strip chart (set\n" 20697 " up in plstripc). \n" 20698 "\n" 20699 " pen (PLINT, input) : Pen number (ranges from 0 to 3). \n" 20700 "\n" 20701 " x (PLFLT, input) : X coordinate of point to plot. \n" 20702 "\n" 20703 " y (PLFLT, input) : Y coordinate of point to plot. \n" 20704 "\n" 20705 ""}, 20706 { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n" 20707 "Create a 4-pen strip chart \n" 20708 "\n" 20709 "DESCRIPTION:\n" 20710 "\n" 20711 " Create a 4-pen strip chart, to be used afterwards by plstripa\n" 20712 "\n" 20713 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n" 20714 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n" 20715 " styline, legline, labx, laby, labz)\n" 20716 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n" 20717 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n" 20718 " ypsec, legline, labx, laby, labtop)\n" 20719 "\n" 20720 "\n" 20721 " This function is used in example 17. \n" 20722 "\n" 20723 "\n" 20724 "\n" 20725 "SYNOPSIS:\n" 20726 "\n" 20727 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n" 20728 "\n" 20729 "ARGUMENTS:\n" 20730 "\n" 20731 " id (PLINT *, output) : Identification number of strip chart to use\n" 20732 " on plstripa and plstripd. \n" 20733 "\n" 20734 " xspec (const char *, input) : X-axis specification as in plbox. \n" 20735 "\n" 20736 " yspec (const char *, input) : Y-axis specification as in plbox. \n" 20737 "\n" 20738 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n" 20739 " change as data are added. \n" 20740 "\n" 20741 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n" 20742 " change as data are added. \n" 20743 "\n" 20744 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n" 20745 " is multiplied by the factor (1 + \n" 20746 " xjump). \n" 20747 "\n" 20748 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n" 20749 " change as data are added. \n" 20750 "\n" 20751 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n" 20752 " change as data are added. \n" 20753 "\n" 20754 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n" 20755 "\n" 20756 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n" 20757 "\n" 20758 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n" 20759 " true, otherwise not. \n" 20760 "\n" 20761 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n" 20762 " otherwise slide display. \n" 20763 "\n" 20764 " colbox (PLINT, input) : Plot box color index (cmap0). \n" 20765 "\n" 20766 " collab (PLINT, input) : Legend color index (cmap0). \n" 20767 "\n" 20768 " colline (const PLINT *, input) : Pointer to array with color\n" 20769 " indices (cmap0) for the 4 pens. \n" 20770 "\n" 20771 " styline (const PLINT *, input) : Pointer to array with line styles\n" 20772 " for the 4 pens. \n" 20773 "\n" 20774 " legline (const char **, input) : Pointer to character array\n" 20775 " containing legends for the 4 pens. \n" 20776 "\n" 20777 " labx (const char *, input) : X-axis label. \n" 20778 "\n" 20779 " laby (const char *, input) : Y-axis label. \n" 20780 "\n" 20781 " labtop (const char *, input) : Plot title. \n" 20782 "\n" 20783 ""}, 20784 { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n" 20785 "Deletes and releases memory used by a strip chart \n" 20786 "\n" 20787 "DESCRIPTION:\n" 20788 "\n" 20789 " Deletes and releases memory used by a strip chart. \n" 20790 "\n" 20791 " Redacted form: plstripd(id)\n" 20792 "\n" 20793 " This function is used in example 17. \n" 20794 "\n" 20795 "\n" 20796 "\n" 20797 "SYNOPSIS:\n" 20798 "\n" 20799 "plstripd(id)\n" 20800 "\n" 20801 "ARGUMENTS:\n" 20802 "\n" 20803 " id (PLINT, input) : Identification number of strip chart to delete. \n" 20804 "\n" 20805 ""}, 20806 { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n" 20807 "Set line style \n" 20808 "\n" 20809 "DESCRIPTION:\n" 20810 "\n" 20811 " This sets up the line style for all lines subsequently drawn. A line\n" 20812 " consists of segments in which the pen is alternately down and up. The\n" 20813 " lengths of these segments are passed in the arrays mark and space\n" 20814 " respectively. The number of mark-space pairs is specified by nms. In\n" 20815 " order to return the line style to the default continuous line, plstyl\n" 20816 " should be called with nms=0.(see also pllsty) \n" 20817 "\n" 20818 " Redacted form: plstyl(mark, space)\n" 20819 "\n" 20820 " This function is used in examples 1,9,14. \n" 20821 "\n" 20822 "\n" 20823 "\n" 20824 "SYNOPSIS:\n" 20825 "\n" 20826 "plstyl(nms, mark, space)\n" 20827 "\n" 20828 "ARGUMENTS:\n" 20829 "\n" 20830 " nms (PLINT, input) : The number of mark and space elements in a\n" 20831 " line. Thus a simple broken line can be obtained by setting nms=1.\n" 20832 " A continuous line is specified by setting nms=0. \n" 20833 "\n" 20834 " mark (const PLINT *, input) : Pointer to array with the lengths of\n" 20835 " the segments during which the pen is down, measured in\n" 20836 " micrometers. \n" 20837 "\n" 20838 " space (const PLINT *, input) : Pointer to array with the lengths of\n" 20839 " the segments during which the pen is up, measured in micrometers. \n" 20840 "\n" 20841 ""}, 20842 { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n" 20843 "Set arrow style for vector plots \n" 20844 "\n" 20845 "DESCRIPTION:\n" 20846 "\n" 20847 " Set the style for the arrow used by plvect to plot vectors. \n" 20848 "\n" 20849 " Redacted form: plsvect(arrowx, arrowy, fill)\n" 20850 "\n" 20851 " This function is used in example 22. \n" 20852 "\n" 20853 "\n" 20854 "\n" 20855 "SYNOPSIS:\n" 20856 "\n" 20857 "plsvect(arrowx, arrowy, npts, fill)\n" 20858 "\n" 20859 "ARGUMENTS:\n" 20860 "\n" 20861 " arrowx, arrowy (const PLFLT *,input) : Pointers to a pair of arrays\n" 20862 " containing the x and y points which make up the arrow. The arrow\n" 20863 " is plotted by joining these points to form a polygon. The scaling\n" 20864 " assumes that the x and y points in the arrow lie in the range -0.5\n" 20865 " <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n" 20866 " style will be reset to its default. \n" 20867 "\n" 20868 " npts (PLINT,input) : Number of points in the arrays arrowx and\n" 20869 " arrowy. \n" 20870 "\n" 20871 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n" 20872 " fill is false then the arrow is open. \n" 20873 "\n" 20874 ""}, 20875 { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n" 20876 "Specify viewport in absolute coordinates \n" 20877 "\n" 20878 "DESCRIPTION:\n" 20879 "\n" 20880 " Alternate routine to plvpor for setting up the viewport. This routine\n" 20881 " should be used only if the viewport is required to have a definite\n" 20882 " size in millimeters. The routine plgspa is useful for finding out the\n" 20883 " size of the current subpage. \n" 20884 "\n" 20885 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n" 20886 "\n" 20887 " This function is used in example 10. \n" 20888 "\n" 20889 "\n" 20890 "\n" 20891 "SYNOPSIS:\n" 20892 "\n" 20893 "plsvpa(xmin, xmax, ymin, ymax)\n" 20894 "\n" 20895 "ARGUMENTS:\n" 20896 "\n" 20897 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n" 20898 " viewport from the left-hand edge of the subpage in millimeters. \n" 20899 "\n" 20900 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n" 20901 " viewport from the left-hand edge of the subpage in millimeters. \n" 20902 "\n" 20903 " ymin (PLFLT, input) : The distance of the bottom edge of the\n" 20904 " viewport from the bottom edge of the subpage in millimeters. \n" 20905 "\n" 20906 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n" 20907 " from the bottom edge of the subpage in millimeters. \n" 20908 "\n" 20909 ""}, 20910 { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n" 20911 "Set x axis parameters \n" 20912 "\n" 20913 "DESCRIPTION:\n" 20914 "\n" 20915 " Sets values of the digmax and digits flags for the x axis. See the\n" 20916 " PLplot documentation for more information. \n" 20917 "\n" 20918 " Redacted form: plsxax(digmax, digits)\n" 20919 "\n" 20920 " This function is used in example 31. \n" 20921 "\n" 20922 "\n" 20923 "\n" 20924 "SYNOPSIS:\n" 20925 "\n" 20926 "plsxax(digmax, digits)\n" 20927 "\n" 20928 "ARGUMENTS:\n" 20929 "\n" 20930 " digmax (PLINT, input) : Variable to set the maximum number of\n" 20931 " digits for the x axis. If nonzero, the printed label will be\n" 20932 " switched to a floating point representation when the number of\n" 20933 " digits exceeds digmax. \n" 20934 "\n" 20935 " digits (PLINT, input) : Field digits value. Currently, changing\n" 20936 " its value here has no effect since it is set only by plbox or\n" 20937 " plbox3. However, the user may obtain its value after a call to\n" 20938 " either of these functions by calling plgxax. \n" 20939 "\n" 20940 ""}, 20941 { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n" 20942 "Set y axis parameters \n" 20943 "\n" 20944 "DESCRIPTION:\n" 20945 "\n" 20946 " Identical to plsxax, except that arguments are flags for y axis. See\n" 20947 " the description of plsxax for more detail. \n" 20948 "\n" 20949 " Redacted form: plsyax(digmax, digits)\n" 20950 "\n" 20951 " This function is used in examples 1,14,31. \n" 20952 "\n" 20953 "\n" 20954 "\n" 20955 "SYNOPSIS:\n" 20956 "\n" 20957 "plsyax(digmax, digits)\n" 20958 "\n" 20959 "ARGUMENTS:\n" 20960 "\n" 20961 " digmax (PLINT, input) : Variable to set the maximum number of\n" 20962 " digits for the y axis. If nonzero, the printed label will be\n" 20963 " switched to a floating point representation when the number of\n" 20964 " digits exceeds digmax. \n" 20965 "\n" 20966 " digits (PLINT, input) : Field digits value. Currently, changing\n" 20967 " its value here has no effect since it is set only by plbox or\n" 20968 " plbox3. However, the user may obtain its value after a call to\n" 20969 " either of these functions by calling plgyax. \n" 20970 "\n" 20971 ""}, 20972 { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n" 20973 "Plot a glyph at the specified points \n" 20974 "\n" 20975 "DESCRIPTION:\n" 20976 "\n" 20977 " Plot a glyph at the specified points. (This function is largely\n" 20978 " superseded by plstring which gives access to many[!] more glyphs.) \n" 20979 "\n" 20980 " Redacted form: plsym(x, y, code)\n" 20981 "\n" 20982 " This function is used in example 7. \n" 20983 "\n" 20984 "\n" 20985 "\n" 20986 "SYNOPSIS:\n" 20987 "\n" 20988 "plsym(n, x, y, code)\n" 20989 "\n" 20990 "ARGUMENTS:\n" 20991 "\n" 20992 " n (PLINT, input) : Number of points in the x and y arrays. \n" 20993 "\n" 20994 " x (const PLFLT *, input) : Pointer to an array with X coordinates\n" 20995 " of points. \n" 20996 "\n" 20997 " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n" 20998 " of points. \n" 20999 "\n" 21000 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n" 21001 " to be plotted at each of the n points. \n" 21002 "\n" 21003 ""}, 21004 { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n" 21005 "Set z axis parameters \n" 21006 "\n" 21007 "DESCRIPTION:\n" 21008 "\n" 21009 " Identical to plsxax, except that arguments are flags for z axis. See\n" 21010 " the description of plsxax for more detail. \n" 21011 "\n" 21012 " Redacted form: plszax(digmax, digits)\n" 21013 "\n" 21014 " This function is used in example 31. \n" 21015 "\n" 21016 "\n" 21017 "\n" 21018 "SYNOPSIS:\n" 21019 "\n" 21020 "plszax(digmax, digits)\n" 21021 "\n" 21022 "ARGUMENTS:\n" 21023 "\n" 21024 " digmax (PLINT, input) : Variable to set the maximum number of\n" 21025 " digits for the z axis. If nonzero, the printed label will be\n" 21026 " switched to a floating point representation when the number of\n" 21027 " digits exceeds digmax. \n" 21028 "\n" 21029 " digits (PLINT, input) : Field digits value. Currently, changing\n" 21030 " its value here has no effect since it is set only by plbox or\n" 21031 " plbox3. However, the user may obtain its value after a call to\n" 21032 " either of these functions by calling plgzax. \n" 21033 "\n" 21034 ""}, 21035 { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n" 21036 "Switch to text screen \n" 21037 "\n" 21038 "DESCRIPTION:\n" 21039 "\n" 21040 " Sets an interactive device to text mode, used in conjunction with\n" 21041 " plgra to allow graphics and text to be interspersed. On a device\n" 21042 " which supports separate text and graphics windows, this command causes\n" 21043 " control to be switched to the text window. This can be useful for\n" 21044 " printing diagnostic messages or getting user input, which would\n" 21045 " otherwise interfere with the plots. The program must switch back to\n" 21046 " the graphics window before issuing plot commands, as the text (or\n" 21047 " console) device will probably become quite confused otherwise. If\n" 21048 " already in text mode, this command is ignored. It is also ignored on\n" 21049 " devices which only support a single window or use a different method\n" 21050 " for shifting focus (see also plgra). \n" 21051 "\n" 21052 " Redacted form: pltext()\n" 21053 "\n" 21054 " This function is used in example 1. \n" 21055 "\n" 21056 "\n" 21057 "\n" 21058 "SYNOPSIS:\n" 21059 "\n" 21060 "pltext()\n" 21061 "\n" 21062 ""}, 21063 { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n" 21064 "Set format for date / time labels \n" 21065 "\n" 21066 "DESCRIPTION:\n" 21067 "\n" 21068 " Sets the format for date / time labels. To enable date / time format\n" 21069 " labels see the options to plbox and plenv. \n" 21070 "\n" 21071 " Redacted form: pltimefmt(fmt)\n" 21072 "\n" 21073 " This function is used in example 29. \n" 21074 "\n" 21075 "\n" 21076 "\n" 21077 "SYNOPSIS:\n" 21078 "\n" 21079 "pltimefmt(fmt)\n" 21080 "\n" 21081 "ARGUMENTS:\n" 21082 "\n" 21083 " fmt (const char *, fmt) : This string is passed directly to the\n" 21084 " system strftime. See the system documentation for a full list of\n" 21085 " conversion specifications for your system. All conversion\n" 21086 " specifications take the form of a '%' character followed by\n" 21087 " further conversion specification character. All other text is\n" 21088 " printed as-is. Common options include: %c: The preferred date and\n" 21089 " time representation for the current locale. \n" 21090 " %d: The day of the month as a decimal number. \n" 21091 " %H: The hour as a decimal number using a 24-hour clock. \n" 21092 " %j: The day of the year as a decimal number. \n" 21093 " %m: The month as a decimal number. \n" 21094 " %M: The minute as a decimal number. \n" 21095 " %S: The second as a decimal number. \n" 21096 " %y: The year as a decimal number without a century. \n" 21097 " %Y: The year as a decimal number including a century. \n" 21098 "\n" 21099 ""}, 21100 { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n" 21101 "Specify viewport using aspect ratio only \n" 21102 "\n" 21103 "DESCRIPTION:\n" 21104 "\n" 21105 " Sets the viewport so that the ratio of the length of the y axis to\n" 21106 " that of the x axis is equal to aspect. \n" 21107 "\n" 21108 " Redacted form: plvasp(aspect)\n" 21109 "\n" 21110 " This function is used in example 13. \n" 21111 "\n" 21112 "\n" 21113 "\n" 21114 "SYNOPSIS:\n" 21115 "\n" 21116 "plvasp(aspect)\n" 21117 "\n" 21118 "ARGUMENTS:\n" 21119 "\n" 21120 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n" 21121 " axis. \n" 21122 "\n" 21123 ""}, 21124 { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n" 21125 "Vector plot \n" 21126 "\n" 21127 "DESCRIPTION:\n" 21128 "\n" 21129 " Draws a vector plot of the vector (\n" 21130 " u[\n" 21131 " nx][\n" 21132 " ny],\n" 21133 " v[\n" 21134 " nx][\n" 21135 " ny]). The scaling factor for the vectors is given by scale. A\n" 21136 " transformation routine pointed to by pltr with a pointer pltr_data for\n" 21137 " additional data required by the transformation routine is used to map\n" 21138 " indices within the array to the world coordinates. The style of the\n" 21139 " vector arrow may be set using plsvect. \n" 21140 "\n" 21141 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n" 21142 "\n" 21143 " This function is used in example 22. \n" 21144 "\n" 21145 "\n" 21146 "\n" 21147 "SYNOPSIS:\n" 21148 "\n" 21149 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n" 21150 "\n" 21151 "ARGUMENTS:\n" 21152 "\n" 21153 " u, v (const PLFLT * const *, input) : Pointers to a pair of\n" 21154 " vectored two-dimensional arrays containing the x and y components\n" 21155 " of the vector data to be plotted. \n" 21156 "\n" 21157 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n" 21158 "\n" 21159 " scale (PLFLT, input) : Parameter to control the scaling factor of\n" 21160 " the vectors for plotting. If scale = 0 then the scaling factor is\n" 21161 " automatically calculated for the data. If scale < 0 then the\n" 21162 " scaling factor is automatically calculated for the data and then\n" 21163 " multiplied by -\n" 21164 " scale. If scale > 0 then the scaling factor is set to scale. \n" 21165 "\n" 21166 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n" 21167 " Pointer to function that defines transformation between indices\n" 21168 " in array z and the world coordinates (C only). Transformation\n" 21169 " functions are provided in the PLplot library: pltr0 for identity\n" 21170 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n" 21171 " defined by one- and two-dimensional arrays. In addition,\n" 21172 " user-supplied routines for the transformation can be used as well.\n" 21173 " Examples of all of these approaches are given in the PLplot\n" 21174 " documentation. The transformation function should have the form\n" 21175 " given by any of pltr0, pltr1, or pltr2. \n" 21176 "\n" 21177 " pltr_data (PLPointer, input) : Extra parameter to help pass\n" 21178 " information to pltr0, pltr1, pltr2, or whatever routine that is\n" 21179 " externally supplied. \n" 21180 "\n" 21181 ""}, 21182 { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n" 21183 "Specify viewport using coordinates and aspect ratio \n" 21184 "\n" 21185 "DESCRIPTION:\n" 21186 "\n" 21187 " Device-independent routine for setting up the viewport. The viewport\n" 21188 " is chosen to be the largest with the given aspect ratio that fits\n" 21189 " within the specified region (in terms of normalized subpage\n" 21190 " coordinates). This routine is functionally equivalent to plvpor when\n" 21191 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n" 21192 " routine reserves no extra space at the edges for labels. \n" 21193 "\n" 21194 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n" 21195 "\n" 21196 " This function is used in example 9. \n" 21197 "\n" 21198 "\n" 21199 "\n" 21200 "SYNOPSIS:\n" 21201 "\n" 21202 "plvpas(xmin, xmax, ymin, ymax, aspect)\n" 21203 "\n" 21204 "ARGUMENTS:\n" 21205 "\n" 21206 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n" 21207 " left-hand edge of the viewport. \n" 21208 "\n" 21209 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n" 21210 " right-hand edge of the viewport. \n" 21211 "\n" 21212 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n" 21213 " bottom edge of the viewport. \n" 21214 "\n" 21215 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n" 21216 " edge of the viewport. \n" 21217 "\n" 21218 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n" 21219 " axis. \n" 21220 "\n" 21221 ""}, 21222 { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n" 21223 "Specify viewport using coordinates \n" 21224 "\n" 21225 "DESCRIPTION:\n" 21226 "\n" 21227 " Device-independent routine for setting up the viewport. This defines\n" 21228 " the viewport in terms of normalized subpage coordinates which run from\n" 21229 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n" 21230 " current subpage. Use the alternate routine plsvpa in order to create\n" 21231 " a viewport of a definite size. \n" 21232 "\n" 21233 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n" 21234 "\n" 21235 " This function is used in examples\n" 21236 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n" 21237 "\n" 21238 "\n" 21239 "\n" 21240 "SYNOPSIS:\n" 21241 "\n" 21242 "plvpor(xmin, xmax, ymin, ymax)\n" 21243 "\n" 21244 "ARGUMENTS:\n" 21245 "\n" 21246 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n" 21247 " left-hand edge of the viewport. \n" 21248 "\n" 21249 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n" 21250 " right-hand edge of the viewport. \n" 21251 "\n" 21252 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n" 21253 " bottom edge of the viewport. \n" 21254 "\n" 21255 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n" 21256 " edge of the viewport. \n" 21257 "\n" 21258 ""}, 21259 { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n" 21260 "Select standard viewport \n" 21261 "\n" 21262 "DESCRIPTION:\n" 21263 "\n" 21264 " Sets up a standard viewport, leaving a left-hand margin of seven\n" 21265 " character heights, and four character heights around the other three\n" 21266 " sides. \n" 21267 "\n" 21268 " Redacted form: plvsta()\n" 21269 "\n" 21270 " This function is used in examples 1,12,14,17,25,29. \n" 21271 "\n" 21272 "\n" 21273 "\n" 21274 "SYNOPSIS:\n" 21275 "\n" 21276 "plvsta()\n" 21277 "\n" 21278 ""}, 21279 { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n" 21280 "Set up window for 3-d plotting \n" 21281 "\n" 21282 "DESCRIPTION:\n" 21283 "\n" 21284 " Sets up a window for a three-dimensional surface plot within the\n" 21285 " currently defined two-dimensional window. The enclosing box for the\n" 21286 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n" 21287 " user-coordinate space is mapped into a box of world coordinate size\n" 21288 " basex by basey by height so that xmin maps to -\n" 21289 " basex/2, xmax maps to basex/2, ymin maps to -\n" 21290 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n" 21291 " The resulting world-coordinate box is then viewed by an observer at\n" 21292 " altitude alt and azimuth az. This routine must be called before\n" 21293 " plbox3 or plot3d. For a more complete description of\n" 21294 " three-dimensional plotting see the PLplot documentation. \n" 21295 "\n" 21296 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n" 21297 " zmin, zmax, alt, az)\n" 21298 "\n" 21299 " This function is examples 8,11,18,21. \n" 21300 "\n" 21301 "\n" 21302 "\n" 21303 "SYNOPSIS:\n" 21304 "\n" 21305 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n" 21306 "\n" 21307 "ARGUMENTS:\n" 21308 "\n" 21309 " basex (PLFLT, input) : The x coordinate size of the\n" 21310 " world-coordinate box. \n" 21311 "\n" 21312 " basey (PLFLT, input) : The y coordinate size of the\n" 21313 " world-coordinate box. \n" 21314 "\n" 21315 " height (PLFLT, input) : The z coordinate size of the\n" 21316 " world-coordinate box. \n" 21317 "\n" 21318 " xmin (PLFLT, input) : The minimum user x coordinate value. \n" 21319 "\n" 21320 " xmax (PLFLT, input) : The maximum user x coordinate value. \n" 21321 "\n" 21322 " ymin (PLFLT, input) : The minimum user y coordinate value. \n" 21323 "\n" 21324 " ymax (PLFLT, input) : The maximum user y coordinate value. \n" 21325 "\n" 21326 " zmin (PLFLT, input) : The minimum user z coordinate value. \n" 21327 "\n" 21328 " zmax (PLFLT, input) : The maximum user z coordinate value. \n" 21329 "\n" 21330 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n" 21331 " plane. \n" 21332 "\n" 21333 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n" 21334 " observer is looking face onto the ZX plane, and as az is\n" 21335 " increased, the observer moves clockwise around the box when viewed\n" 21336 " from above the XY plane. \n" 21337 "\n" 21338 ""}, 21339 { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n" 21340 "Set pen width \n" 21341 "\n" 21342 "DESCRIPTION:\n" 21343 "\n" 21344 " Sets the pen width. \n" 21345 "\n" 21346 " Redacted form: plwidth(width)\n" 21347 "\n" 21348 " This function is used in examples 1,2. \n" 21349 "\n" 21350 "\n" 21351 "\n" 21352 "SYNOPSIS:\n" 21353 "\n" 21354 "plwidth(width)\n" 21355 "\n" 21356 "ARGUMENTS:\n" 21357 "\n" 21358 " width (PLFLT, input) : The desired pen width. If width is negative\n" 21359 " or the same as the previous value no action is taken. width = 0.\n" 21360 " should be interpreted as as the minimum valid pen width for the\n" 21361 " device. The interpretation of positive width values is also\n" 21362 " device dependent. \n" 21363 "\n" 21364 ""}, 21365 { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n" 21366 "Specify world coordinates of viewport boundaries \n" 21367 "\n" 21368 "DESCRIPTION:\n" 21369 "\n" 21370 " Sets up the world coordinates of the edges of the viewport. \n" 21371 "\n" 21372 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n" 21373 "\n" 21374 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n" 21375 "\n" 21376 "\n" 21377 "\n" 21378 "SYNOPSIS:\n" 21379 "\n" 21380 "plwind(xmin, xmax, ymin, ymax)\n" 21381 "\n" 21382 "ARGUMENTS:\n" 21383 "\n" 21384 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n" 21385 " of the viewport. \n" 21386 "\n" 21387 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n" 21388 " of the viewport. \n" 21389 "\n" 21390 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n" 21391 " the viewport. \n" 21392 "\n" 21393 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n" 21394 " viewport. \n" 21395 "\n" 21396 ""}, 21397 { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n" 21398 "Enter or leave xor mode \n" 21399 "\n" 21400 "DESCRIPTION:\n" 21401 "\n" 21402 " Enter (when mode is true) or leave (when mode is false) xor mode for\n" 21403 " those drivers (e.g., the xwin driver) that support it. Enables\n" 21404 " erasing plots by drawing twice the same line, symbol, etc. If driver\n" 21405 " is not capable of xor operation it returns a status of false. \n" 21406 "\n" 21407 " Redacted form: plxormod(mode, status)\n" 21408 "\n" 21409 " This function is used in examples 1,20. \n" 21410 "\n" 21411 "\n" 21412 "\n" 21413 "SYNOPSIS:\n" 21414 "\n" 21415 "plxormod(mode, status)\n" 21416 "\n" 21417 "ARGUMENTS:\n" 21418 "\n" 21419 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n" 21420 " is false means leave xor mode. \n" 21421 "\n" 21422 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n" 21423 " of true (false) means driver is capable (incapable) of xor mode. \n" 21424 "\n" 21425 ""}, 21426 { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n" 21427 "Plot continental outline in world coordinates \n" 21428 "\n" 21429 "DESCRIPTION:\n" 21430 "\n" 21431 " Plots continental outlines in world coordinates. examples/c/x19c\n" 21432 " demonstrates how to use this function to create different\n" 21433 " projections. \n" 21434 "\n" 21435 " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n" 21436 " minlat, maxlat)\n" 21437 " F95, Java, Perl/PDL, Python: Not implemented? \n" 21438 "\n" 21439 "\n" 21440 " This function is used in example 19. \n" 21441 "\n" 21442 "\n" 21443 "\n" 21444 "SYNOPSIS:\n" 21445 "\n" 21446 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n" 21447 "\n" 21448 "ARGUMENTS:\n" 21449 "\n" 21450 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n" 21451 " supplied function to transform the coordinate longitudes and\n" 21452 " latitudes to a plot coordinate system. By using this transform,\n" 21453 " we can change from a longitude, latitude coordinate to a polar\n" 21454 " stereographic project, for example. Initially, x[0]..[n-1] are\n" 21455 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n" 21456 " After the call to mapform(), x[] and y[] should be replaced by\n" 21457 " the corresponding plot coordinates. If no transform is desired,\n" 21458 " mapform can be replaced by NULL. \n" 21459 "\n" 21460 " type (const char *, input) : type is a character string. The value\n" 21461 " of this parameter determines the type of background. The possible\n" 21462 " values are: \"globe\" -- continental outlines \n" 21463 " \"usa\" -- USA and state boundaries \n" 21464 " \"cglobe\" -- continental outlines and countries \n" 21465 " \"usaglobe\" -- USA, state boundaries and continental outlines \n" 21466 "\n" 21467 "\n" 21468 " minlong (PLFLT, input) : The value of the longitude on the left\n" 21469 " side of the plot. The value of minlong must be less than the\n" 21470 " value of maxlong, and the quantity maxlong-minlong must be less\n" 21471 " than or equal to 360. \n" 21472 "\n" 21473 " maxlong (PLFLT, input) : The value of the longitude on the right\n" 21474 " side of the plot. \n" 21475 "\n" 21476 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n" 21477 " background. One can always use -90.0 as the boundary outside the\n" 21478 " plot window will be automatically eliminated. However, the\n" 21479 " program will be faster if one can reduce the size of the\n" 21480 " background plotted. \n" 21481 "\n" 21482 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n" 21483 " background. One can always use 90.0 as the boundary outside the\n" 21484 " plot window will be automatically eliminated. \n" 21485 "\n" 21486 ""}, 21487 { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n" 21488 "Plot latitude and longitude lines \n" 21489 "\n" 21490 "DESCRIPTION:\n" 21491 "\n" 21492 " Displays latitude and longitude on the current plot. The lines are\n" 21493 " plotted in the current color and line style. \n" 21494 "\n" 21495 " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n" 21496 " maxlong, minlat, maxlat)\n" 21497 " F95, Java, Perl/PDL, Python: Not implemented? \n" 21498 "\n" 21499 "\n" 21500 " This function is used in example 19. \n" 21501 "\n" 21502 "\n" 21503 "\n" 21504 "SYNOPSIS:\n" 21505 "\n" 21506 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n" 21507 "\n" 21508 "ARGUMENTS:\n" 21509 "\n" 21510 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n" 21511 " supplied function to transform the coordinate longitudes and\n" 21512 " latitudes to a plot coordinate system. By using this transform,\n" 21513 " we can change from a longitude, latitude coordinate to a polar\n" 21514 " stereographic project, for example. Initially, x[0]..[n-1] are\n" 21515 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n" 21516 " After the call to mapform(), x[] and y[] should be replaced by\n" 21517 " the corresponding plot coordinates. If no transform is desired,\n" 21518 " mapform can be replaced by NULL. \n" 21519 "\n" 21520 " dlong (PLFLT, input) : The interval in degrees at which the\n" 21521 " longitude lines are to be plotted. \n" 21522 "\n" 21523 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n" 21524 " lines are to be plotted. \n" 21525 "\n" 21526 " minlong (PLFLT, input) : The value of the longitude on the left\n" 21527 " side of the plot. The value of minlong must be less than the\n" 21528 " value of maxlong, and the quantity maxlong-minlong must be less\n" 21529 " than or equal to 360. \n" 21530 "\n" 21531 " maxlong (PLFLT, input) : The value of the longitude on the right\n" 21532 " side of the plot. \n" 21533 "\n" 21534 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n" 21535 " background. One can always use -90.0 as the boundary outside the\n" 21536 " plot window will be automatically eliminated. However, the\n" 21537 " program will be faster if one can reduce the size of the\n" 21538 " background plotted. \n" 21539 "\n" 21540 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n" 21541 " background. One can always use 90.0 as the boundary outside the\n" 21542 " plot window will be automatically eliminated. \n" 21543 "\n" 21544 ""}, 21545 { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n" 21546 "Plot a 2D matrix using cmap1 with automatic colour adjustment \n" 21547 "\n" 21548 "DESCRIPTION:\n" 21549 "\n" 21550 " Plot a 2D matrix using color palette 1. The color scale is\n" 21551 " automatically adjusted to use the maximum and minimum values in idata\n" 21552 " as valuemin and valuemax in a call to plimagefr. \n" 21553 "\n" 21554 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n" 21555 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n" 21556 "\n" 21557 "\n" 21558 " This function is used in example 20. \n" 21559 "\n" 21560 "\n" 21561 "\n" 21562 "SYNOPSIS:\n" 21563 "\n" 21564 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n" 21565 "\n" 21566 "ARGUMENTS:\n" 21567 "\n" 21568 " idata (const PLFLT * const *, input) : A 2D array of values\n" 21569 " (intensities) to plot. Should have dimensions idata[nx][ny]. \n" 21570 "\n" 21571 " nx, ny (PLINT, input) : Dimensions of idata \n" 21572 "\n" 21573 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to stretch\n" 21574 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n" 21575 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n" 21576 "\n" 21577 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n" 21578 " (inclusive) will be plotted. \n" 21579 "\n" 21580 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n" 21581 " points whose plot coordinates fall inside the window of (Dxmin,\n" 21582 " Dymin) to (Dxmax, Dymax). \n" 21583 "\n" 21584 ""}, 21585 { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n" 21586 "Plot a 2D matrix using cmap1 \n" 21587 "\n" 21588 "DESCRIPTION:\n" 21589 "\n" 21590 " Plot a 2D matrix using cmap1. \n" 21591 "\n" 21592 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n" 21593 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n" 21594 "\n" 21595 "\n" 21596 " This function is used in example 20. \n" 21597 "\n" 21598 "\n" 21599 "\n" 21600 "SYNOPSIS:\n" 21601 "\n" 21602 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n" 21603 "\n" 21604 "ARGUMENTS:\n" 21605 "\n" 21606 " idata (const PLFLT * const *, input) : A 2D array of values\n" 21607 " (intensities) to plot. Should have dimensions idata[nx][ny]. \n" 21608 "\n" 21609 " nx, ny (PLINT, input) : Dimensions of idata \n" 21610 "\n" 21611 " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n" 21612 " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n" 21613 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n" 21614 "\n" 21615 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n" 21616 " (inclusive) will be plotted. \n" 21617 "\n" 21618 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n" 21619 " values to use for value to color mappings. A datum equal to or\n" 21620 " less than valuemin will be plotted with color 0.0, while a datum\n" 21621 " equal to or greater than valuemax will be plotted with color 1.0. \n" 21622 " Data between valuemin and valuemax map linearly to colors between\n" 21623 " 0.0 and 1.0. \n" 21624 "\n" 21625 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n" 21626 " Pointer to function that defines a transformation between the\n" 21627 " data in the array idata and world coordinates. An input\n" 21628 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n" 21629 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n" 21630 " Some transformation functions are provided in the PLplot library:\n" 21631 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n" 21632 " mappings respectively defined by one- and two-dimensional arrays. \n" 21633 " In addition, user-supplied routines for the transformation can be\n" 21634 " used as well. Examples of all of these approaches are given in\n" 21635 " the PLplot documentation. The transformation function should have\n" 21636 " the form given by any of pltr0, pltr1, or pltr2. \n" 21637 "\n" 21638 " pltr_data (PLPointer, input) : Extra parameter to help pass\n" 21639 " information to pltr0, pltr1, pltr2, or whatever routine is\n" 21640 " externally supplied. \n" 21641 "\n" 21642 ""}, 21643 { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL}, 21644 { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL}, 21645 { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL}, 21646 { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL}, 21647 { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL}, 21648 { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL}, 21649 { NULL, NULL, 0, NULL } 21650 }; 21651 21652 21653 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ 21654 21655 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0}; 21656 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0}; 21657 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0}; 21658 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; 21659 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0}; 21660 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}; 21661 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}; 21662 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}; 21663 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}; 21664 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}; 21665 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0}; 21666 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; 21667 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0}; 21668 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0}; 21669 21670 static swig_type_info *swig_type_initial[] = { 21671 &_swigt__p_PLGraphicsIn, 21672 &_swigt__p_PLcGrid, 21673 &_swigt__p_PLcGrid2, 21674 &_swigt__p_char, 21675 &_swigt__p_double, 21676 &_swigt__p_f_double_double__int, 21677 &_swigt__p_f_double_double_p_double_p_double_p_void__void, 21678 &_swigt__p_f_int_double_p_char_int_p_void__void, 21679 &_swigt__p_f_int_p_double_p_double__void, 21680 &_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 21681 &_swigt__p_int, 21682 &_swigt__p_p_char, 21683 &_swigt__p_p_double, 21684 &_swigt__p_unsigned_int, 21685 }; 21686 21687 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}}; 21688 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}}; 21689 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}}; 21690 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; 21691 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; 21692 static swig_cast_info _swigc__p_f_double_double__int[] = { {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}}; 21693 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = { {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; 21694 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = { {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; 21695 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = { {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}}; 21696 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = { {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}}; 21697 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; 21698 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; 21699 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}}; 21700 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; 21701 21702 static swig_cast_info *swig_cast_initial[] = { 21703 _swigc__p_PLGraphicsIn, 21704 _swigc__p_PLcGrid, 21705 _swigc__p_PLcGrid2, 21706 _swigc__p_char, 21707 _swigc__p_double, 21708 _swigc__p_f_double_double__int, 21709 _swigc__p_f_double_double_p_double_p_double_p_void__void, 21710 _swigc__p_f_int_double_p_char_int_p_void__void, 21711 _swigc__p_f_int_p_double_p_double__void, 21712 _swigc__p_f_int_p_q_const__double_p_q_const__double__void, 21713 _swigc__p_int, 21714 _swigc__p_p_char, 21715 _swigc__p_p_double, 21716 _swigc__p_unsigned_int, 21717 }; 21718 21719 21720 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ 21721 21722 static swig_const_info swig_const_table[] = { 21723 {0, 0, 0, 0.0, 0, 0}}; 21724 21725 #ifdef __cplusplus 21726 } 21727 #endif 21728 /* ----------------------------------------------------------------------------- 21729 * Type initialization: 21730 * This problem is tough by the requirement that no dynamic 21731 * memory is used. Also, since swig_type_info structures store pointers to 21732 * swig_cast_info structures and swig_cast_info structures store pointers back 21733 * to swig_type_info structures, we need some lookup code at initialization. 21734 * The idea is that swig generates all the structures that are needed. 21735 * The runtime then collects these partially filled structures. 21736 * The SWIG_InitializeModule function takes these initial arrays out of 21737 * swig_module, and does all the lookup, filling in the swig_module.types 21738 * array with the correct data and linking the correct swig_cast_info 21739 * structures together. 21740 * 21741 * The generated swig_type_info structures are assigned statically to an initial 21742 * array. We just loop through that array, and handle each type individually. 21743 * First we lookup if this type has been already loaded, and if so, use the 21744 * loaded structure instead of the generated one. Then we have to fill in the 21745 * cast linked list. The cast data is initially stored in something like a 21746 * two-dimensional array. Each row corresponds to a type (there are the same 21747 * number of rows as there are in the swig_type_initial array). Each entry in 21748 * a column is one of the swig_cast_info structures for that type. 21749 * The cast_initial array is actually an array of arrays, because each row has 21750 * a variable number of columns. So to actually build the cast linked list, 21751 * we find the array of casts associated with the type, and loop through it 21752 * adding the casts to the list. The one last trick we need to do is making 21753 * sure the type pointer in the swig_cast_info struct is correct. 21754 * 21755 * First off, we lookup the cast->type name to see if it is already loaded. 21756 * There are three cases to handle: 21757 * 1) If the cast->type has already been loaded AND the type we are adding 21758 * casting info to has not been loaded (it is in this module), THEN we 21759 * replace the cast->type pointer with the type pointer that has already 21760 * been loaded. 21761 * 2) If BOTH types (the one we are adding casting info to, and the 21762 * cast->type) are loaded, THEN the cast info has already been loaded by 21763 * the previous module so we just ignore it. 21764 * 3) Finally, if cast->type has not already been loaded, then we add that 21765 * swig_cast_info to the linked list (because the cast->type) pointer will 21766 * be correct. 21767 * ----------------------------------------------------------------------------- */ 21768 21769 #ifdef __cplusplus 21770 extern "C" { 21771 #if 0 21772 } /* c-mode */ 21773 #endif 21774 #endif 21775 21776 #if 0 21777 #define SWIGRUNTIME_DEBUG 21778 #endif 21779 21780 21781 SWIGRUNTIME void 21782 SWIG_InitializeModule(void *clientdata) { 21783 size_t i; 21784 swig_module_info *module_head, *iter; 21785 int found, init; 21786 21787 /* check to see if the circular list has been setup, if not, set it up */ 21788 if (swig_module.next==0) { 21789 /* Initialize the swig_module */ 21790 swig_module.type_initial = swig_type_initial; 21791 swig_module.cast_initial = swig_cast_initial; 21792 swig_module.next = &swig_module; 21793 init = 1; 21794 } else { 21795 init = 0; 21796 } 21797 21798 /* Try and load any already created modules */ 21799 module_head = SWIG_GetModule(clientdata); 21800 if (!module_head) { 21801 /* This is the first module loaded for this interpreter */ 21802 /* so set the swig module into the interpreter */ 21803 SWIG_SetModule(clientdata, &swig_module); 21804 module_head = &swig_module; 21805 } else { 21806 /* the interpreter has loaded a SWIG module, but has it loaded this one? */ 21807 found=0; 21808 iter=module_head; 21809 do { 21810 if (iter==&swig_module) { 21811 found=1; 21812 break; 21813 } 21814 iter=iter->next; 21815 } while (iter!= module_head); 21816 21817 /* if the is found in the list, then all is done and we may leave */ 21818 if (found) return; 21819 /* otherwise we must add out module into the list */ 21820 swig_module.next = module_head->next; 21821 module_head->next = &swig_module; 21822 } 21823 21824 /* When multiple interpreters are used, a module could have already been initialized in 21825 a different interpreter, but not yet have a pointer in this interpreter. 21826 In this case, we do not want to continue adding types... everything should be 21827 set up already */ 21828 if (init == 0) return; 21829 21830 /* Now work on filling in swig_module.types */ 21831 #ifdef SWIGRUNTIME_DEBUG 21832 printf("SWIG_InitializeModule: size %d\n", swig_module.size); 21833 #endif 21834 for (i = 0; i < swig_module.size; ++i) { 21835 swig_type_info *type = 0; 21836 swig_type_info *ret; 21837 swig_cast_info *cast; 21838 21839 #ifdef SWIGRUNTIME_DEBUG 21840 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); 21841 #endif 21842 21843 /* if there is another module already loaded */ 21844 if (swig_module.next != &swig_module) { 21845 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); 21846 } 21847 if (type) { 21848 /* Overwrite clientdata field */ 21849 #ifdef SWIGRUNTIME_DEBUG 21850 printf("SWIG_InitializeModule: found type %s\n", type->name); 21851 #endif 21852 if (swig_module.type_initial[i]->clientdata) { 21853 type->clientdata = swig_module.type_initial[i]->clientdata; 21854 #ifdef SWIGRUNTIME_DEBUG 21855 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); 21856 #endif 21857 } 21858 } else { 21859 type = swig_module.type_initial[i]; 21860 } 21861 21862 /* Insert casting types */ 21863 cast = swig_module.cast_initial[i]; 21864 while (cast->type) { 21865 /* Don't need to add information already in the list */ 21866 ret = 0; 21867 #ifdef SWIGRUNTIME_DEBUG 21868 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); 21869 #endif 21870 if (swig_module.next != &swig_module) { 21871 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); 21872 #ifdef SWIGRUNTIME_DEBUG 21873 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); 21874 #endif 21875 } 21876 if (ret) { 21877 if (type == swig_module.type_initial[i]) { 21878 #ifdef SWIGRUNTIME_DEBUG 21879 printf("SWIG_InitializeModule: skip old type %s\n", ret->name); 21880 #endif 21881 cast->type = ret; 21882 ret = 0; 21883 } else { 21884 /* Check for casting already in the list */ 21885 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); 21886 #ifdef SWIGRUNTIME_DEBUG 21887 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); 21888 #endif 21889 if (!ocast) ret = 0; 21890 } 21891 } 21892 21893 if (!ret) { 21894 #ifdef SWIGRUNTIME_DEBUG 21895 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); 21896 #endif 21897 if (type->cast) { 21898 type->cast->prev = cast; 21899 cast->next = type->cast; 21900 } 21901 type->cast = cast; 21902 } 21903 cast++; 21904 } 21905 /* Set entry in modules->types array equal to the type */ 21906 swig_module.types[i] = type; 21907 } 21908 swig_module.types[i] = 0; 21909 21910 #ifdef SWIGRUNTIME_DEBUG 21911 printf("**** SWIG_InitializeModule: Cast List ******\n"); 21912 for (i = 0; i < swig_module.size; ++i) { 21913 int j = 0; 21914 swig_cast_info *cast = swig_module.cast_initial[i]; 21915 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); 21916 while (cast->type) { 21917 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); 21918 cast++; 21919 ++j; 21920 } 21921 printf("---- Total casts: %d\n",j); 21922 } 21923 printf("**** SWIG_InitializeModule: Cast List ******\n"); 21924 #endif 21925 } 21926 21927 /* This function will propagate the clientdata field of type to 21928 * any new swig_type_info structures that have been added into the list 21929 * of equivalent types. It is like calling 21930 * SWIG_TypeClientData(type, clientdata) a second time. 21931 */ 21932 SWIGRUNTIME void 21933 SWIG_PropagateClientData(void) { 21934 size_t i; 21935 swig_cast_info *equiv; 21936 static int init_run = 0; 21937 21938 if (init_run) return; 21939 init_run = 1; 21940 21941 for (i = 0; i < swig_module.size; i++) { 21942 if (swig_module.types[i]->clientdata) { 21943 equiv = swig_module.types[i]->cast; 21944 while (equiv) { 21945 if (!equiv->converter) { 21946 if (equiv->type && !equiv->type->clientdata) 21947 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); 21948 } 21949 equiv = equiv->next; 21950 } 21951 } 21952 } 21953 } 21954 21955 #ifdef __cplusplus 21956 #if 0 21957 { 21958 /* c-mode */ 21959 #endif 21960 } 21961 #endif 21962 21963 21964 21965 #ifdef __cplusplus 21966 extern "C" { 21967 #endif 21968 21969 /* Python-specific SWIG API */ 21970 #define SWIG_newvarlink() SWIG_Python_newvarlink() 21971 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) 21972 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) 21973 21974 /* ----------------------------------------------------------------------------- 21975 * global variable support code. 21976 * ----------------------------------------------------------------------------- */ 21977 21978 typedef struct swig_globalvar { 21979 char *name; /* Name of global variable */ 21980 PyObject *(*get_attr)(void); /* Return the current value */ 21981 int (*set_attr)(PyObject *); /* Set the value */ 21982 struct swig_globalvar *next; 21983 } swig_globalvar; 21984 21985 typedef struct swig_varlinkobject { 21986 PyObject_HEAD 21987 swig_globalvar *vars; 21988 } swig_varlinkobject; 21989 21990 SWIGINTERN PyObject * 21991 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { 21992 #if PY_VERSION_HEX >= 0x03000000 21993 return PyUnicode_InternFromString("<Swig global variables>"); 21994 #else 21995 return PyString_FromString("<Swig global variables>"); 21996 #endif 21997 } 21998 21999 SWIGINTERN PyObject * 22000 swig_varlink_str(swig_varlinkobject *v) { 22001 #if PY_VERSION_HEX >= 0x03000000 22002 PyObject *str = PyUnicode_InternFromString("("); 22003 PyObject *tail; 22004 PyObject *joined; 22005 swig_globalvar *var; 22006 for (var = v->vars; var; var=var->next) { 22007 tail = PyUnicode_FromString(var->name); 22008 joined = PyUnicode_Concat(str, tail); 22009 Py_DecRef(str); 22010 Py_DecRef(tail); 22011 str = joined; 22012 if (var->next) { 22013 tail = PyUnicode_InternFromString(", "); 22014 joined = PyUnicode_Concat(str, tail); 22015 Py_DecRef(str); 22016 Py_DecRef(tail); 22017 str = joined; 22018 } 22019 } 22020 tail = PyUnicode_InternFromString(")"); 22021 joined = PyUnicode_Concat(str, tail); 22022 Py_DecRef(str); 22023 Py_DecRef(tail); 22024 str = joined; 22025 #else 22026 PyObject *str = PyString_FromString("("); 22027 swig_globalvar *var; 22028 for (var = v->vars; var; var=var->next) { 22029 PyString_ConcatAndDel(&str,PyString_FromString(var->name)); 22030 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); 22031 } 22032 PyString_ConcatAndDel(&str,PyString_FromString(")")); 22033 #endif 22034 return str; 22035 } 22036 22037 SWIGINTERN int 22038 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { 22039 char *tmp; 22040 PyObject *str = swig_varlink_str(v); 22041 fprintf(fp,"Swig global variables "); 22042 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); 22043 SWIG_Python_str_DelForPy3(tmp); 22044 Py_DECREF(str); 22045 return 0; 22046 } 22047 22048 SWIGINTERN void 22049 swig_varlink_dealloc(swig_varlinkobject *v) { 22050 swig_globalvar *var = v->vars; 22051 while (var) { 22052 swig_globalvar *n = var->next; 22053 free(var->name); 22054 free(var); 22055 var = n; 22056 } 22057 } 22058 22059 SWIGINTERN PyObject * 22060 swig_varlink_getattr(swig_varlinkobject *v, char *n) { 22061 PyObject *res = NULL; 22062 swig_globalvar *var = v->vars; 22063 while (var) { 22064 if (strcmp(var->name,n) == 0) { 22065 res = (*var->get_attr)(); 22066 break; 22067 } 22068 var = var->next; 22069 } 22070 if (res == NULL && !PyErr_Occurred()) { 22071 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); 22072 } 22073 return res; 22074 } 22075 22076 SWIGINTERN int 22077 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { 22078 int res = 1; 22079 swig_globalvar *var = v->vars; 22080 while (var) { 22081 if (strcmp(var->name,n) == 0) { 22082 res = (*var->set_attr)(p); 22083 break; 22084 } 22085 var = var->next; 22086 } 22087 if (res == 1 && !PyErr_Occurred()) { 22088 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); 22089 } 22090 return res; 22091 } 22092 22093 SWIGINTERN PyTypeObject* 22094 swig_varlink_type(void) { 22095 static char varlink__doc__[] = "Swig var link object"; 22096 static PyTypeObject varlink_type; 22097 static int type_init = 0; 22098 if (!type_init) { 22099 const PyTypeObject tmp = { 22100 /* PyObject header changed in Python 3 */ 22101 #if PY_VERSION_HEX >= 0x03000000 22102 PyVarObject_HEAD_INIT(NULL, 0) 22103 #else 22104 PyObject_HEAD_INIT(NULL) 22105 0, /* ob_size */ 22106 #endif 22107 (char *)"swigvarlink", /* tp_name */ 22108 sizeof(swig_varlinkobject), /* tp_basicsize */ 22109 0, /* tp_itemsize */ 22110 (destructor) swig_varlink_dealloc, /* tp_dealloc */ 22111 (printfunc) swig_varlink_print, /* tp_print */ 22112 (getattrfunc) swig_varlink_getattr, /* tp_getattr */ 22113 (setattrfunc) swig_varlink_setattr, /* tp_setattr */ 22114 0, /* tp_compare */ 22115 (reprfunc) swig_varlink_repr, /* tp_repr */ 22116 0, /* tp_as_number */ 22117 0, /* tp_as_sequence */ 22118 0, /* tp_as_mapping */ 22119 0, /* tp_hash */ 22120 0, /* tp_call */ 22121 (reprfunc) swig_varlink_str, /* tp_str */ 22122 0, /* tp_getattro */ 22123 0, /* tp_setattro */ 22124 0, /* tp_as_buffer */ 22125 0, /* tp_flags */ 22126 varlink__doc__, /* tp_doc */ 22127 0, /* tp_traverse */ 22128 0, /* tp_clear */ 22129 0, /* tp_richcompare */ 22130 0, /* tp_weaklistoffset */ 22131 #if PY_VERSION_HEX >= 0x02020000 22132 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ 22133 #endif 22134 #if PY_VERSION_HEX >= 0x02030000 22135 0, /* tp_del */ 22136 #endif 22137 #if PY_VERSION_HEX >= 0x02060000 22138 0, /* tp_version */ 22139 #endif 22140 #ifdef COUNT_ALLOCS 22141 0,0,0,0 /* tp_alloc -> tp_next */ 22142 #endif 22143 }; 22144 varlink_type = tmp; 22145 type_init = 1; 22146 #if PY_VERSION_HEX < 0x02020000 22147 varlink_type.ob_type = &PyType_Type; 22148 #else 22149 if (PyType_Ready(&varlink_type) < 0) 22150 return NULL; 22151 #endif 22152 } 22153 return &varlink_type; 22154 } 22155 22156 /* Create a variable linking object for use later */ 22157 SWIGINTERN PyObject * 22158 SWIG_Python_newvarlink(void) { 22159 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); 22160 if (result) { 22161 result->vars = 0; 22162 } 22163 return ((PyObject*) result); 22164 } 22165 22166 SWIGINTERN void 22167 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { 22168 swig_varlinkobject *v = (swig_varlinkobject *) p; 22169 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); 22170 if (gv) { 22171 size_t size = strlen(name)+1; 22172 gv->name = (char *)malloc(size); 22173 if (gv->name) { 22174 strncpy(gv->name,name,size); 22175 gv->get_attr = get_attr; 22176 gv->set_attr = set_attr; 22177 gv->next = v->vars; 22178 } 22179 } 22180 v->vars = gv; 22181 } 22182 22183 SWIGINTERN PyObject * 22184 SWIG_globals(void) { 22185 static PyObject *_SWIG_globals = 0; 22186 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); 22187 return _SWIG_globals; 22188 } 22189 22190 /* ----------------------------------------------------------------------------- 22191 * constants/methods manipulation 22192 * ----------------------------------------------------------------------------- */ 22193 22194 /* Install Constants */ 22195 SWIGINTERN void 22196 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { 22197 PyObject *obj = 0; 22198 size_t i; 22199 for (i = 0; constants[i].type; ++i) { 22200 switch(constants[i].type) { 22201 case SWIG_PY_POINTER: 22202 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); 22203 break; 22204 case SWIG_PY_BINARY: 22205 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); 22206 break; 22207 default: 22208 obj = 0; 22209 break; 22210 } 22211 if (obj) { 22212 PyDict_SetItemString(d, constants[i].name, obj); 22213 Py_DECREF(obj); 22214 } 22215 } 22216 } 22217 22218 /* -----------------------------------------------------------------------------*/ 22219 /* Fix SwigMethods to carry the callback ptrs when needed */ 22220 /* -----------------------------------------------------------------------------*/ 22221 22222 SWIGINTERN void 22223 SWIG_Python_FixMethods(PyMethodDef *methods, 22224 swig_const_info *const_table, 22225 swig_type_info **types, 22226 swig_type_info **types_initial) { 22227 size_t i; 22228 for (i = 0; methods[i].ml_name; ++i) { 22229 const char *c = methods[i].ml_doc; 22230 if (c && (c = strstr(c, "swig_ptr: "))) { 22231 int j; 22232 swig_const_info *ci = 0; 22233 const char *name = c + 10; 22234 for (j = 0; const_table[j].type; ++j) { 22235 if (strncmp(const_table[j].name, name, 22236 strlen(const_table[j].name)) == 0) { 22237 ci = &(const_table[j]); 22238 break; 22239 } 22240 } 22241 if (ci) { 22242 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; 22243 if (ptr) { 22244 size_t shift = (ci->ptype) - types; 22245 swig_type_info *ty = types_initial[shift]; 22246 size_t ldoc = (c - methods[i].ml_doc); 22247 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; 22248 char *ndoc = (char*)malloc(ldoc + lptr + 10); 22249 if (ndoc) { 22250 char *buff = ndoc; 22251 strncpy(buff, methods[i].ml_doc, ldoc); 22252 buff += ldoc; 22253 strncpy(buff, "swig_ptr: ", 10); 22254 buff += 10; 22255 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); 22256 methods[i].ml_doc = ndoc; 22257 } 22258 } 22259 } 22260 } 22261 } 22262 } 22263 22264 #ifdef __cplusplus 22265 } 22266 #endif 22267 22268 /* -----------------------------------------------------------------------------* 22269 * Partial Init method 22270 * -----------------------------------------------------------------------------*/ 22271 22272 #ifdef __cplusplus 22273 extern "C" 22274 #endif 22275 22276 SWIGEXPORT 22277 #if PY_VERSION_HEX >= 0x03000000 22278 PyObject* 22279 #else 22280 void 22281 #endif 22282 SWIG_init(void) { 22283 PyObject *m, *d, *md; 22284 #if PY_VERSION_HEX >= 0x03000000 22285 static struct PyModuleDef SWIG_module = { 22286 # if PY_VERSION_HEX >= 0x03020000 22287 PyModuleDef_HEAD_INIT, 22288 # else 22289 { 22290 PyObject_HEAD_INIT(NULL) 22291 NULL, /* m_init */ 22292 0, /* m_index */ 22293 NULL, /* m_copy */ 22294 }, 22295 # endif 22296 (char *) SWIG_name, 22297 NULL, 22298 -1, 22299 SwigMethods, 22300 NULL, 22301 NULL, 22302 NULL, 22303 NULL 22304 }; 22305 #endif 22306 22307 #if defined(SWIGPYTHON_BUILTIN) 22308 static SwigPyClientData SwigPyObject_clientdata = { 22309 0, 0, 0, 0, 0, 0, 0 22310 }; 22311 static PyGetSetDef this_getset_def = { 22312 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL 22313 }; 22314 static SwigPyGetSet thisown_getset_closure = { 22315 (PyCFunction) SwigPyObject_own, 22316 (PyCFunction) SwigPyObject_own 22317 }; 22318 static PyGetSetDef thisown_getset_def = { 22319 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure 22320 }; 22321 PyObject *metatype_args; 22322 PyTypeObject *builtin_pytype; 22323 int builtin_base_count; 22324 swig_type_info *builtin_basetype; 22325 PyObject *tuple; 22326 PyGetSetDescrObject *static_getset; 22327 PyTypeObject *metatype; 22328 SwigPyClientData *cd; 22329 PyObject *public_interface, *public_symbol; 22330 PyObject *this_descr; 22331 PyObject *thisown_descr; 22332 int i; 22333 22334 (void)builtin_pytype; 22335 (void)builtin_base_count; 22336 (void)builtin_basetype; 22337 (void)tuple; 22338 (void)static_getset; 22339 22340 /* metatype is used to implement static member variables. */ 22341 metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); 22342 assert(metatype_args); 22343 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); 22344 assert(metatype); 22345 Py_DECREF(metatype_args); 22346 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; 22347 assert(PyType_Ready(metatype) >= 0); 22348 #endif 22349 22350 /* Fix SwigMethods to carry the callback ptrs when needed */ 22351 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); 22352 22353 #if PY_VERSION_HEX >= 0x03000000 22354 m = PyModule_Create(&SWIG_module); 22355 #else 22356 m = Py_InitModule((char *) SWIG_name, SwigMethods); 22357 #endif 22358 md = d = PyModule_GetDict(m); 22359 (void)md; 22360 22361 SWIG_InitializeModule(0); 22362 22363 #ifdef SWIGPYTHON_BUILTIN 22364 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); 22365 assert(SwigPyObject_stype); 22366 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; 22367 if (!cd) { 22368 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; 22369 SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); 22370 } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { 22371 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); 22372 # if PY_VERSION_HEX >= 0x03000000 22373 return NULL; 22374 # else 22375 return; 22376 # endif 22377 } 22378 22379 /* All objects have a 'this' attribute */ 22380 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); 22381 (void)this_descr; 22382 22383 /* All objects have a 'thisown' attribute */ 22384 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); 22385 (void)thisown_descr; 22386 22387 public_interface = PyList_New(0); 22388 public_symbol = 0; 22389 (void)public_symbol; 22390 22391 PyDict_SetItemString(md, "__all__", public_interface); 22392 Py_DECREF(public_interface); 22393 for (i = 0; SwigMethods[i].ml_name != NULL; ++i) 22394 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); 22395 for (i = 0; swig_const_table[i].name != 0; ++i) 22396 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); 22397 #endif 22398 22399 SWIG_InstallConstants(d,swig_const_table); 22400 22401 22402 import_array(); 22403 22404 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1))); 22405 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2))); 22406 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3))); 22407 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4))); 22408 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5))); 22409 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6))); 22410 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7))); 22411 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8))); 22412 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9))); 22413 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10))); 22414 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11))); 22415 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12))); 22416 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13))); 22417 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14))); 22418 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15))); 22419 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16))); 22420 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17))); 22421 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18))); 22422 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19))); 22423 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20))); 22424 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21))); 22425 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22))); 22426 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23))); 22427 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24))); 22428 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25))); 22429 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26))); 22430 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27))); 22431 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28))); 22432 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29))); 22433 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30))); 22434 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31))); 22435 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32))); 22436 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33))); 22437 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34))); 22438 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35))); 22439 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36))); 22440 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37))); 22441 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0))); 22442 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1))); 22443 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2))); 22444 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3))); 22445 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4))); 22446 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5))); 22447 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1))); 22448 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2))); 22449 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3))); 22450 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4))); 22451 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1))); 22452 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2))); 22453 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1))); 22454 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2))); 22455 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3))); 22456 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001))); 22457 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002))); 22458 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004))); 22459 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008))); 22460 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010))); 22461 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100))); 22462 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200))); 22463 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400))); 22464 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800))); 22465 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000))); 22466 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000))); 22467 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001))); 22468 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002))); 22469 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004))); 22470 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008))); 22471 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010))); 22472 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020))); 22473 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040))); 22474 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080))); 22475 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000))); 22476 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000))); 22477 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf))); 22478 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7))); 22479 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf))); 22480 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0))); 22481 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1))); 22482 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2))); 22483 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0))); 22484 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1))); 22485 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2))); 22486 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3))); 22487 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4))); 22488 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0))); 22489 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1))); 22490 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2))); 22491 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0))); 22492 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1))); 22493 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16))); 22494 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64))); 22495 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42)))); 22496 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1))); 22497 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2))); 22498 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3))); 22499 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0))); 22500 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1))); 22501 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2))); 22502 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4))); 22503 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1))); 22504 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2))); 22505 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3))); 22506 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4))); 22507 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5))); 22508 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6))); 22509 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00))); 22510 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01))); 22511 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02))); 22512 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08))); 22513 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10))); 22514 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1))); 22515 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2))); 22516 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4))); 22517 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8))); 22518 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10))); 22519 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20))); 22520 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40))); 22521 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80))); 22522 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1))); 22523 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2))); 22524 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4))); 22525 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8))); 22526 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10))); 22527 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20))); 22528 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40))); 22529 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80))); 22530 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1))); 22531 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2))); 22532 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4))); 22533 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8))); 22534 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10))); 22535 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20))); 22536 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40))); 22537 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80))); 22538 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100))); 22539 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200))); 22540 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400))); 22541 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800))); 22542 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000))); 22543 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000))); 22544 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000))); 22545 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000))); 22546 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000))); 22547 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0))); 22548 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1))); 22549 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2))); 22550 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4))); 22551 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001))); 22552 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002))); 22553 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003))); 22554 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004))); 22555 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008))); 22556 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010))); 22557 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020))); 22558 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040))); 22559 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080))); 22560 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100))); 22561 #if PY_VERSION_HEX >= 0x03000000 22562 return m; 22563 #else 22564 return; 22565 #endif 22566 } 22567