1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.1
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17
18 /* -----------------------------------------------------------------------------
19 * This section contains generic SWIG labels for method/variable
20 * declarations/attributes, and other compiler dependent labels.
21 * ----------------------------------------------------------------------------- */
22
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 # define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 # define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 # define SWIGINLINE inline
40 # else
41 # define SWIGINLINE
42 # endif
43 #endif
44
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 # elif defined(__ICC)
54 # define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 # define SWIGUNUSED
57 # endif
58 #endif
59
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 # define SWIGUNUSEDPARM(p)
69 # else
70 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83
84 /* exporting methods */
85 #if defined(__GNUC__)
86 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 # ifndef GCC_HASCLASSVISIBILITY
88 # define GCC_HASCLASSVISIBILITY
89 # endif
90 # endif
91 #endif
92
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 # if defined(STATIC_LINKED)
96 # define SWIGEXPORT
97 # else
98 # define SWIGEXPORT __declspec(dllexport)
99 # endif
100 # else
101 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 # define SWIGEXPORT __attribute__ ((visibility("default")))
103 # else
104 # define SWIGEXPORT
105 # endif
106 # endif
107 #endif
108
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # define SWIGSTDCALL __stdcall
113 # else
114 # define SWIGSTDCALL
115 # endif
116 #endif
117
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132
133 /* Intel's compiler complains if a variable which was never initialised is
134 * cast to void, which is a common idiom which we use to indicate that we
135 * are aware a variable isn't used. So we just silence that warning.
136 * See: https://github.com/swig/swig/issues/192 for more discussion.
137 */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141
142
143 #if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
144 /* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
145 # include <math.h>
146 #endif
147
148 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
149 /* Use debug wrappers with the Python release dll */
150 # undef _DEBUG
151 # include <Python.h>
152 # define _DEBUG 1
153 #else
154 # include <Python.h>
155 #endif
156
157 /* -----------------------------------------------------------------------------
158 * swigrun.swg
159 *
160 * This file contains generic C API SWIG runtime support for pointer
161 * type checking.
162 * ----------------------------------------------------------------------------- */
163
164 /* This should only be incremented when either the layout of swig_type_info changes,
165 or for whatever reason, the runtime changes incompatibly */
166 #define SWIG_RUNTIME_VERSION "4"
167
168 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
169 #ifdef SWIG_TYPE_TABLE
170 # define SWIG_QUOTE_STRING(x) #x
171 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
172 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
173 #else
174 # define SWIG_TYPE_TABLE_NAME
175 #endif
176
177 /*
178 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
179 creating a static or dynamic library from the SWIG runtime code.
180 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
181
182 But only do this if strictly necessary, ie, if you have problems
183 with your compiler or suchlike.
184 */
185
186 #ifndef SWIGRUNTIME
187 # define SWIGRUNTIME SWIGINTERN
188 #endif
189
190 #ifndef SWIGRUNTIMEINLINE
191 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
192 #endif
193
194 /* Generic buffer size */
195 #ifndef SWIG_BUFFER_SIZE
196 # define SWIG_BUFFER_SIZE 1024
197 #endif
198
199 /* Flags for pointer conversions */
200 #define SWIG_POINTER_DISOWN 0x1
201 #define SWIG_CAST_NEW_MEMORY 0x2
202 #define SWIG_POINTER_NO_NULL 0x4
203
204 /* Flags for new pointer objects */
205 #define SWIG_POINTER_OWN 0x1
206
207
208 /*
209 Flags/methods for returning states.
210
211 The SWIG conversion methods, as ConvertPtr, return an integer
212 that tells if the conversion was successful or not. And if not,
213 an error code can be returned (see swigerrors.swg for the codes).
214
215 Use the following macros/flags to set or process the returning
216 states.
217
218 In old versions of SWIG, code such as the following was usually written:
219
220 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
221 // success code
222 } else {
223 //fail code
224 }
225
226 Now you can be more explicit:
227
228 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
229 if (SWIG_IsOK(res)) {
230 // success code
231 } else {
232 // fail code
233 }
234
235 which is the same really, but now you can also do
236
237 Type *ptr;
238 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
239 if (SWIG_IsOK(res)) {
240 // success code
241 if (SWIG_IsNewObj(res) {
242 ...
243 delete *ptr;
244 } else {
245 ...
246 }
247 } else {
248 // fail code
249 }
250
251 I.e., now SWIG_ConvertPtr can return new objects and you can
252 identify the case and take care of the deallocation. Of course that
253 also requires SWIG_ConvertPtr to return new result values, such as
254
255 int SWIG_ConvertPtr(obj, ptr,...) {
256 if (<obj is ok>) {
257 if (<need new object>) {
258 *ptr = <ptr to new allocated object>;
259 return SWIG_NEWOBJ;
260 } else {
261 *ptr = <ptr to old object>;
262 return SWIG_OLDOBJ;
263 }
264 } else {
265 return SWIG_BADOBJ;
266 }
267 }
268
269 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
270 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
271 SWIG errors code.
272
273 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
274 allows to return the 'cast rank', for example, if you have this
275
276 int food(double)
277 int fooi(int);
278
279 and you call
280
281 food(1) // cast rank '1' (1 -> 1.0)
282 fooi(1) // cast rank '0'
283
284 just use the SWIG_AddCast()/SWIG_CheckState()
285 */
286
287 #define SWIG_OK (0)
288 #define SWIG_ERROR (-1)
289 #define SWIG_IsOK(r) (r >= 0)
290 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
291
292 /* The CastRankLimit says how many bits are used for the cast rank */
293 #define SWIG_CASTRANKLIMIT (1 << 8)
294 /* The NewMask denotes the object was created (using new/malloc) */
295 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
296 /* The TmpMask is for in/out typemaps that use temporal objects */
297 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
298 /* Simple returning values */
299 #define SWIG_BADOBJ (SWIG_ERROR)
300 #define SWIG_OLDOBJ (SWIG_OK)
301 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
302 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
303 /* Check, add and del mask methods */
304 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
305 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
306 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
307 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
308 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
309 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
310
311 /* Cast-Rank Mode */
312 #if defined(SWIG_CASTRANK_MODE)
313 # ifndef SWIG_TypeRank
314 # define SWIG_TypeRank unsigned long
315 # endif
316 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
317 # define SWIG_MAXCASTRANK (2)
318 # endif
319 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
320 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)321 SWIGINTERNINLINE int SWIG_AddCast(int r) {
322 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
323 }
SWIG_CheckState(int r)324 SWIGINTERNINLINE int SWIG_CheckState(int r) {
325 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
326 }
327 #else /* no cast-rank mode */
328 # define SWIG_AddCast(r) (r)
329 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
330 #endif
331
332
333 #include <string.h>
334
335 #ifdef __cplusplus
336 extern "C" {
337 #endif
338
339 typedef void *(*swig_converter_func)(void *, int *);
340 typedef struct swig_type_info *(*swig_dycast_func)(void **);
341
342 /* Structure to store information on one type */
343 typedef struct swig_type_info {
344 const char *name; /* mangled name of this type */
345 const char *str; /* human readable name of this type */
346 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
347 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
348 void *clientdata; /* language specific type data */
349 int owndata; /* flag if the structure owns the clientdata */
350 } swig_type_info;
351
352 /* Structure to store a type and conversion function used for casting */
353 typedef struct swig_cast_info {
354 swig_type_info *type; /* pointer to type that is equivalent to this type */
355 swig_converter_func converter; /* function to cast the void pointers */
356 struct swig_cast_info *next; /* pointer to next cast in linked list */
357 struct swig_cast_info *prev; /* pointer to the previous cast */
358 } swig_cast_info;
359
360 /* Structure used to store module information
361 * Each module generates one structure like this, and the runtime collects
362 * all of these structures and stores them in a circularly linked list.*/
363 typedef struct swig_module_info {
364 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
365 size_t size; /* Number of types in this module */
366 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
367 swig_type_info **type_initial; /* Array of initially generated type structures */
368 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
369 void *clientdata; /* Language specific module data */
370 } swig_module_info;
371
372 /*
373 Compare two type names skipping the space characters, therefore
374 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
375
376 Return 0 when the two name types are equivalent, as in
377 strncmp, but skipping ' '.
378 */
379 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)380 SWIG_TypeNameComp(const char *f1, const char *l1,
381 const char *f2, const char *l2) {
382 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
383 while ((*f1 == ' ') && (f1 != l1)) ++f1;
384 while ((*f2 == ' ') && (f2 != l2)) ++f2;
385 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
386 }
387 return (int)((l1 - f1) - (l2 - f2));
388 }
389
390 /*
391 Check type equivalence in a name list like <name1>|<name2>|...
392 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
393 */
394 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)395 SWIG_TypeCmp(const char *nb, const char *tb) {
396 int equiv = 1;
397 const char* te = tb + strlen(tb);
398 const char* ne = nb;
399 while (equiv != 0 && *ne) {
400 for (nb = ne; *ne; ++ne) {
401 if (*ne == '|') break;
402 }
403 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
404 if (*ne) ++ne;
405 }
406 return equiv;
407 }
408
409 /*
410 Check type equivalence in a name list like <name1>|<name2>|...
411 Return 0 if not equal, 1 if equal
412 */
413 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)414 SWIG_TypeEquiv(const char *nb, const char *tb) {
415 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
416 }
417
418 /*
419 Check the typename
420 */
421 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)422 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
423 if (ty) {
424 swig_cast_info *iter = ty->cast;
425 while (iter) {
426 if (strcmp(iter->type->name, c) == 0) {
427 if (iter == ty->cast)
428 return iter;
429 /* Move iter to the top of the linked list */
430 iter->prev->next = iter->next;
431 if (iter->next)
432 iter->next->prev = iter->prev;
433 iter->next = ty->cast;
434 iter->prev = 0;
435 if (ty->cast) ty->cast->prev = iter;
436 ty->cast = iter;
437 return iter;
438 }
439 iter = iter->next;
440 }
441 }
442 return 0;
443 }
444
445 /*
446 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
447 */
448 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)449 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
450 if (ty) {
451 swig_cast_info *iter = ty->cast;
452 while (iter) {
453 if (iter->type == from) {
454 if (iter == ty->cast)
455 return iter;
456 /* Move iter to the top of the linked list */
457 iter->prev->next = iter->next;
458 if (iter->next)
459 iter->next->prev = iter->prev;
460 iter->next = ty->cast;
461 iter->prev = 0;
462 if (ty->cast) ty->cast->prev = iter;
463 ty->cast = iter;
464 return iter;
465 }
466 iter = iter->next;
467 }
468 }
469 return 0;
470 }
471
472 /*
473 Cast a pointer up an inheritance hierarchy
474 */
475 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)476 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
477 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
478 }
479
480 /*
481 Dynamic pointer casting. Down an inheritance hierarchy
482 */
483 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)484 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
485 swig_type_info *lastty = ty;
486 if (!ty || !ty->dcast) return ty;
487 while (ty && (ty->dcast)) {
488 ty = (*ty->dcast)(ptr);
489 if (ty) lastty = ty;
490 }
491 return lastty;
492 }
493
494 /*
495 Return the name associated with this type
496 */
497 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)498 SWIG_TypeName(const swig_type_info *ty) {
499 return ty->name;
500 }
501
502 /*
503 Return the pretty name associated with this type,
504 that is an unmangled type name in a form presentable to the user.
505 */
506 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)507 SWIG_TypePrettyName(const swig_type_info *type) {
508 /* The "str" field contains the equivalent pretty names of the
509 type, separated by vertical-bar characters. We choose
510 to print the last name, as it is often (?) the most
511 specific. */
512 if (!type) return NULL;
513 if (type->str != NULL) {
514 const char *last_name = type->str;
515 const char *s;
516 for (s = type->str; *s; s++)
517 if (*s == '|') last_name = s+1;
518 return last_name;
519 }
520 else
521 return type->name;
522 }
523
524 /*
525 Set the clientdata field for a type
526 */
527 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)528 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
529 swig_cast_info *cast = ti->cast;
530 /* if (ti->clientdata == clientdata) return; */
531 ti->clientdata = clientdata;
532
533 while (cast) {
534 if (!cast->converter) {
535 swig_type_info *tc = cast->type;
536 if (!tc->clientdata) {
537 SWIG_TypeClientData(tc, clientdata);
538 }
539 }
540 cast = cast->next;
541 }
542 }
543 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)544 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
545 SWIG_TypeClientData(ti, clientdata);
546 ti->owndata = 1;
547 }
548
549 /*
550 Search for a swig_type_info structure only by mangled name
551 Search is a O(log #types)
552
553 We start searching at module start, and finish searching when start == end.
554 Note: if start == end at the beginning of the function, we go all the way around
555 the circular list.
556 */
557 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)558 SWIG_MangledTypeQueryModule(swig_module_info *start,
559 swig_module_info *end,
560 const char *name) {
561 swig_module_info *iter = start;
562 do {
563 if (iter->size) {
564 size_t l = 0;
565 size_t r = iter->size - 1;
566 do {
567 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
568 size_t i = (l + r) >> 1;
569 const char *iname = iter->types[i]->name;
570 if (iname) {
571 int compare = strcmp(name, iname);
572 if (compare == 0) {
573 return iter->types[i];
574 } else if (compare < 0) {
575 if (i) {
576 r = i - 1;
577 } else {
578 break;
579 }
580 } else if (compare > 0) {
581 l = i + 1;
582 }
583 } else {
584 break; /* should never happen */
585 }
586 } while (l <= r);
587 }
588 iter = iter->next;
589 } while (iter != end);
590 return 0;
591 }
592
593 /*
594 Search for a swig_type_info structure for either a mangled name or a human readable name.
595 It first searches the mangled names of the types, which is a O(log #types)
596 If a type is not found it then searches the human readable names, which is O(#types).
597
598 We start searching at module start, and finish searching when start == end.
599 Note: if start == end at the beginning of the function, we go all the way around
600 the circular list.
601 */
602 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)603 SWIG_TypeQueryModule(swig_module_info *start,
604 swig_module_info *end,
605 const char *name) {
606 /* STEP 1: Search the name field using binary search */
607 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
608 if (ret) {
609 return ret;
610 } else {
611 /* STEP 2: If the type hasn't been found, do a complete search
612 of the str field (the human readable name) */
613 swig_module_info *iter = start;
614 do {
615 size_t i = 0;
616 for (; i < iter->size; ++i) {
617 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
618 return iter->types[i];
619 }
620 iter = iter->next;
621 } while (iter != end);
622 }
623
624 /* neither found a match */
625 return 0;
626 }
627
628 /*
629 Pack binary data into a string
630 */
631 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)632 SWIG_PackData(char *c, void *ptr, size_t sz) {
633 static const char hex[17] = "0123456789abcdef";
634 const unsigned char *u = (unsigned char *) ptr;
635 const unsigned char *eu = u + sz;
636 for (; u != eu; ++u) {
637 unsigned char uu = *u;
638 *(c++) = hex[(uu & 0xf0) >> 4];
639 *(c++) = hex[uu & 0xf];
640 }
641 return c;
642 }
643
644 /*
645 Unpack binary data from a string
646 */
647 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)648 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
649 unsigned char *u = (unsigned char *) ptr;
650 const unsigned char *eu = u + sz;
651 for (; u != eu; ++u) {
652 char d = *(c++);
653 unsigned char uu;
654 if ((d >= '0') && (d <= '9'))
655 uu = (unsigned char)((d - '0') << 4);
656 else if ((d >= 'a') && (d <= 'f'))
657 uu = (unsigned char)((d - ('a'-10)) << 4);
658 else
659 return (char *) 0;
660 d = *(c++);
661 if ((d >= '0') && (d <= '9'))
662 uu |= (unsigned char)(d - '0');
663 else if ((d >= 'a') && (d <= 'f'))
664 uu |= (unsigned char)(d - ('a'-10));
665 else
666 return (char *) 0;
667 *u = uu;
668 }
669 return c;
670 }
671
672 /*
673 Pack 'void *' into a string buffer.
674 */
675 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)676 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
677 char *r = buff;
678 if ((2*sizeof(void *) + 2) > bsz) return 0;
679 *(r++) = '_';
680 r = SWIG_PackData(r,&ptr,sizeof(void *));
681 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
682 strcpy(r,name);
683 return buff;
684 }
685
686 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)687 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
688 if (*c != '_') {
689 if (strcmp(c,"NULL") == 0) {
690 *ptr = (void *) 0;
691 return name;
692 } else {
693 return 0;
694 }
695 }
696 return SWIG_UnpackData(++c,ptr,sizeof(void *));
697 }
698
699 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)700 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
701 char *r = buff;
702 size_t lname = (name ? strlen(name) : 0);
703 if ((2*sz + 2 + lname) > bsz) return 0;
704 *(r++) = '_';
705 r = SWIG_PackData(r,ptr,sz);
706 if (lname) {
707 strncpy(r,name,lname+1);
708 } else {
709 *r = 0;
710 }
711 return buff;
712 }
713
714 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)715 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
716 if (*c != '_') {
717 if (strcmp(c,"NULL") == 0) {
718 memset(ptr,0,sz);
719 return name;
720 } else {
721 return 0;
722 }
723 }
724 return SWIG_UnpackData(++c,ptr,sz);
725 }
726
727 #ifdef __cplusplus
728 }
729 #endif
730
731 /* Errors in SWIG */
732 #define SWIG_UnknownError -1
733 #define SWIG_IOError -2
734 #define SWIG_RuntimeError -3
735 #define SWIG_IndexError -4
736 #define SWIG_TypeError -5
737 #define SWIG_DivisionByZero -6
738 #define SWIG_OverflowError -7
739 #define SWIG_SyntaxError -8
740 #define SWIG_ValueError -9
741 #define SWIG_SystemError -10
742 #define SWIG_AttributeError -11
743 #define SWIG_MemoryError -12
744 #define SWIG_NullReferenceError -13
745
746
747
748 /* Compatibility macros for Python 3 */
749 #if PY_VERSION_HEX >= 0x03000000
750
751 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
752 #define PyInt_Check(x) PyLong_Check(x)
753 #define PyInt_AsLong(x) PyLong_AsLong(x)
754 #define PyInt_FromLong(x) PyLong_FromLong(x)
755 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
756 #define PyString_Check(name) PyBytes_Check(name)
757 #define PyString_FromString(x) PyUnicode_FromString(x)
758 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
759 #define PyString_AsString(str) PyBytes_AsString(str)
760 #define PyString_Size(str) PyBytes_Size(str)
761 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
762 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
763 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
764 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
765
766 #endif
767
768 #ifndef Py_TYPE
769 # define Py_TYPE(op) ((op)->ob_type)
770 #endif
771
772 /* SWIG APIs for compatibility of both Python 2 & 3 */
773
774 #if PY_VERSION_HEX >= 0x03000000
775 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
776 #else
777 # define SWIG_Python_str_FromFormat PyString_FromFormat
778 #endif
779
780
781 /* Warning: This function will allocate a new string in Python 3,
782 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
783 */
784 SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject * str)785 SWIG_Python_str_AsChar(PyObject *str)
786 {
787 #if PY_VERSION_HEX >= 0x03000000
788 char *newstr = 0;
789 str = PyUnicode_AsUTF8String(str);
790 if (str) {
791 char *cstr;
792 Py_ssize_t len;
793 PyBytes_AsStringAndSize(str, &cstr, &len);
794 newstr = (char *) malloc(len+1);
795 memcpy(newstr, cstr, len+1);
796 Py_XDECREF(str);
797 }
798 return newstr;
799 #else
800 return PyString_AsString(str);
801 #endif
802 }
803
804 #if PY_VERSION_HEX >= 0x03000000
805 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
806 #else
807 # define SWIG_Python_str_DelForPy3(x)
808 #endif
809
810
811 SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char * c)812 SWIG_Python_str_FromChar(const char *c)
813 {
814 #if PY_VERSION_HEX >= 0x03000000
815 return PyUnicode_FromString(c);
816 #else
817 return PyString_FromString(c);
818 #endif
819 }
820
821 #ifndef PyObject_DEL
822 # define PyObject_DEL PyObject_Del
823 #endif
824
825 // SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
826 // interface files check for it.
827 # define SWIGPY_USE_CAPSULE
828 # define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
829
830 #if PY_VERSION_HEX < 0x03020000
831 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
832 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
833 #define Py_hash_t long
834 #endif
835
836 /* -----------------------------------------------------------------------------
837 * error manipulation
838 * ----------------------------------------------------------------------------- */
839
840 SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code)841 SWIG_Python_ErrorType(int code) {
842 PyObject* type = 0;
843 switch(code) {
844 case SWIG_MemoryError:
845 type = PyExc_MemoryError;
846 break;
847 case SWIG_IOError:
848 type = PyExc_IOError;
849 break;
850 case SWIG_RuntimeError:
851 type = PyExc_RuntimeError;
852 break;
853 case SWIG_IndexError:
854 type = PyExc_IndexError;
855 break;
856 case SWIG_TypeError:
857 type = PyExc_TypeError;
858 break;
859 case SWIG_DivisionByZero:
860 type = PyExc_ZeroDivisionError;
861 break;
862 case SWIG_OverflowError:
863 type = PyExc_OverflowError;
864 break;
865 case SWIG_SyntaxError:
866 type = PyExc_SyntaxError;
867 break;
868 case SWIG_ValueError:
869 type = PyExc_ValueError;
870 break;
871 case SWIG_SystemError:
872 type = PyExc_SystemError;
873 break;
874 case SWIG_AttributeError:
875 type = PyExc_AttributeError;
876 break;
877 default:
878 type = PyExc_RuntimeError;
879 }
880 return type;
881 }
882
883
884 SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char * mesg)885 SWIG_Python_AddErrorMsg(const char* mesg)
886 {
887 PyObject *type = 0;
888 PyObject *value = 0;
889 PyObject *traceback = 0;
890
891 if (PyErr_Occurred())
892 PyErr_Fetch(&type, &value, &traceback);
893 if (value) {
894 PyObject *old_str = PyObject_Str(value);
895 const char *tmp = SWIG_Python_str_AsChar(old_str);
896 PyErr_Clear();
897 Py_XINCREF(type);
898 if (tmp)
899 PyErr_Format(type, "%s %s", tmp, mesg);
900 else
901 PyErr_Format(type, "%s", mesg);
902 SWIG_Python_str_DelForPy3(tmp);
903 Py_DECREF(old_str);
904 Py_DECREF(value);
905 } else {
906 PyErr_SetString(PyExc_RuntimeError, mesg);
907 }
908 }
909
910 SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject * obj)911 SWIG_Python_TypeErrorOccurred(PyObject *obj)
912 {
913 PyObject *error;
914 if (obj)
915 return 0;
916 error = PyErr_Occurred();
917 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
918 }
919
920 SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char * message)921 SWIG_Python_RaiseOrModifyTypeError(const char *message)
922 {
923 if (SWIG_Python_TypeErrorOccurred(NULL)) {
924 /* Use existing TypeError to preserve stacktrace and enhance with given message */
925 PyObject *newvalue;
926 PyObject *type = NULL, *value = NULL, *traceback = NULL;
927 PyErr_Fetch(&type, &value, &traceback);
928 #if PY_VERSION_HEX >= 0x03000000
929 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
930 #else
931 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
932 #endif
933 Py_XDECREF(value);
934 PyErr_Restore(type, newvalue, traceback);
935 } else {
936 /* Raise TypeError using given message */
937 PyErr_SetString(PyExc_TypeError, message);
938 }
939 }
940
941 #if defined(SWIG_PYTHON_NO_THREADS)
942 # if defined(SWIG_PYTHON_THREADS)
943 # undef SWIG_PYTHON_THREADS
944 # endif
945 #endif
946 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
947 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
948 # define SWIG_PYTHON_USE_GIL
949 # endif
950 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
951 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
952 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
953 # endif
954 # ifdef __cplusplus /* C++ code */
955 class SWIG_Python_Thread_Block {
956 bool status;
957 PyGILState_STATE state;
958 public:
end()959 void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block()960 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block()961 ~SWIG_Python_Thread_Block() { end(); }
962 };
963 class SWIG_Python_Thread_Allow {
964 bool status;
965 PyThreadState *save;
966 public:
end()967 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow()968 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow()969 ~SWIG_Python_Thread_Allow() { end(); }
970 };
971 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
972 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
973 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
974 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
975 # else /* C code */
976 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
977 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
978 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
979 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
980 # endif
981 # else /* Old thread way, not implemented, user must provide it */
982 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
983 # define SWIG_PYTHON_INITIALIZE_THREADS
984 # endif
985 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
986 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
987 # endif
988 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
989 # define SWIG_PYTHON_THREAD_END_BLOCK
990 # endif
991 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
992 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
993 # endif
994 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
995 # define SWIG_PYTHON_THREAD_END_ALLOW
996 # endif
997 # endif
998 #else /* No thread support */
999 # define SWIG_PYTHON_INITIALIZE_THREADS
1000 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1001 # define SWIG_PYTHON_THREAD_END_BLOCK
1002 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1003 # define SWIG_PYTHON_THREAD_END_ALLOW
1004 #endif
1005
1006 /* -----------------------------------------------------------------------------
1007 * Python API portion that goes into the runtime
1008 * ----------------------------------------------------------------------------- */
1009
1010 #ifdef __cplusplus
1011 extern "C" {
1012 #endif
1013
1014 /* -----------------------------------------------------------------------------
1015 * Constant declarations
1016 * ----------------------------------------------------------------------------- */
1017
1018 /* Constant Types */
1019 #define SWIG_PY_POINTER 4
1020 #define SWIG_PY_BINARY 5
1021
1022 /* Constant information structure */
1023 typedef struct swig_const_info {
1024 int type;
1025 const char *name;
1026 long lvalue;
1027 double dvalue;
1028 void *pvalue;
1029 swig_type_info **ptype;
1030 } swig_const_info;
1031
1032 #ifdef __cplusplus
1033 }
1034 #endif
1035
1036
1037 /* -----------------------------------------------------------------------------
1038 * pyrun.swg
1039 *
1040 * This file contains the runtime support for Python modules
1041 * and includes code for managing global variables and pointer
1042 * type checking.
1043 *
1044 * ----------------------------------------------------------------------------- */
1045
1046 #if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1047 # error "This version of SWIG only supports Python >= 2.7"
1048 #endif
1049
1050 #if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1051 # error "This version of SWIG only supports Python 3 >= 3.2"
1052 #endif
1053
1054 /* Common SWIG API */
1055
1056 /* for raw pointers */
1057 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1058 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1059 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1060
1061 #ifdef SWIGPYTHON_BUILTIN
1062 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1063 #else
1064 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1065 #endif
1066
1067 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1068
1069 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1070 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1071 #define swig_owntype int
1072
1073 /* for raw packed data */
1074 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1075 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1076
1077 /* for class or struct pointers */
1078 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1079 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1080
1081 /* for C or C++ function pointers */
1082 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1083 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1084
1085 /* for C++ member pointers, ie, member methods */
1086 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1087 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1088
1089
1090 /* Runtime API */
1091
1092 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1093 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1094 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1095
1096 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1097 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1098 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1099 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1100 #define SWIG_fail goto fail
1101
1102
1103 /* Runtime API implementation */
1104
1105 /* Error manipulation */
1106
1107 SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject * errtype,PyObject * obj)1108 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1109 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1110 PyErr_SetObject(errtype, obj);
1111 Py_DECREF(obj);
1112 SWIG_PYTHON_THREAD_END_BLOCK;
1113 }
1114
1115 SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject * errtype,const char * msg)1116 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1117 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1118 PyErr_SetString(errtype, msg);
1119 SWIG_PYTHON_THREAD_END_BLOCK;
1120 }
1121
1122 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1123
1124 /* Set a constant value */
1125
1126 #if defined(SWIGPYTHON_BUILTIN)
1127
1128 SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject * seq,const char * key)1129 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1130 PyObject *s = PyString_InternFromString(key);
1131 PyList_Append(seq, s);
1132 Py_DECREF(s);
1133 }
1134
1135 SWIGINTERN void
SWIG_Python_SetConstant(PyObject * d,PyObject * public_interface,const char * name,PyObject * obj)1136 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1137 PyDict_SetItemString(d, name, obj);
1138 Py_DECREF(obj);
1139 if (public_interface)
1140 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1141 }
1142
1143 #else
1144
1145 SWIGINTERN void
SWIG_Python_SetConstant(PyObject * d,const char * name,PyObject * obj)1146 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1147 PyDict_SetItemString(d, name, obj);
1148 Py_DECREF(obj);
1149 }
1150
1151 #endif
1152
1153 /* Append a value to the result obj */
1154
1155 SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject * result,PyObject * obj)1156 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1157 if (!result) {
1158 result = obj;
1159 } else if (result == Py_None) {
1160 Py_DECREF(result);
1161 result = obj;
1162 } else {
1163 if (!PyList_Check(result)) {
1164 PyObject *o2 = result;
1165 result = PyList_New(1);
1166 PyList_SetItem(result, 0, o2);
1167 }
1168 PyList_Append(result,obj);
1169 Py_DECREF(obj);
1170 }
1171 return result;
1172 }
1173
1174 /* Unpack the argument tuple */
1175
1176 SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject * args,const char * name,Py_ssize_t min,Py_ssize_t max,PyObject ** objs)1177 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1178 {
1179 if (!args) {
1180 if (!min && !max) {
1181 return 1;
1182 } else {
1183 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1184 name, (min == max ? "" : "at least "), (int)min);
1185 return 0;
1186 }
1187 }
1188 if (!PyTuple_Check(args)) {
1189 if (min <= 1 && max >= 1) {
1190 Py_ssize_t i;
1191 objs[0] = args;
1192 for (i = 1; i < max; ++i) {
1193 objs[i] = 0;
1194 }
1195 return 2;
1196 }
1197 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1198 return 0;
1199 } else {
1200 Py_ssize_t l = PyTuple_GET_SIZE(args);
1201 if (l < min) {
1202 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1203 name, (min == max ? "" : "at least "), (int)min, (int)l);
1204 return 0;
1205 } else if (l > max) {
1206 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1207 name, (min == max ? "" : "at most "), (int)max, (int)l);
1208 return 0;
1209 } else {
1210 Py_ssize_t i;
1211 for (i = 0; i < l; ++i) {
1212 objs[i] = PyTuple_GET_ITEM(args, i);
1213 }
1214 for (; l < max; ++l) {
1215 objs[l] = 0;
1216 }
1217 return i + 1;
1218 }
1219 }
1220 }
1221
1222 /* A functor is a function object with one single object argument */
1223 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1224
1225 /*
1226 Helper for static pointer initialization for both C and C++ code, for example
1227 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1228 */
1229 #ifdef __cplusplus
1230 #define SWIG_STATIC_POINTER(var) var
1231 #else
1232 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1233 #endif
1234
1235 /* -----------------------------------------------------------------------------
1236 * Pointer declarations
1237 * ----------------------------------------------------------------------------- */
1238
1239 /* Flags for new pointer objects */
1240 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1241 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1242
1243 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1244
1245 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1246 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1247
1248 #ifdef __cplusplus
1249 extern "C" {
1250 #endif
1251
1252 /* The python void return value */
1253
1254 SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)1255 SWIG_Py_Void(void)
1256 {
1257 PyObject *none = Py_None;
1258 Py_INCREF(none);
1259 return none;
1260 }
1261
1262 /* SwigPyClientData */
1263
1264 typedef struct {
1265 PyObject *klass;
1266 PyObject *newraw;
1267 PyObject *newargs;
1268 PyObject *destroy;
1269 int delargs;
1270 int implicitconv;
1271 PyTypeObject *pytype;
1272 } SwigPyClientData;
1273
1274 SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info * ty)1275 SWIG_Python_CheckImplicit(swig_type_info *ty)
1276 {
1277 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1278 int fail = data ? data->implicitconv : 0;
1279 if (fail)
1280 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1281 return fail;
1282 }
1283
1284 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info * desc)1285 SWIG_Python_ExceptionType(swig_type_info *desc) {
1286 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1287 PyObject *klass = data ? data->klass : 0;
1288 return (klass ? klass : PyExc_RuntimeError);
1289 }
1290
1291
1292 SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject * obj)1293 SwigPyClientData_New(PyObject* obj)
1294 {
1295 if (!obj) {
1296 return 0;
1297 } else {
1298 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1299 /* the klass element */
1300 data->klass = obj;
1301 Py_INCREF(data->klass);
1302 /* the newraw method and newargs arguments used to create a new raw instance */
1303 if (PyClass_Check(obj)) {
1304 data->newraw = 0;
1305 data->newargs = obj;
1306 Py_INCREF(obj);
1307 } else {
1308 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1309 if (data->newraw) {
1310 Py_INCREF(data->newraw);
1311 data->newargs = PyTuple_New(1);
1312 PyTuple_SetItem(data->newargs, 0, obj);
1313 } else {
1314 data->newargs = obj;
1315 }
1316 Py_INCREF(data->newargs);
1317 }
1318 /* the destroy method, aka as the C++ delete method */
1319 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1320 if (PyErr_Occurred()) {
1321 PyErr_Clear();
1322 data->destroy = 0;
1323 }
1324 if (data->destroy) {
1325 int flags;
1326 Py_INCREF(data->destroy);
1327 flags = PyCFunction_GET_FLAGS(data->destroy);
1328 data->delargs = !(flags & (METH_O));
1329 } else {
1330 data->delargs = 0;
1331 }
1332 data->implicitconv = 0;
1333 data->pytype = 0;
1334 return data;
1335 }
1336 }
1337
1338 SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData * data)1339 SwigPyClientData_Del(SwigPyClientData *data) {
1340 Py_XDECREF(data->newraw);
1341 Py_XDECREF(data->newargs);
1342 Py_XDECREF(data->destroy);
1343 }
1344
1345 /* =============== SwigPyObject =====================*/
1346
1347 typedef struct {
1348 PyObject_HEAD
1349 void *ptr;
1350 swig_type_info *ty;
1351 int own;
1352 PyObject *next;
1353 #ifdef SWIGPYTHON_BUILTIN
1354 PyObject *dict;
1355 #endif
1356 } SwigPyObject;
1357
1358
1359 #ifdef SWIGPYTHON_BUILTIN
1360
1361 SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1362 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1363 {
1364 SwigPyObject *sobj = (SwigPyObject *)v;
1365
1366 if (!sobj->dict)
1367 sobj->dict = PyDict_New();
1368
1369 Py_INCREF(sobj->dict);
1370 return sobj->dict;
1371 }
1372
1373 #endif
1374
1375 SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject * v)1376 SwigPyObject_long(SwigPyObject *v)
1377 {
1378 return PyLong_FromVoidPtr(v->ptr);
1379 }
1380
1381 SWIGRUNTIME PyObject *
SwigPyObject_format(const char * fmt,SwigPyObject * v)1382 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1383 {
1384 PyObject *res = NULL;
1385 PyObject *args = PyTuple_New(1);
1386 if (args) {
1387 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1388 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1389 if (ofmt) {
1390 #if PY_VERSION_HEX >= 0x03000000
1391 res = PyUnicode_Format(ofmt,args);
1392 #else
1393 res = PyString_Format(ofmt,args);
1394 #endif
1395 Py_DECREF(ofmt);
1396 }
1397 Py_DECREF(args);
1398 }
1399 }
1400 return res;
1401 }
1402
1403 SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject * v)1404 SwigPyObject_oct(SwigPyObject *v)
1405 {
1406 return SwigPyObject_format("%o",v);
1407 }
1408
1409 SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject * v)1410 SwigPyObject_hex(SwigPyObject *v)
1411 {
1412 return SwigPyObject_format("%x",v);
1413 }
1414
1415 SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject * v)1416 SwigPyObject_repr(SwigPyObject *v)
1417 {
1418 const char *name = SWIG_TypePrettyName(v->ty);
1419 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1420 if (v->next) {
1421 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1422 # if PY_VERSION_HEX >= 0x03000000
1423 PyObject *joined = PyUnicode_Concat(repr, nrep);
1424 Py_DecRef(repr);
1425 Py_DecRef(nrep);
1426 repr = joined;
1427 # else
1428 PyString_ConcatAndDel(&repr,nrep);
1429 # endif
1430 }
1431 return repr;
1432 }
1433
1434 /* We need a version taking two PyObject* parameters so it's a valid
1435 * PyCFunction to use in swigobject_methods[]. */
1436 SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1437 SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1438 {
1439 return SwigPyObject_repr((SwigPyObject*)v);
1440 }
1441
1442 SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject * v,SwigPyObject * w)1443 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1444 {
1445 void *i = v->ptr;
1446 void *j = w->ptr;
1447 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1448 }
1449
1450 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1451 SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject * v,SwigPyObject * w,int op)1452 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1453 {
1454 PyObject* res;
1455 if( op != Py_EQ && op != Py_NE ) {
1456 Py_INCREF(Py_NotImplemented);
1457 return Py_NotImplemented;
1458 }
1459 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1460 return res;
1461 }
1462
1463
1464 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1465
1466 #ifdef SWIGPYTHON_BUILTIN
1467 static swig_type_info *SwigPyObject_stype = 0;
1468 SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void)1469 SwigPyObject_type(void) {
1470 SwigPyClientData *cd;
1471 assert(SwigPyObject_stype);
1472 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1473 assert(cd);
1474 assert(cd->pytype);
1475 return cd->pytype;
1476 }
1477 #else
1478 SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void)1479 SwigPyObject_type(void) {
1480 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1481 return type;
1482 }
1483 #endif
1484
1485 SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject * op)1486 SwigPyObject_Check(PyObject *op) {
1487 #ifdef SWIGPYTHON_BUILTIN
1488 PyTypeObject *target_tp = SwigPyObject_type();
1489 if (PyType_IsSubtype(op->ob_type, target_tp))
1490 return 1;
1491 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1492 #else
1493 return (Py_TYPE(op) == SwigPyObject_type())
1494 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1495 #endif
1496 }
1497
1498 SWIGRUNTIME PyObject *
1499 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1500
1501 SWIGRUNTIME void
SwigPyObject_dealloc(PyObject * v)1502 SwigPyObject_dealloc(PyObject *v)
1503 {
1504 SwigPyObject *sobj = (SwigPyObject *) v;
1505 PyObject *next = sobj->next;
1506 if (sobj->own == SWIG_POINTER_OWN) {
1507 swig_type_info *ty = sobj->ty;
1508 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1509 PyObject *destroy = data ? data->destroy : 0;
1510 if (destroy) {
1511 /* destroy is always a VARARGS method */
1512 PyObject *res;
1513
1514 /* PyObject_CallFunction() has the potential to silently drop
1515 the active exception. In cases of unnamed temporary
1516 variable or where we just finished iterating over a generator
1517 StopIteration will be active right now, and this needs to
1518 remain true upon return from SwigPyObject_dealloc. So save
1519 and restore. */
1520
1521 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1522 PyErr_Fetch(&type, &value, &traceback);
1523
1524 if (data->delargs) {
1525 /* we need to create a temporary object to carry the destroy operation */
1526 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1527 res = SWIG_Python_CallFunctor(destroy, tmp);
1528 Py_DECREF(tmp);
1529 } else {
1530 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1531 PyObject *mself = PyCFunction_GET_SELF(destroy);
1532 res = ((*meth)(mself, v));
1533 }
1534 if (!res)
1535 PyErr_WriteUnraisable(destroy);
1536
1537 PyErr_Restore(type, value, traceback);
1538
1539 Py_XDECREF(res);
1540 }
1541 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1542 else {
1543 const char *name = SWIG_TypePrettyName(ty);
1544 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1545 }
1546 #endif
1547 }
1548 Py_XDECREF(next);
1549 PyObject_DEL(v);
1550 }
1551
1552 SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject * v,PyObject * next)1553 SwigPyObject_append(PyObject* v, PyObject* next)
1554 {
1555 SwigPyObject *sobj = (SwigPyObject *) v;
1556 if (!SwigPyObject_Check(next)) {
1557 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1558 return NULL;
1559 }
1560 sobj->next = next;
1561 Py_INCREF(next);
1562 return SWIG_Py_Void();
1563 }
1564
1565 SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1566 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1567 {
1568 SwigPyObject *sobj = (SwigPyObject *) v;
1569 if (sobj->next) {
1570 Py_INCREF(sobj->next);
1571 return sobj->next;
1572 } else {
1573 return SWIG_Py_Void();
1574 }
1575 }
1576
1577 SWIGINTERN PyObject*
SwigPyObject_disown(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1578 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1579 {
1580 SwigPyObject *sobj = (SwigPyObject *)v;
1581 sobj->own = 0;
1582 return SWIG_Py_Void();
1583 }
1584
1585 SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject * v,PyObject * SWIGUNUSEDPARM (args))1586 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1587 {
1588 SwigPyObject *sobj = (SwigPyObject *)v;
1589 sobj->own = SWIG_POINTER_OWN;
1590 return SWIG_Py_Void();
1591 }
1592
1593 SWIGINTERN PyObject*
SwigPyObject_own(PyObject * v,PyObject * args)1594 SwigPyObject_own(PyObject *v, PyObject *args)
1595 {
1596 PyObject *val = 0;
1597 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1598 return NULL;
1599 } else {
1600 SwigPyObject *sobj = (SwigPyObject *)v;
1601 PyObject *obj = PyBool_FromLong(sobj->own);
1602 if (val) {
1603 if (PyObject_IsTrue(val)) {
1604 SwigPyObject_acquire(v,args);
1605 } else {
1606 SwigPyObject_disown(v,args);
1607 }
1608 }
1609 return obj;
1610 }
1611 }
1612
1613 static PyMethodDef
1614 swigobject_methods[] = {
1615 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1616 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1617 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1618 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1619 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1620 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1621 {0, 0, 0, 0}
1622 };
1623
1624 SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void)1625 SwigPyObject_TypeOnce(void) {
1626 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1627
1628 static PyNumberMethods SwigPyObject_as_number = {
1629 (binaryfunc)0, /*nb_add*/
1630 (binaryfunc)0, /*nb_subtract*/
1631 (binaryfunc)0, /*nb_multiply*/
1632 /* nb_divide removed in Python 3 */
1633 #if PY_VERSION_HEX < 0x03000000
1634 (binaryfunc)0, /*nb_divide*/
1635 #endif
1636 (binaryfunc)0, /*nb_remainder*/
1637 (binaryfunc)0, /*nb_divmod*/
1638 (ternaryfunc)0,/*nb_power*/
1639 (unaryfunc)0, /*nb_negative*/
1640 (unaryfunc)0, /*nb_positive*/
1641 (unaryfunc)0, /*nb_absolute*/
1642 (inquiry)0, /*nb_nonzero*/
1643 0, /*nb_invert*/
1644 0, /*nb_lshift*/
1645 0, /*nb_rshift*/
1646 0, /*nb_and*/
1647 0, /*nb_xor*/
1648 0, /*nb_or*/
1649 #if PY_VERSION_HEX < 0x03000000
1650 0, /*nb_coerce*/
1651 #endif
1652 (unaryfunc)SwigPyObject_long, /*nb_int*/
1653 #if PY_VERSION_HEX < 0x03000000
1654 (unaryfunc)SwigPyObject_long, /*nb_long*/
1655 #else
1656 0, /*nb_reserved*/
1657 #endif
1658 (unaryfunc)0, /*nb_float*/
1659 #if PY_VERSION_HEX < 0x03000000
1660 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1661 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1662 #endif
1663 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1664 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1665 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1666 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1667 #else
1668 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1669 #endif
1670 };
1671
1672 static PyTypeObject swigpyobject_type;
1673 static int type_init = 0;
1674 if (!type_init) {
1675 const PyTypeObject tmp = {
1676 #if PY_VERSION_HEX >= 0x03000000
1677 PyVarObject_HEAD_INIT(NULL, 0)
1678 #else
1679 PyObject_HEAD_INIT(NULL)
1680 0, /* ob_size */
1681 #endif
1682 "SwigPyObject", /* tp_name */
1683 sizeof(SwigPyObject), /* tp_basicsize */
1684 0, /* tp_itemsize */
1685 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1686 0, /* tp_print */
1687 (getattrfunc)0, /* tp_getattr */
1688 (setattrfunc)0, /* tp_setattr */
1689 #if PY_VERSION_HEX >= 0x03000000
1690 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1691 #else
1692 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1693 #endif
1694 (reprfunc)SwigPyObject_repr, /* tp_repr */
1695 &SwigPyObject_as_number, /* tp_as_number */
1696 0, /* tp_as_sequence */
1697 0, /* tp_as_mapping */
1698 (hashfunc)0, /* tp_hash */
1699 (ternaryfunc)0, /* tp_call */
1700 0, /* tp_str */
1701 PyObject_GenericGetAttr, /* tp_getattro */
1702 0, /* tp_setattro */
1703 0, /* tp_as_buffer */
1704 Py_TPFLAGS_DEFAULT, /* tp_flags */
1705 swigobject_doc, /* tp_doc */
1706 0, /* tp_traverse */
1707 0, /* tp_clear */
1708 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1709 0, /* tp_weaklistoffset */
1710 0, /* tp_iter */
1711 0, /* tp_iternext */
1712 swigobject_methods, /* tp_methods */
1713 0, /* tp_members */
1714 0, /* tp_getset */
1715 0, /* tp_base */
1716 0, /* tp_dict */
1717 0, /* tp_descr_get */
1718 0, /* tp_descr_set */
1719 0, /* tp_dictoffset */
1720 0, /* tp_init */
1721 0, /* tp_alloc */
1722 0, /* tp_new */
1723 0, /* tp_free */
1724 0, /* tp_is_gc */
1725 0, /* tp_bases */
1726 0, /* tp_mro */
1727 0, /* tp_cache */
1728 0, /* tp_subclasses */
1729 0, /* tp_weaklist */
1730 0, /* tp_del */
1731 0, /* tp_version_tag */
1732 #if PY_VERSION_HEX >= 0x03040000
1733 0, /* tp_finalize */
1734 #endif
1735 #ifdef COUNT_ALLOCS
1736 0, /* tp_allocs */
1737 0, /* tp_frees */
1738 0, /* tp_maxalloc */
1739 0, /* tp_prev */
1740 0 /* tp_next */
1741 #endif
1742 };
1743 swigpyobject_type = tmp;
1744 type_init = 1;
1745 if (PyType_Ready(&swigpyobject_type) < 0)
1746 return NULL;
1747 }
1748 return &swigpyobject_type;
1749 }
1750
1751 SWIGRUNTIME PyObject *
SwigPyObject_New(void * ptr,swig_type_info * ty,int own)1752 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1753 {
1754 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1755 if (sobj) {
1756 sobj->ptr = ptr;
1757 sobj->ty = ty;
1758 sobj->own = own;
1759 sobj->next = 0;
1760 }
1761 return (PyObject *)sobj;
1762 }
1763
1764 /* -----------------------------------------------------------------------------
1765 * Implements a simple Swig Packed type, and use it instead of string
1766 * ----------------------------------------------------------------------------- */
1767
1768 typedef struct {
1769 PyObject_HEAD
1770 void *pack;
1771 swig_type_info *ty;
1772 size_t size;
1773 } SwigPyPacked;
1774
1775 SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked * v)1776 SwigPyPacked_repr(SwigPyPacked *v)
1777 {
1778 char result[SWIG_BUFFER_SIZE];
1779 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1780 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1781 } else {
1782 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1783 }
1784 }
1785
1786 SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked * v)1787 SwigPyPacked_str(SwigPyPacked *v)
1788 {
1789 char result[SWIG_BUFFER_SIZE];
1790 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1791 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1792 } else {
1793 return SWIG_Python_str_FromChar(v->ty->name);
1794 }
1795 }
1796
1797 SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked * v,SwigPyPacked * w)1798 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1799 {
1800 size_t i = v->size;
1801 size_t j = w->size;
1802 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1803 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1804 }
1805
1806 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1807
1808 SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void)1809 SwigPyPacked_type(void) {
1810 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1811 return type;
1812 }
1813
1814 SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject * op)1815 SwigPyPacked_Check(PyObject *op) {
1816 return ((op)->ob_type == SwigPyPacked_TypeOnce())
1817 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1818 }
1819
1820 SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject * v)1821 SwigPyPacked_dealloc(PyObject *v)
1822 {
1823 if (SwigPyPacked_Check(v)) {
1824 SwigPyPacked *sobj = (SwigPyPacked *) v;
1825 free(sobj->pack);
1826 }
1827 PyObject_DEL(v);
1828 }
1829
1830 SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void)1831 SwigPyPacked_TypeOnce(void) {
1832 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1833 static PyTypeObject swigpypacked_type;
1834 static int type_init = 0;
1835 if (!type_init) {
1836 const PyTypeObject tmp = {
1837 #if PY_VERSION_HEX>=0x03000000
1838 PyVarObject_HEAD_INIT(NULL, 0)
1839 #else
1840 PyObject_HEAD_INIT(NULL)
1841 0, /* ob_size */
1842 #endif
1843 "SwigPyPacked", /* tp_name */
1844 sizeof(SwigPyPacked), /* tp_basicsize */
1845 0, /* tp_itemsize */
1846 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1847 0, /* tp_print */
1848 (getattrfunc)0, /* tp_getattr */
1849 (setattrfunc)0, /* tp_setattr */
1850 #if PY_VERSION_HEX>=0x03000000
1851 0, /* tp_reserved in 3.0.1 */
1852 #else
1853 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1854 #endif
1855 (reprfunc)SwigPyPacked_repr, /* tp_repr */
1856 0, /* tp_as_number */
1857 0, /* tp_as_sequence */
1858 0, /* tp_as_mapping */
1859 (hashfunc)0, /* tp_hash */
1860 (ternaryfunc)0, /* tp_call */
1861 (reprfunc)SwigPyPacked_str, /* tp_str */
1862 PyObject_GenericGetAttr, /* tp_getattro */
1863 0, /* tp_setattro */
1864 0, /* tp_as_buffer */
1865 Py_TPFLAGS_DEFAULT, /* tp_flags */
1866 swigpacked_doc, /* tp_doc */
1867 0, /* tp_traverse */
1868 0, /* tp_clear */
1869 0, /* tp_richcompare */
1870 0, /* tp_weaklistoffset */
1871 0, /* tp_iter */
1872 0, /* tp_iternext */
1873 0, /* tp_methods */
1874 0, /* tp_members */
1875 0, /* tp_getset */
1876 0, /* tp_base */
1877 0, /* tp_dict */
1878 0, /* tp_descr_get */
1879 0, /* tp_descr_set */
1880 0, /* tp_dictoffset */
1881 0, /* tp_init */
1882 0, /* tp_alloc */
1883 0, /* tp_new */
1884 0, /* tp_free */
1885 0, /* tp_is_gc */
1886 0, /* tp_bases */
1887 0, /* tp_mro */
1888 0, /* tp_cache */
1889 0, /* tp_subclasses */
1890 0, /* tp_weaklist */
1891 0, /* tp_del */
1892 0, /* tp_version_tag */
1893 #if PY_VERSION_HEX >= 0x03040000
1894 0, /* tp_finalize */
1895 #endif
1896 #ifdef COUNT_ALLOCS
1897 0, /* tp_allocs */
1898 0, /* tp_frees */
1899 0, /* tp_maxalloc */
1900 0, /* tp_prev */
1901 0 /* tp_next */
1902 #endif
1903 };
1904 swigpypacked_type = tmp;
1905 type_init = 1;
1906 if (PyType_Ready(&swigpypacked_type) < 0)
1907 return NULL;
1908 }
1909 return &swigpypacked_type;
1910 }
1911
1912 SWIGRUNTIME PyObject *
SwigPyPacked_New(void * ptr,size_t size,swig_type_info * ty)1913 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1914 {
1915 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1916 if (sobj) {
1917 void *pack = malloc(size);
1918 if (pack) {
1919 memcpy(pack, ptr, size);
1920 sobj->pack = pack;
1921 sobj->ty = ty;
1922 sobj->size = size;
1923 } else {
1924 PyObject_DEL((PyObject *) sobj);
1925 sobj = 0;
1926 }
1927 }
1928 return (PyObject *) sobj;
1929 }
1930
1931 SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject * obj,void * ptr,size_t size)1932 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1933 {
1934 if (SwigPyPacked_Check(obj)) {
1935 SwigPyPacked *sobj = (SwigPyPacked *)obj;
1936 if (sobj->size != size) return 0;
1937 memcpy(ptr, sobj->pack, size);
1938 return sobj->ty;
1939 } else {
1940 return 0;
1941 }
1942 }
1943
1944 /* -----------------------------------------------------------------------------
1945 * pointers/data manipulation
1946 * ----------------------------------------------------------------------------- */
1947
1948 static PyObject *Swig_This_global = NULL;
1949
1950 SWIGRUNTIME PyObject *
SWIG_This(void)1951 SWIG_This(void)
1952 {
1953 if (Swig_This_global == NULL)
1954 Swig_This_global = SWIG_Python_str_FromChar("this");
1955 return Swig_This_global;
1956 }
1957
1958 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1959
1960 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
1961 #if PY_VERSION_HEX>=0x03000000
1962 #define SWIG_PYTHON_SLOW_GETSET_THIS
1963 #endif
1964
1965 SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject * pyobj)1966 SWIG_Python_GetSwigThis(PyObject *pyobj)
1967 {
1968 PyObject *obj;
1969
1970 if (SwigPyObject_Check(pyobj))
1971 return (SwigPyObject *) pyobj;
1972
1973 #ifdef SWIGPYTHON_BUILTIN
1974 (void)obj;
1975 # ifdef PyWeakref_CheckProxy
1976 if (PyWeakref_CheckProxy(pyobj)) {
1977 pyobj = PyWeakref_GET_OBJECT(pyobj);
1978 if (pyobj && SwigPyObject_Check(pyobj))
1979 return (SwigPyObject*) pyobj;
1980 }
1981 # endif
1982 return NULL;
1983 #else
1984
1985 obj = 0;
1986
1987 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
1988 if (PyInstance_Check(pyobj)) {
1989 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1990 } else {
1991 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1992 if (dictptr != NULL) {
1993 PyObject *dict = *dictptr;
1994 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1995 } else {
1996 #ifdef PyWeakref_CheckProxy
1997 if (PyWeakref_CheckProxy(pyobj)) {
1998 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1999 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2000 }
2001 #endif
2002 obj = PyObject_GetAttr(pyobj,SWIG_This());
2003 if (obj) {
2004 Py_DECREF(obj);
2005 } else {
2006 if (PyErr_Occurred()) PyErr_Clear();
2007 return 0;
2008 }
2009 }
2010 }
2011 #else
2012 obj = PyObject_GetAttr(pyobj,SWIG_This());
2013 if (obj) {
2014 Py_DECREF(obj);
2015 } else {
2016 if (PyErr_Occurred()) PyErr_Clear();
2017 return 0;
2018 }
2019 #endif
2020 if (obj && !SwigPyObject_Check(obj)) {
2021 /* a PyObject is called 'this', try to get the 'real this'
2022 SwigPyObject from it */
2023 return SWIG_Python_GetSwigThis(obj);
2024 }
2025 return (SwigPyObject *)obj;
2026 #endif
2027 }
2028
2029 /* Acquire a pointer value */
2030
2031 SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject * obj,int own)2032 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2033 if (own == SWIG_POINTER_OWN) {
2034 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2035 if (sobj) {
2036 int oldown = sobj->own;
2037 sobj->own = own;
2038 return oldown;
2039 }
2040 }
2041 return 0;
2042 }
2043
2044 /* Convert a pointer value */
2045
2046 SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject * obj,void ** ptr,swig_type_info * ty,int flags,int * own)2047 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2048 int res;
2049 SwigPyObject *sobj;
2050 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2051
2052 if (!obj)
2053 return SWIG_ERROR;
2054 if (obj == Py_None && !implicit_conv) {
2055 if (ptr)
2056 *ptr = 0;
2057 return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
2058 }
2059
2060 res = SWIG_ERROR;
2061
2062 sobj = SWIG_Python_GetSwigThis(obj);
2063 if (own)
2064 *own = 0;
2065 while (sobj) {
2066 void *vptr = sobj->ptr;
2067 if (ty) {
2068 swig_type_info *to = sobj->ty;
2069 if (to == ty) {
2070 /* no type cast needed */
2071 if (ptr) *ptr = vptr;
2072 break;
2073 } else {
2074 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2075 if (!tc) {
2076 sobj = (SwigPyObject *)sobj->next;
2077 } else {
2078 if (ptr) {
2079 int newmemory = 0;
2080 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2081 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2082 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2083 if (own)
2084 *own = *own | SWIG_CAST_NEW_MEMORY;
2085 }
2086 }
2087 break;
2088 }
2089 }
2090 } else {
2091 if (ptr) *ptr = vptr;
2092 break;
2093 }
2094 }
2095 if (sobj) {
2096 if (own)
2097 *own = *own | sobj->own;
2098 if (flags & SWIG_POINTER_DISOWN) {
2099 sobj->own = 0;
2100 }
2101 res = SWIG_OK;
2102 } else {
2103 if (implicit_conv) {
2104 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2105 if (data && !data->implicitconv) {
2106 PyObject *klass = data->klass;
2107 if (klass) {
2108 PyObject *impconv;
2109 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2110 impconv = SWIG_Python_CallFunctor(klass, obj);
2111 data->implicitconv = 0;
2112 if (PyErr_Occurred()) {
2113 PyErr_Clear();
2114 impconv = 0;
2115 }
2116 if (impconv) {
2117 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2118 if (iobj) {
2119 void *vptr;
2120 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2121 if (SWIG_IsOK(res)) {
2122 if (ptr) {
2123 *ptr = vptr;
2124 /* transfer the ownership to 'ptr' */
2125 iobj->own = 0;
2126 res = SWIG_AddCast(res);
2127 res = SWIG_AddNewMask(res);
2128 } else {
2129 res = SWIG_AddCast(res);
2130 }
2131 }
2132 }
2133 Py_DECREF(impconv);
2134 }
2135 }
2136 }
2137 if (!SWIG_IsOK(res) && obj == Py_None) {
2138 if (ptr)
2139 *ptr = 0;
2140 if (PyErr_Occurred())
2141 PyErr_Clear();
2142 res = SWIG_OK;
2143 }
2144 }
2145 }
2146 return res;
2147 }
2148
2149 /* Convert a function ptr value */
2150
2151 SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject * obj,void ** ptr,swig_type_info * ty)2152 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2153 if (!PyCFunction_Check(obj)) {
2154 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2155 } else {
2156 void *vptr = 0;
2157 swig_cast_info *tc;
2158
2159 /* here we get the method pointer for callbacks */
2160 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2161 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2162 if (desc)
2163 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2164 if (!desc)
2165 return SWIG_ERROR;
2166 tc = SWIG_TypeCheck(desc,ty);
2167 if (tc) {
2168 int newmemory = 0;
2169 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2170 assert(!newmemory); /* newmemory handling not yet implemented */
2171 } else {
2172 return SWIG_ERROR;
2173 }
2174 return SWIG_OK;
2175 }
2176 }
2177
2178 /* Convert a packed pointer value */
2179
2180 SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject * obj,void * ptr,size_t sz,swig_type_info * ty)2181 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2182 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2183 if (!to) return SWIG_ERROR;
2184 if (ty) {
2185 if (to != ty) {
2186 /* check type cast? */
2187 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2188 if (!tc) return SWIG_ERROR;
2189 }
2190 }
2191 return SWIG_OK;
2192 }
2193
2194 /* -----------------------------------------------------------------------------
2195 * Create a new pointer object
2196 * ----------------------------------------------------------------------------- */
2197
2198 /*
2199 Create a new instance object, without calling __init__, and set the
2200 'this' attribute.
2201 */
2202
2203 SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData * data,PyObject * swig_this)2204 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2205 {
2206 PyObject *inst = 0;
2207 PyObject *newraw = data->newraw;
2208 if (newraw) {
2209 inst = PyObject_Call(newraw, data->newargs, NULL);
2210 if (inst) {
2211 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2212 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2213 if (dictptr != NULL) {
2214 PyObject *dict = *dictptr;
2215 if (dict == NULL) {
2216 dict = PyDict_New();
2217 *dictptr = dict;
2218 PyDict_SetItem(dict, SWIG_This(), swig_this);
2219 }
2220 }
2221 #else
2222 PyObject *key = SWIG_This();
2223 PyObject_SetAttr(inst, key, swig_this);
2224 #endif
2225 }
2226 } else {
2227 #if PY_VERSION_HEX >= 0x03000000
2228 PyObject *empty_args = PyTuple_New(0);
2229 if (empty_args) {
2230 PyObject *empty_kwargs = PyDict_New();
2231 if (empty_kwargs) {
2232 inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2233 Py_DECREF(empty_kwargs);
2234 if (inst) {
2235 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2236 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2237 }
2238 }
2239 Py_DECREF(empty_args);
2240 }
2241 #else
2242 PyObject *dict = PyDict_New();
2243 if (dict) {
2244 PyDict_SetItem(dict, SWIG_This(), swig_this);
2245 inst = PyInstance_NewRaw(data->newargs, dict);
2246 Py_DECREF(dict);
2247 }
2248 #endif
2249 }
2250 return inst;
2251 }
2252
2253 SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject * inst,PyObject * swig_this)2254 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2255 {
2256 PyObject *dict;
2257 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2258 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2259 if (dictptr != NULL) {
2260 dict = *dictptr;
2261 if (dict == NULL) {
2262 dict = PyDict_New();
2263 *dictptr = dict;
2264 }
2265 PyDict_SetItem(dict, SWIG_This(), swig_this);
2266 return;
2267 }
2268 #endif
2269 dict = PyObject_GetAttrString(inst, "__dict__");
2270 PyDict_SetItem(dict, SWIG_This(), swig_this);
2271 Py_DECREF(dict);
2272 }
2273
2274
2275 SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject * args)2276 SWIG_Python_InitShadowInstance(PyObject *args) {
2277 PyObject *obj[2];
2278 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2279 return NULL;
2280 } else {
2281 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2282 if (sthis) {
2283 SwigPyObject_append((PyObject*) sthis, obj[1]);
2284 } else {
2285 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2286 }
2287 return SWIG_Py_Void();
2288 }
2289 }
2290
2291 /* Create a new pointer object */
2292
2293 SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject * self,void * ptr,swig_type_info * type,int flags)2294 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2295 SwigPyClientData *clientdata;
2296 PyObject * robj;
2297 int own;
2298
2299 if (!ptr)
2300 return SWIG_Py_Void();
2301
2302 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2303 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2304 if (clientdata && clientdata->pytype) {
2305 SwigPyObject *newobj;
2306 if (flags & SWIG_BUILTIN_TP_INIT) {
2307 newobj = (SwigPyObject*) self;
2308 if (newobj->ptr) {
2309 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2310 while (newobj->next)
2311 newobj = (SwigPyObject *) newobj->next;
2312 newobj->next = next_self;
2313 newobj = (SwigPyObject *)next_self;
2314 #ifdef SWIGPYTHON_BUILTIN
2315 newobj->dict = 0;
2316 #endif
2317 }
2318 } else {
2319 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2320 #ifdef SWIGPYTHON_BUILTIN
2321 newobj->dict = 0;
2322 #endif
2323 }
2324 if (newobj) {
2325 newobj->ptr = ptr;
2326 newobj->ty = type;
2327 newobj->own = own;
2328 newobj->next = 0;
2329 return (PyObject*) newobj;
2330 }
2331 return SWIG_Py_Void();
2332 }
2333
2334 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2335
2336 robj = SwigPyObject_New(ptr, type, own);
2337 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2338 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2339 Py_DECREF(robj);
2340 robj = inst;
2341 }
2342 return robj;
2343 }
2344
2345 /* Create a new packed object */
2346
2347 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void * ptr,size_t sz,swig_type_info * type)2348 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2349 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2350 }
2351
2352 /* -----------------------------------------------------------------------------*
2353 * Get type list
2354 * -----------------------------------------------------------------------------*/
2355
2356 #ifdef SWIG_LINK_RUNTIME
2357 void *SWIG_ReturnGlobalTypeList(void *);
2358 #endif
2359
2360 SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void * SWIGUNUSEDPARM (clientdata))2361 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2362 static void *type_pointer = (void *)0;
2363 /* first check if module already created */
2364 if (!type_pointer) {
2365 #ifdef SWIG_LINK_RUNTIME
2366 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2367 #else
2368 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2369 if (PyErr_Occurred()) {
2370 PyErr_Clear();
2371 type_pointer = (void *)0;
2372 }
2373 #endif
2374 }
2375 return (swig_module_info *) type_pointer;
2376 }
2377
2378 SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject * obj)2379 SWIG_Python_DestroyModule(PyObject *obj)
2380 {
2381 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2382 swig_type_info **types = swig_module->types;
2383 size_t i;
2384 for (i =0; i < swig_module->size; ++i) {
2385 swig_type_info *ty = types[i];
2386 if (ty->owndata) {
2387 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2388 if (data) SwigPyClientData_Del(data);
2389 }
2390 }
2391 Py_DECREF(SWIG_This());
2392 Swig_This_global = NULL;
2393 }
2394
2395 SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info * swig_module)2396 SWIG_Python_SetModule(swig_module_info *swig_module) {
2397 #if PY_VERSION_HEX >= 0x03000000
2398 /* Add a dummy module object into sys.modules */
2399 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2400 #else
2401 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2402 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2403 #endif
2404 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2405 if (pointer && module) {
2406 PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2407 } else {
2408 Py_XDECREF(pointer);
2409 }
2410 }
2411
2412 /* The python cached type query */
2413 SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void)2414 SWIG_Python_TypeCache(void) {
2415 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2416 return cache;
2417 }
2418
2419 SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char * type)2420 SWIG_Python_TypeQuery(const char *type)
2421 {
2422 PyObject *cache = SWIG_Python_TypeCache();
2423 PyObject *key = SWIG_Python_str_FromChar(type);
2424 PyObject *obj = PyDict_GetItem(cache, key);
2425 swig_type_info *descriptor;
2426 if (obj) {
2427 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2428 } else {
2429 swig_module_info *swig_module = SWIG_GetModule(0);
2430 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2431 if (descriptor) {
2432 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2433 PyDict_SetItem(cache, key, obj);
2434 Py_DECREF(obj);
2435 }
2436 }
2437 Py_DECREF(key);
2438 return descriptor;
2439 }
2440
2441 /*
2442 For backward compatibility only
2443 */
2444 #define SWIG_POINTER_EXCEPTION 0
2445 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2446 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2447
2448 SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char * mesg,int infront)2449 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2450 {
2451 if (PyErr_Occurred()) {
2452 PyObject *type = 0;
2453 PyObject *value = 0;
2454 PyObject *traceback = 0;
2455 PyErr_Fetch(&type, &value, &traceback);
2456 if (value) {
2457 PyObject *old_str = PyObject_Str(value);
2458 const char *tmp = SWIG_Python_str_AsChar(old_str);
2459 const char *errmesg = tmp ? tmp : "Invalid error message";
2460 Py_XINCREF(type);
2461 PyErr_Clear();
2462 if (infront) {
2463 PyErr_Format(type, "%s %s", mesg, errmesg);
2464 } else {
2465 PyErr_Format(type, "%s %s", errmesg, mesg);
2466 }
2467 SWIG_Python_str_DelForPy3(tmp);
2468 Py_DECREF(old_str);
2469 }
2470 return 1;
2471 } else {
2472 return 0;
2473 }
2474 }
2475
2476 SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)2477 SWIG_Python_ArgFail(int argnum)
2478 {
2479 if (PyErr_Occurred()) {
2480 /* add information about failing argument */
2481 char mesg[256];
2482 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2483 return SWIG_Python_AddErrMesg(mesg, 1);
2484 } else {
2485 return 0;
2486 }
2487 }
2488
2489 SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject * self)2490 SwigPyObject_GetDesc(PyObject *self)
2491 {
2492 SwigPyObject *v = (SwigPyObject *)self;
2493 swig_type_info *ty = v ? v->ty : 0;
2494 return ty ? ty->str : "";
2495 }
2496
2497 SWIGRUNTIME void
SWIG_Python_TypeError(const char * type,PyObject * obj)2498 SWIG_Python_TypeError(const char *type, PyObject *obj)
2499 {
2500 if (type) {
2501 #if defined(SWIG_COBJECT_TYPES)
2502 if (obj && SwigPyObject_Check(obj)) {
2503 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2504 if (otype) {
2505 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2506 type, otype);
2507 return;
2508 }
2509 } else
2510 #endif
2511 {
2512 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2513 if (otype) {
2514 PyObject *str = PyObject_Str(obj);
2515 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2516 if (cstr) {
2517 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2518 type, otype, cstr);
2519 SWIG_Python_str_DelForPy3(cstr);
2520 } else {
2521 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2522 type, otype);
2523 }
2524 Py_XDECREF(str);
2525 return;
2526 }
2527 }
2528 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2529 } else {
2530 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2531 }
2532 }
2533
2534
2535 /* Convert a pointer value, signal an exception on a type mismatch */
2536 SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject * obj,swig_type_info * ty,int SWIGUNUSEDPARM (argnum),int flags)2537 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2538 void *result;
2539 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2540 PyErr_Clear();
2541 #if SWIG_POINTER_EXCEPTION
2542 if (flags) {
2543 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2544 SWIG_Python_ArgFail(argnum);
2545 }
2546 #endif
2547 }
2548 return result;
2549 }
2550
2551 #ifdef SWIGPYTHON_BUILTIN
2552 SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject * obj,PyObject * name,PyObject * value)2553 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2554 PyTypeObject *tp = obj->ob_type;
2555 PyObject *descr;
2556 PyObject *encoded_name;
2557 descrsetfunc f;
2558 int res = -1;
2559
2560 # ifdef Py_USING_UNICODE
2561 if (PyString_Check(name)) {
2562 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2563 if (!name)
2564 return -1;
2565 } else if (!PyUnicode_Check(name))
2566 # else
2567 if (!PyString_Check(name))
2568 # endif
2569 {
2570 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2571 return -1;
2572 } else {
2573 Py_INCREF(name);
2574 }
2575
2576 if (!tp->tp_dict) {
2577 if (PyType_Ready(tp) < 0)
2578 goto done;
2579 }
2580
2581 descr = _PyType_Lookup(tp, name);
2582 f = NULL;
2583 if (descr != NULL)
2584 f = descr->ob_type->tp_descr_set;
2585 if (!f) {
2586 if (PyString_Check(name)) {
2587 encoded_name = name;
2588 Py_INCREF(name);
2589 } else {
2590 encoded_name = PyUnicode_AsUTF8String(name);
2591 if (!encoded_name)
2592 return -1;
2593 }
2594 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2595 Py_DECREF(encoded_name);
2596 } else {
2597 res = f(descr, obj, value);
2598 }
2599
2600 done:
2601 Py_DECREF(name);
2602 return res;
2603 }
2604 #endif
2605
2606
2607 #ifdef __cplusplus
2608 }
2609 #endif
2610
2611
2612
2613 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2614
2615 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2616
2617
2618
2619 #ifdef __cplusplus
2620 extern "C" {
2621 #endif
2622
2623 /* Method creation and docstring support functions */
2624
2625 SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
2626 SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2627 SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2628
2629 #ifdef __cplusplus
2630 }
2631 #endif
2632
2633
2634 /* -------- TYPES TABLE (BEGIN) -------- */
2635
2636 #define SWIGTYPE_p_Distort swig_types[0]
2637 #define SWIGTYPE_p_IRAFsurface swig_types[1]
2638 #define SWIGTYPE_p_WorldCoor swig_types[2]
2639 #define SWIGTYPE_p_a_32__char swig_types[3]
2640 #define SWIGTYPE_p_a_9__char swig_types[4]
2641 #define SWIGTYPE_p_celprm swig_types[5]
2642 #define SWIGTYPE_p_char swig_types[6]
2643 #define SWIGTYPE_p_double swig_types[7]
2644 #define SWIGTYPE_p_int swig_types[8]
2645 #define SWIGTYPE_p_linprm swig_types[9]
2646 #define SWIGTYPE_p_p_char swig_types[10]
2647 #define SWIGTYPE_p_poly swig_types[11]
2648 #define SWIGTYPE_p_prjprm swig_types[12]
2649 #define SWIGTYPE_p_wcsprm swig_types[13]
2650 static swig_type_info *swig_types[15];
2651 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2652 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2653 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2654
2655 /* -------- TYPES TABLE (END) -------- */
2656
2657 #ifdef SWIG_TypeQuery
2658 # undef SWIG_TypeQuery
2659 #endif
2660 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2661
2662 /*-----------------------------------------------
2663 @(target):= _wcs.so
2664 ------------------------------------------------*/
2665 #if PY_VERSION_HEX >= 0x03000000
2666 # define SWIG_init PyInit__wcs
2667
2668 #else
2669 # define SWIG_init init_wcs
2670
2671 #endif
2672 #define SWIG_name "_wcs"
2673
2674 #define SWIGVERSION 0x040001
2675 #define SWIG_VERSION SWIGVERSION
2676
2677
2678 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2679 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2680
2681
new_doubleArray(size_t nelements)2682 static double *new_doubleArray(size_t nelements) {
2683 return (double *)calloc(nelements, sizeof(double));
2684 }
2685
delete_doubleArray(double * ary)2686 static void delete_doubleArray(double *ary) {
2687 free((char*)ary);
2688 }
2689
doubleArray_getitem(double * ary,size_t index)2690 static double doubleArray_getitem(double *ary, size_t index) {
2691 return ary[index];
2692 }
doubleArray_setitem(double * ary,size_t index,double value)2693 static void doubleArray_setitem(double *ary, size_t index, double value) {
2694 ary[index] = value;
2695 }
2696
2697
2698 SWIGINTERN int
SWIG_AsVal_double(PyObject * obj,double * val)2699 SWIG_AsVal_double (PyObject *obj, double *val)
2700 {
2701 int res = SWIG_TypeError;
2702 if (PyFloat_Check(obj)) {
2703 if (val) *val = PyFloat_AsDouble(obj);
2704 return SWIG_OK;
2705 #if PY_VERSION_HEX < 0x03000000
2706 } else if (PyInt_Check(obj)) {
2707 if (val) *val = (double) PyInt_AsLong(obj);
2708 return SWIG_OK;
2709 #endif
2710 } else if (PyLong_Check(obj)) {
2711 double v = PyLong_AsDouble(obj);
2712 if (!PyErr_Occurred()) {
2713 if (val) *val = v;
2714 return SWIG_OK;
2715 } else {
2716 PyErr_Clear();
2717 }
2718 }
2719 #ifdef SWIG_PYTHON_CAST_MODE
2720 {
2721 int dispatch = 0;
2722 double d = PyFloat_AsDouble(obj);
2723 if (!PyErr_Occurred()) {
2724 if (val) *val = d;
2725 return SWIG_AddCast(SWIG_OK);
2726 } else {
2727 PyErr_Clear();
2728 }
2729 if (!dispatch) {
2730 long v = PyLong_AsLong(obj);
2731 if (!PyErr_Occurred()) {
2732 if (val) *val = v;
2733 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2734 } else {
2735 PyErr_Clear();
2736 }
2737 }
2738 }
2739 #endif
2740 return res;
2741 }
2742
2743
2744 #include <float.h>
2745
2746
2747 #include <math.h>
2748
2749
2750 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)2751 SWIG_CanCastAsInteger(double *d, double min, double max) {
2752 double x = *d;
2753 if ((min <= x && x <= max)) {
2754 double fx = floor(x);
2755 double cx = ceil(x);
2756 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2757 if ((errno == EDOM) || (errno == ERANGE)) {
2758 errno = 0;
2759 } else {
2760 double summ, reps, diff;
2761 if (rd < x) {
2762 diff = x - rd;
2763 } else if (rd > x) {
2764 diff = rd - x;
2765 } else {
2766 return 1;
2767 }
2768 summ = rd + x;
2769 reps = diff/summ;
2770 if (reps < 8*DBL_EPSILON) {
2771 *d = rd;
2772 return 1;
2773 }
2774 }
2775 }
2776 return 0;
2777 }
2778
2779
2780 SWIGINTERN int
SWIG_AsVal_unsigned_SS_long(PyObject * obj,unsigned long * val)2781 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2782 {
2783 #if PY_VERSION_HEX < 0x03000000
2784 if (PyInt_Check(obj)) {
2785 long v = PyInt_AsLong(obj);
2786 if (v >= 0) {
2787 if (val) *val = v;
2788 return SWIG_OK;
2789 } else {
2790 return SWIG_OverflowError;
2791 }
2792 } else
2793 #endif
2794 if (PyLong_Check(obj)) {
2795 unsigned long v = PyLong_AsUnsignedLong(obj);
2796 if (!PyErr_Occurred()) {
2797 if (val) *val = v;
2798 return SWIG_OK;
2799 } else {
2800 PyErr_Clear();
2801 return SWIG_OverflowError;
2802 }
2803 }
2804 #ifdef SWIG_PYTHON_CAST_MODE
2805 {
2806 int dispatch = 0;
2807 unsigned long v = PyLong_AsUnsignedLong(obj);
2808 if (!PyErr_Occurred()) {
2809 if (val) *val = v;
2810 return SWIG_AddCast(SWIG_OK);
2811 } else {
2812 PyErr_Clear();
2813 }
2814 if (!dispatch) {
2815 double d;
2816 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2817 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2818 if (val) *val = (unsigned long)(d);
2819 return res;
2820 }
2821 }
2822 }
2823 #endif
2824 return SWIG_TypeError;
2825 }
2826
2827
2828 #include <limits.h>
2829 #if !defined(SWIG_NO_LLONG_MAX)
2830 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2831 # define LLONG_MAX __LONG_LONG_MAX__
2832 # define LLONG_MIN (-LLONG_MAX - 1LL)
2833 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2834 # endif
2835 #endif
2836
2837
2838 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
2839 # define SWIG_LONG_LONG_AVAILABLE
2840 #endif
2841
2842
2843 #ifdef SWIG_LONG_LONG_AVAILABLE
2844 SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long(PyObject * obj,unsigned long long * val)2845 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
2846 {
2847 int res = SWIG_TypeError;
2848 if (PyLong_Check(obj)) {
2849 unsigned long long v = PyLong_AsUnsignedLongLong(obj);
2850 if (!PyErr_Occurred()) {
2851 if (val) *val = v;
2852 return SWIG_OK;
2853 } else {
2854 PyErr_Clear();
2855 res = SWIG_OverflowError;
2856 }
2857 } else {
2858 unsigned long v;
2859 res = SWIG_AsVal_unsigned_SS_long (obj,&v);
2860 if (SWIG_IsOK(res)) {
2861 if (val) *val = v;
2862 return res;
2863 }
2864 }
2865 #ifdef SWIG_PYTHON_CAST_MODE
2866 {
2867 const double mant_max = 1LL << DBL_MANT_DIG;
2868 double d;
2869 res = SWIG_AsVal_double (obj,&d);
2870 if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
2871 return SWIG_OverflowError;
2872 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
2873 if (val) *val = (unsigned long long)(d);
2874 return SWIG_AddCast(res);
2875 }
2876 res = SWIG_TypeError;
2877 }
2878 #endif
2879 return res;
2880 }
2881 #endif
2882
2883
2884 SWIGINTERNINLINE int
SWIG_AsVal_size_t(PyObject * obj,size_t * val)2885 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2886 {
2887 int res = SWIG_TypeError;
2888 #ifdef SWIG_LONG_LONG_AVAILABLE
2889 if (sizeof(size_t) <= sizeof(unsigned long)) {
2890 #endif
2891 unsigned long v;
2892 res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2893 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2894 #ifdef SWIG_LONG_LONG_AVAILABLE
2895 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
2896 unsigned long long v;
2897 res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
2898 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2899 }
2900 #endif
2901 return res;
2902 }
2903
2904
2905 #define SWIG_From_double PyFloat_FromDouble
2906
2907
2908 #include "wcs.h"
2909
2910
2911 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)2912 SWIG_pchar_descriptor(void)
2913 {
2914 static int init = 0;
2915 static swig_type_info* info = 0;
2916 if (!init) {
2917 info = SWIG_TypeQuery("_p_char");
2918 init = 1;
2919 }
2920 return info;
2921 }
2922
2923
2924 SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject * obj,char ** cptr,size_t * psize,int * alloc)2925 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2926 {
2927 #if PY_VERSION_HEX>=0x03000000
2928 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2929 if (PyBytes_Check(obj))
2930 #else
2931 if (PyUnicode_Check(obj))
2932 #endif
2933 #else
2934 if (PyString_Check(obj))
2935 #endif
2936 {
2937 char *cstr; Py_ssize_t len;
2938 int ret = SWIG_OK;
2939 #if PY_VERSION_HEX>=0x03000000
2940 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2941 if (!alloc && cptr) {
2942 /* We can't allow converting without allocation, since the internal
2943 representation of string in Python 3 is UCS-2/UCS-4 but we require
2944 a UTF-8 representation.
2945 TODO(bhy) More detailed explanation */
2946 return SWIG_RuntimeError;
2947 }
2948 obj = PyUnicode_AsUTF8String(obj);
2949 if (!obj)
2950 return SWIG_TypeError;
2951 if (alloc)
2952 *alloc = SWIG_NEWOBJ;
2953 #endif
2954 PyBytes_AsStringAndSize(obj, &cstr, &len);
2955 #else
2956 PyString_AsStringAndSize(obj, &cstr, &len);
2957 #endif
2958 if (cptr) {
2959 if (alloc) {
2960 if (*alloc == SWIG_NEWOBJ) {
2961 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2962 *alloc = SWIG_NEWOBJ;
2963 } else {
2964 *cptr = cstr;
2965 *alloc = SWIG_OLDOBJ;
2966 }
2967 } else {
2968 #if PY_VERSION_HEX>=0x03000000
2969 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2970 *cptr = PyBytes_AsString(obj);
2971 #else
2972 assert(0); /* Should never reach here with Unicode strings in Python 3 */
2973 #endif
2974 #else
2975 *cptr = SWIG_Python_str_AsChar(obj);
2976 if (!*cptr)
2977 ret = SWIG_TypeError;
2978 #endif
2979 }
2980 }
2981 if (psize) *psize = len + 1;
2982 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2983 Py_XDECREF(obj);
2984 #endif
2985 return ret;
2986 } else {
2987 #if defined(SWIG_PYTHON_2_UNICODE)
2988 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2989 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
2990 #endif
2991 #if PY_VERSION_HEX<0x03000000
2992 if (PyUnicode_Check(obj)) {
2993 char *cstr; Py_ssize_t len;
2994 if (!alloc && cptr) {
2995 return SWIG_RuntimeError;
2996 }
2997 obj = PyUnicode_AsUTF8String(obj);
2998 if (!obj)
2999 return SWIG_TypeError;
3000 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3001 if (cptr) {
3002 if (alloc) *alloc = SWIG_NEWOBJ;
3003 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3004 }
3005 if (psize) *psize = len + 1;
3006
3007 Py_XDECREF(obj);
3008 return SWIG_OK;
3009 } else {
3010 Py_XDECREF(obj);
3011 }
3012 }
3013 #endif
3014 #endif
3015
3016 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3017 if (pchar_descriptor) {
3018 void* vptr = 0;
3019 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3020 if (cptr) *cptr = (char *) vptr;
3021 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3022 if (alloc) *alloc = SWIG_OLDOBJ;
3023 return SWIG_OK;
3024 }
3025 }
3026 }
3027 return SWIG_TypeError;
3028 }
3029
3030
3031
3032
3033
3034 SWIGINTERN int
SWIG_AsVal_long(PyObject * obj,long * val)3035 SWIG_AsVal_long (PyObject *obj, long* val)
3036 {
3037 #if PY_VERSION_HEX < 0x03000000
3038 if (PyInt_Check(obj)) {
3039 if (val) *val = PyInt_AsLong(obj);
3040 return SWIG_OK;
3041 } else
3042 #endif
3043 if (PyLong_Check(obj)) {
3044 long v = PyLong_AsLong(obj);
3045 if (!PyErr_Occurred()) {
3046 if (val) *val = v;
3047 return SWIG_OK;
3048 } else {
3049 PyErr_Clear();
3050 return SWIG_OverflowError;
3051 }
3052 }
3053 #ifdef SWIG_PYTHON_CAST_MODE
3054 {
3055 int dispatch = 0;
3056 long v = PyInt_AsLong(obj);
3057 if (!PyErr_Occurred()) {
3058 if (val) *val = v;
3059 return SWIG_AddCast(SWIG_OK);
3060 } else {
3061 PyErr_Clear();
3062 }
3063 if (!dispatch) {
3064 double d;
3065 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3066 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3067 if (val) *val = (long)(d);
3068 return res;
3069 }
3070 }
3071 }
3072 #endif
3073 return SWIG_TypeError;
3074 }
3075
3076
3077 SWIGINTERN int
SWIG_AsVal_int(PyObject * obj,int * val)3078 SWIG_AsVal_int (PyObject * obj, int *val)
3079 {
3080 long v;
3081 int res = SWIG_AsVal_long (obj, &v);
3082 if (SWIG_IsOK(res)) {
3083 if ((v < INT_MIN || v > INT_MAX)) {
3084 return SWIG_OverflowError;
3085 } else {
3086 if (val) *val = (int)(v);
3087 }
3088 }
3089 return res;
3090 }
3091
3092
3093 SWIGINTERNINLINE PyObject*
SWIG_From_int(int value)3094 SWIG_From_int (int value)
3095 {
3096 return PyInt_FromLong((long) value);
3097 }
3098
3099
3100 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)3101 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3102 {
3103 if (carray) {
3104 if (size > INT_MAX) {
3105 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3106 return pchar_descriptor ?
3107 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3108 } else {
3109 #if PY_VERSION_HEX >= 0x03000000
3110 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3111 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3112 #else
3113 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3114 #endif
3115 #else
3116 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3117 #endif
3118 }
3119 } else {
3120 return SWIG_Py_Void();
3121 }
3122 }
3123
3124
3125 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char * cptr)3126 SWIG_FromCharPtr(const char *cptr)
3127 {
3128 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3129 }
3130
3131
3132 SWIGINTERN int
SWIG_AsCharArray(PyObject * obj,char * val,size_t size)3133 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3134 {
3135 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3136 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3137 if (SWIG_IsOK(res)) {
3138 /* special case of single char conversion when we don't need space for NUL */
3139 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3140 if (csize <= size) {
3141 if (val) {
3142 if (csize) memcpy(val, cptr, csize*sizeof(char));
3143 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3144 }
3145 if (alloc == SWIG_NEWOBJ) {
3146 free((char*)cptr);
3147 res = SWIG_DelNewMask(res);
3148 }
3149 return res;
3150 }
3151 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3152 }
3153 return SWIG_TypeError;
3154 }
3155
3156
3157 SWIGINTERN size_t
SWIG_strnlen(const char * s,size_t maxlen)3158 SWIG_strnlen(const char* s, size_t maxlen)
3159 {
3160 const char *p;
3161 for (p = s; maxlen-- && *p; p++)
3162 ;
3163 return p - s;
3164 }
3165
3166
3167 SWIGINTERN int
SWIG_AsVal_char(PyObject * obj,char * val)3168 SWIG_AsVal_char (PyObject * obj, char *val)
3169 {
3170 int res = SWIG_AsCharArray(obj, val, 1);
3171 if (!SWIG_IsOK(res)) {
3172 long v;
3173 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3174 if (SWIG_IsOK(res)) {
3175 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3176 if (val) *val = (char)(v);
3177 } else {
3178 res = SWIG_OverflowError;
3179 }
3180 }
3181 }
3182 return res;
3183 }
3184
3185
3186 SWIGINTERNINLINE PyObject *
SWIG_From_char(char c)3187 SWIG_From_char (char c)
3188 {
3189 return SWIG_FromCharPtrAndSize(&c,1);
3190 }
3191
3192 #ifdef __cplusplus
3193 extern "C" {
3194 #endif
_wrap_new_doubleArray(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3195 SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3196 PyObject *resultobj = 0;
3197 size_t arg1 ;
3198 size_t val1 ;
3199 int ecode1 = 0 ;
3200 PyObject *swig_obj[1] ;
3201 double *result = 0 ;
3202
3203 if (!args) SWIG_fail;
3204 swig_obj[0] = args;
3205 ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
3206 if (!SWIG_IsOK(ecode1)) {
3207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "size_t""'");
3208 }
3209 arg1 = (size_t)(val1);
3210 result = (double *)new_doubleArray(arg1);
3211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
3212 return resultobj;
3213 fail:
3214 return NULL;
3215 }
3216
3217
_wrap_delete_doubleArray(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3218 SWIGINTERN PyObject *_wrap_delete_doubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3219 PyObject *resultobj = 0;
3220 double *arg1 = (double *) 0 ;
3221 void *argp1 = 0 ;
3222 int res1 = 0 ;
3223 PyObject *swig_obj[1] ;
3224
3225 if (!args) SWIG_fail;
3226 swig_obj[0] = args;
3227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 );
3228 if (!SWIG_IsOK(res1)) {
3229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleArray" "', argument " "1"" of type '" "double *""'");
3230 }
3231 arg1 = (double *)(argp1);
3232 delete_doubleArray(arg1);
3233 resultobj = SWIG_Py_Void();
3234 return resultobj;
3235 fail:
3236 return NULL;
3237 }
3238
3239
_wrap_doubleArray_getitem(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3240 SWIGINTERN PyObject *_wrap_doubleArray_getitem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3241 PyObject *resultobj = 0;
3242 double *arg1 = (double *) 0 ;
3243 size_t arg2 ;
3244 void *argp1 = 0 ;
3245 int res1 = 0 ;
3246 size_t val2 ;
3247 int ecode2 = 0 ;
3248 PyObject *swig_obj[2] ;
3249 double result;
3250
3251 if (!SWIG_Python_UnpackTuple(args, "doubleArray_getitem", 2, 2, swig_obj)) SWIG_fail;
3252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 );
3253 if (!SWIG_IsOK(res1)) {
3254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_getitem" "', argument " "1"" of type '" "double *""'");
3255 }
3256 arg1 = (double *)(argp1);
3257 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
3258 if (!SWIG_IsOK(ecode2)) {
3259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_getitem" "', argument " "2"" of type '" "size_t""'");
3260 }
3261 arg2 = (size_t)(val2);
3262 result = (double)doubleArray_getitem(arg1,arg2);
3263 resultobj = SWIG_From_double((double)(result));
3264 return resultobj;
3265 fail:
3266 return NULL;
3267 }
3268
3269
_wrap_doubleArray_setitem(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3270 SWIGINTERN PyObject *_wrap_doubleArray_setitem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3271 PyObject *resultobj = 0;
3272 double *arg1 = (double *) 0 ;
3273 size_t arg2 ;
3274 double arg3 ;
3275 void *argp1 = 0 ;
3276 int res1 = 0 ;
3277 size_t val2 ;
3278 int ecode2 = 0 ;
3279 double val3 ;
3280 int ecode3 = 0 ;
3281 PyObject *swig_obj[3] ;
3282
3283 if (!SWIG_Python_UnpackTuple(args, "doubleArray_setitem", 3, 3, swig_obj)) SWIG_fail;
3284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 );
3285 if (!SWIG_IsOK(res1)) {
3286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_setitem" "', argument " "1"" of type '" "double *""'");
3287 }
3288 arg1 = (double *)(argp1);
3289 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
3290 if (!SWIG_IsOK(ecode2)) {
3291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_setitem" "', argument " "2"" of type '" "size_t""'");
3292 }
3293 arg2 = (size_t)(val2);
3294 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
3295 if (!SWIG_IsOK(ecode3)) {
3296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_setitem" "', argument " "3"" of type '" "double""'");
3297 }
3298 arg3 = (double)(val3);
3299 doubleArray_setitem(arg1,arg2,arg3);
3300 resultobj = SWIG_Py_Void();
3301 return resultobj;
3302 fail:
3303 return NULL;
3304 }
3305
3306
_wrap_wcsinit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3307 SWIGINTERN PyObject *_wrap_wcsinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3308 PyObject *resultobj = 0;
3309 char *arg1 = (char *) 0 ;
3310 int res1 ;
3311 char *buf1 = 0 ;
3312 int alloc1 = 0 ;
3313 PyObject *swig_obj[1] ;
3314 struct WorldCoor *result = 0 ;
3315
3316 if (!args) SWIG_fail;
3317 swig_obj[0] = args;
3318 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
3319 if (!SWIG_IsOK(res1)) {
3320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcsinit" "', argument " "1"" of type '" "char *""'");
3321 }
3322 arg1 = (char *)(buf1);
3323 result = (struct WorldCoor *)wcsinit(arg1);
3324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, 0 | 0 );
3325 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3326 return resultobj;
3327 fail:
3328 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3329 return NULL;
3330 }
3331
3332
_wrap_wcsxinit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3333 SWIGINTERN PyObject *_wrap_wcsxinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3334 PyObject *resultobj = 0;
3335 double arg1 ;
3336 double arg2 ;
3337 double arg3 ;
3338 int arg4 ;
3339 int arg5 ;
3340 int arg6 ;
3341 int arg7 ;
3342 double arg8 ;
3343 int arg9 ;
3344 double arg10 ;
3345 char *arg11 = (char *) 0 ;
3346 double val1 ;
3347 int ecode1 = 0 ;
3348 double val2 ;
3349 int ecode2 = 0 ;
3350 double val3 ;
3351 int ecode3 = 0 ;
3352 int val4 ;
3353 int ecode4 = 0 ;
3354 int val5 ;
3355 int ecode5 = 0 ;
3356 int val6 ;
3357 int ecode6 = 0 ;
3358 int val7 ;
3359 int ecode7 = 0 ;
3360 double val8 ;
3361 int ecode8 = 0 ;
3362 int val9 ;
3363 int ecode9 = 0 ;
3364 double val10 ;
3365 int ecode10 = 0 ;
3366 int res11 ;
3367 char *buf11 = 0 ;
3368 int alloc11 = 0 ;
3369 PyObject *swig_obj[11] ;
3370 struct WorldCoor *result = 0 ;
3371
3372 if (!SWIG_Python_UnpackTuple(args, "wcsxinit", 11, 11, swig_obj)) SWIG_fail;
3373 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3374 if (!SWIG_IsOK(ecode1)) {
3375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wcsxinit" "', argument " "1"" of type '" "double""'");
3376 }
3377 arg1 = (double)(val1);
3378 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3379 if (!SWIG_IsOK(ecode2)) {
3380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wcsxinit" "', argument " "2"" of type '" "double""'");
3381 }
3382 arg2 = (double)(val2);
3383 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
3384 if (!SWIG_IsOK(ecode3)) {
3385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wcsxinit" "', argument " "3"" of type '" "double""'");
3386 }
3387 arg3 = (double)(val3);
3388 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
3389 if (!SWIG_IsOK(ecode4)) {
3390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "wcsxinit" "', argument " "4"" of type '" "int""'");
3391 }
3392 arg4 = (int)(val4);
3393 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
3394 if (!SWIG_IsOK(ecode5)) {
3395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "wcsxinit" "', argument " "5"" of type '" "int""'");
3396 }
3397 arg5 = (int)(val5);
3398 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
3399 if (!SWIG_IsOK(ecode6)) {
3400 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "wcsxinit" "', argument " "6"" of type '" "int""'");
3401 }
3402 arg6 = (int)(val6);
3403 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
3404 if (!SWIG_IsOK(ecode7)) {
3405 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "wcsxinit" "', argument " "7"" of type '" "int""'");
3406 }
3407 arg7 = (int)(val7);
3408 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
3409 if (!SWIG_IsOK(ecode8)) {
3410 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "wcsxinit" "', argument " "8"" of type '" "double""'");
3411 }
3412 arg8 = (double)(val8);
3413 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
3414 if (!SWIG_IsOK(ecode9)) {
3415 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "wcsxinit" "', argument " "9"" of type '" "int""'");
3416 }
3417 arg9 = (int)(val9);
3418 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
3419 if (!SWIG_IsOK(ecode10)) {
3420 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "wcsxinit" "', argument " "10"" of type '" "double""'");
3421 }
3422 arg10 = (double)(val10);
3423 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
3424 if (!SWIG_IsOK(res11)) {
3425 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "wcsxinit" "', argument " "11"" of type '" "char *""'");
3426 }
3427 arg11 = (char *)(buf11);
3428 result = (struct WorldCoor *)wcsxinit(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, 0 | 0 );
3430 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
3431 return resultobj;
3432 fail:
3433 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
3434 return NULL;
3435 }
3436
3437
_wrap_wcskinit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3438 SWIGINTERN PyObject *_wrap_wcskinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3439 PyObject *resultobj = 0;
3440 int arg1 ;
3441 int arg2 ;
3442 char *arg3 = (char *) 0 ;
3443 char *arg4 = (char *) 0 ;
3444 double arg5 ;
3445 double arg6 ;
3446 double arg7 ;
3447 double arg8 ;
3448 double *arg9 = (double *) 0 ;
3449 double arg10 ;
3450 double arg11 ;
3451 double arg12 ;
3452 double arg13 ;
3453 double arg14 ;
3454 int val1 ;
3455 int ecode1 = 0 ;
3456 int val2 ;
3457 int ecode2 = 0 ;
3458 int res3 ;
3459 char *buf3 = 0 ;
3460 int alloc3 = 0 ;
3461 int res4 ;
3462 char *buf4 = 0 ;
3463 int alloc4 = 0 ;
3464 double val5 ;
3465 int ecode5 = 0 ;
3466 double val6 ;
3467 int ecode6 = 0 ;
3468 double val7 ;
3469 int ecode7 = 0 ;
3470 double val8 ;
3471 int ecode8 = 0 ;
3472 void *argp9 = 0 ;
3473 int res9 = 0 ;
3474 double val10 ;
3475 int ecode10 = 0 ;
3476 double val11 ;
3477 int ecode11 = 0 ;
3478 double val12 ;
3479 int ecode12 = 0 ;
3480 double val13 ;
3481 int ecode13 = 0 ;
3482 double val14 ;
3483 int ecode14 = 0 ;
3484 PyObject *swig_obj[14] ;
3485 struct WorldCoor *result = 0 ;
3486
3487 if (!SWIG_Python_UnpackTuple(args, "wcskinit", 14, 14, swig_obj)) SWIG_fail;
3488 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
3489 if (!SWIG_IsOK(ecode1)) {
3490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wcskinit" "', argument " "1"" of type '" "int""'");
3491 }
3492 arg1 = (int)(val1);
3493 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
3494 if (!SWIG_IsOK(ecode2)) {
3495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wcskinit" "', argument " "2"" of type '" "int""'");
3496 }
3497 arg2 = (int)(val2);
3498 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
3499 if (!SWIG_IsOK(res3)) {
3500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wcskinit" "', argument " "3"" of type '" "char *""'");
3501 }
3502 arg3 = (char *)(buf3);
3503 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
3504 if (!SWIG_IsOK(res4)) {
3505 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "wcskinit" "', argument " "4"" of type '" "char *""'");
3506 }
3507 arg4 = (char *)(buf4);
3508 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
3509 if (!SWIG_IsOK(ecode5)) {
3510 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "wcskinit" "', argument " "5"" of type '" "double""'");
3511 }
3512 arg5 = (double)(val5);
3513 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
3514 if (!SWIG_IsOK(ecode6)) {
3515 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "wcskinit" "', argument " "6"" of type '" "double""'");
3516 }
3517 arg6 = (double)(val6);
3518 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
3519 if (!SWIG_IsOK(ecode7)) {
3520 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "wcskinit" "', argument " "7"" of type '" "double""'");
3521 }
3522 arg7 = (double)(val7);
3523 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
3524 if (!SWIG_IsOK(ecode8)) {
3525 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "wcskinit" "', argument " "8"" of type '" "double""'");
3526 }
3527 arg8 = (double)(val8);
3528 res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_double, 0 | 0 );
3529 if (!SWIG_IsOK(res9)) {
3530 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "wcskinit" "', argument " "9"" of type '" "double *""'");
3531 }
3532 arg9 = (double *)(argp9);
3533 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
3534 if (!SWIG_IsOK(ecode10)) {
3535 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "wcskinit" "', argument " "10"" of type '" "double""'");
3536 }
3537 arg10 = (double)(val10);
3538 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
3539 if (!SWIG_IsOK(ecode11)) {
3540 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "wcskinit" "', argument " "11"" of type '" "double""'");
3541 }
3542 arg11 = (double)(val11);
3543 ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
3544 if (!SWIG_IsOK(ecode12)) {
3545 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "wcskinit" "', argument " "12"" of type '" "double""'");
3546 }
3547 arg12 = (double)(val12);
3548 ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
3549 if (!SWIG_IsOK(ecode13)) {
3550 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "wcskinit" "', argument " "13"" of type '" "double""'");
3551 }
3552 arg13 = (double)(val13);
3553 ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
3554 if (!SWIG_IsOK(ecode14)) {
3555 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "wcskinit" "', argument " "14"" of type '" "double""'");
3556 }
3557 arg14 = (double)(val14);
3558 result = (struct WorldCoor *)wcskinit(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
3559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, 0 | 0 );
3560 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3561 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3562 return resultobj;
3563 fail:
3564 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3565 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3566 return NULL;
3567 }
3568
3569
_wrap_iswcs(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3570 SWIGINTERN PyObject *_wrap_iswcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3571 PyObject *resultobj = 0;
3572 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3573 void *argp1 = 0 ;
3574 int res1 = 0 ;
3575 PyObject *swig_obj[1] ;
3576 int result;
3577
3578 if (!args) SWIG_fail;
3579 swig_obj[0] = args;
3580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3581 if (!SWIG_IsOK(res1)) {
3582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iswcs" "', argument " "1"" of type '" "struct WorldCoor *""'");
3583 }
3584 arg1 = (struct WorldCoor *)(argp1);
3585 result = (int)iswcs(arg1);
3586 resultobj = SWIG_From_int((int)(result));
3587 return resultobj;
3588 fail:
3589 return NULL;
3590 }
3591
3592
_wrap_nowcs(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3593 SWIGINTERN PyObject *_wrap_nowcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3594 PyObject *resultobj = 0;
3595 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3596 void *argp1 = 0 ;
3597 int res1 = 0 ;
3598 PyObject *swig_obj[1] ;
3599 int result;
3600
3601 if (!args) SWIG_fail;
3602 swig_obj[0] = args;
3603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3604 if (!SWIG_IsOK(res1)) {
3605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nowcs" "', argument " "1"" of type '" "struct WorldCoor *""'");
3606 }
3607 arg1 = (struct WorldCoor *)(argp1);
3608 result = (int)nowcs(arg1);
3609 resultobj = SWIG_From_int((int)(result));
3610 return resultobj;
3611 fail:
3612 return NULL;
3613 }
3614
3615
_wrap_wcs2pix(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3616 SWIGINTERN PyObject *_wrap_wcs2pix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3617 PyObject *resultobj = 0;
3618 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3619 double arg2 ;
3620 double arg3 ;
3621 double *arg4 = (double *) 0 ;
3622 double *arg5 = (double *) 0 ;
3623 int *arg6 = (int *) 0 ;
3624 void *argp1 = 0 ;
3625 int res1 = 0 ;
3626 double val2 ;
3627 int ecode2 = 0 ;
3628 double val3 ;
3629 int ecode3 = 0 ;
3630 double temp4 ;
3631 int res4 = SWIG_TMPOBJ ;
3632 double temp5 ;
3633 int res5 = SWIG_TMPOBJ ;
3634 int temp6 ;
3635 int res6 = SWIG_TMPOBJ ;
3636 PyObject *swig_obj[3] ;
3637
3638 arg4 = &temp4;
3639 arg5 = &temp5;
3640 arg6 = &temp6;
3641 if (!SWIG_Python_UnpackTuple(args, "wcs2pix", 3, 3, swig_obj)) SWIG_fail;
3642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3643 if (!SWIG_IsOK(res1)) {
3644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcs2pix" "', argument " "1"" of type '" "struct WorldCoor *""'");
3645 }
3646 arg1 = (struct WorldCoor *)(argp1);
3647 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3648 if (!SWIG_IsOK(ecode2)) {
3649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wcs2pix" "', argument " "2"" of type '" "double""'");
3650 }
3651 arg2 = (double)(val2);
3652 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
3653 if (!SWIG_IsOK(ecode3)) {
3654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wcs2pix" "', argument " "3"" of type '" "double""'");
3655 }
3656 arg3 = (double)(val3);
3657 wcs2pix(arg1,arg2,arg3,arg4,arg5,arg6);
3658 resultobj = SWIG_Py_Void();
3659 if (SWIG_IsTmpObj(res4)) {
3660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3661 } else {
3662 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3664 }
3665 if (SWIG_IsTmpObj(res5)) {
3666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
3667 } else {
3668 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
3670 }
3671 if (SWIG_IsTmpObj(res6)) {
3672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
3673 } else {
3674 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
3676 }
3677 return resultobj;
3678 fail:
3679 return NULL;
3680 }
3681
3682
_wrap_pix2wcs(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3683 SWIGINTERN PyObject *_wrap_pix2wcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3684 PyObject *resultobj = 0;
3685 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3686 double arg2 ;
3687 double arg3 ;
3688 double *arg4 = (double *) 0 ;
3689 double *arg5 = (double *) 0 ;
3690 void *argp1 = 0 ;
3691 int res1 = 0 ;
3692 double val2 ;
3693 int ecode2 = 0 ;
3694 double val3 ;
3695 int ecode3 = 0 ;
3696 double temp4 ;
3697 int res4 = SWIG_TMPOBJ ;
3698 double temp5 ;
3699 int res5 = SWIG_TMPOBJ ;
3700 PyObject *swig_obj[3] ;
3701
3702 arg4 = &temp4;
3703 arg5 = &temp5;
3704 if (!SWIG_Python_UnpackTuple(args, "pix2wcs", 3, 3, swig_obj)) SWIG_fail;
3705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3706 if (!SWIG_IsOK(res1)) {
3707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pix2wcs" "', argument " "1"" of type '" "struct WorldCoor *""'");
3708 }
3709 arg1 = (struct WorldCoor *)(argp1);
3710 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3711 if (!SWIG_IsOK(ecode2)) {
3712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pix2wcs" "', argument " "2"" of type '" "double""'");
3713 }
3714 arg2 = (double)(val2);
3715 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
3716 if (!SWIG_IsOK(ecode3)) {
3717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pix2wcs" "', argument " "3"" of type '" "double""'");
3718 }
3719 arg3 = (double)(val3);
3720 pix2wcs(arg1,arg2,arg3,arg4,arg5);
3721 resultobj = SWIG_Py_Void();
3722 if (SWIG_IsTmpObj(res4)) {
3723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3724 } else {
3725 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3727 }
3728 if (SWIG_IsTmpObj(res5)) {
3729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
3730 } else {
3731 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
3733 }
3734 return resultobj;
3735 fail:
3736 return NULL;
3737 }
3738
3739
_wrap_wcscent(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3740 SWIGINTERN PyObject *_wrap_wcscent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3741 PyObject *resultobj = 0;
3742 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3743 void *argp1 = 0 ;
3744 int res1 = 0 ;
3745 PyObject *swig_obj[1] ;
3746
3747 if (!args) SWIG_fail;
3748 swig_obj[0] = args;
3749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3750 if (!SWIG_IsOK(res1)) {
3751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcscent" "', argument " "1"" of type '" "struct WorldCoor *""'");
3752 }
3753 arg1 = (struct WorldCoor *)(argp1);
3754 wcscent(arg1);
3755 resultobj = SWIG_Py_Void();
3756 return resultobj;
3757 fail:
3758 return NULL;
3759 }
3760
3761
_wrap_getradecsys(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3762 SWIGINTERN PyObject *_wrap_getradecsys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3763 PyObject *resultobj = 0;
3764 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3765 void *argp1 = 0 ;
3766 int res1 = 0 ;
3767 PyObject *swig_obj[1] ;
3768 char *result = 0 ;
3769
3770 if (!args) SWIG_fail;
3771 swig_obj[0] = args;
3772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3773 if (!SWIG_IsOK(res1)) {
3774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getradecsys" "', argument " "1"" of type '" "struct WorldCoor *""'");
3775 }
3776 arg1 = (struct WorldCoor *)(argp1);
3777 result = (char *)getradecsys(arg1);
3778 resultobj = SWIG_FromCharPtr((const char *)result);
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
_wrap_wcsoutinit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3785 SWIGINTERN PyObject *_wrap_wcsoutinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3786 PyObject *resultobj = 0;
3787 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3788 char *arg2 = (char *) 0 ;
3789 void *argp1 = 0 ;
3790 int res1 = 0 ;
3791 int res2 ;
3792 char *buf2 = 0 ;
3793 int alloc2 = 0 ;
3794 PyObject *swig_obj[2] ;
3795
3796 if (!SWIG_Python_UnpackTuple(args, "wcsoutinit", 2, 2, swig_obj)) SWIG_fail;
3797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3798 if (!SWIG_IsOK(res1)) {
3799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcsoutinit" "', argument " "1"" of type '" "struct WorldCoor *""'");
3800 }
3801 arg1 = (struct WorldCoor *)(argp1);
3802 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
3803 if (!SWIG_IsOK(res2)) {
3804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wcsoutinit" "', argument " "2"" of type '" "char *""'");
3805 }
3806 arg2 = (char *)(buf2);
3807 wcsoutinit(arg1,arg2);
3808 resultobj = SWIG_Py_Void();
3809 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3810 return resultobj;
3811 fail:
3812 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3813 return NULL;
3814 }
3815
3816
_wrap_wcsininit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3817 SWIGINTERN PyObject *_wrap_wcsininit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3818 PyObject *resultobj = 0;
3819 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3820 char *arg2 = (char *) 0 ;
3821 void *argp1 = 0 ;
3822 int res1 = 0 ;
3823 int res2 ;
3824 char *buf2 = 0 ;
3825 int alloc2 = 0 ;
3826 PyObject *swig_obj[2] ;
3827
3828 if (!SWIG_Python_UnpackTuple(args, "wcsininit", 2, 2, swig_obj)) SWIG_fail;
3829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3830 if (!SWIG_IsOK(res1)) {
3831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcsininit" "', argument " "1"" of type '" "struct WorldCoor *""'");
3832 }
3833 arg1 = (struct WorldCoor *)(argp1);
3834 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
3835 if (!SWIG_IsOK(res2)) {
3836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wcsininit" "', argument " "2"" of type '" "char *""'");
3837 }
3838 arg2 = (char *)(buf2);
3839 wcsininit(arg1,arg2);
3840 resultobj = SWIG_Py_Void();
3841 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3842 return resultobj;
3843 fail:
3844 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3845 return NULL;
3846 }
3847
3848
_wrap_getwcsout(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3849 SWIGINTERN PyObject *_wrap_getwcsout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3850 PyObject *resultobj = 0;
3851 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3852 void *argp1 = 0 ;
3853 int res1 = 0 ;
3854 PyObject *swig_obj[1] ;
3855 char *result = 0 ;
3856
3857 if (!args) SWIG_fail;
3858 swig_obj[0] = args;
3859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3860 if (!SWIG_IsOK(res1)) {
3861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getwcsout" "', argument " "1"" of type '" "struct WorldCoor *""'");
3862 }
3863 arg1 = (struct WorldCoor *)(argp1);
3864 result = (char *)getwcsout(arg1);
3865 resultobj = SWIG_FromCharPtr((const char *)result);
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
_wrap_getwcsin(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3872 SWIGINTERN PyObject *_wrap_getwcsin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3873 PyObject *resultobj = 0;
3874 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3875 void *argp1 = 0 ;
3876 int res1 = 0 ;
3877 PyObject *swig_obj[1] ;
3878 char *result = 0 ;
3879
3880 if (!args) SWIG_fail;
3881 swig_obj[0] = args;
3882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3883 if (!SWIG_IsOK(res1)) {
3884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getwcsin" "', argument " "1"" of type '" "struct WorldCoor *""'");
3885 }
3886 arg1 = (struct WorldCoor *)(argp1);
3887 result = (char *)getwcsin(arg1);
3888 resultobj = SWIG_FromCharPtr((const char *)result);
3889 return resultobj;
3890 fail:
3891 return NULL;
3892 }
3893
3894
_wrap_wcssize(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3895 SWIGINTERN PyObject *_wrap_wcssize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3896 PyObject *resultobj = 0;
3897 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3898 double *arg2 = (double *) 0 ;
3899 double *arg3 = (double *) 0 ;
3900 double *arg4 = (double *) 0 ;
3901 double *arg5 = (double *) 0 ;
3902 void *argp1 = 0 ;
3903 int res1 = 0 ;
3904 double temp2 ;
3905 int res2 = SWIG_TMPOBJ ;
3906 double temp3 ;
3907 int res3 = SWIG_TMPOBJ ;
3908 double temp4 ;
3909 int res4 = SWIG_TMPOBJ ;
3910 double temp5 ;
3911 int res5 = SWIG_TMPOBJ ;
3912 PyObject *swig_obj[1] ;
3913
3914 arg2 = &temp2;
3915 arg3 = &temp3;
3916 arg4 = &temp4;
3917 arg5 = &temp5;
3918 if (!args) SWIG_fail;
3919 swig_obj[0] = args;
3920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3921 if (!SWIG_IsOK(res1)) {
3922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcssize" "', argument " "1"" of type '" "struct WorldCoor *""'");
3923 }
3924 arg1 = (struct WorldCoor *)(argp1);
3925 wcssize(arg1,arg2,arg3,arg4,arg5);
3926 resultobj = SWIG_Py_Void();
3927 if (SWIG_IsTmpObj(res2)) {
3928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
3929 } else {
3930 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
3932 }
3933 if (SWIG_IsTmpObj(res3)) {
3934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3935 } else {
3936 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3938 }
3939 if (SWIG_IsTmpObj(res4)) {
3940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3941 } else {
3942 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3944 }
3945 if (SWIG_IsTmpObj(res5)) {
3946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
3947 } else {
3948 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
3950 }
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
_wrap_wcsfull(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3957 SWIGINTERN PyObject *_wrap_wcsfull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3958 PyObject *resultobj = 0;
3959 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
3960 double *arg2 = (double *) 0 ;
3961 double *arg3 = (double *) 0 ;
3962 double *arg4 = (double *) 0 ;
3963 double *arg5 = (double *) 0 ;
3964 void *argp1 = 0 ;
3965 int res1 = 0 ;
3966 double temp2 ;
3967 int res2 = SWIG_TMPOBJ ;
3968 double temp3 ;
3969 int res3 = SWIG_TMPOBJ ;
3970 double temp4 ;
3971 int res4 = SWIG_TMPOBJ ;
3972 double temp5 ;
3973 int res5 = SWIG_TMPOBJ ;
3974 PyObject *swig_obj[1] ;
3975
3976 arg2 = &temp2;
3977 arg3 = &temp3;
3978 arg4 = &temp4;
3979 arg5 = &temp5;
3980 if (!args) SWIG_fail;
3981 swig_obj[0] = args;
3982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
3983 if (!SWIG_IsOK(res1)) {
3984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wcsfull" "', argument " "1"" of type '" "struct WorldCoor *""'");
3985 }
3986 arg1 = (struct WorldCoor *)(argp1);
3987 wcsfull(arg1,arg2,arg3,arg4,arg5);
3988 resultobj = SWIG_Py_Void();
3989 if (SWIG_IsTmpObj(res2)) {
3990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
3991 } else {
3992 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
3994 }
3995 if (SWIG_IsTmpObj(res3)) {
3996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3997 } else {
3998 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
4000 }
4001 if (SWIG_IsTmpObj(res4)) {
4002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
4003 } else {
4004 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
4006 }
4007 if (SWIG_IsTmpObj(res5)) {
4008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
4009 } else {
4010 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
4012 }
4013 return resultobj;
4014 fail:
4015 return NULL;
4016 }
4017
4018
_wrap_WorldCoor_xref_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4019 SWIGINTERN PyObject *_wrap_WorldCoor_xref_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4020 PyObject *resultobj = 0;
4021 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4022 double arg2 ;
4023 void *argp1 = 0 ;
4024 int res1 = 0 ;
4025 double val2 ;
4026 int ecode2 = 0 ;
4027 PyObject *swig_obj[2] ;
4028
4029 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_xref_set", 2, 2, swig_obj)) SWIG_fail;
4030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4031 if (!SWIG_IsOK(res1)) {
4032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xref_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4033 }
4034 arg1 = (struct WorldCoor *)(argp1);
4035 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4036 if (!SWIG_IsOK(ecode2)) {
4037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_xref_set" "', argument " "2"" of type '" "double""'");
4038 }
4039 arg2 = (double)(val2);
4040 if (arg1) (arg1)->xref = arg2;
4041 resultobj = SWIG_Py_Void();
4042 return resultobj;
4043 fail:
4044 return NULL;
4045 }
4046
4047
_wrap_WorldCoor_xref_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4048 SWIGINTERN PyObject *_wrap_WorldCoor_xref_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4049 PyObject *resultobj = 0;
4050 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4051 void *argp1 = 0 ;
4052 int res1 = 0 ;
4053 PyObject *swig_obj[1] ;
4054 double result;
4055
4056 if (!args) SWIG_fail;
4057 swig_obj[0] = args;
4058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4059 if (!SWIG_IsOK(res1)) {
4060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xref_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4061 }
4062 arg1 = (struct WorldCoor *)(argp1);
4063 result = (double) ((arg1)->xref);
4064 resultobj = SWIG_From_double((double)(result));
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
_wrap_WorldCoor_yref_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4071 SWIGINTERN PyObject *_wrap_WorldCoor_yref_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4072 PyObject *resultobj = 0;
4073 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4074 double arg2 ;
4075 void *argp1 = 0 ;
4076 int res1 = 0 ;
4077 double val2 ;
4078 int ecode2 = 0 ;
4079 PyObject *swig_obj[2] ;
4080
4081 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_yref_set", 2, 2, swig_obj)) SWIG_fail;
4082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4083 if (!SWIG_IsOK(res1)) {
4084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yref_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4085 }
4086 arg1 = (struct WorldCoor *)(argp1);
4087 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4088 if (!SWIG_IsOK(ecode2)) {
4089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_yref_set" "', argument " "2"" of type '" "double""'");
4090 }
4091 arg2 = (double)(val2);
4092 if (arg1) (arg1)->yref = arg2;
4093 resultobj = SWIG_Py_Void();
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
_wrap_WorldCoor_yref_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4100 SWIGINTERN PyObject *_wrap_WorldCoor_yref_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4101 PyObject *resultobj = 0;
4102 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4103 void *argp1 = 0 ;
4104 int res1 = 0 ;
4105 PyObject *swig_obj[1] ;
4106 double result;
4107
4108 if (!args) SWIG_fail;
4109 swig_obj[0] = args;
4110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4111 if (!SWIG_IsOK(res1)) {
4112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yref_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4113 }
4114 arg1 = (struct WorldCoor *)(argp1);
4115 result = (double) ((arg1)->yref);
4116 resultobj = SWIG_From_double((double)(result));
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
_wrap_WorldCoor_xrefpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4123 SWIGINTERN PyObject *_wrap_WorldCoor_xrefpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4124 PyObject *resultobj = 0;
4125 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4126 double arg2 ;
4127 void *argp1 = 0 ;
4128 int res1 = 0 ;
4129 double val2 ;
4130 int ecode2 = 0 ;
4131 PyObject *swig_obj[2] ;
4132
4133 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_xrefpix_set", 2, 2, swig_obj)) SWIG_fail;
4134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4135 if (!SWIG_IsOK(res1)) {
4136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xrefpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4137 }
4138 arg1 = (struct WorldCoor *)(argp1);
4139 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4140 if (!SWIG_IsOK(ecode2)) {
4141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_xrefpix_set" "', argument " "2"" of type '" "double""'");
4142 }
4143 arg2 = (double)(val2);
4144 if (arg1) (arg1)->xrefpix = arg2;
4145 resultobj = SWIG_Py_Void();
4146 return resultobj;
4147 fail:
4148 return NULL;
4149 }
4150
4151
_wrap_WorldCoor_xrefpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4152 SWIGINTERN PyObject *_wrap_WorldCoor_xrefpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4153 PyObject *resultobj = 0;
4154 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4155 void *argp1 = 0 ;
4156 int res1 = 0 ;
4157 PyObject *swig_obj[1] ;
4158 double result;
4159
4160 if (!args) SWIG_fail;
4161 swig_obj[0] = args;
4162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4163 if (!SWIG_IsOK(res1)) {
4164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xrefpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4165 }
4166 arg1 = (struct WorldCoor *)(argp1);
4167 result = (double) ((arg1)->xrefpix);
4168 resultobj = SWIG_From_double((double)(result));
4169 return resultobj;
4170 fail:
4171 return NULL;
4172 }
4173
4174
_wrap_WorldCoor_yrefpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4175 SWIGINTERN PyObject *_wrap_WorldCoor_yrefpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4176 PyObject *resultobj = 0;
4177 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4178 double arg2 ;
4179 void *argp1 = 0 ;
4180 int res1 = 0 ;
4181 double val2 ;
4182 int ecode2 = 0 ;
4183 PyObject *swig_obj[2] ;
4184
4185 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_yrefpix_set", 2, 2, swig_obj)) SWIG_fail;
4186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4187 if (!SWIG_IsOK(res1)) {
4188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yrefpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4189 }
4190 arg1 = (struct WorldCoor *)(argp1);
4191 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4192 if (!SWIG_IsOK(ecode2)) {
4193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_yrefpix_set" "', argument " "2"" of type '" "double""'");
4194 }
4195 arg2 = (double)(val2);
4196 if (arg1) (arg1)->yrefpix = arg2;
4197 resultobj = SWIG_Py_Void();
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
_wrap_WorldCoor_yrefpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4204 SWIGINTERN PyObject *_wrap_WorldCoor_yrefpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4205 PyObject *resultobj = 0;
4206 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4207 void *argp1 = 0 ;
4208 int res1 = 0 ;
4209 PyObject *swig_obj[1] ;
4210 double result;
4211
4212 if (!args) SWIG_fail;
4213 swig_obj[0] = args;
4214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4215 if (!SWIG_IsOK(res1)) {
4216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yrefpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4217 }
4218 arg1 = (struct WorldCoor *)(argp1);
4219 result = (double) ((arg1)->yrefpix);
4220 resultobj = SWIG_From_double((double)(result));
4221 return resultobj;
4222 fail:
4223 return NULL;
4224 }
4225
4226
_wrap_WorldCoor_xinc_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4227 SWIGINTERN PyObject *_wrap_WorldCoor_xinc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4228 PyObject *resultobj = 0;
4229 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4230 double arg2 ;
4231 void *argp1 = 0 ;
4232 int res1 = 0 ;
4233 double val2 ;
4234 int ecode2 = 0 ;
4235 PyObject *swig_obj[2] ;
4236
4237 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_xinc_set", 2, 2, swig_obj)) SWIG_fail;
4238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4239 if (!SWIG_IsOK(res1)) {
4240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xinc_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4241 }
4242 arg1 = (struct WorldCoor *)(argp1);
4243 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4244 if (!SWIG_IsOK(ecode2)) {
4245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_xinc_set" "', argument " "2"" of type '" "double""'");
4246 }
4247 arg2 = (double)(val2);
4248 if (arg1) (arg1)->xinc = arg2;
4249 resultobj = SWIG_Py_Void();
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
_wrap_WorldCoor_xinc_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4256 SWIGINTERN PyObject *_wrap_WorldCoor_xinc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4257 PyObject *resultobj = 0;
4258 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 PyObject *swig_obj[1] ;
4262 double result;
4263
4264 if (!args) SWIG_fail;
4265 swig_obj[0] = args;
4266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4267 if (!SWIG_IsOK(res1)) {
4268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xinc_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4269 }
4270 arg1 = (struct WorldCoor *)(argp1);
4271 result = (double) ((arg1)->xinc);
4272 resultobj = SWIG_From_double((double)(result));
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
_wrap_WorldCoor_yinc_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4279 SWIGINTERN PyObject *_wrap_WorldCoor_yinc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4280 PyObject *resultobj = 0;
4281 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4282 double arg2 ;
4283 void *argp1 = 0 ;
4284 int res1 = 0 ;
4285 double val2 ;
4286 int ecode2 = 0 ;
4287 PyObject *swig_obj[2] ;
4288
4289 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_yinc_set", 2, 2, swig_obj)) SWIG_fail;
4290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4291 if (!SWIG_IsOK(res1)) {
4292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yinc_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4293 }
4294 arg1 = (struct WorldCoor *)(argp1);
4295 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4296 if (!SWIG_IsOK(ecode2)) {
4297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_yinc_set" "', argument " "2"" of type '" "double""'");
4298 }
4299 arg2 = (double)(val2);
4300 if (arg1) (arg1)->yinc = arg2;
4301 resultobj = SWIG_Py_Void();
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
_wrap_WorldCoor_yinc_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4308 SWIGINTERN PyObject *_wrap_WorldCoor_yinc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4311 void *argp1 = 0 ;
4312 int res1 = 0 ;
4313 PyObject *swig_obj[1] ;
4314 double result;
4315
4316 if (!args) SWIG_fail;
4317 swig_obj[0] = args;
4318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4319 if (!SWIG_IsOK(res1)) {
4320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_yinc_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4321 }
4322 arg1 = (struct WorldCoor *)(argp1);
4323 result = (double) ((arg1)->yinc);
4324 resultobj = SWIG_From_double((double)(result));
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
_wrap_WorldCoor_rot_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4331 SWIGINTERN PyObject *_wrap_WorldCoor_rot_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4332 PyObject *resultobj = 0;
4333 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4334 double arg2 ;
4335 void *argp1 = 0 ;
4336 int res1 = 0 ;
4337 double val2 ;
4338 int ecode2 = 0 ;
4339 PyObject *swig_obj[2] ;
4340
4341 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_rot_set", 2, 2, swig_obj)) SWIG_fail;
4342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4343 if (!SWIG_IsOK(res1)) {
4344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rot_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4345 }
4346 arg1 = (struct WorldCoor *)(argp1);
4347 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4348 if (!SWIG_IsOK(ecode2)) {
4349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_rot_set" "', argument " "2"" of type '" "double""'");
4350 }
4351 arg2 = (double)(val2);
4352 if (arg1) (arg1)->rot = arg2;
4353 resultobj = SWIG_Py_Void();
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
_wrap_WorldCoor_rot_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4360 SWIGINTERN PyObject *_wrap_WorldCoor_rot_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4361 PyObject *resultobj = 0;
4362 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4363 void *argp1 = 0 ;
4364 int res1 = 0 ;
4365 PyObject *swig_obj[1] ;
4366 double result;
4367
4368 if (!args) SWIG_fail;
4369 swig_obj[0] = args;
4370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4371 if (!SWIG_IsOK(res1)) {
4372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rot_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4373 }
4374 arg1 = (struct WorldCoor *)(argp1);
4375 result = (double) ((arg1)->rot);
4376 resultobj = SWIG_From_double((double)(result));
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
_wrap_WorldCoor_cd_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4383 SWIGINTERN PyObject *_wrap_WorldCoor_cd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4384 PyObject *resultobj = 0;
4385 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4386 double *arg2 ;
4387 void *argp1 = 0 ;
4388 int res1 = 0 ;
4389 void *argp2 = 0 ;
4390 int res2 = 0 ;
4391 PyObject *swig_obj[2] ;
4392
4393 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_cd_set", 2, 2, swig_obj)) SWIG_fail;
4394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4395 if (!SWIG_IsOK(res1)) {
4396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cd_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4397 }
4398 arg1 = (struct WorldCoor *)(argp1);
4399 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
4400 if (!SWIG_IsOK(res2)) {
4401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_cd_set" "', argument " "2"" of type '" "double [4]""'");
4402 }
4403 arg2 = (double *)(argp2);
4404 {
4405 if (arg2) {
4406 size_t ii = 0;
4407 for (; ii < (size_t)4; ++ii) *(double *)&arg1->cd[ii] = *((double *)arg2 + ii);
4408 } else {
4409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""cd""' of type '""double [4]""'");
4410 }
4411 }
4412 resultobj = SWIG_Py_Void();
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
_wrap_WorldCoor_cd_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4419 SWIGINTERN PyObject *_wrap_WorldCoor_cd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4420 PyObject *resultobj = 0;
4421 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4422 void *argp1 = 0 ;
4423 int res1 = 0 ;
4424 PyObject *swig_obj[1] ;
4425 double *result = 0 ;
4426
4427 if (!args) SWIG_fail;
4428 swig_obj[0] = args;
4429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4430 if (!SWIG_IsOK(res1)) {
4431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cd_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4432 }
4433 arg1 = (struct WorldCoor *)(argp1);
4434 result = (double *)(double *) ((arg1)->cd);
4435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
_wrap_WorldCoor_dc_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4442 SWIGINTERN PyObject *_wrap_WorldCoor_dc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4443 PyObject *resultobj = 0;
4444 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4445 double *arg2 ;
4446 void *argp1 = 0 ;
4447 int res1 = 0 ;
4448 void *argp2 = 0 ;
4449 int res2 = 0 ;
4450 PyObject *swig_obj[2] ;
4451
4452 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_dc_set", 2, 2, swig_obj)) SWIG_fail;
4453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4454 if (!SWIG_IsOK(res1)) {
4455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_dc_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4456 }
4457 arg1 = (struct WorldCoor *)(argp1);
4458 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
4459 if (!SWIG_IsOK(res2)) {
4460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_dc_set" "', argument " "2"" of type '" "double [4]""'");
4461 }
4462 arg2 = (double *)(argp2);
4463 {
4464 if (arg2) {
4465 size_t ii = 0;
4466 for (; ii < (size_t)4; ++ii) *(double *)&arg1->dc[ii] = *((double *)arg2 + ii);
4467 } else {
4468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""dc""' of type '""double [4]""'");
4469 }
4470 }
4471 resultobj = SWIG_Py_Void();
4472 return resultobj;
4473 fail:
4474 return NULL;
4475 }
4476
4477
_wrap_WorldCoor_dc_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4478 SWIGINTERN PyObject *_wrap_WorldCoor_dc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4479 PyObject *resultobj = 0;
4480 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4481 void *argp1 = 0 ;
4482 int res1 = 0 ;
4483 PyObject *swig_obj[1] ;
4484 double *result = 0 ;
4485
4486 if (!args) SWIG_fail;
4487 swig_obj[0] = args;
4488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4489 if (!SWIG_IsOK(res1)) {
4490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_dc_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4491 }
4492 arg1 = (struct WorldCoor *)(argp1);
4493 result = (double *)(double *) ((arg1)->dc);
4494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
4495 return resultobj;
4496 fail:
4497 return NULL;
4498 }
4499
4500
_wrap_WorldCoor_equinox_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4501 SWIGINTERN PyObject *_wrap_WorldCoor_equinox_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4502 PyObject *resultobj = 0;
4503 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4504 double arg2 ;
4505 void *argp1 = 0 ;
4506 int res1 = 0 ;
4507 double val2 ;
4508 int ecode2 = 0 ;
4509 PyObject *swig_obj[2] ;
4510
4511 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_equinox_set", 2, 2, swig_obj)) SWIG_fail;
4512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4513 if (!SWIG_IsOK(res1)) {
4514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_equinox_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4515 }
4516 arg1 = (struct WorldCoor *)(argp1);
4517 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4518 if (!SWIG_IsOK(ecode2)) {
4519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_equinox_set" "', argument " "2"" of type '" "double""'");
4520 }
4521 arg2 = (double)(val2);
4522 if (arg1) (arg1)->equinox = arg2;
4523 resultobj = SWIG_Py_Void();
4524 return resultobj;
4525 fail:
4526 return NULL;
4527 }
4528
4529
_wrap_WorldCoor_equinox_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4530 SWIGINTERN PyObject *_wrap_WorldCoor_equinox_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531 PyObject *resultobj = 0;
4532 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4533 void *argp1 = 0 ;
4534 int res1 = 0 ;
4535 PyObject *swig_obj[1] ;
4536 double result;
4537
4538 if (!args) SWIG_fail;
4539 swig_obj[0] = args;
4540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4541 if (!SWIG_IsOK(res1)) {
4542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_equinox_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4543 }
4544 arg1 = (struct WorldCoor *)(argp1);
4545 result = (double) ((arg1)->equinox);
4546 resultobj = SWIG_From_double((double)(result));
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
_wrap_WorldCoor_epoch_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4553 SWIGINTERN PyObject *_wrap_WorldCoor_epoch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4556 double arg2 ;
4557 void *argp1 = 0 ;
4558 int res1 = 0 ;
4559 double val2 ;
4560 int ecode2 = 0 ;
4561 PyObject *swig_obj[2] ;
4562
4563 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_epoch_set", 2, 2, swig_obj)) SWIG_fail;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_epoch_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4567 }
4568 arg1 = (struct WorldCoor *)(argp1);
4569 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4570 if (!SWIG_IsOK(ecode2)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_epoch_set" "', argument " "2"" of type '" "double""'");
4572 }
4573 arg2 = (double)(val2);
4574 if (arg1) (arg1)->epoch = arg2;
4575 resultobj = SWIG_Py_Void();
4576 return resultobj;
4577 fail:
4578 return NULL;
4579 }
4580
4581
_wrap_WorldCoor_epoch_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4582 SWIGINTERN PyObject *_wrap_WorldCoor_epoch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4583 PyObject *resultobj = 0;
4584 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4585 void *argp1 = 0 ;
4586 int res1 = 0 ;
4587 PyObject *swig_obj[1] ;
4588 double result;
4589
4590 if (!args) SWIG_fail;
4591 swig_obj[0] = args;
4592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4593 if (!SWIG_IsOK(res1)) {
4594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_epoch_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4595 }
4596 arg1 = (struct WorldCoor *)(argp1);
4597 result = (double) ((arg1)->epoch);
4598 resultobj = SWIG_From_double((double)(result));
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
_wrap_WorldCoor_nxpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4605 SWIGINTERN PyObject *_wrap_WorldCoor_nxpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4606 PyObject *resultobj = 0;
4607 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4608 double arg2 ;
4609 void *argp1 = 0 ;
4610 int res1 = 0 ;
4611 double val2 ;
4612 int ecode2 = 0 ;
4613 PyObject *swig_obj[2] ;
4614
4615 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_nxpix_set", 2, 2, swig_obj)) SWIG_fail;
4616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4617 if (!SWIG_IsOK(res1)) {
4618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_nxpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4619 }
4620 arg1 = (struct WorldCoor *)(argp1);
4621 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4622 if (!SWIG_IsOK(ecode2)) {
4623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_nxpix_set" "', argument " "2"" of type '" "double""'");
4624 }
4625 arg2 = (double)(val2);
4626 if (arg1) (arg1)->nxpix = arg2;
4627 resultobj = SWIG_Py_Void();
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
_wrap_WorldCoor_nxpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4634 SWIGINTERN PyObject *_wrap_WorldCoor_nxpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4635 PyObject *resultobj = 0;
4636 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4637 void *argp1 = 0 ;
4638 int res1 = 0 ;
4639 PyObject *swig_obj[1] ;
4640 double result;
4641
4642 if (!args) SWIG_fail;
4643 swig_obj[0] = args;
4644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4645 if (!SWIG_IsOK(res1)) {
4646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_nxpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4647 }
4648 arg1 = (struct WorldCoor *)(argp1);
4649 result = (double) ((arg1)->nxpix);
4650 resultobj = SWIG_From_double((double)(result));
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
_wrap_WorldCoor_nypix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4657 SWIGINTERN PyObject *_wrap_WorldCoor_nypix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4660 double arg2 ;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 double val2 ;
4664 int ecode2 = 0 ;
4665 PyObject *swig_obj[2] ;
4666
4667 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_nypix_set", 2, 2, swig_obj)) SWIG_fail;
4668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4669 if (!SWIG_IsOK(res1)) {
4670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_nypix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4671 }
4672 arg1 = (struct WorldCoor *)(argp1);
4673 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4674 if (!SWIG_IsOK(ecode2)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_nypix_set" "', argument " "2"" of type '" "double""'");
4676 }
4677 arg2 = (double)(val2);
4678 if (arg1) (arg1)->nypix = arg2;
4679 resultobj = SWIG_Py_Void();
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
_wrap_WorldCoor_nypix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4686 SWIGINTERN PyObject *_wrap_WorldCoor_nypix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4687 PyObject *resultobj = 0;
4688 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4689 void *argp1 = 0 ;
4690 int res1 = 0 ;
4691 PyObject *swig_obj[1] ;
4692 double result;
4693
4694 if (!args) SWIG_fail;
4695 swig_obj[0] = args;
4696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4697 if (!SWIG_IsOK(res1)) {
4698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_nypix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4699 }
4700 arg1 = (struct WorldCoor *)(argp1);
4701 result = (double) ((arg1)->nypix);
4702 resultobj = SWIG_From_double((double)(result));
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
_wrap_WorldCoor_plate_ra_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4709 SWIGINTERN PyObject *_wrap_WorldCoor_plate_ra_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4710 PyObject *resultobj = 0;
4711 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4712 double arg2 ;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 double val2 ;
4716 int ecode2 = 0 ;
4717 PyObject *swig_obj[2] ;
4718
4719 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_plate_ra_set", 2, 2, swig_obj)) SWIG_fail;
4720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_ra_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4723 }
4724 arg1 = (struct WorldCoor *)(argp1);
4725 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4726 if (!SWIG_IsOK(ecode2)) {
4727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_plate_ra_set" "', argument " "2"" of type '" "double""'");
4728 }
4729 arg2 = (double)(val2);
4730 if (arg1) (arg1)->plate_ra = arg2;
4731 resultobj = SWIG_Py_Void();
4732 return resultobj;
4733 fail:
4734 return NULL;
4735 }
4736
4737
_wrap_WorldCoor_plate_ra_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4738 SWIGINTERN PyObject *_wrap_WorldCoor_plate_ra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4739 PyObject *resultobj = 0;
4740 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4741 void *argp1 = 0 ;
4742 int res1 = 0 ;
4743 PyObject *swig_obj[1] ;
4744 double result;
4745
4746 if (!args) SWIG_fail;
4747 swig_obj[0] = args;
4748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4749 if (!SWIG_IsOK(res1)) {
4750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_ra_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4751 }
4752 arg1 = (struct WorldCoor *)(argp1);
4753 result = (double) ((arg1)->plate_ra);
4754 resultobj = SWIG_From_double((double)(result));
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
_wrap_WorldCoor_plate_dec_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4761 SWIGINTERN PyObject *_wrap_WorldCoor_plate_dec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4762 PyObject *resultobj = 0;
4763 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4764 double arg2 ;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 double val2 ;
4768 int ecode2 = 0 ;
4769 PyObject *swig_obj[2] ;
4770
4771 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_plate_dec_set", 2, 2, swig_obj)) SWIG_fail;
4772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4773 if (!SWIG_IsOK(res1)) {
4774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_dec_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4775 }
4776 arg1 = (struct WorldCoor *)(argp1);
4777 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4778 if (!SWIG_IsOK(ecode2)) {
4779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_plate_dec_set" "', argument " "2"" of type '" "double""'");
4780 }
4781 arg2 = (double)(val2);
4782 if (arg1) (arg1)->plate_dec = arg2;
4783 resultobj = SWIG_Py_Void();
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
_wrap_WorldCoor_plate_dec_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4790 SWIGINTERN PyObject *_wrap_WorldCoor_plate_dec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4791 PyObject *resultobj = 0;
4792 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4793 void *argp1 = 0 ;
4794 int res1 = 0 ;
4795 PyObject *swig_obj[1] ;
4796 double result;
4797
4798 if (!args) SWIG_fail;
4799 swig_obj[0] = args;
4800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4801 if (!SWIG_IsOK(res1)) {
4802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_dec_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4803 }
4804 arg1 = (struct WorldCoor *)(argp1);
4805 result = (double) ((arg1)->plate_dec);
4806 resultobj = SWIG_From_double((double)(result));
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
_wrap_WorldCoor_plate_scale_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4813 SWIGINTERN PyObject *_wrap_WorldCoor_plate_scale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4814 PyObject *resultobj = 0;
4815 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4816 double arg2 ;
4817 void *argp1 = 0 ;
4818 int res1 = 0 ;
4819 double val2 ;
4820 int ecode2 = 0 ;
4821 PyObject *swig_obj[2] ;
4822
4823 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_plate_scale_set", 2, 2, swig_obj)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_scale_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4827 }
4828 arg1 = (struct WorldCoor *)(argp1);
4829 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4830 if (!SWIG_IsOK(ecode2)) {
4831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_plate_scale_set" "', argument " "2"" of type '" "double""'");
4832 }
4833 arg2 = (double)(val2);
4834 if (arg1) (arg1)->plate_scale = arg2;
4835 resultobj = SWIG_Py_Void();
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
_wrap_WorldCoor_plate_scale_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4842 SWIGINTERN PyObject *_wrap_WorldCoor_plate_scale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4843 PyObject *resultobj = 0;
4844 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4845 void *argp1 = 0 ;
4846 int res1 = 0 ;
4847 PyObject *swig_obj[1] ;
4848 double result;
4849
4850 if (!args) SWIG_fail;
4851 swig_obj[0] = args;
4852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4853 if (!SWIG_IsOK(res1)) {
4854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_plate_scale_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4855 }
4856 arg1 = (struct WorldCoor *)(argp1);
4857 result = (double) ((arg1)->plate_scale);
4858 resultobj = SWIG_From_double((double)(result));
4859 return resultobj;
4860 fail:
4861 return NULL;
4862 }
4863
4864
_wrap_WorldCoor_x_pixel_offset_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4865 SWIGINTERN PyObject *_wrap_WorldCoor_x_pixel_offset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4866 PyObject *resultobj = 0;
4867 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4868 double arg2 ;
4869 void *argp1 = 0 ;
4870 int res1 = 0 ;
4871 double val2 ;
4872 int ecode2 = 0 ;
4873 PyObject *swig_obj[2] ;
4874
4875 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_x_pixel_offset_set", 2, 2, swig_obj)) SWIG_fail;
4876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4877 if (!SWIG_IsOK(res1)) {
4878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_pixel_offset_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4879 }
4880 arg1 = (struct WorldCoor *)(argp1);
4881 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4882 if (!SWIG_IsOK(ecode2)) {
4883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_x_pixel_offset_set" "', argument " "2"" of type '" "double""'");
4884 }
4885 arg2 = (double)(val2);
4886 if (arg1) (arg1)->x_pixel_offset = arg2;
4887 resultobj = SWIG_Py_Void();
4888 return resultobj;
4889 fail:
4890 return NULL;
4891 }
4892
4893
_wrap_WorldCoor_x_pixel_offset_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4894 SWIGINTERN PyObject *_wrap_WorldCoor_x_pixel_offset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4895 PyObject *resultobj = 0;
4896 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4897 void *argp1 = 0 ;
4898 int res1 = 0 ;
4899 PyObject *swig_obj[1] ;
4900 double result;
4901
4902 if (!args) SWIG_fail;
4903 swig_obj[0] = args;
4904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4905 if (!SWIG_IsOK(res1)) {
4906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_pixel_offset_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4907 }
4908 arg1 = (struct WorldCoor *)(argp1);
4909 result = (double) ((arg1)->x_pixel_offset);
4910 resultobj = SWIG_From_double((double)(result));
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
_wrap_WorldCoor_y_pixel_offset_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4917 SWIGINTERN PyObject *_wrap_WorldCoor_y_pixel_offset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4918 PyObject *resultobj = 0;
4919 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4920 double arg2 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 double val2 ;
4924 int ecode2 = 0 ;
4925 PyObject *swig_obj[2] ;
4926
4927 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_y_pixel_offset_set", 2, 2, swig_obj)) SWIG_fail;
4928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4929 if (!SWIG_IsOK(res1)) {
4930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_pixel_offset_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4931 }
4932 arg1 = (struct WorldCoor *)(argp1);
4933 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4934 if (!SWIG_IsOK(ecode2)) {
4935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_y_pixel_offset_set" "', argument " "2"" of type '" "double""'");
4936 }
4937 arg2 = (double)(val2);
4938 if (arg1) (arg1)->y_pixel_offset = arg2;
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
_wrap_WorldCoor_y_pixel_offset_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4946 SWIGINTERN PyObject *_wrap_WorldCoor_y_pixel_offset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4947 PyObject *resultobj = 0;
4948 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4949 void *argp1 = 0 ;
4950 int res1 = 0 ;
4951 PyObject *swig_obj[1] ;
4952 double result;
4953
4954 if (!args) SWIG_fail;
4955 swig_obj[0] = args;
4956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4957 if (!SWIG_IsOK(res1)) {
4958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_pixel_offset_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
4959 }
4960 arg1 = (struct WorldCoor *)(argp1);
4961 result = (double) ((arg1)->y_pixel_offset);
4962 resultobj = SWIG_From_double((double)(result));
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
_wrap_WorldCoor_x_pixel_size_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4969 SWIGINTERN PyObject *_wrap_WorldCoor_x_pixel_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
4972 double arg2 ;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 double val2 ;
4976 int ecode2 = 0 ;
4977 PyObject *swig_obj[2] ;
4978
4979 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_x_pixel_size_set", 2, 2, swig_obj)) SWIG_fail;
4980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
4981 if (!SWIG_IsOK(res1)) {
4982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_pixel_size_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
4983 }
4984 arg1 = (struct WorldCoor *)(argp1);
4985 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4986 if (!SWIG_IsOK(ecode2)) {
4987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_x_pixel_size_set" "', argument " "2"" of type '" "double""'");
4988 }
4989 arg2 = (double)(val2);
4990 if (arg1) (arg1)->x_pixel_size = arg2;
4991 resultobj = SWIG_Py_Void();
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
_wrap_WorldCoor_x_pixel_size_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4998 SWIGINTERN PyObject *_wrap_WorldCoor_x_pixel_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 PyObject *swig_obj[1] ;
5004 double result;
5005
5006 if (!args) SWIG_fail;
5007 swig_obj[0] = args;
5008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5009 if (!SWIG_IsOK(res1)) {
5010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_pixel_size_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5011 }
5012 arg1 = (struct WorldCoor *)(argp1);
5013 result = (double) ((arg1)->x_pixel_size);
5014 resultobj = SWIG_From_double((double)(result));
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
_wrap_WorldCoor_y_pixel_size_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5021 SWIGINTERN PyObject *_wrap_WorldCoor_y_pixel_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5022 PyObject *resultobj = 0;
5023 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5024 double arg2 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 double val2 ;
5028 int ecode2 = 0 ;
5029 PyObject *swig_obj[2] ;
5030
5031 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_y_pixel_size_set", 2, 2, swig_obj)) SWIG_fail;
5032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5033 if (!SWIG_IsOK(res1)) {
5034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_pixel_size_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5035 }
5036 arg1 = (struct WorldCoor *)(argp1);
5037 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5038 if (!SWIG_IsOK(ecode2)) {
5039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_y_pixel_size_set" "', argument " "2"" of type '" "double""'");
5040 }
5041 arg2 = (double)(val2);
5042 if (arg1) (arg1)->y_pixel_size = arg2;
5043 resultobj = SWIG_Py_Void();
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
_wrap_WorldCoor_y_pixel_size_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5050 SWIGINTERN PyObject *_wrap_WorldCoor_y_pixel_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5051 PyObject *resultobj = 0;
5052 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 PyObject *swig_obj[1] ;
5056 double result;
5057
5058 if (!args) SWIG_fail;
5059 swig_obj[0] = args;
5060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5061 if (!SWIG_IsOK(res1)) {
5062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_pixel_size_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5063 }
5064 arg1 = (struct WorldCoor *)(argp1);
5065 result = (double) ((arg1)->y_pixel_size);
5066 resultobj = SWIG_From_double((double)(result));
5067 return resultobj;
5068 fail:
5069 return NULL;
5070 }
5071
5072
_wrap_WorldCoor_ppo_coeff_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5073 SWIGINTERN PyObject *_wrap_WorldCoor_ppo_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5074 PyObject *resultobj = 0;
5075 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5076 double *arg2 ;
5077 void *argp1 = 0 ;
5078 int res1 = 0 ;
5079 void *argp2 = 0 ;
5080 int res2 = 0 ;
5081 PyObject *swig_obj[2] ;
5082
5083 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ppo_coeff_set", 2, 2, swig_obj)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ppo_coeff_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5087 }
5088 arg1 = (struct WorldCoor *)(argp1);
5089 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5090 if (!SWIG_IsOK(res2)) {
5091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ppo_coeff_set" "', argument " "2"" of type '" "double [6]""'");
5092 }
5093 arg2 = (double *)(argp2);
5094 {
5095 if (arg2) {
5096 size_t ii = 0;
5097 for (; ii < (size_t)6; ++ii) *(double *)&arg1->ppo_coeff[ii] = *((double *)arg2 + ii);
5098 } else {
5099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ppo_coeff""' of type '""double [6]""'");
5100 }
5101 }
5102 resultobj = SWIG_Py_Void();
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
_wrap_WorldCoor_ppo_coeff_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5109 SWIGINTERN PyObject *_wrap_WorldCoor_ppo_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5110 PyObject *resultobj = 0;
5111 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5112 void *argp1 = 0 ;
5113 int res1 = 0 ;
5114 PyObject *swig_obj[1] ;
5115 double *result = 0 ;
5116
5117 if (!args) SWIG_fail;
5118 swig_obj[0] = args;
5119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5120 if (!SWIG_IsOK(res1)) {
5121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ppo_coeff_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5122 }
5123 arg1 = (struct WorldCoor *)(argp1);
5124 result = (double *)(double *) ((arg1)->ppo_coeff);
5125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5126 return resultobj;
5127 fail:
5128 return NULL;
5129 }
5130
5131
_wrap_WorldCoor_x_coeff_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5132 SWIGINTERN PyObject *_wrap_WorldCoor_x_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5133 PyObject *resultobj = 0;
5134 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5135 double *arg2 ;
5136 void *argp1 = 0 ;
5137 int res1 = 0 ;
5138 void *argp2 = 0 ;
5139 int res2 = 0 ;
5140 PyObject *swig_obj[2] ;
5141
5142 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_x_coeff_set", 2, 2, swig_obj)) SWIG_fail;
5143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5144 if (!SWIG_IsOK(res1)) {
5145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_coeff_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5146 }
5147 arg1 = (struct WorldCoor *)(argp1);
5148 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5149 if (!SWIG_IsOK(res2)) {
5150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_x_coeff_set" "', argument " "2"" of type '" "double [20]""'");
5151 }
5152 arg2 = (double *)(argp2);
5153 {
5154 if (arg2) {
5155 size_t ii = 0;
5156 for (; ii < (size_t)20; ++ii) *(double *)&arg1->x_coeff[ii] = *((double *)arg2 + ii);
5157 } else {
5158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""x_coeff""' of type '""double [20]""'");
5159 }
5160 }
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
_wrap_WorldCoor_x_coeff_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5168 SWIGINTERN PyObject *_wrap_WorldCoor_x_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5171 void *argp1 = 0 ;
5172 int res1 = 0 ;
5173 PyObject *swig_obj[1] ;
5174 double *result = 0 ;
5175
5176 if (!args) SWIG_fail;
5177 swig_obj[0] = args;
5178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_x_coeff_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5181 }
5182 arg1 = (struct WorldCoor *)(argp1);
5183 result = (double *)(double *) ((arg1)->x_coeff);
5184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
_wrap_WorldCoor_y_coeff_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5191 SWIGINTERN PyObject *_wrap_WorldCoor_y_coeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5192 PyObject *resultobj = 0;
5193 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5194 double *arg2 ;
5195 void *argp1 = 0 ;
5196 int res1 = 0 ;
5197 void *argp2 = 0 ;
5198 int res2 = 0 ;
5199 PyObject *swig_obj[2] ;
5200
5201 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_y_coeff_set", 2, 2, swig_obj)) SWIG_fail;
5202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5203 if (!SWIG_IsOK(res1)) {
5204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_coeff_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5205 }
5206 arg1 = (struct WorldCoor *)(argp1);
5207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5208 if (!SWIG_IsOK(res2)) {
5209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_y_coeff_set" "', argument " "2"" of type '" "double [20]""'");
5210 }
5211 arg2 = (double *)(argp2);
5212 {
5213 if (arg2) {
5214 size_t ii = 0;
5215 for (; ii < (size_t)20; ++ii) *(double *)&arg1->y_coeff[ii] = *((double *)arg2 + ii);
5216 } else {
5217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""y_coeff""' of type '""double [20]""'");
5218 }
5219 }
5220 resultobj = SWIG_Py_Void();
5221 return resultobj;
5222 fail:
5223 return NULL;
5224 }
5225
5226
_wrap_WorldCoor_y_coeff_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5227 SWIGINTERN PyObject *_wrap_WorldCoor_y_coeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5228 PyObject *resultobj = 0;
5229 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5230 void *argp1 = 0 ;
5231 int res1 = 0 ;
5232 PyObject *swig_obj[1] ;
5233 double *result = 0 ;
5234
5235 if (!args) SWIG_fail;
5236 swig_obj[0] = args;
5237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5238 if (!SWIG_IsOK(res1)) {
5239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_y_coeff_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5240 }
5241 arg1 = (struct WorldCoor *)(argp1);
5242 result = (double *)(double *) ((arg1)->y_coeff);
5243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
_wrap_WorldCoor_xpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5250 SWIGINTERN PyObject *_wrap_WorldCoor_xpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5251 PyObject *resultobj = 0;
5252 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5253 double arg2 ;
5254 void *argp1 = 0 ;
5255 int res1 = 0 ;
5256 double val2 ;
5257 int ecode2 = 0 ;
5258 PyObject *swig_obj[2] ;
5259
5260 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_xpix_set", 2, 2, swig_obj)) SWIG_fail;
5261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5264 }
5265 arg1 = (struct WorldCoor *)(argp1);
5266 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5267 if (!SWIG_IsOK(ecode2)) {
5268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_xpix_set" "', argument " "2"" of type '" "double""'");
5269 }
5270 arg2 = (double)(val2);
5271 if (arg1) (arg1)->xpix = arg2;
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
_wrap_WorldCoor_xpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5279 SWIGINTERN PyObject *_wrap_WorldCoor_xpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 PyObject *swig_obj[1] ;
5285 double result;
5286
5287 if (!args) SWIG_fail;
5288 swig_obj[0] = args;
5289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5290 if (!SWIG_IsOK(res1)) {
5291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5292 }
5293 arg1 = (struct WorldCoor *)(argp1);
5294 result = (double) ((arg1)->xpix);
5295 resultobj = SWIG_From_double((double)(result));
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
_wrap_WorldCoor_ypix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5302 SWIGINTERN PyObject *_wrap_WorldCoor_ypix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5303 PyObject *resultobj = 0;
5304 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5305 double arg2 ;
5306 void *argp1 = 0 ;
5307 int res1 = 0 ;
5308 double val2 ;
5309 int ecode2 = 0 ;
5310 PyObject *swig_obj[2] ;
5311
5312 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ypix_set", 2, 2, swig_obj)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ypix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5316 }
5317 arg1 = (struct WorldCoor *)(argp1);
5318 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5319 if (!SWIG_IsOK(ecode2)) {
5320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_ypix_set" "', argument " "2"" of type '" "double""'");
5321 }
5322 arg2 = (double)(val2);
5323 if (arg1) (arg1)->ypix = arg2;
5324 resultobj = SWIG_Py_Void();
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
_wrap_WorldCoor_ypix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5331 SWIGINTERN PyObject *_wrap_WorldCoor_ypix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5334 void *argp1 = 0 ;
5335 int res1 = 0 ;
5336 PyObject *swig_obj[1] ;
5337 double result;
5338
5339 if (!args) SWIG_fail;
5340 swig_obj[0] = args;
5341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5342 if (!SWIG_IsOK(res1)) {
5343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ypix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5344 }
5345 arg1 = (struct WorldCoor *)(argp1);
5346 result = (double) ((arg1)->ypix);
5347 resultobj = SWIG_From_double((double)(result));
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
_wrap_WorldCoor_zpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5354 SWIGINTERN PyObject *_wrap_WorldCoor_zpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5355 PyObject *resultobj = 0;
5356 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5357 double arg2 ;
5358 void *argp1 = 0 ;
5359 int res1 = 0 ;
5360 double val2 ;
5361 int ecode2 = 0 ;
5362 PyObject *swig_obj[2] ;
5363
5364 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_zpix_set", 2, 2, swig_obj)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5368 }
5369 arg1 = (struct WorldCoor *)(argp1);
5370 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5371 if (!SWIG_IsOK(ecode2)) {
5372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_zpix_set" "', argument " "2"" of type '" "double""'");
5373 }
5374 arg2 = (double)(val2);
5375 if (arg1) (arg1)->zpix = arg2;
5376 resultobj = SWIG_Py_Void();
5377 return resultobj;
5378 fail:
5379 return NULL;
5380 }
5381
5382
_wrap_WorldCoor_zpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5383 SWIGINTERN PyObject *_wrap_WorldCoor_zpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5384 PyObject *resultobj = 0;
5385 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5386 void *argp1 = 0 ;
5387 int res1 = 0 ;
5388 PyObject *swig_obj[1] ;
5389 double result;
5390
5391 if (!args) SWIG_fail;
5392 swig_obj[0] = args;
5393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5394 if (!SWIG_IsOK(res1)) {
5395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5396 }
5397 arg1 = (struct WorldCoor *)(argp1);
5398 result = (double) ((arg1)->zpix);
5399 resultobj = SWIG_From_double((double)(result));
5400 return resultobj;
5401 fail:
5402 return NULL;
5403 }
5404
5405
_wrap_WorldCoor_xpos_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5406 SWIGINTERN PyObject *_wrap_WorldCoor_xpos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5407 PyObject *resultobj = 0;
5408 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5409 double arg2 ;
5410 void *argp1 = 0 ;
5411 int res1 = 0 ;
5412 double val2 ;
5413 int ecode2 = 0 ;
5414 PyObject *swig_obj[2] ;
5415
5416 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_xpos_set", 2, 2, swig_obj)) SWIG_fail;
5417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5418 if (!SWIG_IsOK(res1)) {
5419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xpos_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5420 }
5421 arg1 = (struct WorldCoor *)(argp1);
5422 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5423 if (!SWIG_IsOK(ecode2)) {
5424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_xpos_set" "', argument " "2"" of type '" "double""'");
5425 }
5426 arg2 = (double)(val2);
5427 if (arg1) (arg1)->xpos = arg2;
5428 resultobj = SWIG_Py_Void();
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
_wrap_WorldCoor_xpos_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5435 SWIGINTERN PyObject *_wrap_WorldCoor_xpos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5436 PyObject *resultobj = 0;
5437 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5438 void *argp1 = 0 ;
5439 int res1 = 0 ;
5440 PyObject *swig_obj[1] ;
5441 double result;
5442
5443 if (!args) SWIG_fail;
5444 swig_obj[0] = args;
5445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5446 if (!SWIG_IsOK(res1)) {
5447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_xpos_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5448 }
5449 arg1 = (struct WorldCoor *)(argp1);
5450 result = (double) ((arg1)->xpos);
5451 resultobj = SWIG_From_double((double)(result));
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
_wrap_WorldCoor_ypos_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5458 SWIGINTERN PyObject *_wrap_WorldCoor_ypos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5459 PyObject *resultobj = 0;
5460 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5461 double arg2 ;
5462 void *argp1 = 0 ;
5463 int res1 = 0 ;
5464 double val2 ;
5465 int ecode2 = 0 ;
5466 PyObject *swig_obj[2] ;
5467
5468 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ypos_set", 2, 2, swig_obj)) SWIG_fail;
5469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5470 if (!SWIG_IsOK(res1)) {
5471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ypos_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5472 }
5473 arg1 = (struct WorldCoor *)(argp1);
5474 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5475 if (!SWIG_IsOK(ecode2)) {
5476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_ypos_set" "', argument " "2"" of type '" "double""'");
5477 }
5478 arg2 = (double)(val2);
5479 if (arg1) (arg1)->ypos = arg2;
5480 resultobj = SWIG_Py_Void();
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
_wrap_WorldCoor_ypos_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5487 SWIGINTERN PyObject *_wrap_WorldCoor_ypos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488 PyObject *resultobj = 0;
5489 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5490 void *argp1 = 0 ;
5491 int res1 = 0 ;
5492 PyObject *swig_obj[1] ;
5493 double result;
5494
5495 if (!args) SWIG_fail;
5496 swig_obj[0] = args;
5497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5498 if (!SWIG_IsOK(res1)) {
5499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ypos_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5500 }
5501 arg1 = (struct WorldCoor *)(argp1);
5502 result = (double) ((arg1)->ypos);
5503 resultobj = SWIG_From_double((double)(result));
5504 return resultobj;
5505 fail:
5506 return NULL;
5507 }
5508
5509
_wrap_WorldCoor_crpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5510 SWIGINTERN PyObject *_wrap_WorldCoor_crpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511 PyObject *resultobj = 0;
5512 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5513 double *arg2 ;
5514 void *argp1 = 0 ;
5515 int res1 = 0 ;
5516 void *argp2 = 0 ;
5517 int res2 = 0 ;
5518 PyObject *swig_obj[2] ;
5519
5520 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_crpix_set", 2, 2, swig_obj)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_crpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5524 }
5525 arg1 = (struct WorldCoor *)(argp1);
5526 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5527 if (!SWIG_IsOK(res2)) {
5528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_crpix_set" "', argument " "2"" of type '" "double [9]""'");
5529 }
5530 arg2 = (double *)(argp2);
5531 {
5532 if (arg2) {
5533 size_t ii = 0;
5534 for (; ii < (size_t)9; ++ii) *(double *)&arg1->crpix[ii] = *((double *)arg2 + ii);
5535 } else {
5536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""crpix""' of type '""double [9]""'");
5537 }
5538 }
5539 resultobj = SWIG_Py_Void();
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
_wrap_WorldCoor_crpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5546 SWIGINTERN PyObject *_wrap_WorldCoor_crpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547 PyObject *resultobj = 0;
5548 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5549 void *argp1 = 0 ;
5550 int res1 = 0 ;
5551 PyObject *swig_obj[1] ;
5552 double *result = 0 ;
5553
5554 if (!args) SWIG_fail;
5555 swig_obj[0] = args;
5556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5557 if (!SWIG_IsOK(res1)) {
5558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_crpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5559 }
5560 arg1 = (struct WorldCoor *)(argp1);
5561 result = (double *)(double *) ((arg1)->crpix);
5562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5563 return resultobj;
5564 fail:
5565 return NULL;
5566 }
5567
5568
_wrap_WorldCoor_crval_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5569 SWIGINTERN PyObject *_wrap_WorldCoor_crval_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5570 PyObject *resultobj = 0;
5571 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5572 double *arg2 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 void *argp2 = 0 ;
5576 int res2 = 0 ;
5577 PyObject *swig_obj[2] ;
5578
5579 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_crval_set", 2, 2, swig_obj)) SWIG_fail;
5580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5581 if (!SWIG_IsOK(res1)) {
5582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_crval_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5583 }
5584 arg1 = (struct WorldCoor *)(argp1);
5585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5586 if (!SWIG_IsOK(res2)) {
5587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_crval_set" "', argument " "2"" of type '" "double [9]""'");
5588 }
5589 arg2 = (double *)(argp2);
5590 {
5591 if (arg2) {
5592 size_t ii = 0;
5593 for (; ii < (size_t)9; ++ii) *(double *)&arg1->crval[ii] = *((double *)arg2 + ii);
5594 } else {
5595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""crval""' of type '""double [9]""'");
5596 }
5597 }
5598 resultobj = SWIG_Py_Void();
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
_wrap_WorldCoor_crval_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5605 SWIGINTERN PyObject *_wrap_WorldCoor_crval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5606 PyObject *resultobj = 0;
5607 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 PyObject *swig_obj[1] ;
5611 double *result = 0 ;
5612
5613 if (!args) SWIG_fail;
5614 swig_obj[0] = args;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_crval_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5618 }
5619 arg1 = (struct WorldCoor *)(argp1);
5620 result = (double *)(double *) ((arg1)->crval);
5621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
_wrap_WorldCoor_cdelt_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5628 SWIGINTERN PyObject *_wrap_WorldCoor_cdelt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5629 PyObject *resultobj = 0;
5630 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5631 double *arg2 ;
5632 void *argp1 = 0 ;
5633 int res1 = 0 ;
5634 void *argp2 = 0 ;
5635 int res2 = 0 ;
5636 PyObject *swig_obj[2] ;
5637
5638 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_cdelt_set", 2, 2, swig_obj)) SWIG_fail;
5639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5640 if (!SWIG_IsOK(res1)) {
5641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cdelt_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5642 }
5643 arg1 = (struct WorldCoor *)(argp1);
5644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5645 if (!SWIG_IsOK(res2)) {
5646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_cdelt_set" "', argument " "2"" of type '" "double [9]""'");
5647 }
5648 arg2 = (double *)(argp2);
5649 {
5650 if (arg2) {
5651 size_t ii = 0;
5652 for (; ii < (size_t)9; ++ii) *(double *)&arg1->cdelt[ii] = *((double *)arg2 + ii);
5653 } else {
5654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""cdelt""' of type '""double [9]""'");
5655 }
5656 }
5657 resultobj = SWIG_Py_Void();
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
_wrap_WorldCoor_cdelt_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5664 SWIGINTERN PyObject *_wrap_WorldCoor_cdelt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5665 PyObject *resultobj = 0;
5666 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5667 void *argp1 = 0 ;
5668 int res1 = 0 ;
5669 PyObject *swig_obj[1] ;
5670 double *result = 0 ;
5671
5672 if (!args) SWIG_fail;
5673 swig_obj[0] = args;
5674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5675 if (!SWIG_IsOK(res1)) {
5676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cdelt_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5677 }
5678 arg1 = (struct WorldCoor *)(argp1);
5679 result = (double *)(double *) ((arg1)->cdelt);
5680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
_wrap_WorldCoor_pc_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5687 SWIGINTERN PyObject *_wrap_WorldCoor_pc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5690 double *arg2 ;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 void *argp2 = 0 ;
5694 int res2 = 0 ;
5695 PyObject *swig_obj[2] ;
5696
5697 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_pc_set", 2, 2, swig_obj)) SWIG_fail;
5698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5699 if (!SWIG_IsOK(res1)) {
5700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pc_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5701 }
5702 arg1 = (struct WorldCoor *)(argp1);
5703 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5704 if (!SWIG_IsOK(res2)) {
5705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_pc_set" "', argument " "2"" of type '" "double [81]""'");
5706 }
5707 arg2 = (double *)(argp2);
5708 {
5709 if (arg2) {
5710 size_t ii = 0;
5711 for (; ii < (size_t)81; ++ii) *(double *)&arg1->pc[ii] = *((double *)arg2 + ii);
5712 } else {
5713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pc""' of type '""double [81]""'");
5714 }
5715 }
5716 resultobj = SWIG_Py_Void();
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
_wrap_WorldCoor_pc_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5723 SWIGINTERN PyObject *_wrap_WorldCoor_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5724 PyObject *resultobj = 0;
5725 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5726 void *argp1 = 0 ;
5727 int res1 = 0 ;
5728 PyObject *swig_obj[1] ;
5729 double *result = 0 ;
5730
5731 if (!args) SWIG_fail;
5732 swig_obj[0] = args;
5733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5734 if (!SWIG_IsOK(res1)) {
5735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pc_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5736 }
5737 arg1 = (struct WorldCoor *)(argp1);
5738 result = (double *)(double *) ((arg1)->pc);
5739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
_wrap_WorldCoor_projp_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5746 SWIGINTERN PyObject *_wrap_WorldCoor_projp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5747 PyObject *resultobj = 0;
5748 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5749 double *arg2 ;
5750 void *argp1 = 0 ;
5751 int res1 = 0 ;
5752 void *argp2 = 0 ;
5753 int res2 = 0 ;
5754 PyObject *swig_obj[2] ;
5755
5756 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_projp_set", 2, 2, swig_obj)) SWIG_fail;
5757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5758 if (!SWIG_IsOK(res1)) {
5759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_projp_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5760 }
5761 arg1 = (struct WorldCoor *)(argp1);
5762 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5763 if (!SWIG_IsOK(res2)) {
5764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_projp_set" "', argument " "2"" of type '" "double [10]""'");
5765 }
5766 arg2 = (double *)(argp2);
5767 {
5768 if (arg2) {
5769 size_t ii = 0;
5770 for (; ii < (size_t)10; ++ii) *(double *)&arg1->projp[ii] = *((double *)arg2 + ii);
5771 } else {
5772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""projp""' of type '""double [10]""'");
5773 }
5774 }
5775 resultobj = SWIG_Py_Void();
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
_wrap_WorldCoor_projp_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5782 SWIGINTERN PyObject *_wrap_WorldCoor_projp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5783 PyObject *resultobj = 0;
5784 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject *swig_obj[1] ;
5788 double *result = 0 ;
5789
5790 if (!args) SWIG_fail;
5791 swig_obj[0] = args;
5792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5793 if (!SWIG_IsOK(res1)) {
5794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_projp_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5795 }
5796 arg1 = (struct WorldCoor *)(argp1);
5797 result = (double *)(double *) ((arg1)->projp);
5798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
_wrap_WorldCoor_pvfail_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5805 SWIGINTERN PyObject *_wrap_WorldCoor_pvfail_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5806 PyObject *resultobj = 0;
5807 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5808 int arg2 ;
5809 void *argp1 = 0 ;
5810 int res1 = 0 ;
5811 int val2 ;
5812 int ecode2 = 0 ;
5813 PyObject *swig_obj[2] ;
5814
5815 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_pvfail_set", 2, 2, swig_obj)) SWIG_fail;
5816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5817 if (!SWIG_IsOK(res1)) {
5818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pvfail_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5819 }
5820 arg1 = (struct WorldCoor *)(argp1);
5821 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5822 if (!SWIG_IsOK(ecode2)) {
5823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_pvfail_set" "', argument " "2"" of type '" "int""'");
5824 }
5825 arg2 = (int)(val2);
5826 if (arg1) (arg1)->pvfail = arg2;
5827 resultobj = SWIG_Py_Void();
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
_wrap_WorldCoor_pvfail_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5834 SWIGINTERN PyObject *_wrap_WorldCoor_pvfail_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5835 PyObject *resultobj = 0;
5836 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 PyObject *swig_obj[1] ;
5840 int result;
5841
5842 if (!args) SWIG_fail;
5843 swig_obj[0] = args;
5844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5845 if (!SWIG_IsOK(res1)) {
5846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pvfail_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5847 }
5848 arg1 = (struct WorldCoor *)(argp1);
5849 result = (int) ((arg1)->pvfail);
5850 resultobj = SWIG_From_int((int)(result));
5851 return resultobj;
5852 fail:
5853 return NULL;
5854 }
5855
5856
_wrap_WorldCoor_projppv_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5857 SWIGINTERN PyObject *_wrap_WorldCoor_projppv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5858 PyObject *resultobj = 0;
5859 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5860 double *arg2 ;
5861 void *argp1 = 0 ;
5862 int res1 = 0 ;
5863 void *argp2 = 0 ;
5864 int res2 = 0 ;
5865 PyObject *swig_obj[2] ;
5866
5867 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_projppv_set", 2, 2, swig_obj)) SWIG_fail;
5868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5869 if (!SWIG_IsOK(res1)) {
5870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_projppv_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5871 }
5872 arg1 = (struct WorldCoor *)(argp1);
5873 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
5874 if (!SWIG_IsOK(res2)) {
5875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_projppv_set" "', argument " "2"" of type '" "double [2*MAXPV]""'");
5876 }
5877 arg2 = (double *)(argp2);
5878 {
5879 if (arg2) {
5880 size_t ii = 0;
5881 for (; ii < (size_t)2*MAXPV; ++ii) *(double *)&arg1->projppv[ii] = *((double *)arg2 + ii);
5882 } else {
5883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""projppv""' of type '""double [2*MAXPV]""'");
5884 }
5885 }
5886 resultobj = SWIG_Py_Void();
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
_wrap_WorldCoor_projppv_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5893 SWIGINTERN PyObject *_wrap_WorldCoor_projppv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5894 PyObject *resultobj = 0;
5895 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5896 void *argp1 = 0 ;
5897 int res1 = 0 ;
5898 PyObject *swig_obj[1] ;
5899 double *result = 0 ;
5900
5901 if (!args) SWIG_fail;
5902 swig_obj[0] = args;
5903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5904 if (!SWIG_IsOK(res1)) {
5905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_projppv_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5906 }
5907 arg1 = (struct WorldCoor *)(argp1);
5908 result = (double *)(double *) ((arg1)->projppv);
5909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
5910 return resultobj;
5911 fail:
5912 return NULL;
5913 }
5914
5915
_wrap_WorldCoor_inv_x_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5916 SWIGINTERN PyObject *_wrap_WorldCoor_inv_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5917 PyObject *resultobj = 0;
5918 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5919 struct poly *arg2 = (struct poly *) 0 ;
5920 void *argp1 = 0 ;
5921 int res1 = 0 ;
5922 void *argp2 = 0 ;
5923 int res2 = 0 ;
5924 PyObject *swig_obj[2] ;
5925
5926 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_inv_x_set", 2, 2, swig_obj)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_inv_x_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5930 }
5931 arg1 = (struct WorldCoor *)(argp1);
5932 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_poly, SWIG_POINTER_DISOWN | 0 );
5933 if (!SWIG_IsOK(res2)) {
5934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_inv_x_set" "', argument " "2"" of type '" "struct poly *""'");
5935 }
5936 arg2 = (struct poly *)(argp2);
5937 if (arg1) (arg1)->inv_x = arg2;
5938 resultobj = SWIG_Py_Void();
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
_wrap_WorldCoor_inv_x_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5945 SWIGINTERN PyObject *_wrap_WorldCoor_inv_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5946 PyObject *resultobj = 0;
5947 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 PyObject *swig_obj[1] ;
5951 struct poly *result = 0 ;
5952
5953 if (!args) SWIG_fail;
5954 swig_obj[0] = args;
5955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_inv_x_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
5958 }
5959 arg1 = (struct WorldCoor *)(argp1);
5960 result = (struct poly *) ((arg1)->inv_x);
5961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_poly, 0 | 0 );
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
_wrap_WorldCoor_inv_y_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5968 SWIGINTERN PyObject *_wrap_WorldCoor_inv_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5969 PyObject *resultobj = 0;
5970 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
5971 struct poly *arg2 = (struct poly *) 0 ;
5972 void *argp1 = 0 ;
5973 int res1 = 0 ;
5974 void *argp2 = 0 ;
5975 int res2 = 0 ;
5976 PyObject *swig_obj[2] ;
5977
5978 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_inv_y_set", 2, 2, swig_obj)) SWIG_fail;
5979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_inv_y_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
5982 }
5983 arg1 = (struct WorldCoor *)(argp1);
5984 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_poly, SWIG_POINTER_DISOWN | 0 );
5985 if (!SWIG_IsOK(res2)) {
5986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_inv_y_set" "', argument " "2"" of type '" "struct poly *""'");
5987 }
5988 arg2 = (struct poly *)(argp2);
5989 if (arg1) (arg1)->inv_y = arg2;
5990 resultobj = SWIG_Py_Void();
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
_wrap_WorldCoor_inv_y_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5997 SWIGINTERN PyObject *_wrap_WorldCoor_inv_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5998 PyObject *resultobj = 0;
5999 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6000 void *argp1 = 0 ;
6001 int res1 = 0 ;
6002 PyObject *swig_obj[1] ;
6003 struct poly *result = 0 ;
6004
6005 if (!args) SWIG_fail;
6006 swig_obj[0] = args;
6007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6008 if (!SWIG_IsOK(res1)) {
6009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_inv_y_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6010 }
6011 arg1 = (struct WorldCoor *)(argp1);
6012 result = (struct poly *) ((arg1)->inv_y);
6013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_poly, 0 | 0 );
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
_wrap_WorldCoor_longpole_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6020 SWIGINTERN PyObject *_wrap_WorldCoor_longpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6021 PyObject *resultobj = 0;
6022 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6023 double arg2 ;
6024 void *argp1 = 0 ;
6025 int res1 = 0 ;
6026 double val2 ;
6027 int ecode2 = 0 ;
6028 PyObject *swig_obj[2] ;
6029
6030 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_longpole_set", 2, 2, swig_obj)) SWIG_fail;
6031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6032 if (!SWIG_IsOK(res1)) {
6033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_longpole_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6034 }
6035 arg1 = (struct WorldCoor *)(argp1);
6036 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6037 if (!SWIG_IsOK(ecode2)) {
6038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_longpole_set" "', argument " "2"" of type '" "double""'");
6039 }
6040 arg2 = (double)(val2);
6041 if (arg1) (arg1)->longpole = arg2;
6042 resultobj = SWIG_Py_Void();
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
_wrap_WorldCoor_longpole_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6049 SWIGINTERN PyObject *_wrap_WorldCoor_longpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6050 PyObject *resultobj = 0;
6051 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055 double result;
6056
6057 if (!args) SWIG_fail;
6058 swig_obj[0] = args;
6059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6060 if (!SWIG_IsOK(res1)) {
6061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_longpole_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6062 }
6063 arg1 = (struct WorldCoor *)(argp1);
6064 result = (double) ((arg1)->longpole);
6065 resultobj = SWIG_From_double((double)(result));
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
_wrap_WorldCoor_latpole_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6072 SWIGINTERN PyObject *_wrap_WorldCoor_latpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6073 PyObject *resultobj = 0;
6074 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6075 double arg2 ;
6076 void *argp1 = 0 ;
6077 int res1 = 0 ;
6078 double val2 ;
6079 int ecode2 = 0 ;
6080 PyObject *swig_obj[2] ;
6081
6082 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_latpole_set", 2, 2, swig_obj)) SWIG_fail;
6083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6084 if (!SWIG_IsOK(res1)) {
6085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latpole_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6086 }
6087 arg1 = (struct WorldCoor *)(argp1);
6088 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6089 if (!SWIG_IsOK(ecode2)) {
6090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_latpole_set" "', argument " "2"" of type '" "double""'");
6091 }
6092 arg2 = (double)(val2);
6093 if (arg1) (arg1)->latpole = arg2;
6094 resultobj = SWIG_Py_Void();
6095 return resultobj;
6096 fail:
6097 return NULL;
6098 }
6099
6100
_wrap_WorldCoor_latpole_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6101 SWIGINTERN PyObject *_wrap_WorldCoor_latpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6102 PyObject *resultobj = 0;
6103 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6104 void *argp1 = 0 ;
6105 int res1 = 0 ;
6106 PyObject *swig_obj[1] ;
6107 double result;
6108
6109 if (!args) SWIG_fail;
6110 swig_obj[0] = args;
6111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6112 if (!SWIG_IsOK(res1)) {
6113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latpole_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6114 }
6115 arg1 = (struct WorldCoor *)(argp1);
6116 result = (double) ((arg1)->latpole);
6117 resultobj = SWIG_From_double((double)(result));
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
_wrap_WorldCoor_rodeg_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6124 SWIGINTERN PyObject *_wrap_WorldCoor_rodeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6125 PyObject *resultobj = 0;
6126 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6127 double arg2 ;
6128 void *argp1 = 0 ;
6129 int res1 = 0 ;
6130 double val2 ;
6131 int ecode2 = 0 ;
6132 PyObject *swig_obj[2] ;
6133
6134 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_rodeg_set", 2, 2, swig_obj)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rodeg_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6138 }
6139 arg1 = (struct WorldCoor *)(argp1);
6140 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6141 if (!SWIG_IsOK(ecode2)) {
6142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_rodeg_set" "', argument " "2"" of type '" "double""'");
6143 }
6144 arg2 = (double)(val2);
6145 if (arg1) (arg1)->rodeg = arg2;
6146 resultobj = SWIG_Py_Void();
6147 return resultobj;
6148 fail:
6149 return NULL;
6150 }
6151
6152
_wrap_WorldCoor_rodeg_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6153 SWIGINTERN PyObject *_wrap_WorldCoor_rodeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154 PyObject *resultobj = 0;
6155 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6156 void *argp1 = 0 ;
6157 int res1 = 0 ;
6158 PyObject *swig_obj[1] ;
6159 double result;
6160
6161 if (!args) SWIG_fail;
6162 swig_obj[0] = args;
6163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6164 if (!SWIG_IsOK(res1)) {
6165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rodeg_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6166 }
6167 arg1 = (struct WorldCoor *)(argp1);
6168 result = (double) ((arg1)->rodeg);
6169 resultobj = SWIG_From_double((double)(result));
6170 return resultobj;
6171 fail:
6172 return NULL;
6173 }
6174
6175
_wrap_WorldCoor_imrot_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6176 SWIGINTERN PyObject *_wrap_WorldCoor_imrot_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6177 PyObject *resultobj = 0;
6178 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6179 double arg2 ;
6180 void *argp1 = 0 ;
6181 int res1 = 0 ;
6182 double val2 ;
6183 int ecode2 = 0 ;
6184 PyObject *swig_obj[2] ;
6185
6186 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_imrot_set", 2, 2, swig_obj)) SWIG_fail;
6187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6188 if (!SWIG_IsOK(res1)) {
6189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_imrot_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6190 }
6191 arg1 = (struct WorldCoor *)(argp1);
6192 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6193 if (!SWIG_IsOK(ecode2)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_imrot_set" "', argument " "2"" of type '" "double""'");
6195 }
6196 arg2 = (double)(val2);
6197 if (arg1) (arg1)->imrot = arg2;
6198 resultobj = SWIG_Py_Void();
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
_wrap_WorldCoor_imrot_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6205 SWIGINTERN PyObject *_wrap_WorldCoor_imrot_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6206 PyObject *resultobj = 0;
6207 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6208 void *argp1 = 0 ;
6209 int res1 = 0 ;
6210 PyObject *swig_obj[1] ;
6211 double result;
6212
6213 if (!args) SWIG_fail;
6214 swig_obj[0] = args;
6215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6216 if (!SWIG_IsOK(res1)) {
6217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_imrot_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6218 }
6219 arg1 = (struct WorldCoor *)(argp1);
6220 result = (double) ((arg1)->imrot);
6221 resultobj = SWIG_From_double((double)(result));
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
_wrap_WorldCoor_pa_north_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6228 SWIGINTERN PyObject *_wrap_WorldCoor_pa_north_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6229 PyObject *resultobj = 0;
6230 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6231 double arg2 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 double val2 ;
6235 int ecode2 = 0 ;
6236 PyObject *swig_obj[2] ;
6237
6238 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_pa_north_set", 2, 2, swig_obj)) SWIG_fail;
6239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6240 if (!SWIG_IsOK(res1)) {
6241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pa_north_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6242 }
6243 arg1 = (struct WorldCoor *)(argp1);
6244 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6245 if (!SWIG_IsOK(ecode2)) {
6246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_pa_north_set" "', argument " "2"" of type '" "double""'");
6247 }
6248 arg2 = (double)(val2);
6249 if (arg1) (arg1)->pa_north = arg2;
6250 resultobj = SWIG_Py_Void();
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
_wrap_WorldCoor_pa_north_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6257 SWIGINTERN PyObject *_wrap_WorldCoor_pa_north_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258 PyObject *resultobj = 0;
6259 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6260 void *argp1 = 0 ;
6261 int res1 = 0 ;
6262 PyObject *swig_obj[1] ;
6263 double result;
6264
6265 if (!args) SWIG_fail;
6266 swig_obj[0] = args;
6267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pa_north_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6270 }
6271 arg1 = (struct WorldCoor *)(argp1);
6272 result = (double) ((arg1)->pa_north);
6273 resultobj = SWIG_From_double((double)(result));
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
_wrap_WorldCoor_pa_east_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6280 SWIGINTERN PyObject *_wrap_WorldCoor_pa_east_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6281 PyObject *resultobj = 0;
6282 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6283 double arg2 ;
6284 void *argp1 = 0 ;
6285 int res1 = 0 ;
6286 double val2 ;
6287 int ecode2 = 0 ;
6288 PyObject *swig_obj[2] ;
6289
6290 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_pa_east_set", 2, 2, swig_obj)) SWIG_fail;
6291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6292 if (!SWIG_IsOK(res1)) {
6293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pa_east_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6294 }
6295 arg1 = (struct WorldCoor *)(argp1);
6296 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6297 if (!SWIG_IsOK(ecode2)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_pa_east_set" "', argument " "2"" of type '" "double""'");
6299 }
6300 arg2 = (double)(val2);
6301 if (arg1) (arg1)->pa_east = arg2;
6302 resultobj = SWIG_Py_Void();
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
_wrap_WorldCoor_pa_east_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6309 SWIGINTERN PyObject *_wrap_WorldCoor_pa_east_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6310 PyObject *resultobj = 0;
6311 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6312 void *argp1 = 0 ;
6313 int res1 = 0 ;
6314 PyObject *swig_obj[1] ;
6315 double result;
6316
6317 if (!args) SWIG_fail;
6318 swig_obj[0] = args;
6319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_pa_east_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6322 }
6323 arg1 = (struct WorldCoor *)(argp1);
6324 result = (double) ((arg1)->pa_east);
6325 resultobj = SWIG_From_double((double)(result));
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
_wrap_WorldCoor_radvel_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6332 SWIGINTERN PyObject *_wrap_WorldCoor_radvel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6333 PyObject *resultobj = 0;
6334 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6335 double arg2 ;
6336 void *argp1 = 0 ;
6337 int res1 = 0 ;
6338 double val2 ;
6339 int ecode2 = 0 ;
6340 PyObject *swig_obj[2] ;
6341
6342 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_radvel_set", 2, 2, swig_obj)) SWIG_fail;
6343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6344 if (!SWIG_IsOK(res1)) {
6345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radvel_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6346 }
6347 arg1 = (struct WorldCoor *)(argp1);
6348 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6349 if (!SWIG_IsOK(ecode2)) {
6350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_radvel_set" "', argument " "2"" of type '" "double""'");
6351 }
6352 arg2 = (double)(val2);
6353 if (arg1) (arg1)->radvel = arg2;
6354 resultobj = SWIG_Py_Void();
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
_wrap_WorldCoor_radvel_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6361 SWIGINTERN PyObject *_wrap_WorldCoor_radvel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6362 PyObject *resultobj = 0;
6363 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 PyObject *swig_obj[1] ;
6367 double result;
6368
6369 if (!args) SWIG_fail;
6370 swig_obj[0] = args;
6371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radvel_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6374 }
6375 arg1 = (struct WorldCoor *)(argp1);
6376 result = (double) ((arg1)->radvel);
6377 resultobj = SWIG_From_double((double)(result));
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
_wrap_WorldCoor_zvel_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6384 SWIGINTERN PyObject *_wrap_WorldCoor_zvel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6385 PyObject *resultobj = 0;
6386 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6387 double arg2 ;
6388 void *argp1 = 0 ;
6389 int res1 = 0 ;
6390 double val2 ;
6391 int ecode2 = 0 ;
6392 PyObject *swig_obj[2] ;
6393
6394 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_zvel_set", 2, 2, swig_obj)) SWIG_fail;
6395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6396 if (!SWIG_IsOK(res1)) {
6397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zvel_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6398 }
6399 arg1 = (struct WorldCoor *)(argp1);
6400 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6401 if (!SWIG_IsOK(ecode2)) {
6402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_zvel_set" "', argument " "2"" of type '" "double""'");
6403 }
6404 arg2 = (double)(val2);
6405 if (arg1) (arg1)->zvel = arg2;
6406 resultobj = SWIG_Py_Void();
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
_wrap_WorldCoor_zvel_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6413 SWIGINTERN PyObject *_wrap_WorldCoor_zvel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6414 PyObject *resultobj = 0;
6415 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6416 void *argp1 = 0 ;
6417 int res1 = 0 ;
6418 PyObject *swig_obj[1] ;
6419 double result;
6420
6421 if (!args) SWIG_fail;
6422 swig_obj[0] = args;
6423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6424 if (!SWIG_IsOK(res1)) {
6425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zvel_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6426 }
6427 arg1 = (struct WorldCoor *)(argp1);
6428 result = (double) ((arg1)->zvel);
6429 resultobj = SWIG_From_double((double)(result));
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
_wrap_WorldCoor_zpzd_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6436 SWIGINTERN PyObject *_wrap_WorldCoor_zpzd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6437 PyObject *resultobj = 0;
6438 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6439 double arg2 ;
6440 void *argp1 = 0 ;
6441 int res1 = 0 ;
6442 double val2 ;
6443 int ecode2 = 0 ;
6444 PyObject *swig_obj[2] ;
6445
6446 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_zpzd_set", 2, 2, swig_obj)) SWIG_fail;
6447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpzd_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6450 }
6451 arg1 = (struct WorldCoor *)(argp1);
6452 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6453 if (!SWIG_IsOK(ecode2)) {
6454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_zpzd_set" "', argument " "2"" of type '" "double""'");
6455 }
6456 arg2 = (double)(val2);
6457 if (arg1) (arg1)->zpzd = arg2;
6458 resultobj = SWIG_Py_Void();
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
_wrap_WorldCoor_zpzd_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6465 SWIGINTERN PyObject *_wrap_WorldCoor_zpzd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6466 PyObject *resultobj = 0;
6467 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6468 void *argp1 = 0 ;
6469 int res1 = 0 ;
6470 PyObject *swig_obj[1] ;
6471 double result;
6472
6473 if (!args) SWIG_fail;
6474 swig_obj[0] = args;
6475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpzd_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6478 }
6479 arg1 = (struct WorldCoor *)(argp1);
6480 result = (double) ((arg1)->zpzd);
6481 resultobj = SWIG_From_double((double)(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
_wrap_WorldCoor_zpr_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6488 SWIGINTERN PyObject *_wrap_WorldCoor_zpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6489 PyObject *resultobj = 0;
6490 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6491 double arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 double val2 ;
6495 int ecode2 = 0 ;
6496 PyObject *swig_obj[2] ;
6497
6498 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_zpr_set", 2, 2, swig_obj)) SWIG_fail;
6499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6500 if (!SWIG_IsOK(res1)) {
6501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpr_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6502 }
6503 arg1 = (struct WorldCoor *)(argp1);
6504 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6505 if (!SWIG_IsOK(ecode2)) {
6506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_zpr_set" "', argument " "2"" of type '" "double""'");
6507 }
6508 arg2 = (double)(val2);
6509 if (arg1) (arg1)->zpr = arg2;
6510 resultobj = SWIG_Py_Void();
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
_wrap_WorldCoor_zpr_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6517 SWIGINTERN PyObject *_wrap_WorldCoor_zpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6518 PyObject *resultobj = 0;
6519 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6520 void *argp1 = 0 ;
6521 int res1 = 0 ;
6522 PyObject *swig_obj[1] ;
6523 double result;
6524
6525 if (!args) SWIG_fail;
6526 swig_obj[0] = args;
6527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6528 if (!SWIG_IsOK(res1)) {
6529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpr_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6530 }
6531 arg1 = (struct WorldCoor *)(argp1);
6532 result = (double) ((arg1)->zpr);
6533 resultobj = SWIG_From_double((double)(result));
6534 return resultobj;
6535 fail:
6536 return NULL;
6537 }
6538
6539
_wrap_WorldCoor_imflip_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6540 SWIGINTERN PyObject *_wrap_WorldCoor_imflip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6541 PyObject *resultobj = 0;
6542 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6543 int arg2 ;
6544 void *argp1 = 0 ;
6545 int res1 = 0 ;
6546 int val2 ;
6547 int ecode2 = 0 ;
6548 PyObject *swig_obj[2] ;
6549
6550 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_imflip_set", 2, 2, swig_obj)) SWIG_fail;
6551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_imflip_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6554 }
6555 arg1 = (struct WorldCoor *)(argp1);
6556 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6557 if (!SWIG_IsOK(ecode2)) {
6558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_imflip_set" "', argument " "2"" of type '" "int""'");
6559 }
6560 arg2 = (int)(val2);
6561 if (arg1) (arg1)->imflip = arg2;
6562 resultobj = SWIG_Py_Void();
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
_wrap_WorldCoor_imflip_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6569 SWIGINTERN PyObject *_wrap_WorldCoor_imflip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570 PyObject *resultobj = 0;
6571 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6572 void *argp1 = 0 ;
6573 int res1 = 0 ;
6574 PyObject *swig_obj[1] ;
6575 int result;
6576
6577 if (!args) SWIG_fail;
6578 swig_obj[0] = args;
6579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6580 if (!SWIG_IsOK(res1)) {
6581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_imflip_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6582 }
6583 arg1 = (struct WorldCoor *)(argp1);
6584 result = (int) ((arg1)->imflip);
6585 resultobj = SWIG_From_int((int)(result));
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
_wrap_WorldCoor_prjcode_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6592 SWIGINTERN PyObject *_wrap_WorldCoor_prjcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6593 PyObject *resultobj = 0;
6594 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6595 int arg2 ;
6596 void *argp1 = 0 ;
6597 int res1 = 0 ;
6598 int val2 ;
6599 int ecode2 = 0 ;
6600 PyObject *swig_obj[2] ;
6601
6602 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_prjcode_set", 2, 2, swig_obj)) SWIG_fail;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_prjcode_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6606 }
6607 arg1 = (struct WorldCoor *)(argp1);
6608 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6609 if (!SWIG_IsOK(ecode2)) {
6610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_prjcode_set" "', argument " "2"" of type '" "int""'");
6611 }
6612 arg2 = (int)(val2);
6613 if (arg1) (arg1)->prjcode = arg2;
6614 resultobj = SWIG_Py_Void();
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
_wrap_WorldCoor_prjcode_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6621 SWIGINTERN PyObject *_wrap_WorldCoor_prjcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6622 PyObject *resultobj = 0;
6623 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6624 void *argp1 = 0 ;
6625 int res1 = 0 ;
6626 PyObject *swig_obj[1] ;
6627 int result;
6628
6629 if (!args) SWIG_fail;
6630 swig_obj[0] = args;
6631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6632 if (!SWIG_IsOK(res1)) {
6633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_prjcode_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6634 }
6635 arg1 = (struct WorldCoor *)(argp1);
6636 result = (int) ((arg1)->prjcode);
6637 resultobj = SWIG_From_int((int)(result));
6638 return resultobj;
6639 fail:
6640 return NULL;
6641 }
6642
6643
_wrap_WorldCoor_latbase_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6644 SWIGINTERN PyObject *_wrap_WorldCoor_latbase_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6645 PyObject *resultobj = 0;
6646 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6647 int arg2 ;
6648 void *argp1 = 0 ;
6649 int res1 = 0 ;
6650 int val2 ;
6651 int ecode2 = 0 ;
6652 PyObject *swig_obj[2] ;
6653
6654 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_latbase_set", 2, 2, swig_obj)) SWIG_fail;
6655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6656 if (!SWIG_IsOK(res1)) {
6657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latbase_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6658 }
6659 arg1 = (struct WorldCoor *)(argp1);
6660 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6661 if (!SWIG_IsOK(ecode2)) {
6662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_latbase_set" "', argument " "2"" of type '" "int""'");
6663 }
6664 arg2 = (int)(val2);
6665 if (arg1) (arg1)->latbase = arg2;
6666 resultobj = SWIG_Py_Void();
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
_wrap_WorldCoor_latbase_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6673 SWIGINTERN PyObject *_wrap_WorldCoor_latbase_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6674 PyObject *resultobj = 0;
6675 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6676 void *argp1 = 0 ;
6677 int res1 = 0 ;
6678 PyObject *swig_obj[1] ;
6679 int result;
6680
6681 if (!args) SWIG_fail;
6682 swig_obj[0] = args;
6683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6684 if (!SWIG_IsOK(res1)) {
6685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latbase_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6686 }
6687 arg1 = (struct WorldCoor *)(argp1);
6688 result = (int) ((arg1)->latbase);
6689 resultobj = SWIG_From_int((int)(result));
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
_wrap_WorldCoor_ncoeff1_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6696 SWIGINTERN PyObject *_wrap_WorldCoor_ncoeff1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6699 int arg2 ;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 int val2 ;
6703 int ecode2 = 0 ;
6704 PyObject *swig_obj[2] ;
6705
6706 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ncoeff1_set", 2, 2, swig_obj)) SWIG_fail;
6707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ncoeff1_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6710 }
6711 arg1 = (struct WorldCoor *)(argp1);
6712 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6713 if (!SWIG_IsOK(ecode2)) {
6714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_ncoeff1_set" "', argument " "2"" of type '" "int""'");
6715 }
6716 arg2 = (int)(val2);
6717 if (arg1) (arg1)->ncoeff1 = arg2;
6718 resultobj = SWIG_Py_Void();
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
_wrap_WorldCoor_ncoeff1_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6725 SWIGINTERN PyObject *_wrap_WorldCoor_ncoeff1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6726 PyObject *resultobj = 0;
6727 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6728 void *argp1 = 0 ;
6729 int res1 = 0 ;
6730 PyObject *swig_obj[1] ;
6731 int result;
6732
6733 if (!args) SWIG_fail;
6734 swig_obj[0] = args;
6735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ncoeff1_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6738 }
6739 arg1 = (struct WorldCoor *)(argp1);
6740 result = (int) ((arg1)->ncoeff1);
6741 resultobj = SWIG_From_int((int)(result));
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
_wrap_WorldCoor_ncoeff2_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6748 SWIGINTERN PyObject *_wrap_WorldCoor_ncoeff2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6751 int arg2 ;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 int val2 ;
6755 int ecode2 = 0 ;
6756 PyObject *swig_obj[2] ;
6757
6758 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ncoeff2_set", 2, 2, swig_obj)) SWIG_fail;
6759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6760 if (!SWIG_IsOK(res1)) {
6761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ncoeff2_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6762 }
6763 arg1 = (struct WorldCoor *)(argp1);
6764 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6765 if (!SWIG_IsOK(ecode2)) {
6766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_ncoeff2_set" "', argument " "2"" of type '" "int""'");
6767 }
6768 arg2 = (int)(val2);
6769 if (arg1) (arg1)->ncoeff2 = arg2;
6770 resultobj = SWIG_Py_Void();
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
_wrap_WorldCoor_ncoeff2_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6777 SWIGINTERN PyObject *_wrap_WorldCoor_ncoeff2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6780 void *argp1 = 0 ;
6781 int res1 = 0 ;
6782 PyObject *swig_obj[1] ;
6783 int result;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ncoeff2_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6790 }
6791 arg1 = (struct WorldCoor *)(argp1);
6792 result = (int) ((arg1)->ncoeff2);
6793 resultobj = SWIG_From_int((int)(result));
6794 return resultobj;
6795 fail:
6796 return NULL;
6797 }
6798
6799
_wrap_WorldCoor_zpnp_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6800 SWIGINTERN PyObject *_wrap_WorldCoor_zpnp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6801 PyObject *resultobj = 0;
6802 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6803 int arg2 ;
6804 void *argp1 = 0 ;
6805 int res1 = 0 ;
6806 int val2 ;
6807 int ecode2 = 0 ;
6808 PyObject *swig_obj[2] ;
6809
6810 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_zpnp_set", 2, 2, swig_obj)) SWIG_fail;
6811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6812 if (!SWIG_IsOK(res1)) {
6813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpnp_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6814 }
6815 arg1 = (struct WorldCoor *)(argp1);
6816 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6817 if (!SWIG_IsOK(ecode2)) {
6818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_zpnp_set" "', argument " "2"" of type '" "int""'");
6819 }
6820 arg2 = (int)(val2);
6821 if (arg1) (arg1)->zpnp = arg2;
6822 resultobj = SWIG_Py_Void();
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
_wrap_WorldCoor_zpnp_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6829 SWIGINTERN PyObject *_wrap_WorldCoor_zpnp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835 int result;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_zpnp_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6842 }
6843 arg1 = (struct WorldCoor *)(argp1);
6844 result = (int) ((arg1)->zpnp);
6845 resultobj = SWIG_From_int((int)(result));
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
_wrap_WorldCoor_changesys_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6852 SWIGINTERN PyObject *_wrap_WorldCoor_changesys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6853 PyObject *resultobj = 0;
6854 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6855 int arg2 ;
6856 void *argp1 = 0 ;
6857 int res1 = 0 ;
6858 int val2 ;
6859 int ecode2 = 0 ;
6860 PyObject *swig_obj[2] ;
6861
6862 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_changesys_set", 2, 2, swig_obj)) SWIG_fail;
6863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6864 if (!SWIG_IsOK(res1)) {
6865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_changesys_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6866 }
6867 arg1 = (struct WorldCoor *)(argp1);
6868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6869 if (!SWIG_IsOK(ecode2)) {
6870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_changesys_set" "', argument " "2"" of type '" "int""'");
6871 }
6872 arg2 = (int)(val2);
6873 if (arg1) (arg1)->changesys = arg2;
6874 resultobj = SWIG_Py_Void();
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
_wrap_WorldCoor_changesys_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6881 SWIGINTERN PyObject *_wrap_WorldCoor_changesys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6882 PyObject *resultobj = 0;
6883 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6884 void *argp1 = 0 ;
6885 int res1 = 0 ;
6886 PyObject *swig_obj[1] ;
6887 int result;
6888
6889 if (!args) SWIG_fail;
6890 swig_obj[0] = args;
6891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6892 if (!SWIG_IsOK(res1)) {
6893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_changesys_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6894 }
6895 arg1 = (struct WorldCoor *)(argp1);
6896 result = (int) ((arg1)->changesys);
6897 resultobj = SWIG_From_int((int)(result));
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
_wrap_WorldCoor_printsys_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6904 SWIGINTERN PyObject *_wrap_WorldCoor_printsys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6907 int arg2 ;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 int val2 ;
6911 int ecode2 = 0 ;
6912 PyObject *swig_obj[2] ;
6913
6914 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_printsys_set", 2, 2, swig_obj)) SWIG_fail;
6915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_printsys_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6918 }
6919 arg1 = (struct WorldCoor *)(argp1);
6920 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6921 if (!SWIG_IsOK(ecode2)) {
6922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_printsys_set" "', argument " "2"" of type '" "int""'");
6923 }
6924 arg2 = (int)(val2);
6925 if (arg1) (arg1)->printsys = arg2;
6926 resultobj = SWIG_Py_Void();
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
_wrap_WorldCoor_printsys_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6933 SWIGINTERN PyObject *_wrap_WorldCoor_printsys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6934 PyObject *resultobj = 0;
6935 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6936 void *argp1 = 0 ;
6937 int res1 = 0 ;
6938 PyObject *swig_obj[1] ;
6939 int result;
6940
6941 if (!args) SWIG_fail;
6942 swig_obj[0] = args;
6943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_printsys_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6946 }
6947 arg1 = (struct WorldCoor *)(argp1);
6948 result = (int) ((arg1)->printsys);
6949 resultobj = SWIG_From_int((int)(result));
6950 return resultobj;
6951 fail:
6952 return NULL;
6953 }
6954
6955
_wrap_WorldCoor_ndec_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6956 SWIGINTERN PyObject *_wrap_WorldCoor_ndec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6957 PyObject *resultobj = 0;
6958 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6959 int arg2 ;
6960 void *argp1 = 0 ;
6961 int res1 = 0 ;
6962 int val2 ;
6963 int ecode2 = 0 ;
6964 PyObject *swig_obj[2] ;
6965
6966 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ndec_set", 2, 2, swig_obj)) SWIG_fail;
6967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6968 if (!SWIG_IsOK(res1)) {
6969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ndec_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
6970 }
6971 arg1 = (struct WorldCoor *)(argp1);
6972 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6973 if (!SWIG_IsOK(ecode2)) {
6974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_ndec_set" "', argument " "2"" of type '" "int""'");
6975 }
6976 arg2 = (int)(val2);
6977 if (arg1) (arg1)->ndec = arg2;
6978 resultobj = SWIG_Py_Void();
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
_wrap_WorldCoor_ndec_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)6985 SWIGINTERN PyObject *_wrap_WorldCoor_ndec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6986 PyObject *resultobj = 0;
6987 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
6988 void *argp1 = 0 ;
6989 int res1 = 0 ;
6990 PyObject *swig_obj[1] ;
6991 int result;
6992
6993 if (!args) SWIG_fail;
6994 swig_obj[0] = args;
6995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ndec_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
6998 }
6999 arg1 = (struct WorldCoor *)(argp1);
7000 result = (int) ((arg1)->ndec);
7001 resultobj = SWIG_From_int((int)(result));
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
_wrap_WorldCoor_degout_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7008 SWIGINTERN PyObject *_wrap_WorldCoor_degout_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7011 int arg2 ;
7012 void *argp1 = 0 ;
7013 int res1 = 0 ;
7014 int val2 ;
7015 int ecode2 = 0 ;
7016 PyObject *swig_obj[2] ;
7017
7018 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_degout_set", 2, 2, swig_obj)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_degout_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7022 }
7023 arg1 = (struct WorldCoor *)(argp1);
7024 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7025 if (!SWIG_IsOK(ecode2)) {
7026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_degout_set" "', argument " "2"" of type '" "int""'");
7027 }
7028 arg2 = (int)(val2);
7029 if (arg1) (arg1)->degout = arg2;
7030 resultobj = SWIG_Py_Void();
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
_wrap_WorldCoor_degout_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7037 SWIGINTERN PyObject *_wrap_WorldCoor_degout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7038 PyObject *resultobj = 0;
7039 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7040 void *argp1 = 0 ;
7041 int res1 = 0 ;
7042 PyObject *swig_obj[1] ;
7043 int result;
7044
7045 if (!args) SWIG_fail;
7046 swig_obj[0] = args;
7047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7048 if (!SWIG_IsOK(res1)) {
7049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_degout_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7050 }
7051 arg1 = (struct WorldCoor *)(argp1);
7052 result = (int) ((arg1)->degout);
7053 resultobj = SWIG_From_int((int)(result));
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
_wrap_WorldCoor_tabsys_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7060 SWIGINTERN PyObject *_wrap_WorldCoor_tabsys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 PyObject *resultobj = 0;
7062 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7063 int arg2 ;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 int val2 ;
7067 int ecode2 = 0 ;
7068 PyObject *swig_obj[2] ;
7069
7070 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_tabsys_set", 2, 2, swig_obj)) SWIG_fail;
7071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7072 if (!SWIG_IsOK(res1)) {
7073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_tabsys_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7074 }
7075 arg1 = (struct WorldCoor *)(argp1);
7076 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7077 if (!SWIG_IsOK(ecode2)) {
7078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_tabsys_set" "', argument " "2"" of type '" "int""'");
7079 }
7080 arg2 = (int)(val2);
7081 if (arg1) (arg1)->tabsys = arg2;
7082 resultobj = SWIG_Py_Void();
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
_wrap_WorldCoor_tabsys_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7089 SWIGINTERN PyObject *_wrap_WorldCoor_tabsys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7090 PyObject *resultobj = 0;
7091 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7092 void *argp1 = 0 ;
7093 int res1 = 0 ;
7094 PyObject *swig_obj[1] ;
7095 int result;
7096
7097 if (!args) SWIG_fail;
7098 swig_obj[0] = args;
7099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7100 if (!SWIG_IsOK(res1)) {
7101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_tabsys_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7102 }
7103 arg1 = (struct WorldCoor *)(argp1);
7104 result = (int) ((arg1)->tabsys);
7105 resultobj = SWIG_From_int((int)(result));
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
_wrap_WorldCoor_rotmat_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7112 SWIGINTERN PyObject *_wrap_WorldCoor_rotmat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7113 PyObject *resultobj = 0;
7114 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7115 int arg2 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 PyObject *swig_obj[2] ;
7121
7122 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_rotmat_set", 2, 2, swig_obj)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rotmat_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7126 }
7127 arg1 = (struct WorldCoor *)(argp1);
7128 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7129 if (!SWIG_IsOK(ecode2)) {
7130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_rotmat_set" "', argument " "2"" of type '" "int""'");
7131 }
7132 arg2 = (int)(val2);
7133 if (arg1) (arg1)->rotmat = arg2;
7134 resultobj = SWIG_Py_Void();
7135 return resultobj;
7136 fail:
7137 return NULL;
7138 }
7139
7140
_wrap_WorldCoor_rotmat_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7141 SWIGINTERN PyObject *_wrap_WorldCoor_rotmat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7142 PyObject *resultobj = 0;
7143 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7144 void *argp1 = 0 ;
7145 int res1 = 0 ;
7146 PyObject *swig_obj[1] ;
7147 int result;
7148
7149 if (!args) SWIG_fail;
7150 swig_obj[0] = args;
7151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7152 if (!SWIG_IsOK(res1)) {
7153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_rotmat_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7154 }
7155 arg1 = (struct WorldCoor *)(argp1);
7156 result = (int) ((arg1)->rotmat);
7157 resultobj = SWIG_From_int((int)(result));
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
_wrap_WorldCoor_coorflip_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7164 SWIGINTERN PyObject *_wrap_WorldCoor_coorflip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7165 PyObject *resultobj = 0;
7166 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject *swig_obj[2] ;
7173
7174 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_coorflip_set", 2, 2, swig_obj)) SWIG_fail;
7175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7176 if (!SWIG_IsOK(res1)) {
7177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_coorflip_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7178 }
7179 arg1 = (struct WorldCoor *)(argp1);
7180 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7181 if (!SWIG_IsOK(ecode2)) {
7182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_coorflip_set" "', argument " "2"" of type '" "int""'");
7183 }
7184 arg2 = (int)(val2);
7185 if (arg1) (arg1)->coorflip = arg2;
7186 resultobj = SWIG_Py_Void();
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
_wrap_WorldCoor_coorflip_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7193 SWIGINTERN PyObject *_wrap_WorldCoor_coorflip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7194 PyObject *resultobj = 0;
7195 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7196 void *argp1 = 0 ;
7197 int res1 = 0 ;
7198 PyObject *swig_obj[1] ;
7199 int result;
7200
7201 if (!args) SWIG_fail;
7202 swig_obj[0] = args;
7203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7204 if (!SWIG_IsOK(res1)) {
7205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_coorflip_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7206 }
7207 arg1 = (struct WorldCoor *)(argp1);
7208 result = (int) ((arg1)->coorflip);
7209 resultobj = SWIG_From_int((int)(result));
7210 return resultobj;
7211 fail:
7212 return NULL;
7213 }
7214
7215
_wrap_WorldCoor_offscl_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7216 SWIGINTERN PyObject *_wrap_WorldCoor_offscl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7217 PyObject *resultobj = 0;
7218 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7219 int arg2 ;
7220 void *argp1 = 0 ;
7221 int res1 = 0 ;
7222 int val2 ;
7223 int ecode2 = 0 ;
7224 PyObject *swig_obj[2] ;
7225
7226 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_offscl_set", 2, 2, swig_obj)) SWIG_fail;
7227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7228 if (!SWIG_IsOK(res1)) {
7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_offscl_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7230 }
7231 arg1 = (struct WorldCoor *)(argp1);
7232 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7233 if (!SWIG_IsOK(ecode2)) {
7234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_offscl_set" "', argument " "2"" of type '" "int""'");
7235 }
7236 arg2 = (int)(val2);
7237 if (arg1) (arg1)->offscl = arg2;
7238 resultobj = SWIG_Py_Void();
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
_wrap_WorldCoor_offscl_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7245 SWIGINTERN PyObject *_wrap_WorldCoor_offscl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7246 PyObject *resultobj = 0;
7247 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7248 void *argp1 = 0 ;
7249 int res1 = 0 ;
7250 PyObject *swig_obj[1] ;
7251 int result;
7252
7253 if (!args) SWIG_fail;
7254 swig_obj[0] = args;
7255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_offscl_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7258 }
7259 arg1 = (struct WorldCoor *)(argp1);
7260 result = (int) ((arg1)->offscl);
7261 resultobj = SWIG_From_int((int)(result));
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
_wrap_WorldCoor_wcson_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7268 SWIGINTERN PyObject *_wrap_WorldCoor_wcson_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7269 PyObject *resultobj = 0;
7270 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7271 int arg2 ;
7272 void *argp1 = 0 ;
7273 int res1 = 0 ;
7274 int val2 ;
7275 int ecode2 = 0 ;
7276 PyObject *swig_obj[2] ;
7277
7278 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcson_set", 2, 2, swig_obj)) SWIG_fail;
7279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7280 if (!SWIG_IsOK(res1)) {
7281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcson_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7282 }
7283 arg1 = (struct WorldCoor *)(argp1);
7284 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7285 if (!SWIG_IsOK(ecode2)) {
7286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_wcson_set" "', argument " "2"" of type '" "int""'");
7287 }
7288 arg2 = (int)(val2);
7289 if (arg1) (arg1)->wcson = arg2;
7290 resultobj = SWIG_Py_Void();
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
_wrap_WorldCoor_wcson_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7297 SWIGINTERN PyObject *_wrap_WorldCoor_wcson_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7298 PyObject *resultobj = 0;
7299 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 PyObject *swig_obj[1] ;
7303 int result;
7304
7305 if (!args) SWIG_fail;
7306 swig_obj[0] = args;
7307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7308 if (!SWIG_IsOK(res1)) {
7309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcson_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7310 }
7311 arg1 = (struct WorldCoor *)(argp1);
7312 result = (int) ((arg1)->wcson);
7313 resultobj = SWIG_From_int((int)(result));
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
_wrap_WorldCoor_naxis_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7320 SWIGINTERN PyObject *_wrap_WorldCoor_naxis_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 PyObject *resultobj = 0;
7322 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7323 int arg2 ;
7324 void *argp1 = 0 ;
7325 int res1 = 0 ;
7326 int val2 ;
7327 int ecode2 = 0 ;
7328 PyObject *swig_obj[2] ;
7329
7330 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_naxis_set", 2, 2, swig_obj)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_naxis_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7334 }
7335 arg1 = (struct WorldCoor *)(argp1);
7336 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7337 if (!SWIG_IsOK(ecode2)) {
7338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_naxis_set" "', argument " "2"" of type '" "int""'");
7339 }
7340 arg2 = (int)(val2);
7341 if (arg1) (arg1)->naxis = arg2;
7342 resultobj = SWIG_Py_Void();
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
_wrap_WorldCoor_naxis_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7349 SWIGINTERN PyObject *_wrap_WorldCoor_naxis_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7350 PyObject *resultobj = 0;
7351 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 PyObject *swig_obj[1] ;
7355 int result;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_naxis_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7362 }
7363 arg1 = (struct WorldCoor *)(argp1);
7364 result = (int) ((arg1)->naxis);
7365 resultobj = SWIG_From_int((int)(result));
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
_wrap_WorldCoor_naxes_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7372 SWIGINTERN PyObject *_wrap_WorldCoor_naxes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7373 PyObject *resultobj = 0;
7374 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7375 int arg2 ;
7376 void *argp1 = 0 ;
7377 int res1 = 0 ;
7378 int val2 ;
7379 int ecode2 = 0 ;
7380 PyObject *swig_obj[2] ;
7381
7382 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_naxes_set", 2, 2, swig_obj)) SWIG_fail;
7383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_naxes_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7386 }
7387 arg1 = (struct WorldCoor *)(argp1);
7388 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7389 if (!SWIG_IsOK(ecode2)) {
7390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_naxes_set" "', argument " "2"" of type '" "int""'");
7391 }
7392 arg2 = (int)(val2);
7393 if (arg1) (arg1)->naxes = arg2;
7394 resultobj = SWIG_Py_Void();
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
_wrap_WorldCoor_naxes_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7401 SWIGINTERN PyObject *_wrap_WorldCoor_naxes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7402 PyObject *resultobj = 0;
7403 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 PyObject *swig_obj[1] ;
7407 int result;
7408
7409 if (!args) SWIG_fail;
7410 swig_obj[0] = args;
7411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_naxes_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7414 }
7415 arg1 = (struct WorldCoor *)(argp1);
7416 result = (int) ((arg1)->naxes);
7417 resultobj = SWIG_From_int((int)(result));
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
_wrap_WorldCoor_wcsproj_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7424 SWIGINTERN PyObject *_wrap_WorldCoor_wcsproj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7425 PyObject *resultobj = 0;
7426 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7427 int arg2 ;
7428 void *argp1 = 0 ;
7429 int res1 = 0 ;
7430 int val2 ;
7431 int ecode2 = 0 ;
7432 PyObject *swig_obj[2] ;
7433
7434 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcsproj_set", 2, 2, swig_obj)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsproj_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7438 }
7439 arg1 = (struct WorldCoor *)(argp1);
7440 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_wcsproj_set" "', argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = (int)(val2);
7445 if (arg1) (arg1)->wcsproj = arg2;
7446 resultobj = SWIG_Py_Void();
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
_wrap_WorldCoor_wcsproj_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7453 SWIGINTERN PyObject *_wrap_WorldCoor_wcsproj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7454 PyObject *resultobj = 0;
7455 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 PyObject *swig_obj[1] ;
7459 int result;
7460
7461 if (!args) SWIG_fail;
7462 swig_obj[0] = args;
7463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsproj_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7466 }
7467 arg1 = (struct WorldCoor *)(argp1);
7468 result = (int) ((arg1)->wcsproj);
7469 resultobj = SWIG_From_int((int)(result));
7470 return resultobj;
7471 fail:
7472 return NULL;
7473 }
7474
7475
_wrap_WorldCoor_linmode_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7476 SWIGINTERN PyObject *_wrap_WorldCoor_linmode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7477 PyObject *resultobj = 0;
7478 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7479 int arg2 ;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 int val2 ;
7483 int ecode2 = 0 ;
7484 PyObject *swig_obj[2] ;
7485
7486 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_linmode_set", 2, 2, swig_obj)) SWIG_fail;
7487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7488 if (!SWIG_IsOK(res1)) {
7489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_linmode_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7490 }
7491 arg1 = (struct WorldCoor *)(argp1);
7492 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7493 if (!SWIG_IsOK(ecode2)) {
7494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_linmode_set" "', argument " "2"" of type '" "int""'");
7495 }
7496 arg2 = (int)(val2);
7497 if (arg1) (arg1)->linmode = arg2;
7498 resultobj = SWIG_Py_Void();
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
_wrap_WorldCoor_linmode_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7505 SWIGINTERN PyObject *_wrap_WorldCoor_linmode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7506 PyObject *resultobj = 0;
7507 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7508 void *argp1 = 0 ;
7509 int res1 = 0 ;
7510 PyObject *swig_obj[1] ;
7511 int result;
7512
7513 if (!args) SWIG_fail;
7514 swig_obj[0] = args;
7515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_linmode_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7518 }
7519 arg1 = (struct WorldCoor *)(argp1);
7520 result = (int) ((arg1)->linmode);
7521 resultobj = SWIG_From_int((int)(result));
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
_wrap_WorldCoor_detector_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7528 SWIGINTERN PyObject *_wrap_WorldCoor_detector_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7529 PyObject *resultobj = 0;
7530 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7531 int arg2 ;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 int val2 ;
7535 int ecode2 = 0 ;
7536 PyObject *swig_obj[2] ;
7537
7538 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_detector_set", 2, 2, swig_obj)) SWIG_fail;
7539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7540 if (!SWIG_IsOK(res1)) {
7541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_detector_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7542 }
7543 arg1 = (struct WorldCoor *)(argp1);
7544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7545 if (!SWIG_IsOK(ecode2)) {
7546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_detector_set" "', argument " "2"" of type '" "int""'");
7547 }
7548 arg2 = (int)(val2);
7549 if (arg1) (arg1)->detector = arg2;
7550 resultobj = SWIG_Py_Void();
7551 return resultobj;
7552 fail:
7553 return NULL;
7554 }
7555
7556
_wrap_WorldCoor_detector_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7557 SWIGINTERN PyObject *_wrap_WorldCoor_detector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7558 PyObject *resultobj = 0;
7559 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 PyObject *swig_obj[1] ;
7563 int result;
7564
7565 if (!args) SWIG_fail;
7566 swig_obj[0] = args;
7567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7568 if (!SWIG_IsOK(res1)) {
7569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_detector_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7570 }
7571 arg1 = (struct WorldCoor *)(argp1);
7572 result = (int) ((arg1)->detector);
7573 resultobj = SWIG_From_int((int)(result));
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
_wrap_WorldCoor_instrument_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7580 SWIGINTERN PyObject *_wrap_WorldCoor_instrument_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7581 PyObject *resultobj = 0;
7582 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7583 char *arg2 ;
7584 void *argp1 = 0 ;
7585 int res1 = 0 ;
7586 char temp2[32] ;
7587 int res2 ;
7588 PyObject *swig_obj[2] ;
7589
7590 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_instrument_set", 2, 2, swig_obj)) SWIG_fail;
7591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7592 if (!SWIG_IsOK(res1)) {
7593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_instrument_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7594 }
7595 arg1 = (struct WorldCoor *)(argp1);
7596 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 32);
7597 if (!SWIG_IsOK(res2)) {
7598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_instrument_set" "', argument " "2"" of type '" "char [32]""'");
7599 }
7600 arg2 = (char *)(temp2);
7601 if (arg2) memcpy(arg1->instrument,arg2,32*sizeof(char));
7602 else memset(arg1->instrument,0,32*sizeof(char));
7603 resultobj = SWIG_Py_Void();
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
_wrap_WorldCoor_instrument_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7610 SWIGINTERN PyObject *_wrap_WorldCoor_instrument_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611 PyObject *resultobj = 0;
7612 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7613 void *argp1 = 0 ;
7614 int res1 = 0 ;
7615 PyObject *swig_obj[1] ;
7616 char *result = 0 ;
7617
7618 if (!args) SWIG_fail;
7619 swig_obj[0] = args;
7620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_instrument_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7623 }
7624 arg1 = (struct WorldCoor *)(argp1);
7625 result = (char *)(char *) ((arg1)->instrument);
7626 {
7627 size_t size = SWIG_strnlen(result, 32);
7628
7629
7630
7631 resultobj = SWIG_FromCharPtrAndSize(result, size);
7632 }
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
_wrap_WorldCoor_ctype_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7639 SWIGINTERN PyObject *_wrap_WorldCoor_ctype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7640 PyObject *resultobj = 0;
7641 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7642 char (*arg2)[9] ;
7643 void *argp1 = 0 ;
7644 int res1 = 0 ;
7645 void *argp2 = 0 ;
7646 int res2 = 0 ;
7647 PyObject *swig_obj[2] ;
7648
7649 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ctype_set", 2, 2, swig_obj)) SWIG_fail;
7650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ctype_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7653 }
7654 arg1 = (struct WorldCoor *)(argp1);
7655 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_a_9__char, 0 | 0 );
7656 if (!SWIG_IsOK(res2)) {
7657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ctype_set" "', argument " "2"" of type '" "char [9][9]""'");
7658 }
7659 arg2 = (char (*)[9])(argp2);
7660 {
7661 if (arg2) {
7662 size_t ii = 0;
7663 for (; ii < (size_t)9; ++ii) {
7664 if (arg2[ii]) {
7665 size_t jj = 0;
7666 for (; jj < (size_t)9; ++jj) arg1->ctype[ii][jj] = arg2[ii][jj];
7667 } else {
7668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ctype""' of type '""char [9][9]""'");
7669 }
7670 }
7671 } else {
7672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ctype""' of type '""char [9][9]""'");
7673 }
7674 }
7675 resultobj = SWIG_Py_Void();
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
_wrap_WorldCoor_ctype_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7682 SWIGINTERN PyObject *_wrap_WorldCoor_ctype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683 PyObject *resultobj = 0;
7684 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject *swig_obj[1] ;
7688 char (*result)[9] = 0 ;
7689
7690 if (!args) SWIG_fail;
7691 swig_obj[0] = args;
7692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7693 if (!SWIG_IsOK(res1)) {
7694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ctype_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7695 }
7696 arg1 = (struct WorldCoor *)(argp1);
7697 result = (char (*)[9])(char (*)[9]) ((arg1)->ctype);
7698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_9__char, 0 | 0 );
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
_wrap_WorldCoor_c1type_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7705 SWIGINTERN PyObject *_wrap_WorldCoor_c1type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7706 PyObject *resultobj = 0;
7707 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7708 char *arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 char temp2[9] ;
7712 int res2 ;
7713 PyObject *swig_obj[2] ;
7714
7715 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_c1type_set", 2, 2, swig_obj)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_c1type_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7719 }
7720 arg1 = (struct WorldCoor *)(argp1);
7721 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 9);
7722 if (!SWIG_IsOK(res2)) {
7723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_c1type_set" "', argument " "2"" of type '" "char [9]""'");
7724 }
7725 arg2 = (char *)(temp2);
7726 if (arg2) memcpy(arg1->c1type,arg2,9*sizeof(char));
7727 else memset(arg1->c1type,0,9*sizeof(char));
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
_wrap_WorldCoor_c1type_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7735 SWIGINTERN PyObject *_wrap_WorldCoor_c1type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7736 PyObject *resultobj = 0;
7737 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 PyObject *swig_obj[1] ;
7741 char *result = 0 ;
7742
7743 if (!args) SWIG_fail;
7744 swig_obj[0] = args;
7745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_c1type_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7748 }
7749 arg1 = (struct WorldCoor *)(argp1);
7750 result = (char *)(char *) ((arg1)->c1type);
7751 {
7752 size_t size = SWIG_strnlen(result, 9);
7753
7754
7755
7756 resultobj = SWIG_FromCharPtrAndSize(result, size);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
_wrap_WorldCoor_c2type_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7764 SWIGINTERN PyObject *_wrap_WorldCoor_c2type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7765 PyObject *resultobj = 0;
7766 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7767 char *arg2 ;
7768 void *argp1 = 0 ;
7769 int res1 = 0 ;
7770 char temp2[9] ;
7771 int res2 ;
7772 PyObject *swig_obj[2] ;
7773
7774 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_c2type_set", 2, 2, swig_obj)) SWIG_fail;
7775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7776 if (!SWIG_IsOK(res1)) {
7777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_c2type_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7778 }
7779 arg1 = (struct WorldCoor *)(argp1);
7780 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 9);
7781 if (!SWIG_IsOK(res2)) {
7782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_c2type_set" "', argument " "2"" of type '" "char [9]""'");
7783 }
7784 arg2 = (char *)(temp2);
7785 if (arg2) memcpy(arg1->c2type,arg2,9*sizeof(char));
7786 else memset(arg1->c2type,0,9*sizeof(char));
7787 resultobj = SWIG_Py_Void();
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
_wrap_WorldCoor_c2type_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7794 SWIGINTERN PyObject *_wrap_WorldCoor_c2type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 PyObject *resultobj = 0;
7796 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7797 void *argp1 = 0 ;
7798 int res1 = 0 ;
7799 PyObject *swig_obj[1] ;
7800 char *result = 0 ;
7801
7802 if (!args) SWIG_fail;
7803 swig_obj[0] = args;
7804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7805 if (!SWIG_IsOK(res1)) {
7806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_c2type_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7807 }
7808 arg1 = (struct WorldCoor *)(argp1);
7809 result = (char *)(char *) ((arg1)->c2type);
7810 {
7811 size_t size = SWIG_strnlen(result, 9);
7812
7813
7814
7815 resultobj = SWIG_FromCharPtrAndSize(result, size);
7816 }
7817 return resultobj;
7818 fail:
7819 return NULL;
7820 }
7821
7822
_wrap_WorldCoor_ptype_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7823 SWIGINTERN PyObject *_wrap_WorldCoor_ptype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7824 PyObject *resultobj = 0;
7825 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7826 char *arg2 ;
7827 void *argp1 = 0 ;
7828 int res1 = 0 ;
7829 char temp2[9] ;
7830 int res2 ;
7831 PyObject *swig_obj[2] ;
7832
7833 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ptype_set", 2, 2, swig_obj)) SWIG_fail;
7834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ptype_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7837 }
7838 arg1 = (struct WorldCoor *)(argp1);
7839 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 9);
7840 if (!SWIG_IsOK(res2)) {
7841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ptype_set" "', argument " "2"" of type '" "char [9]""'");
7842 }
7843 arg2 = (char *)(temp2);
7844 if (arg2) memcpy(arg1->ptype,arg2,9*sizeof(char));
7845 else memset(arg1->ptype,0,9*sizeof(char));
7846 resultobj = SWIG_Py_Void();
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
_wrap_WorldCoor_ptype_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7853 SWIGINTERN PyObject *_wrap_WorldCoor_ptype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7854 PyObject *resultobj = 0;
7855 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 PyObject *swig_obj[1] ;
7859 char *result = 0 ;
7860
7861 if (!args) SWIG_fail;
7862 swig_obj[0] = args;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ptype_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7866 }
7867 arg1 = (struct WorldCoor *)(argp1);
7868 result = (char *)(char *) ((arg1)->ptype);
7869 {
7870 size_t size = SWIG_strnlen(result, 9);
7871
7872
7873
7874 resultobj = SWIG_FromCharPtrAndSize(result, size);
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
_wrap_WorldCoor_units_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7882 SWIGINTERN PyObject *_wrap_WorldCoor_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7885 char (*arg2)[32] ;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 void *argp2 = 0 ;
7889 int res2 = 0 ;
7890 PyObject *swig_obj[2] ;
7891
7892 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_units_set", 2, 2, swig_obj)) SWIG_fail;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_units_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7896 }
7897 arg1 = (struct WorldCoor *)(argp1);
7898 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_a_32__char, 0 | 0 );
7899 if (!SWIG_IsOK(res2)) {
7900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_units_set" "', argument " "2"" of type '" "char [9][32]""'");
7901 }
7902 arg2 = (char (*)[32])(argp2);
7903 {
7904 if (arg2) {
7905 size_t ii = 0;
7906 for (; ii < (size_t)9; ++ii) {
7907 if (arg2[ii]) {
7908 size_t jj = 0;
7909 for (; jj < (size_t)32; ++jj) arg1->units[ii][jj] = arg2[ii][jj];
7910 } else {
7911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""units""' of type '""char [9][32]""'");
7912 }
7913 }
7914 } else {
7915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""units""' of type '""char [9][32]""'");
7916 }
7917 }
7918 resultobj = SWIG_Py_Void();
7919 return resultobj;
7920 fail:
7921 return NULL;
7922 }
7923
7924
_wrap_WorldCoor_units_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7925 SWIGINTERN PyObject *_wrap_WorldCoor_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7926 PyObject *resultobj = 0;
7927 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 PyObject *swig_obj[1] ;
7931 char (*result)[32] = 0 ;
7932
7933 if (!args) SWIG_fail;
7934 swig_obj[0] = args;
7935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7936 if (!SWIG_IsOK(res1)) {
7937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_units_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7938 }
7939 arg1 = (struct WorldCoor *)(argp1);
7940 result = (char (*)[32])(char (*)[32]) ((arg1)->units);
7941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_32__char, 0 | 0 );
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
_wrap_WorldCoor_radecsys_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7948 SWIGINTERN PyObject *_wrap_WorldCoor_radecsys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7949 PyObject *resultobj = 0;
7950 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7951 char *arg2 ;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 char temp2[32] ;
7955 int res2 ;
7956 PyObject *swig_obj[2] ;
7957
7958 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_radecsys_set", 2, 2, swig_obj)) SWIG_fail;
7959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7960 if (!SWIG_IsOK(res1)) {
7961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecsys_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
7962 }
7963 arg1 = (struct WorldCoor *)(argp1);
7964 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 32);
7965 if (!SWIG_IsOK(res2)) {
7966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_radecsys_set" "', argument " "2"" of type '" "char [32]""'");
7967 }
7968 arg2 = (char *)(temp2);
7969 if (arg2) memcpy(arg1->radecsys,arg2,32*sizeof(char));
7970 else memset(arg1->radecsys,0,32*sizeof(char));
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
_wrap_WorldCoor_radecsys_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)7978 SWIGINTERN PyObject *_wrap_WorldCoor_radecsys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
7981 void *argp1 = 0 ;
7982 int res1 = 0 ;
7983 PyObject *swig_obj[1] ;
7984 char *result = 0 ;
7985
7986 if (!args) SWIG_fail;
7987 swig_obj[0] = args;
7988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
7989 if (!SWIG_IsOK(res1)) {
7990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecsys_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
7991 }
7992 arg1 = (struct WorldCoor *)(argp1);
7993 result = (char *)(char *) ((arg1)->radecsys);
7994 {
7995 size_t size = SWIG_strnlen(result, 32);
7996
7997
7998
7999 resultobj = SWIG_FromCharPtrAndSize(result, size);
8000 }
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
_wrap_WorldCoor_radecout_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8007 SWIGINTERN PyObject *_wrap_WorldCoor_radecout_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8008 PyObject *resultobj = 0;
8009 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8010 char *arg2 ;
8011 void *argp1 = 0 ;
8012 int res1 = 0 ;
8013 char temp2[32] ;
8014 int res2 ;
8015 PyObject *swig_obj[2] ;
8016
8017 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_radecout_set", 2, 2, swig_obj)) SWIG_fail;
8018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8019 if (!SWIG_IsOK(res1)) {
8020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecout_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8021 }
8022 arg1 = (struct WorldCoor *)(argp1);
8023 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 32);
8024 if (!SWIG_IsOK(res2)) {
8025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_radecout_set" "', argument " "2"" of type '" "char [32]""'");
8026 }
8027 arg2 = (char *)(temp2);
8028 if (arg2) memcpy(arg1->radecout,arg2,32*sizeof(char));
8029 else memset(arg1->radecout,0,32*sizeof(char));
8030 resultobj = SWIG_Py_Void();
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
_wrap_WorldCoor_radecout_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8037 SWIGINTERN PyObject *_wrap_WorldCoor_radecout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 PyObject *swig_obj[1] ;
8043 char *result = 0 ;
8044
8045 if (!args) SWIG_fail;
8046 swig_obj[0] = args;
8047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8048 if (!SWIG_IsOK(res1)) {
8049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecout_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8050 }
8051 arg1 = (struct WorldCoor *)(argp1);
8052 result = (char *)(char *) ((arg1)->radecout);
8053 {
8054 size_t size = SWIG_strnlen(result, 32);
8055
8056
8057
8058 resultobj = SWIG_FromCharPtrAndSize(result, size);
8059 }
8060 return resultobj;
8061 fail:
8062 return NULL;
8063 }
8064
8065
_wrap_WorldCoor_radecin_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8066 SWIGINTERN PyObject *_wrap_WorldCoor_radecin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8069 char *arg2 ;
8070 void *argp1 = 0 ;
8071 int res1 = 0 ;
8072 char temp2[32] ;
8073 int res2 ;
8074 PyObject *swig_obj[2] ;
8075
8076 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_radecin_set", 2, 2, swig_obj)) SWIG_fail;
8077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8078 if (!SWIG_IsOK(res1)) {
8079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecin_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8080 }
8081 arg1 = (struct WorldCoor *)(argp1);
8082 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 32);
8083 if (!SWIG_IsOK(res2)) {
8084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_radecin_set" "', argument " "2"" of type '" "char [32]""'");
8085 }
8086 arg2 = (char *)(temp2);
8087 if (arg2) memcpy(arg1->radecin,arg2,32*sizeof(char));
8088 else memset(arg1->radecin,0,32*sizeof(char));
8089 resultobj = SWIG_Py_Void();
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
_wrap_WorldCoor_radecin_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8096 SWIGINTERN PyObject *_wrap_WorldCoor_radecin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8097 PyObject *resultobj = 0;
8098 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8099 void *argp1 = 0 ;
8100 int res1 = 0 ;
8101 PyObject *swig_obj[1] ;
8102 char *result = 0 ;
8103
8104 if (!args) SWIG_fail;
8105 swig_obj[0] = args;
8106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8107 if (!SWIG_IsOK(res1)) {
8108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_radecin_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8109 }
8110 arg1 = (struct WorldCoor *)(argp1);
8111 result = (char *)(char *) ((arg1)->radecin);
8112 {
8113 size_t size = SWIG_strnlen(result, 32);
8114
8115
8116
8117 resultobj = SWIG_FromCharPtrAndSize(result, size);
8118 }
8119 return resultobj;
8120 fail:
8121 return NULL;
8122 }
8123
8124
_wrap_WorldCoor_eqin_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8125 SWIGINTERN PyObject *_wrap_WorldCoor_eqin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8126 PyObject *resultobj = 0;
8127 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8128 double arg2 ;
8129 void *argp1 = 0 ;
8130 int res1 = 0 ;
8131 double val2 ;
8132 int ecode2 = 0 ;
8133 PyObject *swig_obj[2] ;
8134
8135 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_eqin_set", 2, 2, swig_obj)) SWIG_fail;
8136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8137 if (!SWIG_IsOK(res1)) {
8138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_eqin_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8139 }
8140 arg1 = (struct WorldCoor *)(argp1);
8141 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8142 if (!SWIG_IsOK(ecode2)) {
8143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_eqin_set" "', argument " "2"" of type '" "double""'");
8144 }
8145 arg2 = (double)(val2);
8146 if (arg1) (arg1)->eqin = arg2;
8147 resultobj = SWIG_Py_Void();
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
_wrap_WorldCoor_eqin_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8154 SWIGINTERN PyObject *_wrap_WorldCoor_eqin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 PyObject *resultobj = 0;
8156 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8157 void *argp1 = 0 ;
8158 int res1 = 0 ;
8159 PyObject *swig_obj[1] ;
8160 double result;
8161
8162 if (!args) SWIG_fail;
8163 swig_obj[0] = args;
8164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8165 if (!SWIG_IsOK(res1)) {
8166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_eqin_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8167 }
8168 arg1 = (struct WorldCoor *)(argp1);
8169 result = (double) ((arg1)->eqin);
8170 resultobj = SWIG_From_double((double)(result));
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
_wrap_WorldCoor_eqout_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8177 SWIGINTERN PyObject *_wrap_WorldCoor_eqout_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8178 PyObject *resultobj = 0;
8179 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8180 double arg2 ;
8181 void *argp1 = 0 ;
8182 int res1 = 0 ;
8183 double val2 ;
8184 int ecode2 = 0 ;
8185 PyObject *swig_obj[2] ;
8186
8187 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_eqout_set", 2, 2, swig_obj)) SWIG_fail;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_eqout_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8191 }
8192 arg1 = (struct WorldCoor *)(argp1);
8193 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8194 if (!SWIG_IsOK(ecode2)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_eqout_set" "', argument " "2"" of type '" "double""'");
8196 }
8197 arg2 = (double)(val2);
8198 if (arg1) (arg1)->eqout = arg2;
8199 resultobj = SWIG_Py_Void();
8200 return resultobj;
8201 fail:
8202 return NULL;
8203 }
8204
8205
_wrap_WorldCoor_eqout_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8206 SWIGINTERN PyObject *_wrap_WorldCoor_eqout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8207 PyObject *resultobj = 0;
8208 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 PyObject *swig_obj[1] ;
8212 double result;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_eqout_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8219 }
8220 arg1 = (struct WorldCoor *)(argp1);
8221 result = (double) ((arg1)->eqout);
8222 resultobj = SWIG_From_double((double)(result));
8223 return resultobj;
8224 fail:
8225 return NULL;
8226 }
8227
8228
_wrap_WorldCoor_sysin_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8229 SWIGINTERN PyObject *_wrap_WorldCoor_sysin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8230 PyObject *resultobj = 0;
8231 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8232 int arg2 ;
8233 void *argp1 = 0 ;
8234 int res1 = 0 ;
8235 int val2 ;
8236 int ecode2 = 0 ;
8237 PyObject *swig_obj[2] ;
8238
8239 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_sysin_set", 2, 2, swig_obj)) SWIG_fail;
8240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8241 if (!SWIG_IsOK(res1)) {
8242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_sysin_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8243 }
8244 arg1 = (struct WorldCoor *)(argp1);
8245 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8246 if (!SWIG_IsOK(ecode2)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_sysin_set" "', argument " "2"" of type '" "int""'");
8248 }
8249 arg2 = (int)(val2);
8250 if (arg1) (arg1)->sysin = arg2;
8251 resultobj = SWIG_Py_Void();
8252 return resultobj;
8253 fail:
8254 return NULL;
8255 }
8256
8257
_wrap_WorldCoor_sysin_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8258 SWIGINTERN PyObject *_wrap_WorldCoor_sysin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8259 PyObject *resultobj = 0;
8260 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8261 void *argp1 = 0 ;
8262 int res1 = 0 ;
8263 PyObject *swig_obj[1] ;
8264 int result;
8265
8266 if (!args) SWIG_fail;
8267 swig_obj[0] = args;
8268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8269 if (!SWIG_IsOK(res1)) {
8270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_sysin_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8271 }
8272 arg1 = (struct WorldCoor *)(argp1);
8273 result = (int) ((arg1)->sysin);
8274 resultobj = SWIG_From_int((int)(result));
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
_wrap_WorldCoor_syswcs_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8281 SWIGINTERN PyObject *_wrap_WorldCoor_syswcs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8282 PyObject *resultobj = 0;
8283 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8284 int arg2 ;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 int val2 ;
8288 int ecode2 = 0 ;
8289 PyObject *swig_obj[2] ;
8290
8291 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_syswcs_set", 2, 2, swig_obj)) SWIG_fail;
8292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8293 if (!SWIG_IsOK(res1)) {
8294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_syswcs_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8295 }
8296 arg1 = (struct WorldCoor *)(argp1);
8297 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8298 if (!SWIG_IsOK(ecode2)) {
8299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_syswcs_set" "', argument " "2"" of type '" "int""'");
8300 }
8301 arg2 = (int)(val2);
8302 if (arg1) (arg1)->syswcs = arg2;
8303 resultobj = SWIG_Py_Void();
8304 return resultobj;
8305 fail:
8306 return NULL;
8307 }
8308
8309
_wrap_WorldCoor_syswcs_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8310 SWIGINTERN PyObject *_wrap_WorldCoor_syswcs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8311 PyObject *resultobj = 0;
8312 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8313 void *argp1 = 0 ;
8314 int res1 = 0 ;
8315 PyObject *swig_obj[1] ;
8316 int result;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_syswcs_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8323 }
8324 arg1 = (struct WorldCoor *)(argp1);
8325 result = (int) ((arg1)->syswcs);
8326 resultobj = SWIG_From_int((int)(result));
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
_wrap_WorldCoor_sysout_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8333 SWIGINTERN PyObject *_wrap_WorldCoor_sysout_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334 PyObject *resultobj = 0;
8335 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8336 int arg2 ;
8337 void *argp1 = 0 ;
8338 int res1 = 0 ;
8339 int val2 ;
8340 int ecode2 = 0 ;
8341 PyObject *swig_obj[2] ;
8342
8343 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_sysout_set", 2, 2, swig_obj)) SWIG_fail;
8344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8345 if (!SWIG_IsOK(res1)) {
8346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_sysout_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8347 }
8348 arg1 = (struct WorldCoor *)(argp1);
8349 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8350 if (!SWIG_IsOK(ecode2)) {
8351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_sysout_set" "', argument " "2"" of type '" "int""'");
8352 }
8353 arg2 = (int)(val2);
8354 if (arg1) (arg1)->sysout = arg2;
8355 resultobj = SWIG_Py_Void();
8356 return resultobj;
8357 fail:
8358 return NULL;
8359 }
8360
8361
_wrap_WorldCoor_sysout_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8362 SWIGINTERN PyObject *_wrap_WorldCoor_sysout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8363 PyObject *resultobj = 0;
8364 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8365 void *argp1 = 0 ;
8366 int res1 = 0 ;
8367 PyObject *swig_obj[1] ;
8368 int result;
8369
8370 if (!args) SWIG_fail;
8371 swig_obj[0] = args;
8372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8373 if (!SWIG_IsOK(res1)) {
8374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_sysout_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8375 }
8376 arg1 = (struct WorldCoor *)(argp1);
8377 result = (int) ((arg1)->sysout);
8378 resultobj = SWIG_From_int((int)(result));
8379 return resultobj;
8380 fail:
8381 return NULL;
8382 }
8383
8384
_wrap_WorldCoor_center_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8385 SWIGINTERN PyObject *_wrap_WorldCoor_center_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8386 PyObject *resultobj = 0;
8387 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8388 char *arg2 ;
8389 void *argp1 = 0 ;
8390 int res1 = 0 ;
8391 char temp2[32] ;
8392 int res2 ;
8393 PyObject *swig_obj[2] ;
8394
8395 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_center_set", 2, 2, swig_obj)) SWIG_fail;
8396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8397 if (!SWIG_IsOK(res1)) {
8398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_center_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8399 }
8400 arg1 = (struct WorldCoor *)(argp1);
8401 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 32);
8402 if (!SWIG_IsOK(res2)) {
8403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_center_set" "', argument " "2"" of type '" "char [32]""'");
8404 }
8405 arg2 = (char *)(temp2);
8406 if (arg2) memcpy(arg1->center,arg2,32*sizeof(char));
8407 else memset(arg1->center,0,32*sizeof(char));
8408 resultobj = SWIG_Py_Void();
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
_wrap_WorldCoor_center_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8415 SWIGINTERN PyObject *_wrap_WorldCoor_center_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8416 PyObject *resultobj = 0;
8417 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 PyObject *swig_obj[1] ;
8421 char *result = 0 ;
8422
8423 if (!args) SWIG_fail;
8424 swig_obj[0] = args;
8425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_center_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8428 }
8429 arg1 = (struct WorldCoor *)(argp1);
8430 result = (char *)(char *) ((arg1)->center);
8431 {
8432 size_t size = SWIG_strnlen(result, 32);
8433
8434
8435
8436 resultobj = SWIG_FromCharPtrAndSize(result, size);
8437 }
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
_wrap_WorldCoor_wcsl_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8444 SWIGINTERN PyObject *_wrap_WorldCoor_wcsl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8445 PyObject *resultobj = 0;
8446 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8447 struct wcsprm arg2 ;
8448 void *argp1 = 0 ;
8449 int res1 = 0 ;
8450 void *argp2 ;
8451 int res2 = 0 ;
8452 PyObject *swig_obj[2] ;
8453
8454 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcsl_set", 2, 2, swig_obj)) SWIG_fail;
8455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8456 if (!SWIG_IsOK(res1)) {
8457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsl_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8458 }
8459 arg1 = (struct WorldCoor *)(argp1);
8460 {
8461 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wcsprm, 0 );
8462 if (!SWIG_IsOK(res2)) {
8463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_wcsl_set" "', argument " "2"" of type '" "struct wcsprm""'");
8464 }
8465 if (!argp2) {
8466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WorldCoor_wcsl_set" "', argument " "2"" of type '" "struct wcsprm""'");
8467 } else {
8468 arg2 = *((struct wcsprm *)(argp2));
8469 }
8470 }
8471 if (arg1) (arg1)->wcsl = arg2;
8472 resultobj = SWIG_Py_Void();
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
_wrap_WorldCoor_wcsl_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8479 SWIGINTERN PyObject *_wrap_WorldCoor_wcsl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8480 PyObject *resultobj = 0;
8481 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8482 void *argp1 = 0 ;
8483 int res1 = 0 ;
8484 PyObject *swig_obj[1] ;
8485 struct wcsprm result;
8486
8487 if (!args) SWIG_fail;
8488 swig_obj[0] = args;
8489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8490 if (!SWIG_IsOK(res1)) {
8491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsl_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8492 }
8493 arg1 = (struct WorldCoor *)(argp1);
8494 result = ((arg1)->wcsl);
8495 resultobj = SWIG_NewPointerObj((struct wcsprm *)memcpy((struct wcsprm *)calloc(1,sizeof(struct wcsprm)),&result,sizeof(struct wcsprm)), SWIGTYPE_p_wcsprm, SWIG_POINTER_OWN | 0 );
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
_wrap_WorldCoor_lin_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8502 SWIGINTERN PyObject *_wrap_WorldCoor_lin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8505 struct linprm arg2 ;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 void *argp2 ;
8509 int res2 = 0 ;
8510 PyObject *swig_obj[2] ;
8511
8512 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_lin_set", 2, 2, swig_obj)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_lin_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8516 }
8517 arg1 = (struct WorldCoor *)(argp1);
8518 {
8519 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_linprm, 0 );
8520 if (!SWIG_IsOK(res2)) {
8521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_lin_set" "', argument " "2"" of type '" "struct linprm""'");
8522 }
8523 if (!argp2) {
8524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WorldCoor_lin_set" "', argument " "2"" of type '" "struct linprm""'");
8525 } else {
8526 arg2 = *((struct linprm *)(argp2));
8527 }
8528 }
8529 if (arg1) (arg1)->lin = arg2;
8530 resultobj = SWIG_Py_Void();
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
_wrap_WorldCoor_lin_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8537 SWIGINTERN PyObject *_wrap_WorldCoor_lin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8538 PyObject *resultobj = 0;
8539 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543 struct linprm result;
8544
8545 if (!args) SWIG_fail;
8546 swig_obj[0] = args;
8547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8548 if (!SWIG_IsOK(res1)) {
8549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_lin_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8550 }
8551 arg1 = (struct WorldCoor *)(argp1);
8552 result = ((arg1)->lin);
8553 resultobj = SWIG_NewPointerObj((struct linprm *)memcpy((struct linprm *)calloc(1,sizeof(struct linprm)),&result,sizeof(struct linprm)), SWIGTYPE_p_linprm, SWIG_POINTER_OWN | 0 );
8554 return resultobj;
8555 fail:
8556 return NULL;
8557 }
8558
8559
_wrap_WorldCoor_cel_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8560 SWIGINTERN PyObject *_wrap_WorldCoor_cel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8561 PyObject *resultobj = 0;
8562 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8563 struct celprm arg2 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 void *argp2 ;
8567 int res2 = 0 ;
8568 PyObject *swig_obj[2] ;
8569
8570 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_cel_set", 2, 2, swig_obj)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cel_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8574 }
8575 arg1 = (struct WorldCoor *)(argp1);
8576 {
8577 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_celprm, 0 );
8578 if (!SWIG_IsOK(res2)) {
8579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_cel_set" "', argument " "2"" of type '" "struct celprm""'");
8580 }
8581 if (!argp2) {
8582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WorldCoor_cel_set" "', argument " "2"" of type '" "struct celprm""'");
8583 } else {
8584 arg2 = *((struct celprm *)(argp2));
8585 }
8586 }
8587 if (arg1) (arg1)->cel = arg2;
8588 resultobj = SWIG_Py_Void();
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
_wrap_WorldCoor_cel_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8595 SWIGINTERN PyObject *_wrap_WorldCoor_cel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8596 PyObject *resultobj = 0;
8597 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8598 void *argp1 = 0 ;
8599 int res1 = 0 ;
8600 PyObject *swig_obj[1] ;
8601 struct celprm result;
8602
8603 if (!args) SWIG_fail;
8604 swig_obj[0] = args;
8605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_cel_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8608 }
8609 arg1 = (struct WorldCoor *)(argp1);
8610 result = ((arg1)->cel);
8611 resultobj = SWIG_NewPointerObj((struct celprm *)memcpy((struct celprm *)calloc(1,sizeof(struct celprm)),&result,sizeof(struct celprm)), SWIGTYPE_p_celprm, SWIG_POINTER_OWN | 0 );
8612 return resultobj;
8613 fail:
8614 return NULL;
8615 }
8616
8617
_wrap_WorldCoor_prj_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8618 SWIGINTERN PyObject *_wrap_WorldCoor_prj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8619 PyObject *resultobj = 0;
8620 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8621 struct prjprm arg2 ;
8622 void *argp1 = 0 ;
8623 int res1 = 0 ;
8624 void *argp2 ;
8625 int res2 = 0 ;
8626 PyObject *swig_obj[2] ;
8627
8628 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_prj_set", 2, 2, swig_obj)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_prj_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8632 }
8633 arg1 = (struct WorldCoor *)(argp1);
8634 {
8635 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_prjprm, 0 );
8636 if (!SWIG_IsOK(res2)) {
8637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_prj_set" "', argument " "2"" of type '" "struct prjprm""'");
8638 }
8639 if (!argp2) {
8640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WorldCoor_prj_set" "', argument " "2"" of type '" "struct prjprm""'");
8641 } else {
8642 arg2 = *((struct prjprm *)(argp2));
8643 }
8644 }
8645 if (arg1) (arg1)->prj = arg2;
8646 resultobj = SWIG_Py_Void();
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
_wrap_WorldCoor_prj_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8653 SWIGINTERN PyObject *_wrap_WorldCoor_prj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8654 PyObject *resultobj = 0;
8655 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 PyObject *swig_obj[1] ;
8659 struct prjprm result;
8660
8661 if (!args) SWIG_fail;
8662 swig_obj[0] = args;
8663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_prj_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8666 }
8667 arg1 = (struct WorldCoor *)(argp1);
8668 result = ((arg1)->prj);
8669 resultobj = SWIG_NewPointerObj((struct prjprm *)memcpy((struct prjprm *)calloc(1,sizeof(struct prjprm)),&result,sizeof(struct prjprm)), SWIGTYPE_p_prjprm, SWIG_POINTER_OWN | 0 );
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
_wrap_WorldCoor_lngcor_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8676 SWIGINTERN PyObject *_wrap_WorldCoor_lngcor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8677 PyObject *resultobj = 0;
8678 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8679 struct IRAFsurface *arg2 = (struct IRAFsurface *) 0 ;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 void *argp2 = 0 ;
8683 int res2 = 0 ;
8684 PyObject *swig_obj[2] ;
8685
8686 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_lngcor_set", 2, 2, swig_obj)) SWIG_fail;
8687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8688 if (!SWIG_IsOK(res1)) {
8689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_lngcor_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8690 }
8691 arg1 = (struct WorldCoor *)(argp1);
8692 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IRAFsurface, SWIG_POINTER_DISOWN | 0 );
8693 if (!SWIG_IsOK(res2)) {
8694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_lngcor_set" "', argument " "2"" of type '" "struct IRAFsurface *""'");
8695 }
8696 arg2 = (struct IRAFsurface *)(argp2);
8697 if (arg1) (arg1)->lngcor = arg2;
8698 resultobj = SWIG_Py_Void();
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
_wrap_WorldCoor_lngcor_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8705 SWIGINTERN PyObject *_wrap_WorldCoor_lngcor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8706 PyObject *resultobj = 0;
8707 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8708 void *argp1 = 0 ;
8709 int res1 = 0 ;
8710 PyObject *swig_obj[1] ;
8711 struct IRAFsurface *result = 0 ;
8712
8713 if (!args) SWIG_fail;
8714 swig_obj[0] = args;
8715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8716 if (!SWIG_IsOK(res1)) {
8717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_lngcor_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8718 }
8719 arg1 = (struct WorldCoor *)(argp1);
8720 result = (struct IRAFsurface *) ((arg1)->lngcor);
8721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IRAFsurface, 0 | 0 );
8722 return resultobj;
8723 fail:
8724 return NULL;
8725 }
8726
8727
_wrap_WorldCoor_latcor_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8728 SWIGINTERN PyObject *_wrap_WorldCoor_latcor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8729 PyObject *resultobj = 0;
8730 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8731 struct IRAFsurface *arg2 = (struct IRAFsurface *) 0 ;
8732 void *argp1 = 0 ;
8733 int res1 = 0 ;
8734 void *argp2 = 0 ;
8735 int res2 = 0 ;
8736 PyObject *swig_obj[2] ;
8737
8738 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_latcor_set", 2, 2, swig_obj)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latcor_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8742 }
8743 arg1 = (struct WorldCoor *)(argp1);
8744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IRAFsurface, SWIG_POINTER_DISOWN | 0 );
8745 if (!SWIG_IsOK(res2)) {
8746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_latcor_set" "', argument " "2"" of type '" "struct IRAFsurface *""'");
8747 }
8748 arg2 = (struct IRAFsurface *)(argp2);
8749 if (arg1) (arg1)->latcor = arg2;
8750 resultobj = SWIG_Py_Void();
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
_wrap_WorldCoor_latcor_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8757 SWIGINTERN PyObject *_wrap_WorldCoor_latcor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8758 PyObject *resultobj = 0;
8759 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763 struct IRAFsurface *result = 0 ;
8764
8765 if (!args) SWIG_fail;
8766 swig_obj[0] = args;
8767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_latcor_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8770 }
8771 arg1 = (struct WorldCoor *)(argp1);
8772 result = (struct IRAFsurface *) ((arg1)->latcor);
8773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IRAFsurface, 0 | 0 );
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
_wrap_WorldCoor_distcode_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8780 SWIGINTERN PyObject *_wrap_WorldCoor_distcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8781 PyObject *resultobj = 0;
8782 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8783 int arg2 ;
8784 void *argp1 = 0 ;
8785 int res1 = 0 ;
8786 int val2 ;
8787 int ecode2 = 0 ;
8788 PyObject *swig_obj[2] ;
8789
8790 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_distcode_set", 2, 2, swig_obj)) SWIG_fail;
8791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8792 if (!SWIG_IsOK(res1)) {
8793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_distcode_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8794 }
8795 arg1 = (struct WorldCoor *)(argp1);
8796 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8797 if (!SWIG_IsOK(ecode2)) {
8798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_distcode_set" "', argument " "2"" of type '" "int""'");
8799 }
8800 arg2 = (int)(val2);
8801 if (arg1) (arg1)->distcode = arg2;
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
_wrap_WorldCoor_distcode_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8809 SWIGINTERN PyObject *_wrap_WorldCoor_distcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8810 PyObject *resultobj = 0;
8811 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8812 void *argp1 = 0 ;
8813 int res1 = 0 ;
8814 PyObject *swig_obj[1] ;
8815 int result;
8816
8817 if (!args) SWIG_fail;
8818 swig_obj[0] = args;
8819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8820 if (!SWIG_IsOK(res1)) {
8821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_distcode_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8822 }
8823 arg1 = (struct WorldCoor *)(argp1);
8824 result = (int) ((arg1)->distcode);
8825 resultobj = SWIG_From_int((int)(result));
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
_wrap_WorldCoor_distort_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8832 SWIGINTERN PyObject *_wrap_WorldCoor_distort_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8833 PyObject *resultobj = 0;
8834 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8835 struct Distort arg2 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 void *argp2 ;
8839 int res2 = 0 ;
8840 PyObject *swig_obj[2] ;
8841
8842 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_distort_set", 2, 2, swig_obj)) SWIG_fail;
8843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8844 if (!SWIG_IsOK(res1)) {
8845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_distort_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8846 }
8847 arg1 = (struct WorldCoor *)(argp1);
8848 {
8849 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Distort, 0 );
8850 if (!SWIG_IsOK(res2)) {
8851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_distort_set" "', argument " "2"" of type '" "struct Distort""'");
8852 }
8853 if (!argp2) {
8854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WorldCoor_distort_set" "', argument " "2"" of type '" "struct Distort""'");
8855 } else {
8856 arg2 = *((struct Distort *)(argp2));
8857 }
8858 }
8859 if (arg1) (arg1)->distort = arg2;
8860 resultobj = SWIG_Py_Void();
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
_wrap_WorldCoor_distort_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8867 SWIGINTERN PyObject *_wrap_WorldCoor_distort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *resultobj = 0;
8869 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8870 void *argp1 = 0 ;
8871 int res1 = 0 ;
8872 PyObject *swig_obj[1] ;
8873 struct Distort result;
8874
8875 if (!args) SWIG_fail;
8876 swig_obj[0] = args;
8877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8878 if (!SWIG_IsOK(res1)) {
8879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_distort_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8880 }
8881 arg1 = (struct WorldCoor *)(argp1);
8882 result = ((arg1)->distort);
8883 resultobj = SWIG_NewPointerObj((struct Distort *)memcpy((struct Distort *)calloc(1,sizeof(struct Distort)),&result,sizeof(struct Distort)), SWIGTYPE_p_Distort, SWIG_POINTER_OWN | 0 );
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
_wrap_WorldCoor_command_format_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8890 SWIGINTERN PyObject *_wrap_WorldCoor_command_format_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891 PyObject *resultobj = 0;
8892 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8893 char **arg2 ;
8894 void *argp1 = 0 ;
8895 int res1 = 0 ;
8896 void *argp2 = 0 ;
8897 int res2 = 0 ;
8898 PyObject *swig_obj[2] ;
8899
8900 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_command_format_set", 2, 2, swig_obj)) SWIG_fail;
8901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8902 if (!SWIG_IsOK(res1)) {
8903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_command_format_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8904 }
8905 arg1 = (struct WorldCoor *)(argp1);
8906 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
8907 if (!SWIG_IsOK(res2)) {
8908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_command_format_set" "', argument " "2"" of type '" "char *[10]""'");
8909 }
8910 arg2 = (char **)(argp2);
8911 {
8912 if (arg2) {
8913 size_t ii = 0;
8914 for (; ii < (size_t)10; ++ii) *(char * *)&arg1->command_format[ii] = *((char * *)arg2 + ii);
8915 } else {
8916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""command_format""' of type '""char *[10]""'");
8917 }
8918 }
8919 resultobj = SWIG_Py_Void();
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
_wrap_WorldCoor_command_format_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8926 SWIGINTERN PyObject *_wrap_WorldCoor_command_format_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *resultobj = 0;
8928 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8929 void *argp1 = 0 ;
8930 int res1 = 0 ;
8931 PyObject *swig_obj[1] ;
8932 char **result = 0 ;
8933
8934 if (!args) SWIG_fail;
8935 swig_obj[0] = args;
8936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8937 if (!SWIG_IsOK(res1)) {
8938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_command_format_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8939 }
8940 arg1 = (struct WorldCoor *)(argp1);
8941 result = (char **)(char **) ((arg1)->command_format);
8942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 );
8943 return resultobj;
8944 fail:
8945 return NULL;
8946 }
8947
8948
_wrap_WorldCoor_ltm_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8949 SWIGINTERN PyObject *_wrap_WorldCoor_ltm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8950 PyObject *resultobj = 0;
8951 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8952 double *arg2 ;
8953 void *argp1 = 0 ;
8954 int res1 = 0 ;
8955 void *argp2 = 0 ;
8956 int res2 = 0 ;
8957 PyObject *swig_obj[2] ;
8958
8959 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ltm_set", 2, 2, swig_obj)) SWIG_fail;
8960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ltm_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
8963 }
8964 arg1 = (struct WorldCoor *)(argp1);
8965 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
8966 if (!SWIG_IsOK(res2)) {
8967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ltm_set" "', argument " "2"" of type '" "double [4]""'");
8968 }
8969 arg2 = (double *)(argp2);
8970 {
8971 if (arg2) {
8972 size_t ii = 0;
8973 for (; ii < (size_t)4; ++ii) *(double *)&arg1->ltm[ii] = *((double *)arg2 + ii);
8974 } else {
8975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ltm""' of type '""double [4]""'");
8976 }
8977 }
8978 resultobj = SWIG_Py_Void();
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
_wrap_WorldCoor_ltm_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)8985 SWIGINTERN PyObject *_wrap_WorldCoor_ltm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *resultobj = 0;
8987 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
8988 void *argp1 = 0 ;
8989 int res1 = 0 ;
8990 PyObject *swig_obj[1] ;
8991 double *result = 0 ;
8992
8993 if (!args) SWIG_fail;
8994 swig_obj[0] = args;
8995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
8996 if (!SWIG_IsOK(res1)) {
8997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ltm_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
8998 }
8999 arg1 = (struct WorldCoor *)(argp1);
9000 result = (double *)(double *) ((arg1)->ltm);
9001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
_wrap_WorldCoor_ltv_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9008 SWIGINTERN PyObject *_wrap_WorldCoor_ltv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9009 PyObject *resultobj = 0;
9010 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9011 double *arg2 ;
9012 void *argp1 = 0 ;
9013 int res1 = 0 ;
9014 void *argp2 = 0 ;
9015 int res2 = 0 ;
9016 PyObject *swig_obj[2] ;
9017
9018 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ltv_set", 2, 2, swig_obj)) SWIG_fail;
9019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9020 if (!SWIG_IsOK(res1)) {
9021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ltv_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9022 }
9023 arg1 = (struct WorldCoor *)(argp1);
9024 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
9025 if (!SWIG_IsOK(res2)) {
9026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ltv_set" "', argument " "2"" of type '" "double [2]""'");
9027 }
9028 arg2 = (double *)(argp2);
9029 {
9030 if (arg2) {
9031 size_t ii = 0;
9032 for (; ii < (size_t)2; ++ii) *(double *)&arg1->ltv[ii] = *((double *)arg2 + ii);
9033 } else {
9034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ltv""' of type '""double [2]""'");
9035 }
9036 }
9037 resultobj = SWIG_Py_Void();
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
_wrap_WorldCoor_ltv_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9044 SWIGINTERN PyObject *_wrap_WorldCoor_ltv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 PyObject *swig_obj[1] ;
9050 double *result = 0 ;
9051
9052 if (!args) SWIG_fail;
9053 swig_obj[0] = args;
9054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ltv_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9057 }
9058 arg1 = (struct WorldCoor *)(argp1);
9059 result = (double *)(double *) ((arg1)->ltv);
9060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
_wrap_WorldCoor_idpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9067 SWIGINTERN PyObject *_wrap_WorldCoor_idpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9068 PyObject *resultobj = 0;
9069 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9070 int *arg2 ;
9071 void *argp1 = 0 ;
9072 int res1 = 0 ;
9073 void *argp2 = 0 ;
9074 int res2 = 0 ;
9075 PyObject *swig_obj[2] ;
9076
9077 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_idpix_set", 2, 2, swig_obj)) SWIG_fail;
9078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9079 if (!SWIG_IsOK(res1)) {
9080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_idpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9081 }
9082 arg1 = (struct WorldCoor *)(argp1);
9083 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
9084 if (!SWIG_IsOK(res2)) {
9085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_idpix_set" "', argument " "2"" of type '" "int [2]""'");
9086 }
9087 arg2 = (int *)(argp2);
9088 {
9089 if (arg2) {
9090 size_t ii = 0;
9091 for (; ii < (size_t)2; ++ii) *(int *)&arg1->idpix[ii] = *((int *)arg2 + ii);
9092 } else {
9093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""idpix""' of type '""int [2]""'");
9094 }
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
_wrap_WorldCoor_idpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9103 SWIGINTERN PyObject *_wrap_WorldCoor_idpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109 int *result = 0 ;
9110
9111 if (!args) SWIG_fail;
9112 swig_obj[0] = args;
9113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9114 if (!SWIG_IsOK(res1)) {
9115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_idpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9116 }
9117 arg1 = (struct WorldCoor *)(argp1);
9118 result = (int *)(int *) ((arg1)->idpix);
9119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
_wrap_WorldCoor_ndpix_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9126 SWIGINTERN PyObject *_wrap_WorldCoor_ndpix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9127 PyObject *resultobj = 0;
9128 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9129 int *arg2 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 void *argp2 = 0 ;
9133 int res2 = 0 ;
9134 PyObject *swig_obj[2] ;
9135
9136 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_ndpix_set", 2, 2, swig_obj)) SWIG_fail;
9137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9138 if (!SWIG_IsOK(res1)) {
9139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ndpix_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9140 }
9141 arg1 = (struct WorldCoor *)(argp1);
9142 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
9143 if (!SWIG_IsOK(res2)) {
9144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_ndpix_set" "', argument " "2"" of type '" "int [2]""'");
9145 }
9146 arg2 = (int *)(argp2);
9147 {
9148 if (arg2) {
9149 size_t ii = 0;
9150 for (; ii < (size_t)2; ++ii) *(int *)&arg1->ndpix[ii] = *((int *)arg2 + ii);
9151 } else {
9152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ndpix""' of type '""int [2]""'");
9153 }
9154 }
9155 resultobj = SWIG_Py_Void();
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
_wrap_WorldCoor_ndpix_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9162 SWIGINTERN PyObject *_wrap_WorldCoor_ndpix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9163 PyObject *resultobj = 0;
9164 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 PyObject *swig_obj[1] ;
9168 int *result = 0 ;
9169
9170 if (!args) SWIG_fail;
9171 swig_obj[0] = args;
9172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9173 if (!SWIG_IsOK(res1)) {
9174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_ndpix_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9175 }
9176 arg1 = (struct WorldCoor *)(argp1);
9177 result = (int *)(int *) ((arg1)->ndpix);
9178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
_wrap_WorldCoor_wcs_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9185 SWIGINTERN PyObject *_wrap_WorldCoor_wcs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9186 PyObject *resultobj = 0;
9187 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9188 struct WorldCoor *arg2 = (struct WorldCoor *) 0 ;
9189 void *argp1 = 0 ;
9190 int res1 = 0 ;
9191 void *argp2 = 0 ;
9192 int res2 = 0 ;
9193 PyObject *swig_obj[2] ;
9194
9195 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcs_set", 2, 2, swig_obj)) SWIG_fail;
9196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9197 if (!SWIG_IsOK(res1)) {
9198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcs_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9199 }
9200 arg1 = (struct WorldCoor *)(argp1);
9201 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_WorldCoor, SWIG_POINTER_DISOWN | 0 );
9202 if (!SWIG_IsOK(res2)) {
9203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_wcs_set" "', argument " "2"" of type '" "struct WorldCoor *""'");
9204 }
9205 arg2 = (struct WorldCoor *)(argp2);
9206 if (arg1) (arg1)->wcs = arg2;
9207 resultobj = SWIG_Py_Void();
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
_wrap_WorldCoor_wcs_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9214 SWIGINTERN PyObject *_wrap_WorldCoor_wcs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 PyObject *resultobj = 0;
9216 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9217 void *argp1 = 0 ;
9218 int res1 = 0 ;
9219 PyObject *swig_obj[1] ;
9220 struct WorldCoor *result = 0 ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcs_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9227 }
9228 arg1 = (struct WorldCoor *)(argp1);
9229 result = (struct WorldCoor *) ((arg1)->wcs);
9230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, 0 | 0 );
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
_wrap_WorldCoor_wcsdep_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9237 SWIGINTERN PyObject *_wrap_WorldCoor_wcsdep_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9240 struct WorldCoor *arg2 = (struct WorldCoor *) 0 ;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 void *argp2 = 0 ;
9244 int res2 = 0 ;
9245 PyObject *swig_obj[2] ;
9246
9247 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcsdep_set", 2, 2, swig_obj)) SWIG_fail;
9248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9249 if (!SWIG_IsOK(res1)) {
9250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsdep_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9251 }
9252 arg1 = (struct WorldCoor *)(argp1);
9253 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_WorldCoor, SWIG_POINTER_DISOWN | 0 );
9254 if (!SWIG_IsOK(res2)) {
9255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_wcsdep_set" "', argument " "2"" of type '" "struct WorldCoor *""'");
9256 }
9257 arg2 = (struct WorldCoor *)(argp2);
9258 if (arg1) (arg1)->wcsdep = arg2;
9259 resultobj = SWIG_Py_Void();
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
_wrap_WorldCoor_wcsdep_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9266 SWIGINTERN PyObject *_wrap_WorldCoor_wcsdep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9269 void *argp1 = 0 ;
9270 int res1 = 0 ;
9271 PyObject *swig_obj[1] ;
9272 struct WorldCoor *result = 0 ;
9273
9274 if (!args) SWIG_fail;
9275 swig_obj[0] = args;
9276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9277 if (!SWIG_IsOK(res1)) {
9278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsdep_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9279 }
9280 arg1 = (struct WorldCoor *)(argp1);
9281 result = (struct WorldCoor *) ((arg1)->wcsdep);
9282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, 0 | 0 );
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
_wrap_WorldCoor_wcsname_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9289 SWIGINTERN PyObject *_wrap_WorldCoor_wcsname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9290 PyObject *resultobj = 0;
9291 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9292 char *arg2 = (char *) 0 ;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 int res2 ;
9296 char *buf2 = 0 ;
9297 int alloc2 = 0 ;
9298 PyObject *swig_obj[2] ;
9299
9300 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcsname_set", 2, 2, swig_obj)) SWIG_fail;
9301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsname_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9304 }
9305 arg1 = (struct WorldCoor *)(argp1);
9306 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
9307 if (!SWIG_IsOK(res2)) {
9308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WorldCoor_wcsname_set" "', argument " "2"" of type '" "char *""'");
9309 }
9310 arg2 = (char *)(buf2);
9311 if (arg1->wcsname) free((char*)arg1->wcsname);
9312 if (arg2) {
9313 size_t size = strlen((const char *)(arg2)) + 1;
9314 arg1->wcsname = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9315 } else {
9316 arg1->wcsname = 0;
9317 }
9318 resultobj = SWIG_Py_Void();
9319 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9320 return resultobj;
9321 fail:
9322 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9323 return NULL;
9324 }
9325
9326
_wrap_WorldCoor_wcsname_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9327 SWIGINTERN PyObject *_wrap_WorldCoor_wcsname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 PyObject *swig_obj[1] ;
9333 char *result = 0 ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcsname_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9340 }
9341 arg1 = (struct WorldCoor *)(argp1);
9342 result = (char *) ((arg1)->wcsname);
9343 resultobj = SWIG_FromCharPtr((const char *)result);
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
_wrap_WorldCoor_wcschar_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9350 SWIGINTERN PyObject *_wrap_WorldCoor_wcschar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9351 PyObject *resultobj = 0;
9352 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9353 char arg2 ;
9354 void *argp1 = 0 ;
9355 int res1 = 0 ;
9356 char val2 ;
9357 int ecode2 = 0 ;
9358 PyObject *swig_obj[2] ;
9359
9360 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_wcschar_set", 2, 2, swig_obj)) SWIG_fail;
9361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9362 if (!SWIG_IsOK(res1)) {
9363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcschar_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9364 }
9365 arg1 = (struct WorldCoor *)(argp1);
9366 ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
9367 if (!SWIG_IsOK(ecode2)) {
9368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_wcschar_set" "', argument " "2"" of type '" "char""'");
9369 }
9370 arg2 = (char)(val2);
9371 if (arg1) (arg1)->wcschar = arg2;
9372 resultobj = SWIG_Py_Void();
9373 return resultobj;
9374 fail:
9375 return NULL;
9376 }
9377
9378
_wrap_WorldCoor_wcschar_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9379 SWIGINTERN PyObject *_wrap_WorldCoor_wcschar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 PyObject *resultobj = 0;
9381 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9382 void *argp1 = 0 ;
9383 int res1 = 0 ;
9384 PyObject *swig_obj[1] ;
9385 char result;
9386
9387 if (!args) SWIG_fail;
9388 swig_obj[0] = args;
9389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9390 if (!SWIG_IsOK(res1)) {
9391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_wcschar_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9392 }
9393 arg1 = (struct WorldCoor *)(argp1);
9394 result = (char) ((arg1)->wcschar);
9395 resultobj = SWIG_From_char((char)(result));
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
_wrap_WorldCoor_logwcs_set(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9402 SWIGINTERN PyObject *_wrap_WorldCoor_logwcs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9403 PyObject *resultobj = 0;
9404 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9405 int arg2 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 int val2 ;
9409 int ecode2 = 0 ;
9410 PyObject *swig_obj[2] ;
9411
9412 if (!SWIG_Python_UnpackTuple(args, "WorldCoor_logwcs_set", 2, 2, swig_obj)) SWIG_fail;
9413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_logwcs_set" "', argument " "1"" of type '" "struct WorldCoor *""'");
9416 }
9417 arg1 = (struct WorldCoor *)(argp1);
9418 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WorldCoor_logwcs_set" "', argument " "2"" of type '" "int""'");
9421 }
9422 arg2 = (int)(val2);
9423 if (arg1) (arg1)->logwcs = arg2;
9424 resultobj = SWIG_Py_Void();
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
_wrap_WorldCoor_logwcs_get(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9431 SWIGINTERN PyObject *_wrap_WorldCoor_logwcs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9432 PyObject *resultobj = 0;
9433 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 PyObject *swig_obj[1] ;
9437 int result;
9438
9439 if (!args) SWIG_fail;
9440 swig_obj[0] = args;
9441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, 0 | 0 );
9442 if (!SWIG_IsOK(res1)) {
9443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WorldCoor_logwcs_get" "', argument " "1"" of type '" "struct WorldCoor *""'");
9444 }
9445 arg1 = (struct WorldCoor *)(argp1);
9446 result = (int) ((arg1)->logwcs);
9447 resultobj = SWIG_From_int((int)(result));
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
_wrap_new_WorldCoor(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9454 SWIGINTERN PyObject *_wrap_new_WorldCoor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9455 PyObject *resultobj = 0;
9456 struct WorldCoor *result = 0 ;
9457
9458 if (!SWIG_Python_UnpackTuple(args, "new_WorldCoor", 0, 0, 0)) SWIG_fail;
9459 result = (struct WorldCoor *)calloc(1, sizeof(struct WorldCoor));
9460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WorldCoor, SWIG_POINTER_NEW | 0 );
9461 return resultobj;
9462 fail:
9463 return NULL;
9464 }
9465
9466
_wrap_delete_WorldCoor(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9467 SWIGINTERN PyObject *_wrap_delete_WorldCoor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9468 PyObject *resultobj = 0;
9469 struct WorldCoor *arg1 = (struct WorldCoor *) 0 ;
9470 void *argp1 = 0 ;
9471 int res1 = 0 ;
9472 PyObject *swig_obj[1] ;
9473
9474 if (!args) SWIG_fail;
9475 swig_obj[0] = args;
9476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_WorldCoor, SWIG_POINTER_DISOWN | 0 );
9477 if (!SWIG_IsOK(res1)) {
9478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WorldCoor" "', argument " "1"" of type '" "struct WorldCoor *""'");
9479 }
9480 arg1 = (struct WorldCoor *)(argp1);
9481 free((char *) arg1);
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
WorldCoor_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9489 SWIGINTERN PyObject *WorldCoor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *obj;
9491 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
9492 SWIG_TypeNewClientData(SWIGTYPE_p_WorldCoor, SWIG_NewClientData(obj));
9493 return SWIG_Py_Void();
9494 }
9495
WorldCoor_swiginit(PyObject * SWIGUNUSEDPARM (self),PyObject * args)9496 SWIGINTERN PyObject *WorldCoor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9497 return SWIG_Python_InitShadowInstance(args);
9498 }
9499
9500 static PyMethodDef SwigMethods[] = {
9501 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
9502 { "new_doubleArray", _wrap_new_doubleArray, METH_O, "new_doubleArray(nelements) -> double *"},
9503 { "delete_doubleArray", _wrap_delete_doubleArray, METH_O, "delete_doubleArray(ary)"},
9504 { "doubleArray_getitem", _wrap_doubleArray_getitem, METH_VARARGS, "doubleArray_getitem(ary, index) -> double"},
9505 { "doubleArray_setitem", _wrap_doubleArray_setitem, METH_VARARGS, "doubleArray_setitem(ary, index, value)"},
9506 { "wcsinit", _wrap_wcsinit, METH_O, "wcsinit(hstring) -> WorldCoor"},
9507 { "wcsxinit", _wrap_wcsxinit, METH_VARARGS, "wcsxinit(cra, cdec, secpix, xrpix, yrpix, nxpix, nypix, rotate, equinox, epoch, proj) -> WorldCoor"},
9508 { "wcskinit", _wrap_wcskinit, METH_VARARGS, "wcskinit(nxpix, nypix, ctype1, ctype2, crpix1, crpix2, crval1, crval2, cd, cdelt1, cdelt2, crota, equinox, epoch) -> WorldCoor"},
9509 { "iswcs", _wrap_iswcs, METH_O, "iswcs(wcs) -> int"},
9510 { "nowcs", _wrap_nowcs, METH_O, "nowcs(wcs) -> int"},
9511 { "wcs2pix", _wrap_wcs2pix, METH_VARARGS, "wcs2pix(wcs, xpos, ypos)"},
9512 { "pix2wcs", _wrap_pix2wcs, METH_VARARGS, "pix2wcs(wcs, xpix, ypix)"},
9513 { "wcscent", _wrap_wcscent, METH_O, "wcscent(wcs)"},
9514 { "getradecsys", _wrap_getradecsys, METH_O, "getradecsys(wcs) -> char *"},
9515 { "wcsoutinit", _wrap_wcsoutinit, METH_VARARGS, "wcsoutinit(wcs, coorsys)"},
9516 { "wcsininit", _wrap_wcsininit, METH_VARARGS, "wcsininit(wcs, coorsys)"},
9517 { "getwcsout", _wrap_getwcsout, METH_O, "getwcsout(wcs) -> char *"},
9518 { "getwcsin", _wrap_getwcsin, METH_O, "getwcsin(wcs) -> char *"},
9519 { "wcssize", _wrap_wcssize, METH_O, "wcssize(wcs)"},
9520 { "wcsfull", _wrap_wcsfull, METH_O, "wcsfull(wcs)"},
9521 { "WorldCoor_xref_set", _wrap_WorldCoor_xref_set, METH_VARARGS, "WorldCoor_xref_set(self, xref)"},
9522 { "WorldCoor_xref_get", _wrap_WorldCoor_xref_get, METH_O, "WorldCoor_xref_get(self) -> double"},
9523 { "WorldCoor_yref_set", _wrap_WorldCoor_yref_set, METH_VARARGS, "WorldCoor_yref_set(self, yref)"},
9524 { "WorldCoor_yref_get", _wrap_WorldCoor_yref_get, METH_O, "WorldCoor_yref_get(self) -> double"},
9525 { "WorldCoor_xrefpix_set", _wrap_WorldCoor_xrefpix_set, METH_VARARGS, "WorldCoor_xrefpix_set(self, xrefpix)"},
9526 { "WorldCoor_xrefpix_get", _wrap_WorldCoor_xrefpix_get, METH_O, "WorldCoor_xrefpix_get(self) -> double"},
9527 { "WorldCoor_yrefpix_set", _wrap_WorldCoor_yrefpix_set, METH_VARARGS, "WorldCoor_yrefpix_set(self, yrefpix)"},
9528 { "WorldCoor_yrefpix_get", _wrap_WorldCoor_yrefpix_get, METH_O, "WorldCoor_yrefpix_get(self) -> double"},
9529 { "WorldCoor_xinc_set", _wrap_WorldCoor_xinc_set, METH_VARARGS, "WorldCoor_xinc_set(self, xinc)"},
9530 { "WorldCoor_xinc_get", _wrap_WorldCoor_xinc_get, METH_O, "WorldCoor_xinc_get(self) -> double"},
9531 { "WorldCoor_yinc_set", _wrap_WorldCoor_yinc_set, METH_VARARGS, "WorldCoor_yinc_set(self, yinc)"},
9532 { "WorldCoor_yinc_get", _wrap_WorldCoor_yinc_get, METH_O, "WorldCoor_yinc_get(self) -> double"},
9533 { "WorldCoor_rot_set", _wrap_WorldCoor_rot_set, METH_VARARGS, "WorldCoor_rot_set(self, rot)"},
9534 { "WorldCoor_rot_get", _wrap_WorldCoor_rot_get, METH_O, "WorldCoor_rot_get(self) -> double"},
9535 { "WorldCoor_cd_set", _wrap_WorldCoor_cd_set, METH_VARARGS, "WorldCoor_cd_set(self, cd)"},
9536 { "WorldCoor_cd_get", _wrap_WorldCoor_cd_get, METH_O, "WorldCoor_cd_get(self) -> double [4]"},
9537 { "WorldCoor_dc_set", _wrap_WorldCoor_dc_set, METH_VARARGS, "WorldCoor_dc_set(self, dc)"},
9538 { "WorldCoor_dc_get", _wrap_WorldCoor_dc_get, METH_O, "WorldCoor_dc_get(self) -> double [4]"},
9539 { "WorldCoor_equinox_set", _wrap_WorldCoor_equinox_set, METH_VARARGS, "WorldCoor_equinox_set(self, equinox)"},
9540 { "WorldCoor_equinox_get", _wrap_WorldCoor_equinox_get, METH_O, "WorldCoor_equinox_get(self) -> double"},
9541 { "WorldCoor_epoch_set", _wrap_WorldCoor_epoch_set, METH_VARARGS, "WorldCoor_epoch_set(self, epoch)"},
9542 { "WorldCoor_epoch_get", _wrap_WorldCoor_epoch_get, METH_O, "WorldCoor_epoch_get(self) -> double"},
9543 { "WorldCoor_nxpix_set", _wrap_WorldCoor_nxpix_set, METH_VARARGS, "WorldCoor_nxpix_set(self, nxpix)"},
9544 { "WorldCoor_nxpix_get", _wrap_WorldCoor_nxpix_get, METH_O, "WorldCoor_nxpix_get(self) -> double"},
9545 { "WorldCoor_nypix_set", _wrap_WorldCoor_nypix_set, METH_VARARGS, "WorldCoor_nypix_set(self, nypix)"},
9546 { "WorldCoor_nypix_get", _wrap_WorldCoor_nypix_get, METH_O, "WorldCoor_nypix_get(self) -> double"},
9547 { "WorldCoor_plate_ra_set", _wrap_WorldCoor_plate_ra_set, METH_VARARGS, "WorldCoor_plate_ra_set(self, plate_ra)"},
9548 { "WorldCoor_plate_ra_get", _wrap_WorldCoor_plate_ra_get, METH_O, "WorldCoor_plate_ra_get(self) -> double"},
9549 { "WorldCoor_plate_dec_set", _wrap_WorldCoor_plate_dec_set, METH_VARARGS, "WorldCoor_plate_dec_set(self, plate_dec)"},
9550 { "WorldCoor_plate_dec_get", _wrap_WorldCoor_plate_dec_get, METH_O, "WorldCoor_plate_dec_get(self) -> double"},
9551 { "WorldCoor_plate_scale_set", _wrap_WorldCoor_plate_scale_set, METH_VARARGS, "WorldCoor_plate_scale_set(self, plate_scale)"},
9552 { "WorldCoor_plate_scale_get", _wrap_WorldCoor_plate_scale_get, METH_O, "WorldCoor_plate_scale_get(self) -> double"},
9553 { "WorldCoor_x_pixel_offset_set", _wrap_WorldCoor_x_pixel_offset_set, METH_VARARGS, "WorldCoor_x_pixel_offset_set(self, x_pixel_offset)"},
9554 { "WorldCoor_x_pixel_offset_get", _wrap_WorldCoor_x_pixel_offset_get, METH_O, "WorldCoor_x_pixel_offset_get(self) -> double"},
9555 { "WorldCoor_y_pixel_offset_set", _wrap_WorldCoor_y_pixel_offset_set, METH_VARARGS, "WorldCoor_y_pixel_offset_set(self, y_pixel_offset)"},
9556 { "WorldCoor_y_pixel_offset_get", _wrap_WorldCoor_y_pixel_offset_get, METH_O, "WorldCoor_y_pixel_offset_get(self) -> double"},
9557 { "WorldCoor_x_pixel_size_set", _wrap_WorldCoor_x_pixel_size_set, METH_VARARGS, "WorldCoor_x_pixel_size_set(self, x_pixel_size)"},
9558 { "WorldCoor_x_pixel_size_get", _wrap_WorldCoor_x_pixel_size_get, METH_O, "WorldCoor_x_pixel_size_get(self) -> double"},
9559 { "WorldCoor_y_pixel_size_set", _wrap_WorldCoor_y_pixel_size_set, METH_VARARGS, "WorldCoor_y_pixel_size_set(self, y_pixel_size)"},
9560 { "WorldCoor_y_pixel_size_get", _wrap_WorldCoor_y_pixel_size_get, METH_O, "WorldCoor_y_pixel_size_get(self) -> double"},
9561 { "WorldCoor_ppo_coeff_set", _wrap_WorldCoor_ppo_coeff_set, METH_VARARGS, "WorldCoor_ppo_coeff_set(self, ppo_coeff)"},
9562 { "WorldCoor_ppo_coeff_get", _wrap_WorldCoor_ppo_coeff_get, METH_O, "WorldCoor_ppo_coeff_get(self) -> double [6]"},
9563 { "WorldCoor_x_coeff_set", _wrap_WorldCoor_x_coeff_set, METH_VARARGS, "WorldCoor_x_coeff_set(self, x_coeff)"},
9564 { "WorldCoor_x_coeff_get", _wrap_WorldCoor_x_coeff_get, METH_O, "WorldCoor_x_coeff_get(self) -> double [20]"},
9565 { "WorldCoor_y_coeff_set", _wrap_WorldCoor_y_coeff_set, METH_VARARGS, "WorldCoor_y_coeff_set(self, y_coeff)"},
9566 { "WorldCoor_y_coeff_get", _wrap_WorldCoor_y_coeff_get, METH_O, "WorldCoor_y_coeff_get(self) -> double [20]"},
9567 { "WorldCoor_xpix_set", _wrap_WorldCoor_xpix_set, METH_VARARGS, "WorldCoor_xpix_set(self, xpix)"},
9568 { "WorldCoor_xpix_get", _wrap_WorldCoor_xpix_get, METH_O, "WorldCoor_xpix_get(self) -> double"},
9569 { "WorldCoor_ypix_set", _wrap_WorldCoor_ypix_set, METH_VARARGS, "WorldCoor_ypix_set(self, ypix)"},
9570 { "WorldCoor_ypix_get", _wrap_WorldCoor_ypix_get, METH_O, "WorldCoor_ypix_get(self) -> double"},
9571 { "WorldCoor_zpix_set", _wrap_WorldCoor_zpix_set, METH_VARARGS, "WorldCoor_zpix_set(self, zpix)"},
9572 { "WorldCoor_zpix_get", _wrap_WorldCoor_zpix_get, METH_O, "WorldCoor_zpix_get(self) -> double"},
9573 { "WorldCoor_xpos_set", _wrap_WorldCoor_xpos_set, METH_VARARGS, "WorldCoor_xpos_set(self, xpos)"},
9574 { "WorldCoor_xpos_get", _wrap_WorldCoor_xpos_get, METH_O, "WorldCoor_xpos_get(self) -> double"},
9575 { "WorldCoor_ypos_set", _wrap_WorldCoor_ypos_set, METH_VARARGS, "WorldCoor_ypos_set(self, ypos)"},
9576 { "WorldCoor_ypos_get", _wrap_WorldCoor_ypos_get, METH_O, "WorldCoor_ypos_get(self) -> double"},
9577 { "WorldCoor_crpix_set", _wrap_WorldCoor_crpix_set, METH_VARARGS, "WorldCoor_crpix_set(self, crpix)"},
9578 { "WorldCoor_crpix_get", _wrap_WorldCoor_crpix_get, METH_O, "WorldCoor_crpix_get(self) -> double [9]"},
9579 { "WorldCoor_crval_set", _wrap_WorldCoor_crval_set, METH_VARARGS, "WorldCoor_crval_set(self, crval)"},
9580 { "WorldCoor_crval_get", _wrap_WorldCoor_crval_get, METH_O, "WorldCoor_crval_get(self) -> double [9]"},
9581 { "WorldCoor_cdelt_set", _wrap_WorldCoor_cdelt_set, METH_VARARGS, "WorldCoor_cdelt_set(self, cdelt)"},
9582 { "WorldCoor_cdelt_get", _wrap_WorldCoor_cdelt_get, METH_O, "WorldCoor_cdelt_get(self) -> double [9]"},
9583 { "WorldCoor_pc_set", _wrap_WorldCoor_pc_set, METH_VARARGS, "WorldCoor_pc_set(self, pc)"},
9584 { "WorldCoor_pc_get", _wrap_WorldCoor_pc_get, METH_O, "WorldCoor_pc_get(self) -> double [81]"},
9585 { "WorldCoor_projp_set", _wrap_WorldCoor_projp_set, METH_VARARGS, "WorldCoor_projp_set(self, projp)"},
9586 { "WorldCoor_projp_get", _wrap_WorldCoor_projp_get, METH_O, "WorldCoor_projp_get(self) -> double [10]"},
9587 { "WorldCoor_pvfail_set", _wrap_WorldCoor_pvfail_set, METH_VARARGS, "WorldCoor_pvfail_set(self, pvfail)"},
9588 { "WorldCoor_pvfail_get", _wrap_WorldCoor_pvfail_get, METH_O, "WorldCoor_pvfail_get(self) -> int"},
9589 { "WorldCoor_projppv_set", _wrap_WorldCoor_projppv_set, METH_VARARGS, "WorldCoor_projppv_set(self, projppv)"},
9590 { "WorldCoor_projppv_get", _wrap_WorldCoor_projppv_get, METH_O, "WorldCoor_projppv_get(self) -> double [2*MAXPV]"},
9591 { "WorldCoor_inv_x_set", _wrap_WorldCoor_inv_x_set, METH_VARARGS, "WorldCoor_inv_x_set(self, inv_x)"},
9592 { "WorldCoor_inv_x_get", _wrap_WorldCoor_inv_x_get, METH_O, "WorldCoor_inv_x_get(self) -> struct poly *"},
9593 { "WorldCoor_inv_y_set", _wrap_WorldCoor_inv_y_set, METH_VARARGS, "WorldCoor_inv_y_set(self, inv_y)"},
9594 { "WorldCoor_inv_y_get", _wrap_WorldCoor_inv_y_get, METH_O, "WorldCoor_inv_y_get(self) -> struct poly *"},
9595 { "WorldCoor_longpole_set", _wrap_WorldCoor_longpole_set, METH_VARARGS, "WorldCoor_longpole_set(self, longpole)"},
9596 { "WorldCoor_longpole_get", _wrap_WorldCoor_longpole_get, METH_O, "WorldCoor_longpole_get(self) -> double"},
9597 { "WorldCoor_latpole_set", _wrap_WorldCoor_latpole_set, METH_VARARGS, "WorldCoor_latpole_set(self, latpole)"},
9598 { "WorldCoor_latpole_get", _wrap_WorldCoor_latpole_get, METH_O, "WorldCoor_latpole_get(self) -> double"},
9599 { "WorldCoor_rodeg_set", _wrap_WorldCoor_rodeg_set, METH_VARARGS, "WorldCoor_rodeg_set(self, rodeg)"},
9600 { "WorldCoor_rodeg_get", _wrap_WorldCoor_rodeg_get, METH_O, "WorldCoor_rodeg_get(self) -> double"},
9601 { "WorldCoor_imrot_set", _wrap_WorldCoor_imrot_set, METH_VARARGS, "WorldCoor_imrot_set(self, imrot)"},
9602 { "WorldCoor_imrot_get", _wrap_WorldCoor_imrot_get, METH_O, "WorldCoor_imrot_get(self) -> double"},
9603 { "WorldCoor_pa_north_set", _wrap_WorldCoor_pa_north_set, METH_VARARGS, "WorldCoor_pa_north_set(self, pa_north)"},
9604 { "WorldCoor_pa_north_get", _wrap_WorldCoor_pa_north_get, METH_O, "WorldCoor_pa_north_get(self) -> double"},
9605 { "WorldCoor_pa_east_set", _wrap_WorldCoor_pa_east_set, METH_VARARGS, "WorldCoor_pa_east_set(self, pa_east)"},
9606 { "WorldCoor_pa_east_get", _wrap_WorldCoor_pa_east_get, METH_O, "WorldCoor_pa_east_get(self) -> double"},
9607 { "WorldCoor_radvel_set", _wrap_WorldCoor_radvel_set, METH_VARARGS, "WorldCoor_radvel_set(self, radvel)"},
9608 { "WorldCoor_radvel_get", _wrap_WorldCoor_radvel_get, METH_O, "WorldCoor_radvel_get(self) -> double"},
9609 { "WorldCoor_zvel_set", _wrap_WorldCoor_zvel_set, METH_VARARGS, "WorldCoor_zvel_set(self, zvel)"},
9610 { "WorldCoor_zvel_get", _wrap_WorldCoor_zvel_get, METH_O, "WorldCoor_zvel_get(self) -> double"},
9611 { "WorldCoor_zpzd_set", _wrap_WorldCoor_zpzd_set, METH_VARARGS, "WorldCoor_zpzd_set(self, zpzd)"},
9612 { "WorldCoor_zpzd_get", _wrap_WorldCoor_zpzd_get, METH_O, "WorldCoor_zpzd_get(self) -> double"},
9613 { "WorldCoor_zpr_set", _wrap_WorldCoor_zpr_set, METH_VARARGS, "WorldCoor_zpr_set(self, zpr)"},
9614 { "WorldCoor_zpr_get", _wrap_WorldCoor_zpr_get, METH_O, "WorldCoor_zpr_get(self) -> double"},
9615 { "WorldCoor_imflip_set", _wrap_WorldCoor_imflip_set, METH_VARARGS, "WorldCoor_imflip_set(self, imflip)"},
9616 { "WorldCoor_imflip_get", _wrap_WorldCoor_imflip_get, METH_O, "WorldCoor_imflip_get(self) -> int"},
9617 { "WorldCoor_prjcode_set", _wrap_WorldCoor_prjcode_set, METH_VARARGS, "WorldCoor_prjcode_set(self, prjcode)"},
9618 { "WorldCoor_prjcode_get", _wrap_WorldCoor_prjcode_get, METH_O, "WorldCoor_prjcode_get(self) -> int"},
9619 { "WorldCoor_latbase_set", _wrap_WorldCoor_latbase_set, METH_VARARGS, "WorldCoor_latbase_set(self, latbase)"},
9620 { "WorldCoor_latbase_get", _wrap_WorldCoor_latbase_get, METH_O, "WorldCoor_latbase_get(self) -> int"},
9621 { "WorldCoor_ncoeff1_set", _wrap_WorldCoor_ncoeff1_set, METH_VARARGS, "WorldCoor_ncoeff1_set(self, ncoeff1)"},
9622 { "WorldCoor_ncoeff1_get", _wrap_WorldCoor_ncoeff1_get, METH_O, "WorldCoor_ncoeff1_get(self) -> int"},
9623 { "WorldCoor_ncoeff2_set", _wrap_WorldCoor_ncoeff2_set, METH_VARARGS, "WorldCoor_ncoeff2_set(self, ncoeff2)"},
9624 { "WorldCoor_ncoeff2_get", _wrap_WorldCoor_ncoeff2_get, METH_O, "WorldCoor_ncoeff2_get(self) -> int"},
9625 { "WorldCoor_zpnp_set", _wrap_WorldCoor_zpnp_set, METH_VARARGS, "WorldCoor_zpnp_set(self, zpnp)"},
9626 { "WorldCoor_zpnp_get", _wrap_WorldCoor_zpnp_get, METH_O, "WorldCoor_zpnp_get(self) -> int"},
9627 { "WorldCoor_changesys_set", _wrap_WorldCoor_changesys_set, METH_VARARGS, "WorldCoor_changesys_set(self, changesys)"},
9628 { "WorldCoor_changesys_get", _wrap_WorldCoor_changesys_get, METH_O, "WorldCoor_changesys_get(self) -> int"},
9629 { "WorldCoor_printsys_set", _wrap_WorldCoor_printsys_set, METH_VARARGS, "WorldCoor_printsys_set(self, printsys)"},
9630 { "WorldCoor_printsys_get", _wrap_WorldCoor_printsys_get, METH_O, "WorldCoor_printsys_get(self) -> int"},
9631 { "WorldCoor_ndec_set", _wrap_WorldCoor_ndec_set, METH_VARARGS, "WorldCoor_ndec_set(self, ndec)"},
9632 { "WorldCoor_ndec_get", _wrap_WorldCoor_ndec_get, METH_O, "WorldCoor_ndec_get(self) -> int"},
9633 { "WorldCoor_degout_set", _wrap_WorldCoor_degout_set, METH_VARARGS, "WorldCoor_degout_set(self, degout)"},
9634 { "WorldCoor_degout_get", _wrap_WorldCoor_degout_get, METH_O, "WorldCoor_degout_get(self) -> int"},
9635 { "WorldCoor_tabsys_set", _wrap_WorldCoor_tabsys_set, METH_VARARGS, "WorldCoor_tabsys_set(self, tabsys)"},
9636 { "WorldCoor_tabsys_get", _wrap_WorldCoor_tabsys_get, METH_O, "WorldCoor_tabsys_get(self) -> int"},
9637 { "WorldCoor_rotmat_set", _wrap_WorldCoor_rotmat_set, METH_VARARGS, "WorldCoor_rotmat_set(self, rotmat)"},
9638 { "WorldCoor_rotmat_get", _wrap_WorldCoor_rotmat_get, METH_O, "WorldCoor_rotmat_get(self) -> int"},
9639 { "WorldCoor_coorflip_set", _wrap_WorldCoor_coorflip_set, METH_VARARGS, "WorldCoor_coorflip_set(self, coorflip)"},
9640 { "WorldCoor_coorflip_get", _wrap_WorldCoor_coorflip_get, METH_O, "WorldCoor_coorflip_get(self) -> int"},
9641 { "WorldCoor_offscl_set", _wrap_WorldCoor_offscl_set, METH_VARARGS, "WorldCoor_offscl_set(self, offscl)"},
9642 { "WorldCoor_offscl_get", _wrap_WorldCoor_offscl_get, METH_O, "WorldCoor_offscl_get(self) -> int"},
9643 { "WorldCoor_wcson_set", _wrap_WorldCoor_wcson_set, METH_VARARGS, "WorldCoor_wcson_set(self, wcson)"},
9644 { "WorldCoor_wcson_get", _wrap_WorldCoor_wcson_get, METH_O, "WorldCoor_wcson_get(self) -> int"},
9645 { "WorldCoor_naxis_set", _wrap_WorldCoor_naxis_set, METH_VARARGS, "WorldCoor_naxis_set(self, naxis)"},
9646 { "WorldCoor_naxis_get", _wrap_WorldCoor_naxis_get, METH_O, "WorldCoor_naxis_get(self) -> int"},
9647 { "WorldCoor_naxes_set", _wrap_WorldCoor_naxes_set, METH_VARARGS, "WorldCoor_naxes_set(self, naxes)"},
9648 { "WorldCoor_naxes_get", _wrap_WorldCoor_naxes_get, METH_O, "WorldCoor_naxes_get(self) -> int"},
9649 { "WorldCoor_wcsproj_set", _wrap_WorldCoor_wcsproj_set, METH_VARARGS, "WorldCoor_wcsproj_set(self, wcsproj)"},
9650 { "WorldCoor_wcsproj_get", _wrap_WorldCoor_wcsproj_get, METH_O, "WorldCoor_wcsproj_get(self) -> int"},
9651 { "WorldCoor_linmode_set", _wrap_WorldCoor_linmode_set, METH_VARARGS, "WorldCoor_linmode_set(self, linmode)"},
9652 { "WorldCoor_linmode_get", _wrap_WorldCoor_linmode_get, METH_O, "WorldCoor_linmode_get(self) -> int"},
9653 { "WorldCoor_detector_set", _wrap_WorldCoor_detector_set, METH_VARARGS, "WorldCoor_detector_set(self, detector)"},
9654 { "WorldCoor_detector_get", _wrap_WorldCoor_detector_get, METH_O, "WorldCoor_detector_get(self) -> int"},
9655 { "WorldCoor_instrument_set", _wrap_WorldCoor_instrument_set, METH_VARARGS, "WorldCoor_instrument_set(self, instrument)"},
9656 { "WorldCoor_instrument_get", _wrap_WorldCoor_instrument_get, METH_O, "WorldCoor_instrument_get(self) -> char [32]"},
9657 { "WorldCoor_ctype_set", _wrap_WorldCoor_ctype_set, METH_VARARGS, "WorldCoor_ctype_set(self, ctype)"},
9658 { "WorldCoor_ctype_get", _wrap_WorldCoor_ctype_get, METH_O, "WorldCoor_ctype_get(self) -> char [9][9]"},
9659 { "WorldCoor_c1type_set", _wrap_WorldCoor_c1type_set, METH_VARARGS, "WorldCoor_c1type_set(self, c1type)"},
9660 { "WorldCoor_c1type_get", _wrap_WorldCoor_c1type_get, METH_O, "WorldCoor_c1type_get(self) -> char [9]"},
9661 { "WorldCoor_c2type_set", _wrap_WorldCoor_c2type_set, METH_VARARGS, "WorldCoor_c2type_set(self, c2type)"},
9662 { "WorldCoor_c2type_get", _wrap_WorldCoor_c2type_get, METH_O, "WorldCoor_c2type_get(self) -> char [9]"},
9663 { "WorldCoor_ptype_set", _wrap_WorldCoor_ptype_set, METH_VARARGS, "WorldCoor_ptype_set(self, ptype)"},
9664 { "WorldCoor_ptype_get", _wrap_WorldCoor_ptype_get, METH_O, "WorldCoor_ptype_get(self) -> char [9]"},
9665 { "WorldCoor_units_set", _wrap_WorldCoor_units_set, METH_VARARGS, "WorldCoor_units_set(self, units)"},
9666 { "WorldCoor_units_get", _wrap_WorldCoor_units_get, METH_O, "WorldCoor_units_get(self) -> char [9][32]"},
9667 { "WorldCoor_radecsys_set", _wrap_WorldCoor_radecsys_set, METH_VARARGS, "WorldCoor_radecsys_set(self, radecsys)"},
9668 { "WorldCoor_radecsys_get", _wrap_WorldCoor_radecsys_get, METH_O, "WorldCoor_radecsys_get(self) -> char [32]"},
9669 { "WorldCoor_radecout_set", _wrap_WorldCoor_radecout_set, METH_VARARGS, "WorldCoor_radecout_set(self, radecout)"},
9670 { "WorldCoor_radecout_get", _wrap_WorldCoor_radecout_get, METH_O, "WorldCoor_radecout_get(self) -> char [32]"},
9671 { "WorldCoor_radecin_set", _wrap_WorldCoor_radecin_set, METH_VARARGS, "WorldCoor_radecin_set(self, radecin)"},
9672 { "WorldCoor_radecin_get", _wrap_WorldCoor_radecin_get, METH_O, "WorldCoor_radecin_get(self) -> char [32]"},
9673 { "WorldCoor_eqin_set", _wrap_WorldCoor_eqin_set, METH_VARARGS, "WorldCoor_eqin_set(self, eqin)"},
9674 { "WorldCoor_eqin_get", _wrap_WorldCoor_eqin_get, METH_O, "WorldCoor_eqin_get(self) -> double"},
9675 { "WorldCoor_eqout_set", _wrap_WorldCoor_eqout_set, METH_VARARGS, "WorldCoor_eqout_set(self, eqout)"},
9676 { "WorldCoor_eqout_get", _wrap_WorldCoor_eqout_get, METH_O, "WorldCoor_eqout_get(self) -> double"},
9677 { "WorldCoor_sysin_set", _wrap_WorldCoor_sysin_set, METH_VARARGS, "WorldCoor_sysin_set(self, sysin)"},
9678 { "WorldCoor_sysin_get", _wrap_WorldCoor_sysin_get, METH_O, "WorldCoor_sysin_get(self) -> int"},
9679 { "WorldCoor_syswcs_set", _wrap_WorldCoor_syswcs_set, METH_VARARGS, "WorldCoor_syswcs_set(self, syswcs)"},
9680 { "WorldCoor_syswcs_get", _wrap_WorldCoor_syswcs_get, METH_O, "WorldCoor_syswcs_get(self) -> int"},
9681 { "WorldCoor_sysout_set", _wrap_WorldCoor_sysout_set, METH_VARARGS, "WorldCoor_sysout_set(self, sysout)"},
9682 { "WorldCoor_sysout_get", _wrap_WorldCoor_sysout_get, METH_O, "WorldCoor_sysout_get(self) -> int"},
9683 { "WorldCoor_center_set", _wrap_WorldCoor_center_set, METH_VARARGS, "WorldCoor_center_set(self, center)"},
9684 { "WorldCoor_center_get", _wrap_WorldCoor_center_get, METH_O, "WorldCoor_center_get(self) -> char [32]"},
9685 { "WorldCoor_wcsl_set", _wrap_WorldCoor_wcsl_set, METH_VARARGS, "WorldCoor_wcsl_set(self, wcsl)"},
9686 { "WorldCoor_wcsl_get", _wrap_WorldCoor_wcsl_get, METH_O, "WorldCoor_wcsl_get(self) -> struct wcsprm"},
9687 { "WorldCoor_lin_set", _wrap_WorldCoor_lin_set, METH_VARARGS, "WorldCoor_lin_set(self, lin)"},
9688 { "WorldCoor_lin_get", _wrap_WorldCoor_lin_get, METH_O, "WorldCoor_lin_get(self) -> struct linprm"},
9689 { "WorldCoor_cel_set", _wrap_WorldCoor_cel_set, METH_VARARGS, "WorldCoor_cel_set(self, cel)"},
9690 { "WorldCoor_cel_get", _wrap_WorldCoor_cel_get, METH_O, "WorldCoor_cel_get(self) -> struct celprm"},
9691 { "WorldCoor_prj_set", _wrap_WorldCoor_prj_set, METH_VARARGS, "WorldCoor_prj_set(self, prj)"},
9692 { "WorldCoor_prj_get", _wrap_WorldCoor_prj_get, METH_O, "WorldCoor_prj_get(self) -> struct prjprm"},
9693 { "WorldCoor_lngcor_set", _wrap_WorldCoor_lngcor_set, METH_VARARGS, "WorldCoor_lngcor_set(self, lngcor)"},
9694 { "WorldCoor_lngcor_get", _wrap_WorldCoor_lngcor_get, METH_O, "WorldCoor_lngcor_get(self) -> struct IRAFsurface *"},
9695 { "WorldCoor_latcor_set", _wrap_WorldCoor_latcor_set, METH_VARARGS, "WorldCoor_latcor_set(self, latcor)"},
9696 { "WorldCoor_latcor_get", _wrap_WorldCoor_latcor_get, METH_O, "WorldCoor_latcor_get(self) -> struct IRAFsurface *"},
9697 { "WorldCoor_distcode_set", _wrap_WorldCoor_distcode_set, METH_VARARGS, "WorldCoor_distcode_set(self, distcode)"},
9698 { "WorldCoor_distcode_get", _wrap_WorldCoor_distcode_get, METH_O, "WorldCoor_distcode_get(self) -> int"},
9699 { "WorldCoor_distort_set", _wrap_WorldCoor_distort_set, METH_VARARGS, "WorldCoor_distort_set(self, distort)"},
9700 { "WorldCoor_distort_get", _wrap_WorldCoor_distort_get, METH_O, "WorldCoor_distort_get(self) -> struct Distort"},
9701 { "WorldCoor_command_format_set", _wrap_WorldCoor_command_format_set, METH_VARARGS, "WorldCoor_command_format_set(self, command_format)"},
9702 { "WorldCoor_command_format_get", _wrap_WorldCoor_command_format_get, METH_O, "WorldCoor_command_format_get(self) -> char *[10]"},
9703 { "WorldCoor_ltm_set", _wrap_WorldCoor_ltm_set, METH_VARARGS, "WorldCoor_ltm_set(self, ltm)"},
9704 { "WorldCoor_ltm_get", _wrap_WorldCoor_ltm_get, METH_O, "WorldCoor_ltm_get(self) -> double [4]"},
9705 { "WorldCoor_ltv_set", _wrap_WorldCoor_ltv_set, METH_VARARGS, "WorldCoor_ltv_set(self, ltv)"},
9706 { "WorldCoor_ltv_get", _wrap_WorldCoor_ltv_get, METH_O, "WorldCoor_ltv_get(self) -> double [2]"},
9707 { "WorldCoor_idpix_set", _wrap_WorldCoor_idpix_set, METH_VARARGS, "WorldCoor_idpix_set(self, idpix)"},
9708 { "WorldCoor_idpix_get", _wrap_WorldCoor_idpix_get, METH_O, "WorldCoor_idpix_get(self) -> int [2]"},
9709 { "WorldCoor_ndpix_set", _wrap_WorldCoor_ndpix_set, METH_VARARGS, "WorldCoor_ndpix_set(self, ndpix)"},
9710 { "WorldCoor_ndpix_get", _wrap_WorldCoor_ndpix_get, METH_O, "WorldCoor_ndpix_get(self) -> int [2]"},
9711 { "WorldCoor_wcs_set", _wrap_WorldCoor_wcs_set, METH_VARARGS, "WorldCoor_wcs_set(self, wcs)"},
9712 { "WorldCoor_wcs_get", _wrap_WorldCoor_wcs_get, METH_O, "WorldCoor_wcs_get(self) -> WorldCoor"},
9713 { "WorldCoor_wcsdep_set", _wrap_WorldCoor_wcsdep_set, METH_VARARGS, "WorldCoor_wcsdep_set(self, wcsdep)"},
9714 { "WorldCoor_wcsdep_get", _wrap_WorldCoor_wcsdep_get, METH_O, "WorldCoor_wcsdep_get(self) -> WorldCoor"},
9715 { "WorldCoor_wcsname_set", _wrap_WorldCoor_wcsname_set, METH_VARARGS, "WorldCoor_wcsname_set(self, wcsname)"},
9716 { "WorldCoor_wcsname_get", _wrap_WorldCoor_wcsname_get, METH_O, "WorldCoor_wcsname_get(self) -> char *"},
9717 { "WorldCoor_wcschar_set", _wrap_WorldCoor_wcschar_set, METH_VARARGS, "WorldCoor_wcschar_set(self, wcschar)"},
9718 { "WorldCoor_wcschar_get", _wrap_WorldCoor_wcschar_get, METH_O, "WorldCoor_wcschar_get(self) -> char"},
9719 { "WorldCoor_logwcs_set", _wrap_WorldCoor_logwcs_set, METH_VARARGS, "WorldCoor_logwcs_set(self, logwcs)"},
9720 { "WorldCoor_logwcs_get", _wrap_WorldCoor_logwcs_get, METH_O, "WorldCoor_logwcs_get(self) -> int"},
9721 { "new_WorldCoor", _wrap_new_WorldCoor, METH_NOARGS, "new_WorldCoor() -> WorldCoor"},
9722 { "delete_WorldCoor", _wrap_delete_WorldCoor, METH_O, "delete_WorldCoor(self)"},
9723 { "WorldCoor_swigregister", WorldCoor_swigregister, METH_O, NULL},
9724 { "WorldCoor_swiginit", WorldCoor_swiginit, METH_VARARGS, NULL},
9725 { NULL, NULL, 0, NULL }
9726 };
9727
9728 static PyMethodDef SwigMethods_proxydocs[] = {
9729 { NULL, NULL, 0, NULL }
9730 };
9731
9732
9733 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
9734
9735 static swig_type_info _swigt__p_Distort = {"_p_Distort", "struct Distort *", 0, 0, (void*)0, 0};
9736 static swig_type_info _swigt__p_IRAFsurface = {"_p_IRAFsurface", "struct IRAFsurface *", 0, 0, (void*)0, 0};
9737 static swig_type_info _swigt__p_WorldCoor = {"_p_WorldCoor", "struct WorldCoor *|WorldCoor *", 0, 0, (void*)0, 0};
9738 static swig_type_info _swigt__p_a_32__char = {"_p_a_32__char", "char (*)[32]", 0, 0, (void*)0, 0};
9739 static swig_type_info _swigt__p_a_9__char = {"_p_a_9__char", "char (*)[9]", 0, 0, (void*)0, 0};
9740 static swig_type_info _swigt__p_celprm = {"_p_celprm", "struct celprm *", 0, 0, (void*)0, 0};
9741 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
9742 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
9743 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
9744 static swig_type_info _swigt__p_linprm = {"_p_linprm", "struct linprm *", 0, 0, (void*)0, 0};
9745 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
9746 static swig_type_info _swigt__p_poly = {"_p_poly", "struct poly *", 0, 0, (void*)0, 0};
9747 static swig_type_info _swigt__p_prjprm = {"_p_prjprm", "struct prjprm *", 0, 0, (void*)0, 0};
9748 static swig_type_info _swigt__p_wcsprm = {"_p_wcsprm", "struct wcsprm *", 0, 0, (void*)0, 0};
9749
9750 static swig_type_info *swig_type_initial[] = {
9751 &_swigt__p_Distort,
9752 &_swigt__p_IRAFsurface,
9753 &_swigt__p_WorldCoor,
9754 &_swigt__p_a_32__char,
9755 &_swigt__p_a_9__char,
9756 &_swigt__p_celprm,
9757 &_swigt__p_char,
9758 &_swigt__p_double,
9759 &_swigt__p_int,
9760 &_swigt__p_linprm,
9761 &_swigt__p_p_char,
9762 &_swigt__p_poly,
9763 &_swigt__p_prjprm,
9764 &_swigt__p_wcsprm,
9765 };
9766
9767 static swig_cast_info _swigc__p_Distort[] = { {&_swigt__p_Distort, 0, 0, 0},{0, 0, 0, 0}};
9768 static swig_cast_info _swigc__p_IRAFsurface[] = { {&_swigt__p_IRAFsurface, 0, 0, 0},{0, 0, 0, 0}};
9769 static swig_cast_info _swigc__p_WorldCoor[] = { {&_swigt__p_WorldCoor, 0, 0, 0},{0, 0, 0, 0}};
9770 static swig_cast_info _swigc__p_a_32__char[] = { {&_swigt__p_a_32__char, 0, 0, 0},{0, 0, 0, 0}};
9771 static swig_cast_info _swigc__p_a_9__char[] = { {&_swigt__p_a_9__char, 0, 0, 0},{0, 0, 0, 0}};
9772 static swig_cast_info _swigc__p_celprm[] = { {&_swigt__p_celprm, 0, 0, 0},{0, 0, 0, 0}};
9773 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
9774 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
9775 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
9776 static swig_cast_info _swigc__p_linprm[] = { {&_swigt__p_linprm, 0, 0, 0},{0, 0, 0, 0}};
9777 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
9778 static swig_cast_info _swigc__p_poly[] = { {&_swigt__p_poly, 0, 0, 0},{0, 0, 0, 0}};
9779 static swig_cast_info _swigc__p_prjprm[] = { {&_swigt__p_prjprm, 0, 0, 0},{0, 0, 0, 0}};
9780 static swig_cast_info _swigc__p_wcsprm[] = { {&_swigt__p_wcsprm, 0, 0, 0},{0, 0, 0, 0}};
9781
9782 static swig_cast_info *swig_cast_initial[] = {
9783 _swigc__p_Distort,
9784 _swigc__p_IRAFsurface,
9785 _swigc__p_WorldCoor,
9786 _swigc__p_a_32__char,
9787 _swigc__p_a_9__char,
9788 _swigc__p_celprm,
9789 _swigc__p_char,
9790 _swigc__p_double,
9791 _swigc__p_int,
9792 _swigc__p_linprm,
9793 _swigc__p_p_char,
9794 _swigc__p_poly,
9795 _swigc__p_prjprm,
9796 _swigc__p_wcsprm,
9797 };
9798
9799
9800 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
9801
9802 static swig_const_info swig_const_table[] = {
9803 {0, 0, 0, 0.0, 0, 0}};
9804
9805 #ifdef __cplusplus
9806 }
9807 #endif
9808 /* -----------------------------------------------------------------------------
9809 * Type initialization:
9810 * This problem is tough by the requirement that no dynamic
9811 * memory is used. Also, since swig_type_info structures store pointers to
9812 * swig_cast_info structures and swig_cast_info structures store pointers back
9813 * to swig_type_info structures, we need some lookup code at initialization.
9814 * The idea is that swig generates all the structures that are needed.
9815 * The runtime then collects these partially filled structures.
9816 * The SWIG_InitializeModule function takes these initial arrays out of
9817 * swig_module, and does all the lookup, filling in the swig_module.types
9818 * array with the correct data and linking the correct swig_cast_info
9819 * structures together.
9820 *
9821 * The generated swig_type_info structures are assigned statically to an initial
9822 * array. We just loop through that array, and handle each type individually.
9823 * First we lookup if this type has been already loaded, and if so, use the
9824 * loaded structure instead of the generated one. Then we have to fill in the
9825 * cast linked list. The cast data is initially stored in something like a
9826 * two-dimensional array. Each row corresponds to a type (there are the same
9827 * number of rows as there are in the swig_type_initial array). Each entry in
9828 * a column is one of the swig_cast_info structures for that type.
9829 * The cast_initial array is actually an array of arrays, because each row has
9830 * a variable number of columns. So to actually build the cast linked list,
9831 * we find the array of casts associated with the type, and loop through it
9832 * adding the casts to the list. The one last trick we need to do is making
9833 * sure the type pointer in the swig_cast_info struct is correct.
9834 *
9835 * First off, we lookup the cast->type name to see if it is already loaded.
9836 * There are three cases to handle:
9837 * 1) If the cast->type has already been loaded AND the type we are adding
9838 * casting info to has not been loaded (it is in this module), THEN we
9839 * replace the cast->type pointer with the type pointer that has already
9840 * been loaded.
9841 * 2) If BOTH types (the one we are adding casting info to, and the
9842 * cast->type) are loaded, THEN the cast info has already been loaded by
9843 * the previous module so we just ignore it.
9844 * 3) Finally, if cast->type has not already been loaded, then we add that
9845 * swig_cast_info to the linked list (because the cast->type) pointer will
9846 * be correct.
9847 * ----------------------------------------------------------------------------- */
9848
9849 #ifdef __cplusplus
9850 extern "C" {
9851 #if 0
9852 } /* c-mode */
9853 #endif
9854 #endif
9855
9856 #if 0
9857 #define SWIGRUNTIME_DEBUG
9858 #endif
9859
9860
9861 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)9862 SWIG_InitializeModule(void *clientdata) {
9863 size_t i;
9864 swig_module_info *module_head, *iter;
9865 int init;
9866
9867 /* check to see if the circular list has been setup, if not, set it up */
9868 if (swig_module.next==0) {
9869 /* Initialize the swig_module */
9870 swig_module.type_initial = swig_type_initial;
9871 swig_module.cast_initial = swig_cast_initial;
9872 swig_module.next = &swig_module;
9873 init = 1;
9874 } else {
9875 init = 0;
9876 }
9877
9878 /* Try and load any already created modules */
9879 module_head = SWIG_GetModule(clientdata);
9880 if (!module_head) {
9881 /* This is the first module loaded for this interpreter */
9882 /* so set the swig module into the interpreter */
9883 SWIG_SetModule(clientdata, &swig_module);
9884 } else {
9885 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
9886 iter=module_head;
9887 do {
9888 if (iter==&swig_module) {
9889 /* Our module is already in the list, so there's nothing more to do. */
9890 return;
9891 }
9892 iter=iter->next;
9893 } while (iter!= module_head);
9894
9895 /* otherwise we must add our module into the list */
9896 swig_module.next = module_head->next;
9897 module_head->next = &swig_module;
9898 }
9899
9900 /* When multiple interpreters are used, a module could have already been initialized in
9901 a different interpreter, but not yet have a pointer in this interpreter.
9902 In this case, we do not want to continue adding types... everything should be
9903 set up already */
9904 if (init == 0) return;
9905
9906 /* Now work on filling in swig_module.types */
9907 #ifdef SWIGRUNTIME_DEBUG
9908 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
9909 #endif
9910 for (i = 0; i < swig_module.size; ++i) {
9911 swig_type_info *type = 0;
9912 swig_type_info *ret;
9913 swig_cast_info *cast;
9914
9915 #ifdef SWIGRUNTIME_DEBUG
9916 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
9917 #endif
9918
9919 /* if there is another module already loaded */
9920 if (swig_module.next != &swig_module) {
9921 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
9922 }
9923 if (type) {
9924 /* Overwrite clientdata field */
9925 #ifdef SWIGRUNTIME_DEBUG
9926 printf("SWIG_InitializeModule: found type %s\n", type->name);
9927 #endif
9928 if (swig_module.type_initial[i]->clientdata) {
9929 type->clientdata = swig_module.type_initial[i]->clientdata;
9930 #ifdef SWIGRUNTIME_DEBUG
9931 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
9932 #endif
9933 }
9934 } else {
9935 type = swig_module.type_initial[i];
9936 }
9937
9938 /* Insert casting types */
9939 cast = swig_module.cast_initial[i];
9940 while (cast->type) {
9941 /* Don't need to add information already in the list */
9942 ret = 0;
9943 #ifdef SWIGRUNTIME_DEBUG
9944 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
9945 #endif
9946 if (swig_module.next != &swig_module) {
9947 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
9948 #ifdef SWIGRUNTIME_DEBUG
9949 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
9950 #endif
9951 }
9952 if (ret) {
9953 if (type == swig_module.type_initial[i]) {
9954 #ifdef SWIGRUNTIME_DEBUG
9955 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
9956 #endif
9957 cast->type = ret;
9958 ret = 0;
9959 } else {
9960 /* Check for casting already in the list */
9961 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
9962 #ifdef SWIGRUNTIME_DEBUG
9963 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
9964 #endif
9965 if (!ocast) ret = 0;
9966 }
9967 }
9968
9969 if (!ret) {
9970 #ifdef SWIGRUNTIME_DEBUG
9971 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
9972 #endif
9973 if (type->cast) {
9974 type->cast->prev = cast;
9975 cast->next = type->cast;
9976 }
9977 type->cast = cast;
9978 }
9979 cast++;
9980 }
9981 /* Set entry in modules->types array equal to the type */
9982 swig_module.types[i] = type;
9983 }
9984 swig_module.types[i] = 0;
9985
9986 #ifdef SWIGRUNTIME_DEBUG
9987 printf("**** SWIG_InitializeModule: Cast List ******\n");
9988 for (i = 0; i < swig_module.size; ++i) {
9989 int j = 0;
9990 swig_cast_info *cast = swig_module.cast_initial[i];
9991 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
9992 while (cast->type) {
9993 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
9994 cast++;
9995 ++j;
9996 }
9997 printf("---- Total casts: %d\n",j);
9998 }
9999 printf("**** SWIG_InitializeModule: Cast List ******\n");
10000 #endif
10001 }
10002
10003 /* This function will propagate the clientdata field of type to
10004 * any new swig_type_info structures that have been added into the list
10005 * of equivalent types. It is like calling
10006 * SWIG_TypeClientData(type, clientdata) a second time.
10007 */
10008 SWIGRUNTIME void
SWIG_PropagateClientData(void)10009 SWIG_PropagateClientData(void) {
10010 size_t i;
10011 swig_cast_info *equiv;
10012 static int init_run = 0;
10013
10014 if (init_run) return;
10015 init_run = 1;
10016
10017 for (i = 0; i < swig_module.size; i++) {
10018 if (swig_module.types[i]->clientdata) {
10019 equiv = swig_module.types[i]->cast;
10020 while (equiv) {
10021 if (!equiv->converter) {
10022 if (equiv->type && !equiv->type->clientdata)
10023 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
10024 }
10025 equiv = equiv->next;
10026 }
10027 }
10028 }
10029 }
10030
10031 #ifdef __cplusplus
10032 #if 0
10033 {
10034 /* c-mode */
10035 #endif
10036 }
10037 #endif
10038
10039
10040
10041 #ifdef __cplusplus
10042 extern "C" {
10043 #endif
10044
10045 /* Python-specific SWIG API */
10046 #define SWIG_newvarlink() SWIG_Python_newvarlink()
10047 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
10048 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
10049
10050 /* -----------------------------------------------------------------------------
10051 * global variable support code.
10052 * ----------------------------------------------------------------------------- */
10053
10054 typedef struct swig_globalvar {
10055 char *name; /* Name of global variable */
10056 PyObject *(*get_attr)(void); /* Return the current value */
10057 int (*set_attr)(PyObject *); /* Set the value */
10058 struct swig_globalvar *next;
10059 } swig_globalvar;
10060
10061 typedef struct swig_varlinkobject {
10062 PyObject_HEAD
10063 swig_globalvar *vars;
10064 } swig_varlinkobject;
10065
10066 SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject * SWIGUNUSEDPARM (v))10067 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
10068 #if PY_VERSION_HEX >= 0x03000000
10069 return PyUnicode_InternFromString("<Swig global variables>");
10070 #else
10071 return PyString_FromString("<Swig global variables>");
10072 #endif
10073 }
10074
10075 SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject * v)10076 swig_varlink_str(swig_varlinkobject *v) {
10077 #if PY_VERSION_HEX >= 0x03000000
10078 PyObject *str = PyUnicode_InternFromString("(");
10079 PyObject *tail;
10080 PyObject *joined;
10081 swig_globalvar *var;
10082 for (var = v->vars; var; var=var->next) {
10083 tail = PyUnicode_FromString(var->name);
10084 joined = PyUnicode_Concat(str, tail);
10085 Py_DecRef(str);
10086 Py_DecRef(tail);
10087 str = joined;
10088 if (var->next) {
10089 tail = PyUnicode_InternFromString(", ");
10090 joined = PyUnicode_Concat(str, tail);
10091 Py_DecRef(str);
10092 Py_DecRef(tail);
10093 str = joined;
10094 }
10095 }
10096 tail = PyUnicode_InternFromString(")");
10097 joined = PyUnicode_Concat(str, tail);
10098 Py_DecRef(str);
10099 Py_DecRef(tail);
10100 str = joined;
10101 #else
10102 PyObject *str = PyString_FromString("(");
10103 swig_globalvar *var;
10104 for (var = v->vars; var; var=var->next) {
10105 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
10106 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
10107 }
10108 PyString_ConcatAndDel(&str,PyString_FromString(")"));
10109 #endif
10110 return str;
10111 }
10112
10113 SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject * v)10114 swig_varlink_dealloc(swig_varlinkobject *v) {
10115 swig_globalvar *var = v->vars;
10116 while (var) {
10117 swig_globalvar *n = var->next;
10118 free(var->name);
10119 free(var);
10120 var = n;
10121 }
10122 }
10123
10124 SWIGINTERN PyObject *
swig_varlink_getattr(swig_varlinkobject * v,char * n)10125 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
10126 PyObject *res = NULL;
10127 swig_globalvar *var = v->vars;
10128 while (var) {
10129 if (strcmp(var->name,n) == 0) {
10130 res = (*var->get_attr)();
10131 break;
10132 }
10133 var = var->next;
10134 }
10135 if (res == NULL && !PyErr_Occurred()) {
10136 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
10137 }
10138 return res;
10139 }
10140
10141 SWIGINTERN int
swig_varlink_setattr(swig_varlinkobject * v,char * n,PyObject * p)10142 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
10143 int res = 1;
10144 swig_globalvar *var = v->vars;
10145 while (var) {
10146 if (strcmp(var->name,n) == 0) {
10147 res = (*var->set_attr)(p);
10148 break;
10149 }
10150 var = var->next;
10151 }
10152 if (res == 1 && !PyErr_Occurred()) {
10153 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
10154 }
10155 return res;
10156 }
10157
10158 SWIGINTERN PyTypeObject*
swig_varlink_type(void)10159 swig_varlink_type(void) {
10160 static char varlink__doc__[] = "Swig var link object";
10161 static PyTypeObject varlink_type;
10162 static int type_init = 0;
10163 if (!type_init) {
10164 const PyTypeObject tmp = {
10165 #if PY_VERSION_HEX >= 0x03000000
10166 PyVarObject_HEAD_INIT(NULL, 0)
10167 #else
10168 PyObject_HEAD_INIT(NULL)
10169 0, /* ob_size */
10170 #endif
10171 "swigvarlink", /* tp_name */
10172 sizeof(swig_varlinkobject), /* tp_basicsize */
10173 0, /* tp_itemsize */
10174 (destructor) swig_varlink_dealloc, /* tp_dealloc */
10175 0, /* tp_print */
10176 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
10177 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
10178 0, /* tp_compare */
10179 (reprfunc) swig_varlink_repr, /* tp_repr */
10180 0, /* tp_as_number */
10181 0, /* tp_as_sequence */
10182 0, /* tp_as_mapping */
10183 0, /* tp_hash */
10184 0, /* tp_call */
10185 (reprfunc) swig_varlink_str, /* tp_str */
10186 0, /* tp_getattro */
10187 0, /* tp_setattro */
10188 0, /* tp_as_buffer */
10189 0, /* tp_flags */
10190 varlink__doc__, /* tp_doc */
10191 0, /* tp_traverse */
10192 0, /* tp_clear */
10193 0, /* tp_richcompare */
10194 0, /* tp_weaklistoffset */
10195 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
10196 0, /* tp_del */
10197 0, /* tp_version_tag */
10198 #if PY_VERSION_HEX >= 0x03040000
10199 0, /* tp_finalize */
10200 #endif
10201 #ifdef COUNT_ALLOCS
10202 0, /* tp_allocs */
10203 0, /* tp_frees */
10204 0, /* tp_maxalloc */
10205 0, /* tp_prev */
10206 0 /* tp_next */
10207 #endif
10208 };
10209 varlink_type = tmp;
10210 type_init = 1;
10211 if (PyType_Ready(&varlink_type) < 0)
10212 return NULL;
10213 }
10214 return &varlink_type;
10215 }
10216
10217 /* Create a variable linking object for use later */
10218 SWIGINTERN PyObject *
SWIG_Python_newvarlink(void)10219 SWIG_Python_newvarlink(void) {
10220 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
10221 if (result) {
10222 result->vars = 0;
10223 }
10224 return ((PyObject*) result);
10225 }
10226
10227 SWIGINTERN void
SWIG_Python_addvarlink(PyObject * p,const char * name,PyObject * (* get_attr)(void),int (* set_attr)(PyObject * p))10228 SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
10229 swig_varlinkobject *v = (swig_varlinkobject *) p;
10230 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
10231 if (gv) {
10232 size_t size = strlen(name)+1;
10233 gv->name = (char *)malloc(size);
10234 if (gv->name) {
10235 memcpy(gv->name, name, size);
10236 gv->get_attr = get_attr;
10237 gv->set_attr = set_attr;
10238 gv->next = v->vars;
10239 }
10240 }
10241 v->vars = gv;
10242 }
10243
10244 SWIGINTERN PyObject *
SWIG_globals(void)10245 SWIG_globals(void) {
10246 static PyObject *globals = 0;
10247 if (!globals) {
10248 globals = SWIG_newvarlink();
10249 }
10250 return globals;
10251 }
10252
10253 /* -----------------------------------------------------------------------------
10254 * constants/methods manipulation
10255 * ----------------------------------------------------------------------------- */
10256
10257 /* Install Constants */
10258 SWIGINTERN void
SWIG_Python_InstallConstants(PyObject * d,swig_const_info constants[])10259 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
10260 PyObject *obj = 0;
10261 size_t i;
10262 for (i = 0; constants[i].type; ++i) {
10263 switch(constants[i].type) {
10264 case SWIG_PY_POINTER:
10265 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
10266 break;
10267 case SWIG_PY_BINARY:
10268 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
10269 break;
10270 default:
10271 obj = 0;
10272 break;
10273 }
10274 if (obj) {
10275 PyDict_SetItemString(d, constants[i].name, obj);
10276 Py_DECREF(obj);
10277 }
10278 }
10279 }
10280
10281 /* -----------------------------------------------------------------------------*/
10282 /* Fix SwigMethods to carry the callback ptrs when needed */
10283 /* -----------------------------------------------------------------------------*/
10284
10285 SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef * methods,swig_const_info * const_table,swig_type_info ** types,swig_type_info ** types_initial)10286 SWIG_Python_FixMethods(PyMethodDef *methods,
10287 swig_const_info *const_table,
10288 swig_type_info **types,
10289 swig_type_info **types_initial) {
10290 size_t i;
10291 for (i = 0; methods[i].ml_name; ++i) {
10292 const char *c = methods[i].ml_doc;
10293 if (!c) continue;
10294 c = strstr(c, "swig_ptr: ");
10295 if (c) {
10296 int j;
10297 swig_const_info *ci = 0;
10298 const char *name = c + 10;
10299 for (j = 0; const_table[j].type; ++j) {
10300 if (strncmp(const_table[j].name, name,
10301 strlen(const_table[j].name)) == 0) {
10302 ci = &(const_table[j]);
10303 break;
10304 }
10305 }
10306 if (ci) {
10307 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
10308 if (ptr) {
10309 size_t shift = (ci->ptype) - types;
10310 swig_type_info *ty = types_initial[shift];
10311 size_t ldoc = (c - methods[i].ml_doc);
10312 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
10313 char *ndoc = (char*)malloc(ldoc + lptr + 10);
10314 if (ndoc) {
10315 char *buff = ndoc;
10316 memcpy(buff, methods[i].ml_doc, ldoc);
10317 buff += ldoc;
10318 memcpy(buff, "swig_ptr: ", 10);
10319 buff += 10;
10320 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
10321 methods[i].ml_doc = ndoc;
10322 }
10323 }
10324 }
10325 }
10326 }
10327 }
10328
10329 /* -----------------------------------------------------------------------------
10330 * Method creation and docstring support functions
10331 * ----------------------------------------------------------------------------- */
10332
10333 /* -----------------------------------------------------------------------------
10334 * Function to find the method definition with the correct docstring for the
10335 * proxy module as opposed to the low-level API
10336 * ----------------------------------------------------------------------------- */
10337
SWIG_PythonGetProxyDoc(const char * name)10338 SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
10339 /* Find the function in the modified method table */
10340 size_t offset = 0;
10341 int found = 0;
10342 while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
10343 if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
10344 found = 1;
10345 break;
10346 }
10347 offset++;
10348 }
10349 /* Use the copy with the modified docstring if available */
10350 return found ? &SwigMethods_proxydocs[offset] : NULL;
10351 }
10352
10353 /* -----------------------------------------------------------------------------
10354 * Wrapper of PyInstanceMethod_New() used in Python 3
10355 * It is exported to the generated module, used for -fastproxy
10356 * ----------------------------------------------------------------------------- */
10357
SWIG_PyInstanceMethod_New(PyObject * SWIGUNUSEDPARM (self),PyObject * func)10358 SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
10359 if (PyCFunction_Check(func)) {
10360 PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
10361 PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
10362 if (ml)
10363 func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
10364 }
10365 #if PY_VERSION_HEX >= 0x03000000
10366 return PyInstanceMethod_New(func);
10367 #else
10368 return PyMethod_New(func, NULL, NULL);
10369 #endif
10370 }
10371
10372 /* -----------------------------------------------------------------------------
10373 * Wrapper of PyStaticMethod_New()
10374 * It is exported to the generated module, used for -fastproxy
10375 * ----------------------------------------------------------------------------- */
10376
SWIG_PyStaticMethod_New(PyObject * SWIGUNUSEDPARM (self),PyObject * func)10377 SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
10378 if (PyCFunction_Check(func)) {
10379 PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
10380 PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
10381 if (ml)
10382 func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
10383 }
10384 return PyStaticMethod_New(func);
10385 }
10386
10387 #ifdef __cplusplus
10388 }
10389 #endif
10390
10391 /* -----------------------------------------------------------------------------*
10392 * Partial Init method
10393 * -----------------------------------------------------------------------------*/
10394
10395 #ifdef __cplusplus
10396 extern "C"
10397 #endif
10398
10399 SWIGEXPORT
10400 #if PY_VERSION_HEX >= 0x03000000
10401 PyObject*
10402 #else
10403 void
10404 #endif
SWIG_init(void)10405 SWIG_init(void) {
10406 PyObject *m, *d, *md, *globals;
10407
10408 #if PY_VERSION_HEX >= 0x03000000
10409 static struct PyModuleDef SWIG_module = {
10410 PyModuleDef_HEAD_INIT,
10411 SWIG_name,
10412 NULL,
10413 -1,
10414 SwigMethods,
10415 NULL,
10416 NULL,
10417 NULL,
10418 NULL
10419 };
10420 #endif
10421
10422 #if defined(SWIGPYTHON_BUILTIN)
10423 static SwigPyClientData SwigPyObject_clientdata = {
10424 0, 0, 0, 0, 0, 0, 0
10425 };
10426 static PyGetSetDef this_getset_def = {
10427 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
10428 };
10429 static SwigPyGetSet thisown_getset_closure = {
10430 SwigPyObject_own,
10431 SwigPyObject_own
10432 };
10433 static PyGetSetDef thisown_getset_def = {
10434 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
10435 };
10436 PyTypeObject *builtin_pytype;
10437 int builtin_base_count;
10438 swig_type_info *builtin_basetype;
10439 PyObject *tuple;
10440 PyGetSetDescrObject *static_getset;
10441 PyTypeObject *metatype;
10442 PyTypeObject *swigpyobject;
10443 SwigPyClientData *cd;
10444 PyObject *public_interface, *public_symbol;
10445 PyObject *this_descr;
10446 PyObject *thisown_descr;
10447 PyObject *self = 0;
10448 int i;
10449
10450 (void)builtin_pytype;
10451 (void)builtin_base_count;
10452 (void)builtin_basetype;
10453 (void)tuple;
10454 (void)static_getset;
10455 (void)self;
10456
10457 /* Metaclass is used to implement static member variables */
10458 metatype = SwigPyObjectType();
10459 assert(metatype);
10460 #endif
10461
10462 (void)globals;
10463
10464 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
10465 SWIG_This();
10466 SWIG_Python_TypeCache();
10467 SwigPyPacked_type();
10468 #ifndef SWIGPYTHON_BUILTIN
10469 SwigPyObject_type();
10470 #endif
10471
10472 /* Fix SwigMethods to carry the callback ptrs when needed */
10473 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
10474
10475 #if PY_VERSION_HEX >= 0x03000000
10476 m = PyModule_Create(&SWIG_module);
10477 #else
10478 m = Py_InitModule(SWIG_name, SwigMethods);
10479 #endif
10480
10481 md = d = PyModule_GetDict(m);
10482 (void)md;
10483
10484 SWIG_InitializeModule(0);
10485
10486 #ifdef SWIGPYTHON_BUILTIN
10487 swigpyobject = SwigPyObject_TypeOnce();
10488
10489 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
10490 assert(SwigPyObject_stype);
10491 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
10492 if (!cd) {
10493 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
10494 SwigPyObject_clientdata.pytype = swigpyobject;
10495 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
10496 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
10497 # if PY_VERSION_HEX >= 0x03000000
10498 return NULL;
10499 # else
10500 return;
10501 # endif
10502 }
10503
10504 /* All objects have a 'this' attribute */
10505 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
10506 (void)this_descr;
10507
10508 /* All objects have a 'thisown' attribute */
10509 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
10510 (void)thisown_descr;
10511
10512 public_interface = PyList_New(0);
10513 public_symbol = 0;
10514 (void)public_symbol;
10515
10516 PyDict_SetItemString(md, "__all__", public_interface);
10517 Py_DECREF(public_interface);
10518 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
10519 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
10520 for (i = 0; swig_const_table[i].name != 0; ++i)
10521 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
10522 #endif
10523
10524 SWIG_InstallConstants(d,swig_const_table);
10525
10526 #if PY_VERSION_HEX >= 0x03000000
10527 return m;
10528 #else
10529 return;
10530 #endif
10531 }
10532
10533