1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 1.3.40
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 : #define SWIGPYTHON
12 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13 :
14 :
15 : #ifdef __cplusplus
16 : /* SwigValueWrapper is described in swig.swg */
17 : template<typename T> class SwigValueWrapper {
18 : struct SwigMovePointer {
19 : T *ptr;
20 : SwigMovePointer(T *p) : ptr(p) { }
21 : ~SwigMovePointer() { delete ptr; }
22 : SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23 : } pointer;
24 : SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25 : SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 : public:
27 : SwigValueWrapper() : pointer(0) { }
28 : SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29 : operator T&() const { return *pointer.ptr; }
30 : T *operator&() { return pointer.ptr; }
31 : };
32 :
33 : template <typename T> T SwigValueInit() {
34 : return T();
35 : }
36 : #endif
37 :
38 : /* -----------------------------------------------------------------------------
39 : * This section contains generic SWIG labels for method/variable
40 : * declarations/attributes, and other compiler dependent labels.
41 : * ----------------------------------------------------------------------------- */
42 :
43 : /* template workaround for compilers that cannot correctly implement the C++ standard */
44 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 : # define SWIGTEMPLATEDISAMBIGUATOR template
47 : # elif defined(__HP_aCC)
48 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 : # define SWIGTEMPLATEDISAMBIGUATOR template
51 : # else
52 : # define SWIGTEMPLATEDISAMBIGUATOR
53 : # endif
54 : #endif
55 :
56 : /* inline attribute */
57 : #ifndef SWIGINLINE
58 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 : # define SWIGINLINE inline
60 : # else
61 : # define SWIGINLINE
62 : # endif
63 : #endif
64 :
65 : /* attribute recognised by some compilers to avoid 'unused' warnings */
66 : #ifndef SWIGUNUSED
67 : # if defined(__GNUC__)
68 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 : # define SWIGUNUSED __attribute__ ((__unused__))
70 : # else
71 : # define SWIGUNUSED
72 : # endif
73 : # elif defined(__ICC)
74 : # define SWIGUNUSED __attribute__ ((__unused__))
75 : # else
76 : # define SWIGUNUSED
77 : # endif
78 : #endif
79 :
80 : #ifndef SWIG_MSC_UNSUPPRESS_4505
81 : # if defined(_MSC_VER)
82 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 : # endif
84 : #endif
85 :
86 : #ifndef SWIGUNUSEDPARM
87 : # ifdef __cplusplus
88 : # define SWIGUNUSEDPARM(p)
89 : # else
90 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 : # endif
92 : #endif
93 :
94 : /* internal SWIG method */
95 : #ifndef SWIGINTERN
96 : # define SWIGINTERN static SWIGUNUSED
97 : #endif
98 :
99 : /* internal inline SWIG method */
100 : #ifndef SWIGINTERNINLINE
101 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 : #endif
103 :
104 : /* exporting methods */
105 : #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 : # ifndef GCC_HASCLASSVISIBILITY
107 : # define GCC_HASCLASSVISIBILITY
108 : # endif
109 : #endif
110 :
111 : #ifndef SWIGEXPORT
112 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 : # if defined(STATIC_LINKED)
114 : # define SWIGEXPORT
115 : # else
116 : # define SWIGEXPORT __declspec(dllexport)
117 : # endif
118 : # else
119 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 : # define SWIGEXPORT __attribute__ ((visibility("default")))
121 : # else
122 : # define SWIGEXPORT
123 : # endif
124 : # endif
125 : #endif
126 :
127 : /* calling conventions for Windows */
128 : #ifndef SWIGSTDCALL
129 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 : # define SWIGSTDCALL __stdcall
131 : # else
132 : # define SWIGSTDCALL
133 : # endif
134 : #endif
135 :
136 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 : # define _CRT_SECURE_NO_DEPRECATE
139 : #endif
140 :
141 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 : # define _SCL_SECURE_NO_DEPRECATE
144 : #endif
145 :
146 :
147 :
148 : /* Python.h has to appear first */
149 : #include <Python.h>
150 :
151 : /* -----------------------------------------------------------------------------
152 : * swigrun.swg
153 : *
154 : * This file contains generic C API SWIG runtime support for pointer
155 : * type checking.
156 : * ----------------------------------------------------------------------------- */
157 :
158 : /* This should only be incremented when either the layout of swig_type_info changes,
159 : or for whatever reason, the runtime changes incompatibly */
160 : #define SWIG_RUNTIME_VERSION "4"
161 :
162 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
163 : #ifdef SWIG_TYPE_TABLE
164 : # define SWIG_QUOTE_STRING(x) #x
165 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
166 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
167 : #else
168 : # define SWIG_TYPE_TABLE_NAME
169 : #endif
170 :
171 : /*
172 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
173 : creating a static or dynamic library from the SWIG runtime code.
174 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
175 :
176 : But only do this if strictly necessary, ie, if you have problems
177 : with your compiler or suchlike.
178 : */
179 :
180 : #ifndef SWIGRUNTIME
181 : # define SWIGRUNTIME SWIGINTERN
182 : #endif
183 :
184 : #ifndef SWIGRUNTIMEINLINE
185 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
186 : #endif
187 :
188 : /* Generic buffer size */
189 : #ifndef SWIG_BUFFER_SIZE
190 : # define SWIG_BUFFER_SIZE 1024
191 : #endif
192 :
193 : /* Flags for pointer conversions */
194 : #define SWIG_POINTER_DISOWN 0x1
195 : #define SWIG_CAST_NEW_MEMORY 0x2
196 :
197 : /* Flags for new pointer objects */
198 : #define SWIG_POINTER_OWN 0x1
199 :
200 :
201 : /*
202 : Flags/methods for returning states.
203 :
204 : The SWIG conversion methods, as ConvertPtr, return and integer
205 : that tells if the conversion was successful or not. And if not,
206 : an error code can be returned (see swigerrors.swg for the codes).
207 :
208 : Use the following macros/flags to set or process the returning
209 : states.
210 :
211 : In old versions of SWIG, code such as the following was usually written:
212 :
213 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
214 : // success code
215 : } else {
216 : //fail code
217 : }
218 :
219 : Now you can be more explicit:
220 :
221 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
222 : if (SWIG_IsOK(res)) {
223 : // success code
224 : } else {
225 : // fail code
226 : }
227 :
228 : which is the same really, but now you can also do
229 :
230 : Type *ptr;
231 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
232 : if (SWIG_IsOK(res)) {
233 : // success code
234 : if (SWIG_IsNewObj(res) {
235 : ...
236 : delete *ptr;
237 : } else {
238 : ...
239 : }
240 : } else {
241 : // fail code
242 : }
243 :
244 : I.e., now SWIG_ConvertPtr can return new objects and you can
245 : identify the case and take care of the deallocation. Of course that
246 : also requires SWIG_ConvertPtr to return new result values, such as
247 :
248 : int SWIG_ConvertPtr(obj, ptr,...) {
249 : if (<obj is ok>) {
250 : if (<need new object>) {
251 : *ptr = <ptr to new allocated object>;
252 : return SWIG_NEWOBJ;
253 : } else {
254 : *ptr = <ptr to old object>;
255 : return SWIG_OLDOBJ;
256 : }
257 : } else {
258 : return SWIG_BADOBJ;
259 : }
260 : }
261 :
262 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
263 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
264 : SWIG errors code.
265 :
266 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
267 : allows to return the 'cast rank', for example, if you have this
268 :
269 : int food(double)
270 : int fooi(int);
271 :
272 : and you call
273 :
274 : food(1) // cast rank '1' (1 -> 1.0)
275 : fooi(1) // cast rank '0'
276 :
277 : just use the SWIG_AddCast()/SWIG_CheckState()
278 : */
279 :
280 : #define SWIG_OK (0)
281 : #define SWIG_ERROR (-1)
282 : #define SWIG_IsOK(r) (r >= 0)
283 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
284 :
285 : /* The CastRankLimit says how many bits are used for the cast rank */
286 : #define SWIG_CASTRANKLIMIT (1 << 8)
287 : /* The NewMask denotes the object was created (using new/malloc) */
288 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
289 : /* The TmpMask is for in/out typemaps that use temporal objects */
290 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
291 : /* Simple returning values */
292 : #define SWIG_BADOBJ (SWIG_ERROR)
293 : #define SWIG_OLDOBJ (SWIG_OK)
294 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
295 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
296 : /* Check, add and del mask methods */
297 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
298 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
299 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
300 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
301 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
302 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
303 :
304 : /* Cast-Rank Mode */
305 : #if defined(SWIG_CASTRANK_MODE)
306 : # ifndef SWIG_TypeRank
307 : # define SWIG_TypeRank unsigned long
308 : # endif
309 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
310 : # define SWIG_MAXCASTRANK (2)
311 : # endif
312 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
313 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
314 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
315 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
316 : }
317 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
318 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
319 : }
320 : #else /* no cast-rank mode */
321 : # define SWIG_AddCast
322 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
323 : #endif
324 :
325 :
326 : #include <string.h>
327 :
328 : #ifdef __cplusplus
329 : extern "C" {
330 : #endif
331 :
332 : typedef void *(*swig_converter_func)(void *, int *);
333 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
334 :
335 : /* Structure to store information on one type */
336 : typedef struct swig_type_info {
337 : const char *name; /* mangled name of this type */
338 : const char *str; /* human readable name of this type */
339 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
340 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
341 : void *clientdata; /* language specific type data */
342 : int owndata; /* flag if the structure owns the clientdata */
343 : } swig_type_info;
344 :
345 : /* Structure to store a type and conversion function used for casting */
346 : typedef struct swig_cast_info {
347 : swig_type_info *type; /* pointer to type that is equivalent to this type */
348 : swig_converter_func converter; /* function to cast the void pointers */
349 : struct swig_cast_info *next; /* pointer to next cast in linked list */
350 : struct swig_cast_info *prev; /* pointer to the previous cast */
351 : } swig_cast_info;
352 :
353 : /* Structure used to store module information
354 : * Each module generates one structure like this, and the runtime collects
355 : * all of these structures and stores them in a circularly linked list.*/
356 : typedef struct swig_module_info {
357 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
358 : size_t size; /* Number of types in this module */
359 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
360 : swig_type_info **type_initial; /* Array of initially generated type structures */
361 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
362 : void *clientdata; /* Language specific module data */
363 : } swig_module_info;
364 :
365 : /*
366 : Compare two type names skipping the space characters, therefore
367 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
368 :
369 : Return 0 when the two name types are equivalent, as in
370 : strncmp, but skipping ' '.
371 : */
372 : SWIGRUNTIME int
373 : SWIG_TypeNameComp(const char *f1, const char *l1,
374 : const char *f2, const char *l2) {
375 0 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
376 0 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
377 0 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
378 0 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
379 : }
380 0 : return (int)((l1 - f1) - (l2 - f2));
381 : }
382 :
383 : /*
384 : Check type equivalence in a name list like <name1>|<name2>|...
385 : Return 0 if not equal, 1 if equal
386 : */
387 : SWIGRUNTIME int
388 : SWIG_TypeEquiv(const char *nb, const char *tb) {
389 0 : int equiv = 0;
390 0 : const char* te = tb + strlen(tb);
391 0 : const char* ne = nb;
392 0 : while (!equiv && *ne) {
393 0 : for (nb = ne; *ne; ++ne) {
394 0 : if (*ne == '|') break;
395 : }
396 0 : equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
397 0 : if (*ne) ++ne;
398 : }
399 0 : return equiv;
400 : }
401 :
402 : /*
403 : Check type equivalence in a name list like <name1>|<name2>|...
404 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
405 : */
406 : SWIGRUNTIME int
407 : SWIG_TypeCompare(const char *nb, const char *tb) {
408 : int equiv = 0;
409 : const char* te = tb + strlen(tb);
410 : const char* ne = nb;
411 : while (!equiv && *ne) {
412 : for (nb = ne; *ne; ++ne) {
413 : if (*ne == '|') break;
414 : }
415 : equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
416 : if (*ne) ++ne;
417 : }
418 : return equiv;
419 : }
420 :
421 :
422 : /*
423 : Check the typename
424 : */
425 : SWIGRUNTIME swig_cast_info *
426 19 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
427 19 : if (ty) {
428 19 : swig_cast_info *iter = ty->cast;
429 38 : while (iter) {
430 19 : if (strcmp(iter->type->name, c) == 0) {
431 19 : if (iter == ty->cast)
432 19 : return iter;
433 : /* Move iter to the top of the linked list */
434 0 : iter->prev->next = iter->next;
435 0 : if (iter->next)
436 0 : iter->next->prev = iter->prev;
437 0 : iter->next = ty->cast;
438 0 : iter->prev = 0;
439 0 : if (ty->cast) ty->cast->prev = iter;
440 0 : ty->cast = iter;
441 0 : return iter;
442 : }
443 0 : iter = iter->next;
444 : }
445 : }
446 0 : return 0;
447 : }
448 :
449 : /*
450 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
451 : */
452 : SWIGRUNTIME swig_cast_info *
453 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
454 : if (ty) {
455 : swig_cast_info *iter = ty->cast;
456 : while (iter) {
457 : if (iter->type == from) {
458 : if (iter == ty->cast)
459 : return iter;
460 : /* Move iter to the top of the linked list */
461 : iter->prev->next = iter->next;
462 : if (iter->next)
463 : iter->next->prev = iter->prev;
464 : iter->next = ty->cast;
465 : iter->prev = 0;
466 : if (ty->cast) ty->cast->prev = iter;
467 : ty->cast = iter;
468 : return iter;
469 : }
470 : iter = iter->next;
471 : }
472 : }
473 : return 0;
474 : }
475 :
476 : /*
477 : Cast a pointer up an inheritance hierarchy
478 : */
479 : SWIGRUNTIMEINLINE void *
480 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
481 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
482 : }
483 :
484 : /*
485 : Dynamic pointer casting. Down an inheritance hierarchy
486 : */
487 : SWIGRUNTIME swig_type_info *
488 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
489 : swig_type_info *lastty = ty;
490 : if (!ty || !ty->dcast) return ty;
491 : while (ty && (ty->dcast)) {
492 : ty = (*ty->dcast)(ptr);
493 : if (ty) lastty = ty;
494 : }
495 : return lastty;
496 : }
497 :
498 : /*
499 : Return the name associated with this type
500 : */
501 : SWIGRUNTIMEINLINE const char *
502 : SWIG_TypeName(const swig_type_info *ty) {
503 : return ty->name;
504 : }
505 :
506 : /*
507 : Return the pretty name associated with this type,
508 : that is an unmangled type name in a form presentable to the user.
509 : */
510 : SWIGRUNTIME const char *
511 : SWIG_TypePrettyName(const swig_type_info *type) {
512 : /* The "str" field contains the equivalent pretty names of the
513 : type, separated by vertical-bar characters. We choose
514 : to print the last name, as it is often (?) the most
515 : specific. */
516 0 : if (!type) return NULL;
517 0 : if (type->str != NULL) {
518 0 : const char *last_name = type->str;
519 : const char *s;
520 0 : for (s = type->str; *s; s++)
521 0 : if (*s == '|') last_name = s+1;
522 0 : return last_name;
523 : }
524 : else
525 0 : return type->name;
526 : }
527 :
528 : /*
529 : Set the clientdata field for a type
530 : */
531 : SWIGRUNTIME void
532 8 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
533 8 : swig_cast_info *cast = ti->cast;
534 : /* if (ti->clientdata == clientdata) return; */
535 8 : ti->clientdata = clientdata;
536 :
537 24 : while (cast) {
538 8 : if (!cast->converter) {
539 8 : swig_type_info *tc = cast->type;
540 8 : if (!tc->clientdata) {
541 0 : SWIG_TypeClientData(tc, clientdata);
542 : }
543 : }
544 8 : cast = cast->next;
545 : }
546 8 : }
547 : SWIGRUNTIME void
548 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
549 8 : SWIG_TypeClientData(ti, clientdata);
550 8 : ti->owndata = 1;
551 : }
552 :
553 : /*
554 : Search for a swig_type_info structure only by mangled name
555 : Search is a O(log #types)
556 :
557 : We start searching at module start, and finish searching when start == end.
558 : Note: if start == end at the beginning of the function, we go all the way around
559 : the circular list.
560 : */
561 : SWIGRUNTIME swig_type_info *
562 64 : SWIG_MangledTypeQueryModule(swig_module_info *start,
563 : swig_module_info *end,
564 : const char *name) {
565 64 : swig_module_info *iter = start;
566 70 : do {
567 108 : if (iter->size) {
568 108 : register size_t l = 0;
569 108 : register size_t r = iter->size - 1;
570 236 : do {
571 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
572 286 : register size_t i = (l + r) >> 1;
573 286 : const char *iname = iter->types[i]->name;
574 286 : if (iname) {
575 286 : register int compare = strcmp(name, iname);
576 286 : if (compare == 0) {
577 38 : return iter->types[i];
578 248 : } else if (compare < 0) {
579 84 : if (i) {
580 72 : r = i - 1;
581 : } else {
582 : break;
583 : }
584 164 : } else if (compare > 0) {
585 164 : l = i + 1;
586 : }
587 : } else {
588 : break; /* should never happen */
589 : }
590 : } while (l <= r);
591 : }
592 70 : iter = iter->next;
593 : } while (iter != end);
594 26 : return 0;
595 : }
596 :
597 : /*
598 : Search for a swig_type_info structure for either a mangled name or a human readable name.
599 : It first searches the mangled names of the types, which is a O(log #types)
600 : If a type is not found it then searches the human readable names, which is O(#types).
601 :
602 : We start searching at module start, and finish searching when start == end.
603 : Note: if start == end at the beginning of the function, we go all the way around
604 : the circular list.
605 : */
606 : SWIGRUNTIME swig_type_info *
607 0 : SWIG_TypeQueryModule(swig_module_info *start,
608 : swig_module_info *end,
609 : const char *name) {
610 : /* STEP 1: Search the name field using binary search */
611 0 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
612 0 : if (ret) {
613 0 : return ret;
614 : } else {
615 : /* STEP 2: If the type hasn't been found, do a complete search
616 : of the str field (the human readable name) */
617 0 : swig_module_info *iter = start;
618 0 : do {
619 0 : register size_t i = 0;
620 0 : for (; i < iter->size; ++i) {
621 0 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
622 0 : return iter->types[i];
623 : }
624 0 : iter = iter->next;
625 : } while (iter != end);
626 : }
627 :
628 : /* neither found a match */
629 0 : return 0;
630 : }
631 :
632 : /*
633 : Pack binary data into a string
634 : */
635 : SWIGRUNTIME char *
636 : SWIG_PackData(char *c, void *ptr, size_t sz) {
637 : static const char hex[17] = "0123456789abcdef";
638 0 : register const unsigned char *u = (unsigned char *) ptr;
639 0 : register const unsigned char *eu = u + sz;
640 0 : for (; u != eu; ++u) {
641 0 : register unsigned char uu = *u;
642 0 : *(c++) = hex[(uu & 0xf0) >> 4];
643 0 : *(c++) = hex[uu & 0xf];
644 : }
645 0 : return c;
646 : }
647 :
648 : /*
649 : Unpack binary data from a string
650 : */
651 : SWIGRUNTIME const char *
652 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
653 : register unsigned char *u = (unsigned char *) ptr;
654 : register const unsigned char *eu = u + sz;
655 : for (; u != eu; ++u) {
656 : register char d = *(c++);
657 : register unsigned char uu;
658 : if ((d >= '0') && (d <= '9'))
659 : uu = ((d - '0') << 4);
660 : else if ((d >= 'a') && (d <= 'f'))
661 : uu = ((d - ('a'-10)) << 4);
662 : else
663 : return (char *) 0;
664 : d = *(c++);
665 : if ((d >= '0') && (d <= '9'))
666 : uu |= (d - '0');
667 : else if ((d >= 'a') && (d <= 'f'))
668 : uu |= (d - ('a'-10));
669 : else
670 : return (char *) 0;
671 : *u = uu;
672 : }
673 : return c;
674 : }
675 :
676 : /*
677 : Pack 'void *' into a string buffer.
678 : */
679 : SWIGRUNTIME char *
680 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
681 0 : char *r = buff;
682 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
683 0 : *(r++) = '_';
684 0 : r = SWIG_PackData(r,&ptr,sizeof(void *));
685 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
686 : strcpy(r,name);
687 0 : return buff;
688 : }
689 :
690 : SWIGRUNTIME const char *
691 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
692 : if (*c != '_') {
693 : if (strcmp(c,"NULL") == 0) {
694 : *ptr = (void *) 0;
695 : return name;
696 : } else {
697 : return 0;
698 : }
699 : }
700 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
701 : }
702 :
703 : SWIGRUNTIME char *
704 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
705 0 : char *r = buff;
706 0 : size_t lname = (name ? strlen(name) : 0);
707 0 : if ((2*sz + 2 + lname) > bsz) return 0;
708 0 : *(r++) = '_';
709 0 : r = SWIG_PackData(r,ptr,sz);
710 0 : if (lname) {
711 0 : strncpy(r,name,lname+1);
712 : } else {
713 0 : *r = 0;
714 : }
715 0 : return buff;
716 : }
717 :
718 : SWIGRUNTIME const char *
719 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
720 : if (*c != '_') {
721 : if (strcmp(c,"NULL") == 0) {
722 : memset(ptr,0,sz);
723 : return name;
724 : } else {
725 : return 0;
726 : }
727 : }
728 : return SWIG_UnpackData(++c,ptr,sz);
729 : }
730 :
731 : #ifdef __cplusplus
732 : }
733 : #endif
734 :
735 : /* Errors in SWIG */
736 : #define SWIG_UnknownError -1
737 : #define SWIG_IOError -2
738 : #define SWIG_RuntimeError -3
739 : #define SWIG_IndexError -4
740 : #define SWIG_TypeError -5
741 : #define SWIG_DivisionByZero -6
742 : #define SWIG_OverflowError -7
743 : #define SWIG_SyntaxError -8
744 : #define SWIG_ValueError -9
745 : #define SWIG_SystemError -10
746 : #define SWIG_AttributeError -11
747 : #define SWIG_MemoryError -12
748 : #define SWIG_NullReferenceError -13
749 :
750 :
751 :
752 : /* Compatibility macros for Python 3 */
753 : #if PY_VERSION_HEX >= 0x03000000
754 :
755 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
756 : #define PyInt_Check(x) PyLong_Check(x)
757 : #define PyInt_AsLong(x) PyLong_AsLong(x)
758 : #define PyInt_FromLong(x) PyLong_FromLong(x)
759 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
760 :
761 : #endif
762 :
763 : #ifndef Py_TYPE
764 : # define Py_TYPE(op) ((op)->ob_type)
765 : #endif
766 :
767 : /* SWIG APIs for compatibility of both Python 2 & 3 */
768 :
769 : #if PY_VERSION_HEX >= 0x03000000
770 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
771 : #else
772 : # define SWIG_Python_str_FromFormat PyString_FromFormat
773 : #endif
774 :
775 :
776 : /* Warning: This function will allocate a new string in Python 3,
777 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
778 : */
779 : SWIGINTERN char*
780 : SWIG_Python_str_AsChar(PyObject *str)
781 : {
782 : #if PY_VERSION_HEX >= 0x03000000
783 : char *cstr;
784 : char *newstr;
785 : Py_ssize_t len;
786 : str = PyUnicode_AsUTF8String(str);
787 : PyBytes_AsStringAndSize(str, &cstr, &len);
788 : newstr = (char *) malloc(len+1);
789 : memcpy(newstr, cstr, len+1);
790 : Py_XDECREF(str);
791 : return newstr;
792 : #else
793 0 : return PyString_AsString(str);
794 : #endif
795 : }
796 :
797 : #if PY_VERSION_HEX >= 0x03000000
798 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
799 : #else
800 : # define SWIG_Python_str_DelForPy3(x)
801 : #endif
802 :
803 :
804 : SWIGINTERN PyObject*
805 : SWIG_Python_str_FromChar(const char *c)
806 : {
807 : #if PY_VERSION_HEX >= 0x03000000
808 : return PyUnicode_FromString(c);
809 : #else
810 2 : return PyString_FromString(c);
811 : #endif
812 : }
813 :
814 : /* Add PyOS_snprintf for old Pythons */
815 : #if PY_VERSION_HEX < 0x02020000
816 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
817 : # define PyOS_snprintf _snprintf
818 : # else
819 : # define PyOS_snprintf snprintf
820 : # endif
821 : #endif
822 :
823 : /* A crude PyString_FromFormat implementation for old Pythons */
824 : #if PY_VERSION_HEX < 0x02020000
825 :
826 : #ifndef SWIG_PYBUFFER_SIZE
827 : # define SWIG_PYBUFFER_SIZE 1024
828 : #endif
829 :
830 : static PyObject *
831 : PyString_FromFormat(const char *fmt, ...) {
832 : va_list ap;
833 : char buf[SWIG_PYBUFFER_SIZE * 2];
834 : int res;
835 : va_start(ap, fmt);
836 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
837 : va_end(ap);
838 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
839 : }
840 : #endif
841 :
842 : /* Add PyObject_Del for old Pythons */
843 : #if PY_VERSION_HEX < 0x01060000
844 : # define PyObject_Del(op) PyMem_DEL((op))
845 : #endif
846 : #ifndef PyObject_DEL
847 : # define PyObject_DEL PyObject_Del
848 : #endif
849 :
850 : /* A crude PyExc_StopIteration exception for old Pythons */
851 : #if PY_VERSION_HEX < 0x02020000
852 : # ifndef PyExc_StopIteration
853 : # define PyExc_StopIteration PyExc_RuntimeError
854 : # endif
855 : # ifndef PyObject_GenericGetAttr
856 : # define PyObject_GenericGetAttr 0
857 : # endif
858 : #endif
859 :
860 : /* Py_NotImplemented is defined in 2.1 and up. */
861 : #if PY_VERSION_HEX < 0x02010000
862 : # ifndef Py_NotImplemented
863 : # define Py_NotImplemented PyExc_RuntimeError
864 : # endif
865 : #endif
866 :
867 : /* A crude PyString_AsStringAndSize implementation for old Pythons */
868 : #if PY_VERSION_HEX < 0x02010000
869 : # ifndef PyString_AsStringAndSize
870 : # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
871 : # endif
872 : #endif
873 :
874 : /* PySequence_Size for old Pythons */
875 : #if PY_VERSION_HEX < 0x02000000
876 : # ifndef PySequence_Size
877 : # define PySequence_Size PySequence_Length
878 : # endif
879 : #endif
880 :
881 : /* PyBool_FromLong for old Pythons */
882 : #if PY_VERSION_HEX < 0x02030000
883 : static
884 : PyObject *PyBool_FromLong(long ok)
885 : {
886 : PyObject *result = ok ? Py_True : Py_False;
887 : Py_INCREF(result);
888 : return result;
889 : }
890 : #endif
891 :
892 : /* Py_ssize_t for old Pythons */
893 : /* This code is as recommended by: */
894 : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
895 : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
896 : typedef int Py_ssize_t;
897 : # define PY_SSIZE_T_MAX INT_MAX
898 : # define PY_SSIZE_T_MIN INT_MIN
899 : #endif
900 :
901 : /* -----------------------------------------------------------------------------
902 : * error manipulation
903 : * ----------------------------------------------------------------------------- */
904 :
905 : SWIGRUNTIME PyObject*
906 0 : SWIG_Python_ErrorType(int code) {
907 0 : PyObject* type = 0;
908 0 : switch(code) {
909 : case SWIG_MemoryError:
910 0 : type = PyExc_MemoryError;
911 0 : break;
912 : case SWIG_IOError:
913 0 : type = PyExc_IOError;
914 0 : break;
915 : case SWIG_RuntimeError:
916 0 : type = PyExc_RuntimeError;
917 0 : break;
918 : case SWIG_IndexError:
919 0 : type = PyExc_IndexError;
920 0 : break;
921 : case SWIG_TypeError:
922 0 : type = PyExc_TypeError;
923 0 : break;
924 : case SWIG_DivisionByZero:
925 0 : type = PyExc_ZeroDivisionError;
926 0 : break;
927 : case SWIG_OverflowError:
928 0 : type = PyExc_OverflowError;
929 0 : break;
930 : case SWIG_SyntaxError:
931 0 : type = PyExc_SyntaxError;
932 0 : break;
933 : case SWIG_ValueError:
934 0 : type = PyExc_ValueError;
935 0 : break;
936 : case SWIG_SystemError:
937 0 : type = PyExc_SystemError;
938 0 : break;
939 : case SWIG_AttributeError:
940 0 : type = PyExc_AttributeError;
941 0 : break;
942 : default:
943 0 : type = PyExc_RuntimeError;
944 : }
945 0 : return type;
946 : }
947 :
948 :
949 : SWIGRUNTIME void
950 : SWIG_Python_AddErrorMsg(const char* mesg)
951 : {
952 : PyObject *type = 0;
953 : PyObject *value = 0;
954 : PyObject *traceback = 0;
955 :
956 : if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
957 : if (value) {
958 : char *tmp;
959 : PyObject *old_str = PyObject_Str(value);
960 : PyErr_Clear();
961 : Py_XINCREF(type);
962 :
963 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
964 : SWIG_Python_str_DelForPy3(tmp);
965 : Py_DECREF(old_str);
966 : Py_DECREF(value);
967 : } else {
968 : PyErr_SetString(PyExc_RuntimeError, mesg);
969 : }
970 : }
971 :
972 : #if defined(SWIG_PYTHON_NO_THREADS)
973 : # if defined(SWIG_PYTHON_THREADS)
974 : # undef SWIG_PYTHON_THREADS
975 : # endif
976 : #endif
977 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
978 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
979 : # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
980 : # define SWIG_PYTHON_USE_GIL
981 : # endif
982 : # endif
983 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
984 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
985 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
986 : # endif
987 : # ifdef __cplusplus /* C++ code */
988 : class SWIG_Python_Thread_Block {
989 : bool status;
990 : PyGILState_STATE state;
991 : public:
992 : void end() { if (status) { PyGILState_Release(state); status = false;} }
993 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
994 : ~SWIG_Python_Thread_Block() { end(); }
995 : };
996 : class SWIG_Python_Thread_Allow {
997 : bool status;
998 : PyThreadState *save;
999 : public:
1000 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1001 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1002 : ~SWIG_Python_Thread_Allow() { end(); }
1003 : };
1004 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1005 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1006 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1007 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1008 : # else /* C code */
1009 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1010 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1011 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1012 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1013 : # endif
1014 : # else /* Old thread way, not implemented, user must provide it */
1015 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1016 : # define SWIG_PYTHON_INITIALIZE_THREADS
1017 : # endif
1018 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1019 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1020 : # endif
1021 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1022 : # define SWIG_PYTHON_THREAD_END_BLOCK
1023 : # endif
1024 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1025 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1026 : # endif
1027 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1028 : # define SWIG_PYTHON_THREAD_END_ALLOW
1029 : # endif
1030 : # endif
1031 : #else /* No thread support */
1032 : # define SWIG_PYTHON_INITIALIZE_THREADS
1033 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1034 : # define SWIG_PYTHON_THREAD_END_BLOCK
1035 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1036 : # define SWIG_PYTHON_THREAD_END_ALLOW
1037 : #endif
1038 :
1039 : /* -----------------------------------------------------------------------------
1040 : * Python API portion that goes into the runtime
1041 : * ----------------------------------------------------------------------------- */
1042 :
1043 : #ifdef __cplusplus
1044 : extern "C" {
1045 : #if 0
1046 : } /* cc-mode */
1047 : #endif
1048 : #endif
1049 :
1050 : /* -----------------------------------------------------------------------------
1051 : * Constant declarations
1052 : * ----------------------------------------------------------------------------- */
1053 :
1054 : /* Constant Types */
1055 : #define SWIG_PY_POINTER 4
1056 : #define SWIG_PY_BINARY 5
1057 :
1058 : /* Constant information structure */
1059 : typedef struct swig_const_info {
1060 : int type;
1061 : char *name;
1062 : long lvalue;
1063 : double dvalue;
1064 : void *pvalue;
1065 : swig_type_info **ptype;
1066 : } swig_const_info;
1067 :
1068 :
1069 : /* -----------------------------------------------------------------------------
1070 : * Wrapper of PyInstanceMethod_New() used in Python 3
1071 : * It is exported to the generated module, used for -fastproxy
1072 : * ----------------------------------------------------------------------------- */
1073 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
1074 : {
1075 : #if PY_VERSION_HEX >= 0x03000000
1076 : return PyInstanceMethod_New(func);
1077 : #else
1078 0 : return NULL;
1079 : #endif
1080 : }
1081 :
1082 : #ifdef __cplusplus
1083 : #if 0
1084 : { /* cc-mode */
1085 : #endif
1086 : }
1087 : #endif
1088 :
1089 :
1090 : /* -----------------------------------------------------------------------------
1091 : * See the LICENSE file for information on copyright, usage and redistribution
1092 : * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1093 : *
1094 : * pyrun.swg
1095 : *
1096 : * This file contains the runtime support for Python modules
1097 : * and includes code for managing global variables and pointer
1098 : * type checking.
1099 : *
1100 : * ----------------------------------------------------------------------------- */
1101 :
1102 : /* Common SWIG API */
1103 :
1104 : /* for raw pointers */
1105 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1106 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1107 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1108 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1109 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1110 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1111 : #define swig_owntype int
1112 :
1113 : /* for raw packed data */
1114 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1115 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1116 :
1117 : /* for class or struct pointers */
1118 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1119 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1120 :
1121 : /* for C or C++ function pointers */
1122 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1123 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1124 :
1125 : /* for C++ member pointers, ie, member methods */
1126 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1127 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1128 :
1129 :
1130 : /* Runtime API */
1131 :
1132 : #if PY_VERSION_HEX >= 0x03020000
1133 : #define SWIG_PYTHON_USE_CAPSULE
1134 : #endif
1135 :
1136 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1137 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1138 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1139 :
1140 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1141 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1142 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1143 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1144 : #define SWIG_fail goto fail
1145 :
1146 :
1147 : /* Runtime API implementation */
1148 :
1149 : /* Error manipulation */
1150 :
1151 : SWIGINTERN void
1152 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1153 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1154 : PyErr_SetObject(errtype, obj);
1155 : Py_DECREF(obj);
1156 : SWIG_PYTHON_THREAD_END_BLOCK;
1157 : }
1158 :
1159 : SWIGINTERN void
1160 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1161 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1162 0 : PyErr_SetString(errtype, (char *) msg);
1163 : SWIG_PYTHON_THREAD_END_BLOCK;
1164 : }
1165 :
1166 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1167 :
1168 : /* Set a constant value */
1169 :
1170 : SWIGINTERN void
1171 456 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1172 456 : PyDict_SetItemString(d, (char*) name, obj);
1173 456 : Py_DECREF(obj);
1174 456 : }
1175 :
1176 : /* Append a value to the result obj */
1177 :
1178 : SWIGINTERN PyObject*
1179 61543 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1180 : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1181 61543 : if (!result) {
1182 61445 : result = obj;
1183 98 : } else if (result == Py_None) {
1184 83 : Py_DECREF(result);
1185 83 : result = obj;
1186 : } else {
1187 15 : if (!PyList_Check(result)) {
1188 7 : PyObject *o2 = result;
1189 7 : result = PyList_New(1);
1190 7 : PyList_SetItem(result, 0, o2);
1191 : }
1192 15 : PyList_Append(result,obj);
1193 15 : Py_DECREF(obj);
1194 : }
1195 61543 : return result;
1196 : #else
1197 : PyObject* o2;
1198 : PyObject* o3;
1199 : if (!result) {
1200 : result = obj;
1201 : } else if (result == Py_None) {
1202 : Py_DECREF(result);
1203 : result = obj;
1204 : } else {
1205 : if (!PyTuple_Check(result)) {
1206 : o2 = result;
1207 : result = PyTuple_New(1);
1208 : PyTuple_SET_ITEM(result, 0, o2);
1209 : }
1210 : o3 = PyTuple_New(1);
1211 : PyTuple_SET_ITEM(o3, 0, obj);
1212 : o2 = result;
1213 : result = PySequence_Concat(o2, o3);
1214 : Py_DECREF(o2);
1215 : Py_DECREF(o3);
1216 : }
1217 : return result;
1218 : #endif
1219 : }
1220 :
1221 : /* Unpack the argument tuple */
1222 :
1223 : SWIGINTERN int
1224 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1225 : {
1226 : if (!args) {
1227 : if (!min && !max) {
1228 : return 1;
1229 : } else {
1230 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1231 : name, (min == max ? "" : "at least "), (int)min);
1232 : return 0;
1233 : }
1234 : }
1235 : if (!PyTuple_Check(args)) {
1236 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1237 : return 0;
1238 : } else {
1239 : register Py_ssize_t l = PyTuple_GET_SIZE(args);
1240 : if (l < min) {
1241 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1242 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1243 : return 0;
1244 : } else if (l > max) {
1245 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1246 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1247 : return 0;
1248 : } else {
1249 : register int i;
1250 : for (i = 0; i < l; ++i) {
1251 : objs[i] = PyTuple_GET_ITEM(args, i);
1252 : }
1253 : for (; l < max; ++l) {
1254 : objs[l] = 0;
1255 : }
1256 : return i + 1;
1257 : }
1258 : }
1259 : }
1260 :
1261 : /* A functor is a function object with one single object argument */
1262 : #if PY_VERSION_HEX >= 0x02020000
1263 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1264 : #else
1265 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1266 : #endif
1267 :
1268 : /*
1269 : Helper for static pointer initialization for both C and C++ code, for example
1270 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1271 : */
1272 : #ifdef __cplusplus
1273 : #define SWIG_STATIC_POINTER(var) var
1274 : #else
1275 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1276 : #endif
1277 :
1278 : /* -----------------------------------------------------------------------------
1279 : * Pointer declarations
1280 : * ----------------------------------------------------------------------------- */
1281 :
1282 : /* Flags for new pointer objects */
1283 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1284 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1285 :
1286 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1287 :
1288 : #ifdef __cplusplus
1289 : extern "C" {
1290 : #if 0
1291 : } /* cc-mode */
1292 : #endif
1293 : #endif
1294 :
1295 : /* How to access Py_None */
1296 : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1297 : # ifndef SWIG_PYTHON_NO_BUILD_NONE
1298 : # ifndef SWIG_PYTHON_BUILD_NONE
1299 : # define SWIG_PYTHON_BUILD_NONE
1300 : # endif
1301 : # endif
1302 : #endif
1303 :
1304 : #ifdef SWIG_PYTHON_BUILD_NONE
1305 : # ifdef Py_None
1306 : # undef Py_None
1307 : # define Py_None SWIG_Py_None()
1308 : # endif
1309 : SWIGRUNTIMEINLINE PyObject *
1310 : _SWIG_Py_None(void)
1311 : {
1312 : PyObject *none = Py_BuildValue((char*)"");
1313 : Py_DECREF(none);
1314 : return none;
1315 : }
1316 : SWIGRUNTIME PyObject *
1317 : SWIG_Py_None(void)
1318 : {
1319 : static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1320 : return none;
1321 : }
1322 : #endif
1323 :
1324 : /* The python void return value */
1325 :
1326 : SWIGRUNTIMEINLINE PyObject *
1327 : SWIG_Py_Void(void)
1328 : {
1329 49555 : PyObject *none = Py_None;
1330 49555 : Py_INCREF(none);
1331 49555 : return none;
1332 : }
1333 :
1334 : /* SwigPyClientData */
1335 :
1336 : typedef struct {
1337 : PyObject *klass;
1338 : PyObject *newraw;
1339 : PyObject *newargs;
1340 : PyObject *destroy;
1341 : int delargs;
1342 : int implicitconv;
1343 : } SwigPyClientData;
1344 :
1345 : SWIGRUNTIMEINLINE int
1346 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1347 : {
1348 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1349 : return data ? data->implicitconv : 0;
1350 : }
1351 :
1352 : SWIGRUNTIMEINLINE PyObject *
1353 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1354 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1355 : PyObject *klass = data ? data->klass : 0;
1356 : return (klass ? klass : PyExc_RuntimeError);
1357 : }
1358 :
1359 :
1360 : SWIGRUNTIME SwigPyClientData *
1361 8 : SwigPyClientData_New(PyObject* obj)
1362 : {
1363 8 : if (!obj) {
1364 0 : return 0;
1365 : } else {
1366 8 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1367 : /* the klass element */
1368 8 : data->klass = obj;
1369 8 : Py_INCREF(data->klass);
1370 : /* the newraw method and newargs arguments used to create a new raw instance */
1371 8 : if (PyClass_Check(obj)) {
1372 0 : data->newraw = 0;
1373 0 : data->newargs = obj;
1374 0 : Py_INCREF(obj);
1375 : } else {
1376 : #if (PY_VERSION_HEX < 0x02020000)
1377 : data->newraw = 0;
1378 : #else
1379 8 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1380 : #endif
1381 8 : if (data->newraw) {
1382 8 : Py_INCREF(data->newraw);
1383 8 : data->newargs = PyTuple_New(1);
1384 8 : PyTuple_SetItem(data->newargs, 0, obj);
1385 : } else {
1386 0 : data->newargs = obj;
1387 : }
1388 8 : Py_INCREF(data->newargs);
1389 : }
1390 : /* the destroy method, aka as the C++ delete method */
1391 8 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1392 8 : if (PyErr_Occurred()) {
1393 0 : PyErr_Clear();
1394 0 : data->destroy = 0;
1395 : }
1396 8 : if (data->destroy) {
1397 : int flags;
1398 8 : Py_INCREF(data->destroy);
1399 8 : flags = PyCFunction_GET_FLAGS(data->destroy);
1400 : #ifdef METH_O
1401 8 : data->delargs = !(flags & (METH_O));
1402 : #else
1403 : data->delargs = 0;
1404 : #endif
1405 : } else {
1406 0 : data->delargs = 0;
1407 : }
1408 8 : data->implicitconv = 0;
1409 8 : return data;
1410 : }
1411 : }
1412 :
1413 : SWIGRUNTIME void
1414 : SwigPyClientData_Del(SwigPyClientData* data)
1415 : {
1416 0 : Py_XDECREF(data->newraw);
1417 0 : Py_XDECREF(data->newargs);
1418 0 : Py_XDECREF(data->destroy);
1419 : }
1420 :
1421 : /* =============== SwigPyObject =====================*/
1422 :
1423 : typedef struct {
1424 : PyObject_HEAD
1425 : void *ptr;
1426 : swig_type_info *ty;
1427 : int own;
1428 : PyObject *next;
1429 : } SwigPyObject;
1430 :
1431 : SWIGRUNTIME PyObject *
1432 0 : SwigPyObject_long(SwigPyObject *v)
1433 : {
1434 0 : return PyLong_FromVoidPtr(v->ptr);
1435 : }
1436 :
1437 : SWIGRUNTIME PyObject *
1438 0 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1439 : {
1440 0 : PyObject *res = NULL;
1441 0 : PyObject *args = PyTuple_New(1);
1442 0 : if (args) {
1443 0 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1444 0 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1445 0 : if (ofmt) {
1446 : #if PY_VERSION_HEX >= 0x03000000
1447 : res = PyUnicode_Format(ofmt,args);
1448 : #else
1449 0 : res = PyString_Format(ofmt,args);
1450 : #endif
1451 0 : Py_DECREF(ofmt);
1452 : }
1453 0 : Py_DECREF(args);
1454 : }
1455 : }
1456 0 : return res;
1457 : }
1458 :
1459 : SWIGRUNTIME PyObject *
1460 0 : SwigPyObject_oct(SwigPyObject *v)
1461 : {
1462 0 : return SwigPyObject_format("%o",v);
1463 : }
1464 :
1465 : SWIGRUNTIME PyObject *
1466 0 : SwigPyObject_hex(SwigPyObject *v)
1467 : {
1468 0 : return SwigPyObject_format("%x",v);
1469 : }
1470 :
1471 : SWIGRUNTIME PyObject *
1472 : #ifdef METH_NOARGS
1473 0 : SwigPyObject_repr(SwigPyObject *v)
1474 : #else
1475 : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1476 : #endif
1477 : {
1478 0 : const char *name = SWIG_TypePrettyName(v->ty);
1479 0 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
1480 0 : if (v->next) {
1481 : #ifdef METH_NOARGS
1482 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1483 : #else
1484 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1485 : #endif
1486 : #if PY_VERSION_HEX >= 0x03000000
1487 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1488 : Py_DecRef(repr);
1489 : Py_DecRef(nrep);
1490 : repr = joined;
1491 : #else
1492 0 : PyString_ConcatAndDel(&repr,nrep);
1493 : #endif
1494 : }
1495 0 : return repr;
1496 : }
1497 :
1498 : SWIGRUNTIME int
1499 0 : SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1500 : {
1501 : char *str;
1502 : #ifdef METH_NOARGS
1503 0 : PyObject *repr = SwigPyObject_repr(v);
1504 : #else
1505 : PyObject *repr = SwigPyObject_repr(v, NULL);
1506 : #endif
1507 0 : if (repr) {
1508 0 : str = SWIG_Python_str_AsChar(repr);
1509 0 : fputs(str, fp);
1510 : SWIG_Python_str_DelForPy3(str);
1511 0 : Py_DECREF(repr);
1512 0 : return 0;
1513 : } else {
1514 0 : return 1;
1515 : }
1516 : }
1517 :
1518 : SWIGRUNTIME PyObject *
1519 0 : SwigPyObject_str(SwigPyObject *v)
1520 : {
1521 : char result[SWIG_BUFFER_SIZE];
1522 : return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1523 0 : SWIG_Python_str_FromChar(result) : 0;
1524 : }
1525 :
1526 : SWIGRUNTIME int
1527 0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1528 : {
1529 0 : void *i = v->ptr;
1530 0 : void *j = w->ptr;
1531 0 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1532 : }
1533 :
1534 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1535 : SWIGRUNTIME PyObject*
1536 0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1537 : {
1538 : PyObject* res;
1539 0 : if( op != Py_EQ && op != Py_NE ) {
1540 0 : Py_INCREF(Py_NotImplemented);
1541 0 : return Py_NotImplemented;
1542 : }
1543 0 : if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1544 0 : res = Py_True;
1545 : else
1546 0 : res = Py_False;
1547 0 : Py_INCREF(res);
1548 0 : return res;
1549 : }
1550 :
1551 :
1552 : SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1553 :
1554 : SWIGRUNTIME PyTypeObject*
1555 649516 : SwigPyObject_type(void) {
1556 649516 : static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1557 649516 : return type;
1558 : }
1559 :
1560 : SWIGRUNTIMEINLINE int
1561 470688 : SwigPyObject_Check(PyObject *op) {
1562 : return (Py_TYPE(op) == SwigPyObject_type())
1563 470688 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1564 : }
1565 :
1566 : SWIGRUNTIME PyObject *
1567 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1568 :
1569 : SWIGRUNTIME void
1570 89414 : SwigPyObject_dealloc(PyObject *v)
1571 : {
1572 89414 : SwigPyObject *sobj = (SwigPyObject *) v;
1573 89414 : PyObject *next = sobj->next;
1574 89414 : if (sobj->own == SWIG_POINTER_OWN) {
1575 44707 : swig_type_info *ty = sobj->ty;
1576 44707 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1577 44707 : PyObject *destroy = data ? data->destroy : 0;
1578 44707 : if (destroy) {
1579 : /* destroy is always a VARARGS method */
1580 : PyObject *res;
1581 44707 : if (data->delargs) {
1582 : /* we need to create a temporary object to carry the destroy operation */
1583 44707 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1584 44707 : res = SWIG_Python_CallFunctor(destroy, tmp);
1585 44707 : Py_DECREF(tmp);
1586 : } else {
1587 0 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1588 0 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1589 0 : res = ((*meth)(mself, v));
1590 : }
1591 44707 : Py_XDECREF(res);
1592 : }
1593 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1594 : else {
1595 0 : const char *name = SWIG_TypePrettyName(ty);
1596 0 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1597 : }
1598 : #endif
1599 : }
1600 89414 : Py_XDECREF(next);
1601 89414 : PyObject_DEL(v);
1602 89414 : }
1603 :
1604 : SWIGRUNTIME PyObject*
1605 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1606 : {
1607 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1608 : #ifndef METH_O
1609 : PyObject *tmp = 0;
1610 : if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1611 : next = tmp;
1612 : #endif
1613 0 : if (!SwigPyObject_Check(next)) {
1614 0 : return NULL;
1615 : }
1616 0 : sobj->next = next;
1617 0 : Py_INCREF(next);
1618 0 : return SWIG_Py_Void();
1619 : }
1620 :
1621 : SWIGRUNTIME PyObject*
1622 : #ifdef METH_NOARGS
1623 0 : SwigPyObject_next(PyObject* v)
1624 : #else
1625 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1626 : #endif
1627 : {
1628 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1629 0 : if (sobj->next) {
1630 0 : Py_INCREF(sobj->next);
1631 0 : return sobj->next;
1632 : } else {
1633 0 : return SWIG_Py_Void();
1634 : }
1635 : }
1636 :
1637 : SWIGINTERN PyObject*
1638 : #ifdef METH_NOARGS
1639 0 : SwigPyObject_disown(PyObject *v)
1640 : #else
1641 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1642 : #endif
1643 : {
1644 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1645 0 : sobj->own = 0;
1646 0 : return SWIG_Py_Void();
1647 : }
1648 :
1649 : SWIGINTERN PyObject*
1650 : #ifdef METH_NOARGS
1651 0 : SwigPyObject_acquire(PyObject *v)
1652 : #else
1653 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1654 : #endif
1655 : {
1656 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1657 0 : sobj->own = SWIG_POINTER_OWN;
1658 0 : return SWIG_Py_Void();
1659 : }
1660 :
1661 : SWIGINTERN PyObject*
1662 0 : SwigPyObject_own(PyObject *v, PyObject *args)
1663 : {
1664 0 : PyObject *val = 0;
1665 : #if (PY_VERSION_HEX < 0x02020000)
1666 : if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1667 : #else
1668 0 : if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1669 : #endif
1670 : {
1671 0 : return NULL;
1672 : }
1673 : else
1674 : {
1675 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1676 0 : PyObject *obj = PyBool_FromLong(sobj->own);
1677 0 : if (val) {
1678 : #ifdef METH_NOARGS
1679 0 : if (PyObject_IsTrue(val)) {
1680 : SwigPyObject_acquire(v);
1681 : } else {
1682 : SwigPyObject_disown(v);
1683 : }
1684 : #else
1685 : if (PyObject_IsTrue(val)) {
1686 : SwigPyObject_acquire(v,args);
1687 : } else {
1688 : SwigPyObject_disown(v,args);
1689 : }
1690 : #endif
1691 : }
1692 0 : return obj;
1693 : }
1694 : }
1695 :
1696 : #ifdef METH_O
1697 : static PyMethodDef
1698 : swigobject_methods[] = {
1699 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1700 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1701 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1702 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1703 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1704 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1705 : {0, 0, 0, 0}
1706 : };
1707 : #else
1708 : static PyMethodDef
1709 : swigobject_methods[] = {
1710 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1711 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1712 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1713 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1714 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1715 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1716 : {0, 0, 0, 0}
1717 : };
1718 : #endif
1719 :
1720 : #if PY_VERSION_HEX < 0x02020000
1721 : SWIGINTERN PyObject *
1722 : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1723 : {
1724 : return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1725 : }
1726 : #endif
1727 :
1728 : SWIGRUNTIME PyTypeObject*
1729 2 : _PySwigObject_type(void) {
1730 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1731 :
1732 : static PyNumberMethods SwigPyObject_as_number = {
1733 : (binaryfunc)0, /*nb_add*/
1734 : (binaryfunc)0, /*nb_subtract*/
1735 : (binaryfunc)0, /*nb_multiply*/
1736 : /* nb_divide removed in Python 3 */
1737 : #if PY_VERSION_HEX < 0x03000000
1738 : (binaryfunc)0, /*nb_divide*/
1739 : #endif
1740 : (binaryfunc)0, /*nb_remainder*/
1741 : (binaryfunc)0, /*nb_divmod*/
1742 : (ternaryfunc)0,/*nb_power*/
1743 : (unaryfunc)0, /*nb_negative*/
1744 : (unaryfunc)0, /*nb_positive*/
1745 : (unaryfunc)0, /*nb_absolute*/
1746 : (inquiry)0, /*nb_nonzero*/
1747 : 0, /*nb_invert*/
1748 : 0, /*nb_lshift*/
1749 : 0, /*nb_rshift*/
1750 : 0, /*nb_and*/
1751 : 0, /*nb_xor*/
1752 : 0, /*nb_or*/
1753 : #if PY_VERSION_HEX < 0x03000000
1754 : 0, /*nb_coerce*/
1755 : #endif
1756 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1757 : #if PY_VERSION_HEX < 0x03000000
1758 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1759 : #else
1760 : 0, /*nb_reserved*/
1761 : #endif
1762 : (unaryfunc)0, /*nb_float*/
1763 : #if PY_VERSION_HEX < 0x03000000
1764 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1765 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1766 : #endif
1767 : #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1768 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1769 : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1770 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1771 : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1772 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1773 : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1774 : 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1775 : #endif
1776 : };
1777 :
1778 : static PyTypeObject swigpyobject_type;
1779 : static int type_init = 0;
1780 2 : if (!type_init) {
1781 : const PyTypeObject tmp
1782 : = {
1783 : /* PyObject header changed in Python 3 */
1784 : #if PY_VERSION_HEX >= 0x03000000
1785 : PyVarObject_HEAD_INIT(&PyType_Type, 0)
1786 : #else
1787 : PyObject_HEAD_INIT(NULL)
1788 : 0, /* ob_size */
1789 : #endif
1790 : (char *)"SwigPyObject", /* tp_name */
1791 : sizeof(SwigPyObject), /* tp_basicsize */
1792 : 0, /* tp_itemsize */
1793 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1794 : (printfunc)SwigPyObject_print, /* tp_print */
1795 : #if PY_VERSION_HEX < 0x02020000
1796 : (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1797 : #else
1798 : (getattrfunc)0, /* tp_getattr */
1799 : #endif
1800 : (setattrfunc)0, /* tp_setattr */
1801 : #if PY_VERSION_HEX >= 0x03000000
1802 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1803 : #else
1804 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1805 : #endif
1806 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1807 : &SwigPyObject_as_number, /* tp_as_number */
1808 : 0, /* tp_as_sequence */
1809 : 0, /* tp_as_mapping */
1810 : (hashfunc)0, /* tp_hash */
1811 : (ternaryfunc)0, /* tp_call */
1812 : (reprfunc)SwigPyObject_str, /* tp_str */
1813 : PyObject_GenericGetAttr, /* tp_getattro */
1814 : 0, /* tp_setattro */
1815 : 0, /* tp_as_buffer */
1816 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1817 : swigobject_doc, /* tp_doc */
1818 : 0, /* tp_traverse */
1819 : 0, /* tp_clear */
1820 : (richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
1821 : 0, /* tp_weaklistoffset */
1822 : #if PY_VERSION_HEX >= 0x02020000
1823 : 0, /* tp_iter */
1824 : 0, /* tp_iternext */
1825 : swigobject_methods, /* tp_methods */
1826 : 0, /* tp_members */
1827 : 0, /* tp_getset */
1828 : 0, /* tp_base */
1829 : 0, /* tp_dict */
1830 : 0, /* tp_descr_get */
1831 : 0, /* tp_descr_set */
1832 : 0, /* tp_dictoffset */
1833 : 0, /* tp_init */
1834 : 0, /* tp_alloc */
1835 : 0, /* tp_new */
1836 : 0, /* tp_free */
1837 : 0, /* tp_is_gc */
1838 : 0, /* tp_bases */
1839 : 0, /* tp_mro */
1840 : 0, /* tp_cache */
1841 : 0, /* tp_subclasses */
1842 : 0, /* tp_weaklist */
1843 : #endif
1844 : #if PY_VERSION_HEX >= 0x02030000
1845 : 0, /* tp_del */
1846 : #endif
1847 : #ifdef COUNT_ALLOCS
1848 : 0,0,0,0 /* tp_alloc -> tp_next */
1849 : #endif
1850 2 : };
1851 2 : swigpyobject_type = tmp;
1852 : /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
1853 : #if PY_VERSION_HEX < 0x03000000
1854 2 : swigpyobject_type.ob_type = &PyType_Type;
1855 : #endif
1856 2 : type_init = 1;
1857 : }
1858 2 : return &swigpyobject_type;
1859 : }
1860 :
1861 : SWIGRUNTIME PyObject *
1862 89414 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1863 : {
1864 89414 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1865 89414 : if (sobj) {
1866 89414 : sobj->ptr = ptr;
1867 89414 : sobj->ty = ty;
1868 89414 : sobj->own = own;
1869 89414 : sobj->next = 0;
1870 : }
1871 89414 : return (PyObject *)sobj;
1872 : }
1873 :
1874 : /* -----------------------------------------------------------------------------
1875 : * Implements a simple Swig Packed type, and use it instead of string
1876 : * ----------------------------------------------------------------------------- */
1877 :
1878 : typedef struct {
1879 : PyObject_HEAD
1880 : void *pack;
1881 : swig_type_info *ty;
1882 : size_t size;
1883 : } SwigPyPacked;
1884 :
1885 : SWIGRUNTIME int
1886 0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1887 : {
1888 : char result[SWIG_BUFFER_SIZE];
1889 0 : fputs("<Swig Packed ", fp);
1890 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1891 0 : fputs("at ", fp);
1892 0 : fputs(result, fp);
1893 : }
1894 0 : fputs(v->ty->name,fp);
1895 0 : fputs(">", fp);
1896 0 : return 0;
1897 : }
1898 :
1899 : SWIGRUNTIME PyObject *
1900 0 : SwigPyPacked_repr(SwigPyPacked *v)
1901 : {
1902 : char result[SWIG_BUFFER_SIZE];
1903 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1904 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1905 : } else {
1906 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1907 : }
1908 : }
1909 :
1910 : SWIGRUNTIME PyObject *
1911 0 : SwigPyPacked_str(SwigPyPacked *v)
1912 : {
1913 : char result[SWIG_BUFFER_SIZE];
1914 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1915 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1916 : } else {
1917 0 : return SWIG_Python_str_FromChar(v->ty->name);
1918 : }
1919 : }
1920 :
1921 : SWIGRUNTIME int
1922 0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1923 : {
1924 0 : size_t i = v->size;
1925 0 : size_t j = w->size;
1926 0 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1927 0 : return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1928 : }
1929 :
1930 : SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1931 :
1932 : SWIGRUNTIME PyTypeObject*
1933 0 : SwigPyPacked_type(void) {
1934 0 : static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1935 0 : return type;
1936 : }
1937 :
1938 : SWIGRUNTIMEINLINE int
1939 : SwigPyPacked_Check(PyObject *op) {
1940 : return ((op)->ob_type == _PySwigPacked_type())
1941 0 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1942 : }
1943 :
1944 : SWIGRUNTIME void
1945 0 : SwigPyPacked_dealloc(PyObject *v)
1946 : {
1947 0 : if (SwigPyPacked_Check(v)) {
1948 0 : SwigPyPacked *sobj = (SwigPyPacked *) v;
1949 0 : free(sobj->pack);
1950 : }
1951 0 : PyObject_DEL(v);
1952 0 : }
1953 :
1954 : SWIGRUNTIME PyTypeObject*
1955 0 : _PySwigPacked_type(void) {
1956 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1957 : static PyTypeObject swigpypacked_type;
1958 : static int type_init = 0;
1959 0 : if (!type_init) {
1960 : const PyTypeObject tmp
1961 : = {
1962 : /* PyObject header changed in Python 3 */
1963 : #if PY_VERSION_HEX>=0x03000000
1964 : PyVarObject_HEAD_INIT(&PyType_Type, 0)
1965 : #else
1966 : PyObject_HEAD_INIT(NULL)
1967 : 0, /* ob_size */
1968 : #endif
1969 : (char *)"SwigPyPacked", /* tp_name */
1970 : sizeof(SwigPyPacked), /* tp_basicsize */
1971 : 0, /* tp_itemsize */
1972 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1973 : (printfunc)SwigPyPacked_print, /* tp_print */
1974 : (getattrfunc)0, /* tp_getattr */
1975 : (setattrfunc)0, /* tp_setattr */
1976 : #if PY_VERSION_HEX>=0x03000000
1977 : 0, /* tp_reserved in 3.0.1 */
1978 : #else
1979 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1980 : #endif
1981 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
1982 : 0, /* tp_as_number */
1983 : 0, /* tp_as_sequence */
1984 : 0, /* tp_as_mapping */
1985 : (hashfunc)0, /* tp_hash */
1986 : (ternaryfunc)0, /* tp_call */
1987 : (reprfunc)SwigPyPacked_str, /* tp_str */
1988 : PyObject_GenericGetAttr, /* tp_getattro */
1989 : 0, /* tp_setattro */
1990 : 0, /* tp_as_buffer */
1991 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1992 : swigpacked_doc, /* tp_doc */
1993 : 0, /* tp_traverse */
1994 : 0, /* tp_clear */
1995 : 0, /* tp_richcompare */
1996 : 0, /* tp_weaklistoffset */
1997 : #if PY_VERSION_HEX >= 0x02020000
1998 : 0, /* tp_iter */
1999 : 0, /* tp_iternext */
2000 : 0, /* tp_methods */
2001 : 0, /* tp_members */
2002 : 0, /* tp_getset */
2003 : 0, /* tp_base */
2004 : 0, /* tp_dict */
2005 : 0, /* tp_descr_get */
2006 : 0, /* tp_descr_set */
2007 : 0, /* tp_dictoffset */
2008 : 0, /* tp_init */
2009 : 0, /* tp_alloc */
2010 : 0, /* tp_new */
2011 : 0, /* tp_free */
2012 : 0, /* tp_is_gc */
2013 : 0, /* tp_bases */
2014 : 0, /* tp_mro */
2015 : 0, /* tp_cache */
2016 : 0, /* tp_subclasses */
2017 : 0, /* tp_weaklist */
2018 : #endif
2019 : #if PY_VERSION_HEX >= 0x02030000
2020 : 0, /* tp_del */
2021 : #endif
2022 : #ifdef COUNT_ALLOCS
2023 : 0,0,0,0 /* tp_alloc -> tp_next */
2024 : #endif
2025 0 : };
2026 0 : swigpypacked_type = tmp;
2027 : /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2028 : #if PY_VERSION_HEX < 0x03000000
2029 0 : swigpypacked_type.ob_type = &PyType_Type;
2030 : #endif
2031 0 : type_init = 1;
2032 : }
2033 0 : return &swigpypacked_type;
2034 : }
2035 :
2036 : SWIGRUNTIME PyObject *
2037 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2038 : {
2039 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2040 0 : if (sobj) {
2041 0 : void *pack = malloc(size);
2042 0 : if (pack) {
2043 : memcpy(pack, ptr, size);
2044 0 : sobj->pack = pack;
2045 0 : sobj->ty = ty;
2046 0 : sobj->size = size;
2047 : } else {
2048 0 : PyObject_DEL((PyObject *) sobj);
2049 0 : sobj = 0;
2050 : }
2051 : }
2052 0 : return (PyObject *) sobj;
2053 : }
2054 :
2055 : SWIGRUNTIME swig_type_info *
2056 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2057 : {
2058 : if (SwigPyPacked_Check(obj)) {
2059 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
2060 : if (sobj->size != size) return 0;
2061 : memcpy(ptr, sobj->pack, size);
2062 : return sobj->ty;
2063 : } else {
2064 : return 0;
2065 : }
2066 : }
2067 :
2068 : /* -----------------------------------------------------------------------------
2069 : * pointers/data manipulation
2070 : * ----------------------------------------------------------------------------- */
2071 :
2072 : SWIGRUNTIMEINLINE PyObject *
2073 : _SWIG_This(void)
2074 : {
2075 2 : return SWIG_Python_str_FromChar("this");
2076 : }
2077 :
2078 : SWIGRUNTIME PyObject *
2079 241729 : SWIG_This(void)
2080 : {
2081 241731 : static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2082 241729 : return swig_this;
2083 : }
2084 :
2085 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2086 :
2087 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2088 : #if PY_VERSION_HEX>=0x03000000
2089 : #define SWIG_PYTHON_SLOW_GETSET_THIS
2090 : #endif
2091 :
2092 : SWIGRUNTIME SwigPyObject *
2093 257814 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2094 : {
2095 257814 : if (SwigPyObject_Check(pyobj)) {
2096 44940 : return (SwigPyObject *) pyobj;
2097 : } else {
2098 212874 : PyObject *obj = 0;
2099 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2100 212874 : if (PyInstance_Check(pyobj)) {
2101 0 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2102 : } else {
2103 212874 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2104 212874 : if (dictptr != NULL) {
2105 212874 : PyObject *dict = *dictptr;
2106 212874 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2107 : } else {
2108 : #ifdef PyWeakref_CheckProxy
2109 0 : if (PyWeakref_CheckProxy(pyobj)) {
2110 0 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2111 0 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2112 : }
2113 : #endif
2114 0 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2115 0 : if (obj) {
2116 0 : Py_DECREF(obj);
2117 : } else {
2118 0 : if (PyErr_Occurred()) PyErr_Clear();
2119 0 : return 0;
2120 : }
2121 : }
2122 : }
2123 : #else
2124 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2125 : if (obj) {
2126 : Py_DECREF(obj);
2127 : } else {
2128 : if (PyErr_Occurred()) PyErr_Clear();
2129 : return 0;
2130 : }
2131 : #endif
2132 212874 : if (obj && !SwigPyObject_Check(obj)) {
2133 : /* a PyObject is called 'this', try to get the 'real this'
2134 : SwigPyObject from it */
2135 0 : return SWIG_Python_GetSwigThis(obj);
2136 : }
2137 212874 : return (SwigPyObject *)obj;
2138 : }
2139 : }
2140 :
2141 : /* Acquire a pointer value */
2142 :
2143 : SWIGRUNTIME int
2144 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2145 : if (own == SWIG_POINTER_OWN) {
2146 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2147 : if (sobj) {
2148 : int oldown = sobj->own;
2149 : sobj->own = own;
2150 : return oldown;
2151 : }
2152 : }
2153 : return 0;
2154 : }
2155 :
2156 : /* Convert a pointer value */
2157 :
2158 : SWIGRUNTIME int
2159 257816 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2160 257816 : if (!obj) return SWIG_ERROR;
2161 257816 : if (obj == Py_None) {
2162 2 : if (ptr) *ptr = 0;
2163 2 : return SWIG_OK;
2164 : } else {
2165 257814 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2166 257814 : if (own)
2167 0 : *own = 0;
2168 257814 : while (sobj) {
2169 257814 : void *vptr = sobj->ptr;
2170 257814 : if (ty) {
2171 257814 : swig_type_info *to = sobj->ty;
2172 257814 : if (to == ty) {
2173 : /* no type cast needed */
2174 257814 : if (ptr) *ptr = vptr;
2175 : break;
2176 : } else {
2177 0 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2178 0 : if (!tc) {
2179 0 : sobj = (SwigPyObject *)sobj->next;
2180 : } else {
2181 0 : if (ptr) {
2182 0 : int newmemory = 0;
2183 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2184 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2185 : assert(own);
2186 0 : if (own)
2187 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2188 : }
2189 : }
2190 : break;
2191 : }
2192 : }
2193 : } else {
2194 0 : if (ptr) *ptr = vptr;
2195 : break;
2196 : }
2197 : }
2198 257814 : if (sobj) {
2199 257814 : if (own)
2200 0 : *own = *own | sobj->own;
2201 257814 : if (flags & SWIG_POINTER_DISOWN) {
2202 44940 : sobj->own = 0;
2203 : }
2204 257814 : return SWIG_OK;
2205 : } else {
2206 0 : int res = SWIG_ERROR;
2207 0 : if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2208 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2209 0 : if (data && !data->implicitconv) {
2210 0 : PyObject *klass = data->klass;
2211 0 : if (klass) {
2212 : PyObject *impconv;
2213 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2214 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2215 0 : data->implicitconv = 0;
2216 0 : if (PyErr_Occurred()) {
2217 0 : PyErr_Clear();
2218 0 : impconv = 0;
2219 : }
2220 0 : if (impconv) {
2221 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2222 0 : if (iobj) {
2223 : void *vptr;
2224 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2225 0 : if (SWIG_IsOK(res)) {
2226 0 : if (ptr) {
2227 0 : *ptr = vptr;
2228 : /* transfer the ownership to 'ptr' */
2229 0 : iobj->own = 0;
2230 0 : res = SWIG_AddCast(res);
2231 0 : res = SWIG_AddNewMask(res);
2232 : } else {
2233 0 : res = SWIG_AddCast(res);
2234 : }
2235 : }
2236 : }
2237 0 : Py_DECREF(impconv);
2238 : }
2239 : }
2240 : }
2241 : }
2242 0 : return res;
2243 : }
2244 : }
2245 : }
2246 :
2247 : /* Convert a function ptr value */
2248 :
2249 : SWIGRUNTIME int
2250 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2251 : if (!PyCFunction_Check(obj)) {
2252 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2253 : } else {
2254 : void *vptr = 0;
2255 :
2256 : /* here we get the method pointer for callbacks */
2257 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2258 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2259 : if (desc)
2260 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2261 : if (!desc)
2262 : return SWIG_ERROR;
2263 : if (ty) {
2264 : swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2265 : if (tc) {
2266 : int newmemory = 0;
2267 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2268 : assert(!newmemory); /* newmemory handling not yet implemented */
2269 : } else {
2270 : return SWIG_ERROR;
2271 : }
2272 : } else {
2273 : *ptr = vptr;
2274 : }
2275 : return SWIG_OK;
2276 : }
2277 : }
2278 :
2279 : /* Convert a packed value value */
2280 :
2281 : SWIGRUNTIME int
2282 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2283 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2284 : if (!to) return SWIG_ERROR;
2285 : if (ty) {
2286 : if (to != ty) {
2287 : /* check type cast? */
2288 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2289 : if (!tc) return SWIG_ERROR;
2290 : }
2291 : }
2292 : return SWIG_OK;
2293 : }
2294 :
2295 : /* -----------------------------------------------------------------------------
2296 : * Create a new pointer object
2297 : * ----------------------------------------------------------------------------- */
2298 :
2299 : /*
2300 : Create a new instance object, without calling __init__, and set the
2301 : 'this' attribute.
2302 : */
2303 :
2304 : SWIGRUNTIME PyObject*
2305 28855 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2306 : {
2307 : #if (PY_VERSION_HEX >= 0x02020000)
2308 28855 : PyObject *inst = 0;
2309 28855 : PyObject *newraw = data->newraw;
2310 28855 : if (newraw) {
2311 28855 : inst = PyObject_Call(newraw, data->newargs, NULL);
2312 28855 : if (inst) {
2313 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2314 28855 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2315 28855 : if (dictptr != NULL) {
2316 28855 : PyObject *dict = *dictptr;
2317 28855 : if (dict == NULL) {
2318 28855 : dict = PyDict_New();
2319 28855 : *dictptr = dict;
2320 28855 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2321 : }
2322 : }
2323 : #else
2324 : PyObject *key = SWIG_This();
2325 : PyObject_SetAttr(inst, key, swig_this);
2326 : #endif
2327 : }
2328 : } else {
2329 : #if PY_VERSION_HEX >= 0x03000000
2330 : inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2331 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2332 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2333 : #else
2334 0 : PyObject *dict = PyDict_New();
2335 0 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2336 0 : inst = PyInstance_NewRaw(data->newargs, dict);
2337 0 : Py_DECREF(dict);
2338 : #endif
2339 : }
2340 28855 : return inst;
2341 : #else
2342 : #if (PY_VERSION_HEX >= 0x02010000)
2343 : PyObject *inst;
2344 : PyObject *dict = PyDict_New();
2345 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2346 : inst = PyInstance_NewRaw(data->newargs, dict);
2347 : Py_DECREF(dict);
2348 : return (PyObject *) inst;
2349 : #else
2350 : PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2351 : if (inst == NULL) {
2352 : return NULL;
2353 : }
2354 : inst->in_class = (PyClassObject *)data->newargs;
2355 : Py_INCREF(inst->in_class);
2356 : inst->in_dict = PyDict_New();
2357 : if (inst->in_dict == NULL) {
2358 : Py_DECREF(inst);
2359 : return NULL;
2360 : }
2361 : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2362 : inst->in_weakreflist = NULL;
2363 : #endif
2364 : #ifdef Py_TPFLAGS_GC
2365 : PyObject_GC_Init(inst);
2366 : #endif
2367 : PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2368 : return (PyObject *) inst;
2369 : #endif
2370 : #endif
2371 : }
2372 :
2373 : SWIGRUNTIME void
2374 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2375 : {
2376 : PyObject *dict;
2377 : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2378 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2379 : if (dictptr != NULL) {
2380 : dict = *dictptr;
2381 : if (dict == NULL) {
2382 : dict = PyDict_New();
2383 : *dictptr = dict;
2384 : }
2385 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2386 : return;
2387 : }
2388 : #endif
2389 : dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2390 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2391 : Py_DECREF(dict);
2392 : }
2393 :
2394 :
2395 : SWIGINTERN PyObject *
2396 : SWIG_Python_InitShadowInstance(PyObject *args) {
2397 : PyObject *obj[2];
2398 : if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2399 : return NULL;
2400 : } else {
2401 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2402 : if (sthis) {
2403 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2404 : } else {
2405 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2406 : }
2407 : return SWIG_Py_Void();
2408 : }
2409 : }
2410 :
2411 : /* Create a new pointer object */
2412 :
2413 : SWIGRUNTIME PyObject *
2414 44708 : SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2415 44708 : if (!ptr) {
2416 1 : return SWIG_Py_Void();
2417 : } else {
2418 44707 : int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2419 44707 : PyObject *robj = SwigPyObject_New(ptr, type, own);
2420 44707 : SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2421 44707 : if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2422 28855 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2423 28855 : if (inst) {
2424 28855 : Py_DECREF(robj);
2425 28855 : robj = inst;
2426 : }
2427 : }
2428 44707 : return robj;
2429 : }
2430 : }
2431 :
2432 : /* Create a new packed object */
2433 :
2434 : SWIGRUNTIMEINLINE PyObject *
2435 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2436 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2437 : }
2438 :
2439 : /* -----------------------------------------------------------------------------*
2440 : * Get type list
2441 : * -----------------------------------------------------------------------------*/
2442 :
2443 : #ifdef SWIG_LINK_RUNTIME
2444 : void *SWIG_ReturnGlobalTypeList(void *);
2445 : #endif
2446 :
2447 : SWIGRUNTIME swig_module_info *
2448 : SWIG_Python_GetModule(void) {
2449 : static void *type_pointer = (void *)0;
2450 : /* first check if module already created */
2451 4 : if (!type_pointer) {
2452 : #ifdef SWIG_LINK_RUNTIME
2453 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2454 : #else
2455 : #ifdef SWIG_PYTHON_USE_CAPSULE
2456 : type_pointer = PyCapsule_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer" SWIG_TYPE_TABLE_NAME, 0);
2457 : #else
2458 : type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2459 4 : (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2460 : #endif
2461 4 : if (PyErr_Occurred()) {
2462 0 : PyErr_Clear();
2463 0 : type_pointer = (void *)0;
2464 : }
2465 : #endif
2466 : }
2467 4 : return (swig_module_info *) type_pointer;
2468 : }
2469 :
2470 : #if PY_MAJOR_VERSION < 2
2471 : /* PyModule_AddObject function was introduced in Python 2.0. The following function
2472 : is copied out of Python/modsupport.c in python version 2.3.4 */
2473 : SWIGINTERN int
2474 : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2475 : {
2476 : PyObject *dict;
2477 : if (!PyModule_Check(m)) {
2478 : PyErr_SetString(PyExc_TypeError,
2479 : "PyModule_AddObject() needs module as first arg");
2480 : return SWIG_ERROR;
2481 : }
2482 : if (!o) {
2483 : PyErr_SetString(PyExc_TypeError,
2484 : "PyModule_AddObject() needs non-NULL value");
2485 : return SWIG_ERROR;
2486 : }
2487 :
2488 : dict = PyModule_GetDict(m);
2489 : if (dict == NULL) {
2490 : /* Internal error -- modules must have a dict! */
2491 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2492 : PyModule_GetName(m));
2493 : return SWIG_ERROR;
2494 : }
2495 : if (PyDict_SetItemString(dict, name, o))
2496 : return SWIG_ERROR;
2497 : Py_DECREF(o);
2498 : return SWIG_OK;
2499 : }
2500 : #endif
2501 :
2502 : SWIGRUNTIME void
2503 : #ifdef SWIG_PYTHON_USE_CAPSULE
2504 : SWIG_Python_DestroyModule(PyObject *capsule)
2505 : {
2506 : swig_module_info *swig_module;
2507 : swig_type_info **types;
2508 : size_t i;
2509 : swig_module = (swig_module_info *)PyCapsule_GetPointer(capsule, (char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2510 : if (swig_module == NULL)
2511 : {
2512 : PyErr_Clear();
2513 : return;
2514 : }
2515 : types = swig_module->types;
2516 : #else
2517 0 : SWIG_Python_DestroyModule(void *vptr)
2518 : {
2519 0 : swig_module_info *swig_module = (swig_module_info *) vptr;
2520 0 : swig_type_info **types = swig_module->types;
2521 : size_t i;
2522 : #endif
2523 0 : for (i =0; i < swig_module->size; ++i) {
2524 0 : swig_type_info *ty = types[i];
2525 0 : if (ty->owndata) {
2526 0 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2527 0 : if (data) SwigPyClientData_Del(data);
2528 : }
2529 : }
2530 0 : Py_DECREF(SWIG_This());
2531 0 : }
2532 :
2533 : SWIGRUNTIME void
2534 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2535 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2536 :
2537 : #if PY_VERSION_HEX >= 0x03000000
2538 : /* Add a dummy module object into sys.modules */
2539 : PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2540 : #else
2541 0 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2542 : swig_empty_runtime_method_table);
2543 : #endif
2544 : #ifdef SWIG_PYTHON_USE_CAPSULE
2545 : PyObject *pointer = PyCapsule_New((void *) swig_module,
2546 : (char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer" SWIG_TYPE_TABLE_NAME,
2547 : SWIG_Python_DestroyModule);
2548 : #else
2549 0 : PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2550 : #endif
2551 0 : if (pointer && module) {
2552 0 : PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2553 : } else {
2554 0 : Py_XDECREF(pointer);
2555 : }
2556 : }
2557 :
2558 : /* The python cached type query */
2559 : SWIGRUNTIME PyObject *
2560 : SWIG_Python_TypeCache(void) {
2561 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2562 : return cache;
2563 : }
2564 :
2565 : SWIGRUNTIME swig_type_info *
2566 : SWIG_Python_TypeQuery(const char *type)
2567 : {
2568 : PyObject *cache = SWIG_Python_TypeCache();
2569 : PyObject *key = SWIG_Python_str_FromChar(type);
2570 : PyObject *obj = PyDict_GetItem(cache, key);
2571 : swig_type_info *descriptor;
2572 : if (obj) {
2573 : #ifdef SWIG_PYTHON_USE_CAPSULE
2574 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, (char*)"swig_type_info");
2575 : #else
2576 : descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2577 : #endif
2578 : } else {
2579 : swig_module_info *swig_module = SWIG_Python_GetModule();
2580 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2581 : if (descriptor) {
2582 : #ifdef SWIG_PYTHON_USE_CAPSULE
2583 : obj = PyCapsule_New(descriptor, (char*)"swig_type_info", NULL);
2584 : #else
2585 : obj = PyCObject_FromVoidPtr(descriptor, NULL);
2586 : #endif
2587 : PyDict_SetItem(cache, key, obj);
2588 : Py_DECREF(obj);
2589 : }
2590 : }
2591 : Py_DECREF(key);
2592 : return descriptor;
2593 : }
2594 :
2595 : /*
2596 : For backward compatibility only
2597 : */
2598 : #define SWIG_POINTER_EXCEPTION 0
2599 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2600 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2601 :
2602 : SWIGRUNTIME int
2603 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2604 : {
2605 : if (PyErr_Occurred()) {
2606 : PyObject *type = 0;
2607 : PyObject *value = 0;
2608 : PyObject *traceback = 0;
2609 : PyErr_Fetch(&type, &value, &traceback);
2610 : if (value) {
2611 : char *tmp;
2612 : PyObject *old_str = PyObject_Str(value);
2613 : Py_XINCREF(type);
2614 : PyErr_Clear();
2615 : if (infront) {
2616 : PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2617 : } else {
2618 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2619 : }
2620 : SWIG_Python_str_DelForPy3(tmp);
2621 : Py_DECREF(old_str);
2622 : }
2623 : return 1;
2624 : } else {
2625 : return 0;
2626 : }
2627 : }
2628 :
2629 : SWIGRUNTIME int
2630 : SWIG_Python_ArgFail(int argnum)
2631 : {
2632 : if (PyErr_Occurred()) {
2633 : /* add information about failing argument */
2634 : char mesg[256];
2635 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2636 : return SWIG_Python_AddErrMesg(mesg, 1);
2637 : } else {
2638 : return 0;
2639 : }
2640 : }
2641 :
2642 : SWIGRUNTIMEINLINE const char *
2643 : SwigPyObject_GetDesc(PyObject *self)
2644 : {
2645 : SwigPyObject *v = (SwigPyObject *)self;
2646 : swig_type_info *ty = v ? v->ty : 0;
2647 : return ty ? ty->str : (char*)"";
2648 : }
2649 :
2650 : SWIGRUNTIME void
2651 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2652 : {
2653 : if (type) {
2654 : #if defined(SWIG_COBJECT_TYPES)
2655 : if (obj && SwigPyObject_Check(obj)) {
2656 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2657 : if (otype) {
2658 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2659 : type, otype);
2660 : return;
2661 : }
2662 : } else
2663 : #endif
2664 : {
2665 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2666 : if (otype) {
2667 : PyObject *str = PyObject_Str(obj);
2668 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2669 : if (cstr) {
2670 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2671 : type, otype, cstr);
2672 : SWIG_Python_str_DelForPy3(cstr);
2673 : } else {
2674 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2675 : type, otype);
2676 : }
2677 : Py_XDECREF(str);
2678 : return;
2679 : }
2680 : }
2681 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2682 : } else {
2683 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2684 : }
2685 : }
2686 :
2687 :
2688 : /* Convert a pointer value, signal an exception on a type mismatch */
2689 : SWIGRUNTIME void *
2690 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2691 : void *result;
2692 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2693 : PyErr_Clear();
2694 : #if SWIG_POINTER_EXCEPTION
2695 : if (flags) {
2696 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2697 : SWIG_Python_ArgFail(argnum);
2698 : }
2699 : #endif
2700 : }
2701 : return result;
2702 : }
2703 :
2704 :
2705 : #ifdef __cplusplus
2706 : #if 0
2707 : { /* cc-mode */
2708 : #endif
2709 : }
2710 : #endif
2711 :
2712 :
2713 :
2714 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2715 :
2716 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2717 :
2718 :
2719 :
2720 : #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2721 :
2722 :
2723 : /* -------- TYPES TABLE (BEGIN) -------- */
2724 :
2725 : #define SWIGTYPE_p_OSRCoordinateTransformationShadow swig_types[0]
2726 : #define SWIGTYPE_p_OSRSpatialReferenceShadow swig_types[1]
2727 : #define SWIGTYPE_p_char swig_types[2]
2728 : #define SWIGTYPE_p_double swig_types[3]
2729 : #define SWIGTYPE_p_int swig_types[4]
2730 : #define SWIGTYPE_p_long swig_types[5]
2731 : #define SWIGTYPE_p_p_char swig_types[6]
2732 : #define SWIGTYPE_p_p_double swig_types[7]
2733 : static swig_type_info *swig_types[9];
2734 : static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
2735 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2736 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2737 :
2738 : /* -------- TYPES TABLE (END) -------- */
2739 :
2740 : #if (PY_VERSION_HEX <= 0x02000000)
2741 : # if !defined(SWIG_PYTHON_CLASSIC)
2742 : # error "This python version requires swig to be run with the '-classic' option"
2743 : # endif
2744 : #endif
2745 :
2746 : /*-----------------------------------------------
2747 : @(target):= _osr.so
2748 : ------------------------------------------------*/
2749 : #if PY_VERSION_HEX >= 0x03000000
2750 : # define SWIG_init PyInit__osr
2751 :
2752 : #else
2753 : # define SWIG_init init_osr
2754 :
2755 : #endif
2756 : #define SWIG_name "_osr"
2757 :
2758 : #define SWIGVERSION 0x010340
2759 : #define SWIG_VERSION SWIGVERSION
2760 :
2761 :
2762 : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2763 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2764 :
2765 :
2766 : #include <stdexcept>
2767 :
2768 :
2769 : namespace swig {
2770 : class SwigPtr_PyObject {
2771 : protected:
2772 : PyObject *_obj;
2773 :
2774 : public:
2775 : SwigPtr_PyObject() :_obj(0)
2776 : {
2777 : }
2778 :
2779 : SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2780 : {
2781 : Py_XINCREF(_obj);
2782 : }
2783 :
2784 : SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2785 : {
2786 : if (initial_ref) {
2787 : Py_XINCREF(_obj);
2788 : }
2789 : }
2790 :
2791 : SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2792 : {
2793 : Py_XINCREF(item._obj);
2794 : Py_XDECREF(_obj);
2795 : _obj = item._obj;
2796 : return *this;
2797 : }
2798 :
2799 : ~SwigPtr_PyObject()
2800 : {
2801 : Py_XDECREF(_obj);
2802 : }
2803 :
2804 : operator PyObject *() const
2805 : {
2806 : return _obj;
2807 : }
2808 :
2809 : PyObject *operator->() const
2810 : {
2811 : return _obj;
2812 : }
2813 : };
2814 : }
2815 :
2816 :
2817 : namespace swig {
2818 : struct SwigVar_PyObject : SwigPtr_PyObject {
2819 : SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2820 :
2821 : SwigVar_PyObject & operator = (PyObject* obj)
2822 : {
2823 : Py_XDECREF(_obj);
2824 : _obj = obj;
2825 : return *this;
2826 : }
2827 : };
2828 : }
2829 :
2830 :
2831 : SWIGINTERN swig_type_info*
2832 : SWIG_pchar_descriptor(void)
2833 : {
2834 : static int init = 0;
2835 : static swig_type_info* info = 0;
2836 0 : if (!init) {
2837 0 : info = SWIG_TypeQuery("_p_char");
2838 0 : init = 1;
2839 : }
2840 0 : return info;
2841 : }
2842 :
2843 :
2844 : SWIGINTERNINLINE PyObject *
2845 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2846 : {
2847 22148 : if (carray) {
2848 17628 : if (size > INT_MAX) {
2849 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2850 : return pchar_descriptor ?
2851 0 : SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2852 : } else {
2853 : #if PY_VERSION_HEX >= 0x03000000
2854 : return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
2855 : #else
2856 17628 : return PyString_FromStringAndSize(carray, static_cast< int >(size));
2857 : #endif
2858 : }
2859 : } else {
2860 4520 : return SWIG_Py_Void();
2861 : }
2862 : }
2863 :
2864 :
2865 : SWIGINTERNINLINE PyObject *
2866 22148 : SWIG_FromCharPtr(const char *cptr)
2867 : {
2868 44296 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2869 : }
2870 :
2871 :
2872 : #define SWIG_From_double PyFloat_FromDouble
2873 :
2874 :
2875 : typedef char retStringAndCPLFree;
2876 :
2877 :
2878 : #include <iostream>
2879 : using namespace std;
2880 :
2881 : #include "cpl_string.h"
2882 : #include "cpl_conv.h"
2883 :
2884 : #include "ogr_srs_api.h"
2885 :
2886 : #ifdef DEBUG
2887 : typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
2888 : typedef struct OGRCoordinateTransformationHS OSRCoordinateTransformationShadow;
2889 : typedef struct OGRCoordinateTransformationHS OGRCoordinateTransformationShadow;
2890 : #else
2891 : typedef void OSRSpatialReferenceShadow;
2892 : typedef void OSRCoordinateTransformationShadow;
2893 : #endif
2894 :
2895 :
2896 : int bUseExceptions=0;
2897 : CPLErrorHandler pfnPreviousHandler = CPLDefaultErrorHandler;
2898 :
2899 : void CPL_STDCALL
2900 0 : PythonBindingErrorHandler(CPLErr eclass, int code, const char *msg )
2901 : {
2902 : /*
2903 : ** Generally we want to supress error reporting if we have exceptions
2904 : ** enabled as the error message will be in the exception thrown in
2905 : ** Python.
2906 : */
2907 :
2908 : /* If the error class is CE_Fatal, we want to have a message issued
2909 : because the CPL support code does an abort() before any exception
2910 : can be generated */
2911 0 : if (eclass == CE_Fatal ) {
2912 0 : pfnPreviousHandler(eclass, code, msg );
2913 : }
2914 :
2915 : /*
2916 : ** We do not want to interfere with warnings or debug messages since
2917 : ** they won't be translated into exceptions.
2918 : */
2919 0 : if (eclass == CE_Warning || eclass == CE_Debug ) {
2920 0 : pfnPreviousHandler(eclass, code, msg );
2921 : }
2922 0 : }
2923 :
2924 :
2925 :
2926 0 : int GetUseExceptions() {
2927 0 : return bUseExceptions;
2928 : }
2929 :
2930 0 : void UseExceptions() {
2931 0 : bUseExceptions = 1;
2932 : pfnPreviousHandler =
2933 0 : CPLSetErrorHandler( (CPLErrorHandler) PythonBindingErrorHandler );
2934 0 : }
2935 :
2936 0 : void DontUseExceptions() {
2937 0 : bUseExceptions = 0;
2938 0 : CPLSetErrorHandler( pfnPreviousHandler );
2939 0 : }
2940 :
2941 :
2942 : #define SWIG_From_long PyInt_FromLong
2943 :
2944 :
2945 : SWIGINTERNINLINE PyObject *
2946 : SWIG_From_int (int value)
2947 : {
2948 14705 : return SWIG_From_long (value);
2949 : }
2950 :
2951 :
2952 :
2953 : /* Return a PyObject* from a NULL terminated C String */
2954 61452 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr)
2955 : {
2956 61452 : const unsigned char* pszIter = (const unsigned char*) pszStr;
2957 26934804 : while(*pszIter != 0)
2958 : {
2959 26811900 : if (*pszIter > 127)
2960 : {
2961 0 : PyObject* pyObj = PyUnicode_DecodeUTF8(pszStr, strlen(pszStr), "ignore");
2962 0 : if (pyObj != NULL)
2963 0 : return pyObj;
2964 : #if PY_VERSION_HEX >= 0x03000000
2965 : return PyBytes_FromString(pszStr);
2966 : #else
2967 0 : return PyString_FromString(pszStr);
2968 : #endif
2969 : }
2970 26811900 : pszIter ++;
2971 : }
2972 : #if PY_VERSION_HEX >= 0x03000000
2973 : return PyUnicode_FromString(pszStr);
2974 : #else
2975 61452 : return PyString_FromString(pszStr);
2976 : #endif
2977 : }
2978 :
2979 : /* Return a NULL terminated c String from a PyObject */
2980 : /* Result must be freed with GDALPythonFreeCStr */
2981 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree)
2982 : {
2983 : *pbToFree = 0;
2984 : if (PyUnicode_Check(pyObject))
2985 : {
2986 : char *pszStr;
2987 : char *pszNewStr;
2988 : Py_ssize_t nLen;
2989 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObject);
2990 : #if PY_VERSION_HEX >= 0x03000000
2991 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
2992 : #else
2993 : PyString_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
2994 : #endif
2995 : pszNewStr = (char *) malloc(nLen+1);
2996 : memcpy(pszNewStr, pszStr, nLen+1);
2997 : Py_XDECREF(pyUTF8Str);
2998 : *pbToFree = 1;
2999 : return pszNewStr;
3000 : }
3001 : else
3002 : {
3003 : #if PY_VERSION_HEX >= 0x03000000
3004 : return PyBytes_AsString(pyObject);
3005 : #else
3006 : return PyString_AsString(pyObject);
3007 : #endif
3008 : }
3009 : }
3010 :
3011 : static void GDALPythonFreeCStr(void* ptr, int bToFree)
3012 : {
3013 : if (bToFree)
3014 : free(ptr);
3015 : }
3016 :
3017 :
3018 :
3019 : static PyObject *
3020 1 : py_OPTGetProjectionMethods(PyObject *self, PyObject *args) {
3021 :
3022 : PyObject *py_MList;
3023 : char **papszMethods;
3024 : int iMethod;
3025 :
3026 1 : self = self;
3027 1 : args = args;
3028 :
3029 1 : papszMethods = OPTGetProjectionMethods();
3030 1 : py_MList = PyList_New(CSLCount(papszMethods));
3031 :
3032 49 : for( iMethod = 0; papszMethods[iMethod] != NULL; iMethod++ )
3033 : {
3034 : char *pszUserMethodName;
3035 : char **papszParameters;
3036 : PyObject *py_PList;
3037 : int iParam;
3038 :
3039 48 : papszParameters = OPTGetParameterList( papszMethods[iMethod],
3040 96 : &pszUserMethodName );
3041 48 : if( papszParameters == NULL )
3042 0 : return NULL;
3043 :
3044 48 : py_PList = PyList_New(CSLCount(papszParameters));
3045 236 : for( iParam = 0; papszParameters[iParam] != NULL; iParam++ )
3046 : {
3047 : char *pszType;
3048 : char *pszUserParamName;
3049 : double dfDefault;
3050 :
3051 188 : OPTGetParameterInfo( papszMethods[iMethod],
3052 188 : papszParameters[iParam],
3053 : &pszUserParamName,
3054 564 : &pszType, &dfDefault );
3055 : PyList_SetItem(py_PList, iParam,
3056 : Py_BuildValue("(sssd)",
3057 : papszParameters[iParam],
3058 : pszUserParamName,
3059 188 : pszType, dfDefault ));
3060 : }
3061 :
3062 48 : CSLDestroy( papszParameters );
3063 :
3064 : PyList_SetItem(py_MList, iMethod,
3065 : Py_BuildValue("(ssO)",
3066 : papszMethods[iMethod],
3067 : pszUserMethodName,
3068 48 : py_PList));
3069 :
3070 48 : Py_XDECREF( py_PList );
3071 : }
3072 :
3073 1 : CSLDestroy( papszMethods );
3074 :
3075 1 : return py_MList;
3076 : }
3077 :
3078 :
3079 0 : OGRErr GetWellKnownGeogCSAsWKT( const char *name, char **argout ) {
3080 0 : OGRSpatialReferenceH srs = OSRNewSpatialReference("");
3081 0 : OGRErr rcode = OSRSetWellKnownGeogCS( srs, name );
3082 0 : if( rcode == OGRERR_NONE )
3083 0 : rcode = OSRExportToWkt ( srs, argout );
3084 0 : OSRDestroySpatialReference( srs );
3085 0 : return rcode;
3086 : }
3087 :
3088 :
3089 : SWIGINTERN int
3090 32530 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3091 : {
3092 : #if PY_VERSION_HEX>=0x03000000
3093 : if (PyUnicode_Check(obj))
3094 : #else
3095 32530 : if (PyString_Check(obj))
3096 : #endif
3097 : {
3098 : char *cstr; Py_ssize_t len;
3099 : #if PY_VERSION_HEX>=0x03000000
3100 : if (!alloc && cptr) {
3101 : /* We can't allow converting without allocation, since the internal
3102 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3103 : a UTF-8 representation.
3104 : TODO(bhy) More detailed explanation */
3105 : return SWIG_RuntimeError;
3106 : }
3107 : obj = PyUnicode_AsUTF8String(obj);
3108 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3109 : if(alloc) *alloc = SWIG_NEWOBJ;
3110 : #else
3111 32530 : PyString_AsStringAndSize(obj, &cstr, &len);
3112 : #endif
3113 32530 : if (cptr) {
3114 32530 : if (alloc) {
3115 : /*
3116 : In python the user should not be able to modify the inner
3117 : string representation. To warranty that, if you define
3118 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3119 : buffer is always returned.
3120 :
3121 : The default behavior is just to return the pointer value,
3122 : so, be careful.
3123 : */
3124 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3125 : if (*alloc != SWIG_OLDOBJ)
3126 : #else
3127 32530 : if (*alloc == SWIG_NEWOBJ)
3128 : #endif
3129 : {
3130 0 : *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3131 0 : *alloc = SWIG_NEWOBJ;
3132 : }
3133 : else {
3134 32530 : *cptr = cstr;
3135 32530 : *alloc = SWIG_OLDOBJ;
3136 : }
3137 : } else {
3138 : #if PY_VERSION_HEX>=0x03000000
3139 : assert(0); /* Should never reach here in Python 3 */
3140 : #endif
3141 0 : *cptr = SWIG_Python_str_AsChar(obj);
3142 : }
3143 : }
3144 32530 : if (psize) *psize = len + 1;
3145 : #if PY_VERSION_HEX>=0x03000000
3146 : Py_XDECREF(obj);
3147 : #endif
3148 32530 : return SWIG_OK;
3149 : } else {
3150 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3151 0 : if (pchar_descriptor) {
3152 0 : void* vptr = 0;
3153 0 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3154 0 : if (cptr) *cptr = (char *) vptr;
3155 0 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3156 0 : if (alloc) *alloc = SWIG_OLDOBJ;
3157 0 : return SWIG_OK;
3158 : }
3159 : }
3160 : }
3161 0 : return SWIG_TypeError;
3162 : }
3163 :
3164 :
3165 :
3166 :
3167 :
3168 : #define t_output_helper SWIG_Python_AppendOutput
3169 :
3170 :
3171 :
3172 : #include "ogr_core.h"
3173 : static char const *
3174 0 : OGRErrMessages( int rc ) {
3175 0 : switch( rc ) {
3176 : case OGRERR_NONE:
3177 0 : return "OGR Error: None";
3178 : case OGRERR_NOT_ENOUGH_DATA:
3179 0 : return "OGR Error: Not enough data to deserialize";
3180 : case OGRERR_NOT_ENOUGH_MEMORY:
3181 0 : return "OGR Error: Not enough memory";
3182 : case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
3183 0 : return "OGR Error: Unsupported geometry type";
3184 : case OGRERR_UNSUPPORTED_OPERATION:
3185 0 : return "OGR Error: Unsupported operation";
3186 : case OGRERR_CORRUPT_DATA:
3187 0 : return "OGR Error: Corrupt data";
3188 : case OGRERR_FAILURE:
3189 0 : return "OGR Error: General Error";
3190 : case OGRERR_UNSUPPORTED_SRS:
3191 0 : return "OGR Error: Unsupported SRS";
3192 : case OGRERR_INVALID_HANDLE:
3193 0 : return "OGR Error: Invalid handle";
3194 : default:
3195 0 : return "OGR Error: Unknown";
3196 : }
3197 : }
3198 :
3199 :
3200 13 : OGRErr GetUserInputAsWKT( const char *name, char **argout ) {
3201 13 : OGRSpatialReferenceH srs = OSRNewSpatialReference("");
3202 13 : OGRErr rcode = OSRSetFromUserInput( srs, name );
3203 13 : if( rcode == OGRERR_NONE )
3204 13 : rcode = OSRExportToWkt ( srs, argout );
3205 13 : OSRDestroySpatialReference( srs );
3206 13 : return rcode;
3207 : }
3208 :
3209 : SWIGINTERN OSRSpatialReferenceShadow *new_OSRSpatialReferenceShadow(char const *wkt=""){
3210 15812 : return (OSRSpatialReferenceShadow*) OSRNewSpatialReference(wkt);
3211 : }
3212 : SWIGINTERN void delete_OSRSpatialReferenceShadow(OSRSpatialReferenceShadow *self){
3213 44900 : if (OSRDereference( self ) == 0 ) {
3214 44697 : OSRDestroySpatialReference( self );
3215 : }
3216 : }
3217 : SWIGINTERN retStringAndCPLFree *OSRSpatialReferenceShadow___str__(OSRSpatialReferenceShadow *self){
3218 4 : char *buf = 0;
3219 4 : OSRExportToPrettyWkt( self, &buf, 0 );
3220 4 : return buf;
3221 : }
3222 : SWIGINTERN int OSRSpatialReferenceShadow_IsSame(OSRSpatialReferenceShadow *self,OSRSpatialReferenceShadow *rhs){
3223 14691 : return OSRIsSame( self, rhs );
3224 : }
3225 : SWIGINTERN int OSRSpatialReferenceShadow_IsSameGeogCS(OSRSpatialReferenceShadow *self,OSRSpatialReferenceShadow *rhs){
3226 0 : return OSRIsSameGeogCS( self, rhs );
3227 : }
3228 : SWIGINTERN int OSRSpatialReferenceShadow_IsSameVertCS(OSRSpatialReferenceShadow *self,OSRSpatialReferenceShadow *rhs){
3229 0 : return OSRIsSameVertCS( self, rhs );
3230 : }
3231 : SWIGINTERN int OSRSpatialReferenceShadow_IsGeographic(OSRSpatialReferenceShadow *self){
3232 1 : return OSRIsGeographic(self);
3233 : }
3234 : SWIGINTERN int OSRSpatialReferenceShadow_IsProjected(OSRSpatialReferenceShadow *self){
3235 3 : return OSRIsProjected(self);
3236 : }
3237 : SWIGINTERN int OSRSpatialReferenceShadow_IsCompound(OSRSpatialReferenceShadow *self){
3238 1 : return OSRIsCompound(self);
3239 : }
3240 : SWIGINTERN int OSRSpatialReferenceShadow_IsGeocentric(OSRSpatialReferenceShadow *self){
3241 2 : return OSRIsGeocentric(self);
3242 : }
3243 : SWIGINTERN int OSRSpatialReferenceShadow_IsLocal(OSRSpatialReferenceShadow *self){
3244 1 : return OSRIsLocal(self);
3245 : }
3246 : SWIGINTERN int OSRSpatialReferenceShadow_IsVertical(OSRSpatialReferenceShadow *self){
3247 0 : return OSRIsVertical(self);
3248 : }
3249 : SWIGINTERN int OSRSpatialReferenceShadow_EPSGTreatsAsLatLong(OSRSpatialReferenceShadow *self){
3250 4 : return OSREPSGTreatsAsLatLong(self);
3251 : }
3252 :
3253 : #include <limits.h>
3254 : #if !defined(SWIG_NO_LLONG_MAX)
3255 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3256 : # define LLONG_MAX __LONG_LONG_MAX__
3257 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3258 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3259 : # endif
3260 : #endif
3261 :
3262 :
3263 : SWIGINTERN int
3264 803 : SWIG_AsVal_double (PyObject *obj, double *val)
3265 : {
3266 803 : int res = SWIG_TypeError;
3267 803 : if (PyFloat_Check(obj)) {
3268 515 : if (val) *val = PyFloat_AsDouble(obj);
3269 515 : return SWIG_OK;
3270 288 : } else if (PyInt_Check(obj)) {
3271 288 : if (val) *val = PyInt_AsLong(obj);
3272 288 : return SWIG_OK;
3273 0 : } else if (PyLong_Check(obj)) {
3274 0 : double v = PyLong_AsDouble(obj);
3275 0 : if (!PyErr_Occurred()) {
3276 0 : if (val) *val = v;
3277 0 : return SWIG_OK;
3278 : } else {
3279 0 : PyErr_Clear();
3280 : }
3281 : }
3282 : #ifdef SWIG_PYTHON_CAST_MODE
3283 : {
3284 : int dispatch = 0;
3285 : double d = PyFloat_AsDouble(obj);
3286 : if (!PyErr_Occurred()) {
3287 : if (val) *val = d;
3288 : return SWIG_AddCast(SWIG_OK);
3289 : } else {
3290 : PyErr_Clear();
3291 : }
3292 : if (!dispatch) {
3293 : long v = PyLong_AsLong(obj);
3294 : if (!PyErr_Occurred()) {
3295 : if (val) *val = v;
3296 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3297 : } else {
3298 : PyErr_Clear();
3299 : }
3300 : }
3301 : }
3302 : #endif
3303 0 : return res;
3304 : }
3305 :
3306 :
3307 : #include <float.h>
3308 :
3309 :
3310 : #include <math.h>
3311 :
3312 :
3313 : SWIGINTERNINLINE int
3314 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3315 : double x = *d;
3316 : if ((min <= x && x <= max)) {
3317 : double fx = floor(x);
3318 : double cx = ceil(x);
3319 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3320 : if ((errno == EDOM) || (errno == ERANGE)) {
3321 : errno = 0;
3322 : } else {
3323 : double summ, reps, diff;
3324 : if (rd < x) {
3325 : diff = x - rd;
3326 : } else if (rd > x) {
3327 : diff = rd - x;
3328 : } else {
3329 : return 1;
3330 : }
3331 : summ = rd + x;
3332 : reps = diff/summ;
3333 : if (reps < 8*DBL_EPSILON) {
3334 : *d = rd;
3335 : return 1;
3336 : }
3337 : }
3338 : }
3339 : return 0;
3340 : }
3341 :
3342 :
3343 : SWIGINTERN int
3344 9338 : SWIG_AsVal_long (PyObject *obj, long* val)
3345 : {
3346 9338 : if (PyInt_Check(obj)) {
3347 9338 : if (val) *val = PyInt_AsLong(obj);
3348 9338 : return SWIG_OK;
3349 0 : } else if (PyLong_Check(obj)) {
3350 0 : long v = PyLong_AsLong(obj);
3351 0 : if (!PyErr_Occurred()) {
3352 0 : if (val) *val = v;
3353 0 : return SWIG_OK;
3354 : } else {
3355 0 : PyErr_Clear();
3356 : }
3357 : }
3358 : #ifdef SWIG_PYTHON_CAST_MODE
3359 : {
3360 : int dispatch = 0;
3361 : long v = PyInt_AsLong(obj);
3362 : if (!PyErr_Occurred()) {
3363 : if (val) *val = v;
3364 : return SWIG_AddCast(SWIG_OK);
3365 : } else {
3366 : PyErr_Clear();
3367 : }
3368 : if (!dispatch) {
3369 : double d;
3370 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3371 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3372 : if (val) *val = (long)(d);
3373 : return res;
3374 : }
3375 : }
3376 : }
3377 : #endif
3378 0 : return SWIG_TypeError;
3379 : }
3380 :
3381 :
3382 : SWIGINTERN int
3383 9335 : SWIG_AsVal_int (PyObject * obj, int *val)
3384 : {
3385 : long v;
3386 9335 : int res = SWIG_AsVal_long (obj, &v);
3387 9335 : if (SWIG_IsOK(res)) {
3388 9335 : if ((v < INT_MIN || v > INT_MAX)) {
3389 0 : return SWIG_OverflowError;
3390 : } else {
3391 9335 : if (val) *val = static_cast< int >(v);
3392 : }
3393 : }
3394 9335 : return res;
3395 : }
3396 :
3397 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetAuthority(OSRSpatialReferenceShadow *self,char const *pszTargetKey,char const *pszAuthority,int nCode){
3398 0 : return OSRSetAuthority( self, pszTargetKey, pszAuthority, nCode );
3399 : }
3400 : SWIGINTERN char const *OSRSpatialReferenceShadow_GetAttrValue(OSRSpatialReferenceShadow *self,char const *name,int child=0){
3401 20430 : return OSRGetAttrValue( self, name, child );
3402 : }
3403 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetAttrValue(OSRSpatialReferenceShadow *self,char const *name,char const *value){
3404 621 : return OSRSetAttrValue( self, name, value );
3405 : }
3406 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetAngularUnits(OSRSpatialReferenceShadow *self,char const *name,double to_radians){
3407 0 : return OSRSetAngularUnits( self, name, to_radians );
3408 : }
3409 : SWIGINTERN double OSRSpatialReferenceShadow_GetAngularUnits(OSRSpatialReferenceShadow *self){
3410 : // Return code ignored.
3411 0 : return OSRGetAngularUnits( self, 0 );
3412 : }
3413 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTargetLinearUnits(OSRSpatialReferenceShadow *self,char const *target,char const *name,double to_meters){
3414 1 : return OSRSetTargetLinearUnits( self, target, name, to_meters );
3415 : }
3416 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLinearUnits(OSRSpatialReferenceShadow *self,char const *name,double to_meters){
3417 2 : return OSRSetLinearUnits( self, name, to_meters );
3418 : }
3419 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLinearUnitsAndUpdateParameters(OSRSpatialReferenceShadow *self,char const *name,double to_meters){
3420 1 : return OSRSetLinearUnitsAndUpdateParameters( self, name, to_meters );
3421 : }
3422 : SWIGINTERN double OSRSpatialReferenceShadow_GetLinearUnits(OSRSpatialReferenceShadow *self){
3423 : // Return code ignored.
3424 0 : return OSRGetLinearUnits( self, 0 );
3425 : }
3426 : SWIGINTERN char const *OSRSpatialReferenceShadow_GetLinearUnitsName(OSRSpatialReferenceShadow *self){
3427 2 : const char *name = 0;
3428 2 : if ( OSRIsProjected( self ) ) {
3429 2 : name = OSRGetAttrValue( self, "PROJCS|UNIT", 0 );
3430 : }
3431 0 : else if ( OSRIsLocal( self ) ) {
3432 0 : name = OSRGetAttrValue( self, "LOCAL_CS|UNIT", 0 );
3433 : }
3434 :
3435 2 : if (name != 0)
3436 2 : return name;
3437 :
3438 0 : return "Meter";
3439 : }
3440 : SWIGINTERN char const *OSRSpatialReferenceShadow_GetAuthorityCode(OSRSpatialReferenceShadow *self,char const *target_key){
3441 1259 : return OSRGetAuthorityCode( self, target_key );
3442 : }
3443 : SWIGINTERN char const *OSRSpatialReferenceShadow_GetAuthorityName(OSRSpatialReferenceShadow *self,char const *target_key){
3444 9 : return OSRGetAuthorityName( self, target_key );
3445 : }
3446 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetUTM(OSRSpatialReferenceShadow *self,int zone,int north=1){
3447 12 : return OSRSetUTM( self, zone, north );
3448 : }
3449 : SWIGINTERN int OSRSpatialReferenceShadow_GetUTMZone(OSRSpatialReferenceShadow *self){
3450 : // Note: we will return south zones as negative since it is
3451 : // hard to return two values as the C API does.
3452 2 : int bNorth = FALSE;
3453 2 : int nZone = OSRGetUTMZone( self, &bNorth );
3454 2 : if( !bNorth )
3455 1 : nZone = -1 * ABS(nZone);
3456 2 : return nZone;
3457 : }
3458 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetStatePlane(OSRSpatialReferenceShadow *self,int zone,int is_nad83=1,char const *unitsname="",double units=0.0){
3459 2 : return OSRSetStatePlaneWithUnits( self, zone, is_nad83, unitsname, units );
3460 : }
3461 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_AutoIdentifyEPSG(OSRSpatialReferenceShadow *self){
3462 0 : return OSRAutoIdentifyEPSG( self );
3463 : }
3464 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetProjection(OSRSpatialReferenceShadow *self,char const *arg){
3465 0 : return OSRSetProjection( self, arg );
3466 : }
3467 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetProjParm(OSRSpatialReferenceShadow *self,char const *name,double val){
3468 142 : return OSRSetProjParm( self, name, val );
3469 : }
3470 : SWIGINTERN double OSRSpatialReferenceShadow_GetProjParm(OSRSpatialReferenceShadow *self,char const *name,double default_val=0.0){
3471 : // Return code ignored.
3472 8815 : return OSRGetProjParm( self, name, default_val, 0 );
3473 : }
3474 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetNormProjParm(OSRSpatialReferenceShadow *self,char const *name,double val){
3475 0 : return OSRSetNormProjParm( self, name, val );
3476 : }
3477 : SWIGINTERN double OSRSpatialReferenceShadow_GetNormProjParm(OSRSpatialReferenceShadow *self,char const *name,double default_val=0.0){
3478 : // Return code ignored.
3479 0 : return OSRGetNormProjParm( self, name, default_val, 0 );
3480 : }
3481 : SWIGINTERN double OSRSpatialReferenceShadow_GetSemiMajor(OSRSpatialReferenceShadow *self){
3482 : // Return code ignored.
3483 3 : return OSRGetSemiMajor( self, 0 );
3484 : }
3485 : SWIGINTERN double OSRSpatialReferenceShadow_GetSemiMinor(OSRSpatialReferenceShadow *self){
3486 : // Return code ignored.
3487 3 : return OSRGetSemiMinor( self, 0 );
3488 : }
3489 : SWIGINTERN double OSRSpatialReferenceShadow_GetInvFlattening(OSRSpatialReferenceShadow *self){
3490 : // Return code ignored.
3491 3 : return OSRGetInvFlattening( self, 0 );
3492 : }
3493 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetACEA(OSRSpatialReferenceShadow *self,double stdp1,double stdp2,double clat,double clong,double fe,double fn){
3494 : return OSRSetACEA( self, stdp1, stdp2, clat, clong,
3495 0 : fe, fn );
3496 : }
3497 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetAE(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3498 : return OSRSetAE( self, clat, clong,
3499 0 : fe, fn );
3500 : }
3501 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetBonne(OSRSpatialReferenceShadow *self,double stdp,double cm,double fe,double fn){
3502 0 : return OSRSetBonne( self, stdp, cm, fe, fn );
3503 : }
3504 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetCEA(OSRSpatialReferenceShadow *self,double stdp1,double cm,double fe,double fn){
3505 : return OSRSetCEA( self, stdp1, cm,
3506 0 : fe, fn );
3507 : }
3508 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetCS(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3509 : return OSRSetCS( self, clat, clong,
3510 0 : fe, fn );
3511 : }
3512 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetEC(OSRSpatialReferenceShadow *self,double stdp1,double stdp2,double clat,double clong,double fe,double fn){
3513 : return OSRSetEC( self, stdp1, stdp2, clat, clong,
3514 0 : fe, fn );
3515 : }
3516 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetEckertIV(OSRSpatialReferenceShadow *self,double cm,double fe,double fn){
3517 0 : return OSRSetEckertIV( self, cm, fe, fn);
3518 : }
3519 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetEckertVI(OSRSpatialReferenceShadow *self,double cm,double fe,double fn){
3520 0 : return OSRSetEckertVI( self, cm, fe, fn);
3521 : }
3522 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetEquirectangular(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3523 : return OSRSetEquirectangular( self, clat, clong,
3524 0 : fe, fn );
3525 : }
3526 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetEquirectangular2(OSRSpatialReferenceShadow *self,double clat,double clong,double pseudostdparallellat,double fe,double fn){
3527 : return OSRSetEquirectangular2( self, clat, clong,
3528 : pseudostdparallellat,
3529 0 : fe, fn );
3530 : }
3531 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGaussSchreiberTMercator(OSRSpatialReferenceShadow *self,double clat,double clong,double sc,double fe,double fn){
3532 0 : return OSRSetGaussSchreiberTMercator( self, clat, clong, sc, fe, fn );
3533 : }
3534 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGS(OSRSpatialReferenceShadow *self,double cm,double fe,double fn){
3535 1 : return OSRSetGS( self, cm, fe, fn );
3536 : }
3537 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGH(OSRSpatialReferenceShadow *self,double cm,double fe,double fn){
3538 0 : return OSRSetGH( self, cm, fe, fn );
3539 : }
3540 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetIGH(OSRSpatialReferenceShadow *self){
3541 0 : return OSRSetIGH( self );
3542 : }
3543 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGEOS(OSRSpatialReferenceShadow *self,double cm,double satelliteheight,double fe,double fn){
3544 : return OSRSetGEOS( self, cm, satelliteheight,
3545 0 : fe, fn );
3546 : }
3547 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGnomonic(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3548 : return OSRSetGnomonic( self, clat, clong,
3549 0 : fe, fn );
3550 : }
3551 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetHOM(OSRSpatialReferenceShadow *self,double clat,double clong,double azimuth,double recttoskew,double scale,double fe,double fn){
3552 : return OSRSetHOM( self, clat, clong, azimuth, recttoskew,
3553 0 : scale, fe, fn );
3554 : }
3555 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetHOM2PNO(OSRSpatialReferenceShadow *self,double clat,double dfLat1,double dfLong1,double dfLat2,double dfLong2,double scale,double fe,double fn){
3556 : return OSRSetHOM2PNO( self, clat, dfLat1, dfLong1, dfLat2, dfLong2,
3557 0 : scale, fe, fn );
3558 : }
3559 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetKrovak(OSRSpatialReferenceShadow *self,double clat,double clong,double azimuth,double pseudostdparallellat,double scale,double fe,double fn){
3560 : return OSRSetKrovak( self, clat, clong,
3561 : azimuth, pseudostdparallellat,
3562 0 : scale, fe, fn );
3563 : }
3564 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLAEA(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3565 : return OSRSetLAEA( self, clat, clong,
3566 0 : fe, fn );
3567 : }
3568 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLCC(OSRSpatialReferenceShadow *self,double stdp1,double stdp2,double clat,double clong,double fe,double fn){
3569 : return OSRSetLCC( self, stdp1, stdp2, clat, clong,
3570 0 : fe, fn );
3571 : }
3572 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLCC1SP(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3573 : return OSRSetLCC1SP( self, clat, clong, scale,
3574 0 : fe, fn );
3575 : }
3576 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLCCB(OSRSpatialReferenceShadow *self,double stdp1,double stdp2,double clat,double clong,double fe,double fn){
3577 : return OSRSetLCCB( self, stdp1, stdp2, clat, clong,
3578 0 : fe, fn );
3579 : }
3580 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetMC(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3581 : return OSRSetMC( self, clat, clong,
3582 0 : fe, fn );
3583 : }
3584 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetMercator(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3585 : return OSRSetMercator( self, clat, clong,
3586 0 : scale, fe, fn );
3587 : }
3588 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetMollweide(OSRSpatialReferenceShadow *self,double cm,double fe,double fn){
3589 : return OSRSetMollweide( self, cm,
3590 0 : fe, fn );
3591 : }
3592 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetNZMG(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3593 : return OSRSetNZMG( self, clat, clong,
3594 0 : fe, fn );
3595 : }
3596 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetOS(OSRSpatialReferenceShadow *self,double dfOriginLat,double dfCMeridian,double scale,double fe,double fn){
3597 : return OSRSetOS( self, dfOriginLat, dfCMeridian, scale,
3598 0 : fe, fn );
3599 : }
3600 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetOrthographic(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3601 : return OSRSetOrthographic( self, clat, clong,
3602 0 : fe, fn );
3603 : }
3604 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetPolyconic(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3605 : return OSRSetPolyconic( self, clat, clong,
3606 0 : fe, fn );
3607 : }
3608 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetPS(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3609 : return OSRSetPS( self, clat, clong, scale,
3610 0 : fe, fn );
3611 : }
3612 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetRobinson(OSRSpatialReferenceShadow *self,double clong,double fe,double fn){
3613 0 : return OSRSetRobinson( self, clong, fe, fn );
3614 : }
3615 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetSinusoidal(OSRSpatialReferenceShadow *self,double clong,double fe,double fn){
3616 0 : return OSRSetSinusoidal( self, clong, fe, fn );
3617 : }
3618 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetStereographic(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3619 : return OSRSetStereographic( self, clat, clong, scale,
3620 0 : fe, fn );
3621 : }
3622 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetSOC(OSRSpatialReferenceShadow *self,double latitudeoforigin,double cm,double fe,double fn){
3623 : return OSRSetSOC( self, latitudeoforigin, cm,
3624 0 : fe, fn );
3625 : }
3626 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTM(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3627 : return OSRSetTM( self, clat, clong, scale,
3628 0 : fe, fn );
3629 : }
3630 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTMVariant(OSRSpatialReferenceShadow *self,char const *pszVariantName,double clat,double clong,double scale,double fe,double fn){
3631 : return OSRSetTMVariant( self, pszVariantName, clat, clong,
3632 0 : scale, fe, fn );
3633 : }
3634 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTMG(OSRSpatialReferenceShadow *self,double clat,double clong,double fe,double fn){
3635 : return OSRSetTMG( self, clat, clong,
3636 0 : fe, fn );
3637 : }
3638 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTMSO(OSRSpatialReferenceShadow *self,double clat,double clong,double scale,double fe,double fn){
3639 : return OSRSetTMSO( self, clat, clong, scale,
3640 0 : fe, fn );
3641 : }
3642 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetVDG(OSRSpatialReferenceShadow *self,double clong,double fe,double fn){
3643 0 : return OSRSetVDG( self, clong, fe, fn );
3644 : }
3645 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetWellKnownGeogCS(OSRSpatialReferenceShadow *self,char const *name){
3646 41 : return OSRSetWellKnownGeogCS( self, name );
3647 : }
3648 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetFromUserInput(OSRSpatialReferenceShadow *self,char const *name){
3649 251 : return OSRSetFromUserInput( self, name );
3650 : }
3651 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_CopyGeogCSFrom(OSRSpatialReferenceShadow *self,OSRSpatialReferenceShadow *rhs){
3652 0 : return OSRCopyGeogCSFrom( self, rhs );
3653 : }
3654 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetTOWGS84(OSRSpatialReferenceShadow *self,double p1,double p2,double p3,double p4=0.0,double p5=0.0,double p6=0.0,double p7=0.0){
3655 :
3656 20 : return OSRSetTOWGS84( self, p1, p2, p3, p4, p5, p6, p7 );
3657 : }
3658 :
3659 : static PyObject *
3660 92 : CreateTupleFromDoubleArray( double *first, unsigned int size ) {
3661 92 : PyObject *out = PyTuple_New( size );
3662 472 : for( unsigned int i=0; i<size; i++ ) {
3663 380 : PyObject *val = PyFloat_FromDouble( *first );
3664 380 : ++first;
3665 380 : PyTuple_SetItem( out, i, val );
3666 : }
3667 92 : return out;
3668 : }
3669 :
3670 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_GetTOWGS84(OSRSpatialReferenceShadow *self,double argout[7]){
3671 2 : return OSRGetTOWGS84( self, argout, 7 );
3672 : }
3673 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetLocalCS(OSRSpatialReferenceShadow *self,char const *pszName){
3674 0 : return OSRSetLocalCS( self, pszName );
3675 : }
3676 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGeogCS(OSRSpatialReferenceShadow *self,char const *pszGeogName,char const *pszDatumName,char const *pszEllipsoidName,double dfSemiMajor,double dfInvFlattening,char const *pszPMName="Greenwich",double dfPMOffset=0.0,char const *pszUnits="degree",double dfConvertToRadians=0.0174532925199433){
3677 : return OSRSetGeogCS( self, pszGeogName, pszDatumName, pszEllipsoidName,
3678 : dfSemiMajor, dfInvFlattening,
3679 1 : pszPMName, dfPMOffset, pszUnits, dfConvertToRadians );
3680 : }
3681 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetProjCS(OSRSpatialReferenceShadow *self,char const *name="unnamed"){
3682 0 : return OSRSetProjCS( self, name );
3683 : }
3684 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetGeocCS(OSRSpatialReferenceShadow *self,char const *name="unnamed"){
3685 5 : return OSRSetGeocCS( self, name );
3686 : }
3687 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetVertCS(OSRSpatialReferenceShadow *self,char const *VertCSName="unnamed",char const *VertDatumName="unnamed",int VertDatumType=0){
3688 0 : return OSRSetVertCS( self, VertCSName, VertDatumName, VertDatumType );
3689 : }
3690 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_SetCompoundCS(OSRSpatialReferenceShadow *self,char const *name,OSRSpatialReferenceShadow *horizcs,OSRSpatialReferenceShadow *vertcs){
3691 1 : return OSRSetCompoundCS( self, name, horizcs, vertcs );
3692 : }
3693 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromWkt(OSRSpatialReferenceShadow *self,char **ppszInput){
3694 6022 : return OSRImportFromWkt( self, ppszInput );
3695 : }
3696 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromProj4(OSRSpatialReferenceShadow *self,char *ppszInput){
3697 73 : return OSRImportFromProj4( self, ppszInput );
3698 : }
3699 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromUrl(OSRSpatialReferenceShadow *self,char *url){
3700 2 : return OSRImportFromUrl( self, url );
3701 : }
3702 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromESRI(OSRSpatialReferenceShadow *self,char **ppszInput){
3703 5 : return OSRImportFromESRI( self, ppszInput );
3704 : }
3705 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromEPSG(OSRSpatialReferenceShadow *self,int arg){
3706 9211 : return OSRImportFromEPSG(self, arg);
3707 : }
3708 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromEPSGA(OSRSpatialReferenceShadow *self,int arg){
3709 3 : return OSRImportFromEPSGA(self, arg);
3710 : }
3711 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromPCI(OSRSpatialReferenceShadow *self,char const *proj,char const *units="METRE",double argin[17]=0){
3712 7 : return OSRImportFromPCI( self, proj, units, argin );
3713 : }
3714 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromUSGS(OSRSpatialReferenceShadow *self,long proj_code,long zone=0,double argin[15]=0,long datum_code=0){
3715 1 : return OSRImportFromUSGS( self, proj_code, zone, argin, datum_code );
3716 : }
3717 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromXML(OSRSpatialReferenceShadow *self,char const *xmlString){
3718 1 : return OSRImportFromXML( self, xmlString );
3719 : }
3720 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromERM(OSRSpatialReferenceShadow *self,char const *proj,char const *datum,char const *units){
3721 6 : return OSRImportFromERM( self, proj, datum, units );
3722 : }
3723 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromMICoordSys(OSRSpatialReferenceShadow *self,char const *pszCoordSys){
3724 1 : return OSRImportFromMICoordSys( self, pszCoordSys );
3725 : }
3726 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ImportFromOzi(OSRSpatialReferenceShadow *self,char const *datum,char const *proj,char const *projParms){
3727 3 : return OSRImportFromOzi( self, datum, proj, projParms );
3728 : }
3729 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToWkt(OSRSpatialReferenceShadow *self,char **argout){
3730 61279 : return OSRExportToWkt( self, argout );
3731 : }
3732 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToPrettyWkt(OSRSpatialReferenceShadow *self,char **argout,int simplify=0){
3733 35 : return OSRExportToPrettyWkt( self, argout, simplify );
3734 : }
3735 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToProj4(OSRSpatialReferenceShadow *self,char **argout){
3736 107 : return OSRExportToProj4( self, argout );
3737 : }
3738 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToPCI(OSRSpatialReferenceShadow *self,char **proj,char **units,double *parms[17]){
3739 6 : return OSRExportToPCI( self, proj, units, parms );
3740 : }
3741 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToUSGS(OSRSpatialReferenceShadow *self,long *code,long *zone,double *parms[15],long *datum){
3742 1 : return OSRExportToUSGS( self, code, zone, parms, datum );
3743 : }
3744 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToXML(OSRSpatialReferenceShadow *self,char **argout,char const *dialect=""){
3745 1 : return OSRExportToXML( self, argout, dialect );
3746 : }
3747 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_ExportToMICoordSys(OSRSpatialReferenceShadow *self,char **argout){
3748 1 : return OSRExportToMICoordSys( self, argout );
3749 : }
3750 : SWIGINTERN OSRSpatialReferenceShadow *OSRSpatialReferenceShadow_CloneGeogCS(OSRSpatialReferenceShadow *self){
3751 14 : return (OSRSpatialReferenceShadow*) OSRCloneGeogCS(self);
3752 : }
3753 : SWIGINTERN OSRSpatialReferenceShadow *OSRSpatialReferenceShadow_Clone(OSRSpatialReferenceShadow *self){
3754 28841 : return (OSRSpatialReferenceShadow*) OSRClone(self);
3755 : }
3756 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_Validate(OSRSpatialReferenceShadow *self){
3757 61 : return OSRValidate(self);
3758 : }
3759 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_StripCTParms(OSRSpatialReferenceShadow *self){
3760 17037 : return OSRStripCTParms(self);
3761 : }
3762 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_FixupOrdering(OSRSpatialReferenceShadow *self){
3763 0 : return OSRFixupOrdering(self);
3764 : }
3765 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_Fixup(OSRSpatialReferenceShadow *self){
3766 1 : return OSRFixup(self);
3767 : }
3768 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_MorphToESRI(OSRSpatialReferenceShadow *self){
3769 14437 : return OSRMorphToESRI(self);
3770 : }
3771 : SWIGINTERN OGRErr OSRSpatialReferenceShadow_MorphFromESRI(OSRSpatialReferenceShadow *self){
3772 14440 : return OSRMorphFromESRI(self);
3773 : }
3774 : SWIGINTERN OSRCoordinateTransformationShadow *new_OSRCoordinateTransformationShadow(OSRSpatialReferenceShadow *src,OSRSpatialReferenceShadow *dst){
3775 40 : OSRCoordinateTransformationShadow *obj = (OSRCoordinateTransformationShadow*) OCTNewCoordinateTransformation( src, dst );
3776 40 : return obj;
3777 : }
3778 : SWIGINTERN void delete_OSRCoordinateTransformationShadow(OSRCoordinateTransformationShadow *self){
3779 40 : OCTDestroyCoordinateTransformation( self );
3780 : }
3781 : SWIGINTERN void OSRCoordinateTransformationShadow_TransformPoint__SWIG_0(OSRCoordinateTransformationShadow *self,double inout[3]){
3782 0 : if (self == NULL)
3783 : return;
3784 0 : OCTTransform( self, 1, &inout[0], &inout[1], &inout[2] );
3785 : }
3786 : SWIGINTERN void OSRCoordinateTransformationShadow_TransformPoint__SWIG_1(OSRCoordinateTransformationShadow *self,double argout[3],double x,double y,double z=0.0){
3787 83 : if (self == NULL)
3788 : return;
3789 83 : argout[0] = x;
3790 83 : argout[1] = y;
3791 83 : argout[2] = z;
3792 83 : OCTTransform( self, 1, &argout[0], &argout[1], &argout[2] );
3793 : }
3794 :
3795 : static int
3796 3 : DecomposeSequenceOfCoordinates( PyObject *seq, int nCount, double *x, double *y, double *z )
3797 : {
3798 9 : for( int i = 0; i<nCount; ++i )
3799 : {
3800 :
3801 6 : PyObject *o = PySequence_GetItem(seq, i);
3802 6 : if ( !PySequence_Check(o) )
3803 : {
3804 0 : Py_DECREF(o);
3805 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
3806 :
3807 0 : return FALSE;
3808 : }
3809 :
3810 6 : Py_ssize_t len = PySequence_Size(o);
3811 :
3812 6 : if (len == 2 || len == 3)
3813 : {
3814 6 : PyObject *o1 = PySequence_GetItem(o, 0);
3815 6 : if (!PyNumber_Check(o1))
3816 : {
3817 0 : Py_DECREF(o); Py_DECREF(o1);
3818 0 : PyErr_SetString(PyExc_TypeError, "not a number");
3819 :
3820 0 : return FALSE;
3821 : }
3822 6 : x[i] = PyFloat_AsDouble(o1);
3823 6 : Py_DECREF(o1);
3824 :
3825 6 : o1 = PySequence_GetItem(o, 1);
3826 6 : if (!PyNumber_Check(o1))
3827 : {
3828 0 : Py_DECREF(o); Py_DECREF(o1);
3829 0 : PyErr_SetString(PyExc_TypeError, "not a number");
3830 :
3831 0 : return FALSE;
3832 : }
3833 6 : y[i] = PyFloat_AsDouble(o1);
3834 6 : Py_DECREF(o1);
3835 :
3836 : /* The 3rd coordinate is optional, default 0.0 */
3837 6 : if (len == 3)
3838 : {
3839 3 : o1 = PySequence_GetItem(o, 2);
3840 3 : if (!PyNumber_Check(o1))
3841 : {
3842 0 : Py_DECREF(o); Py_DECREF(o1);
3843 0 : PyErr_SetString(PyExc_TypeError, "not a number");
3844 :
3845 0 : return FALSE;
3846 : }
3847 3 : z[i] = PyFloat_AsDouble(o1);
3848 3 : Py_DECREF(o1);
3849 : }
3850 : else
3851 : {
3852 3 : z[i] = 0.0;
3853 : }
3854 : }
3855 : else
3856 : {
3857 0 : Py_DECREF(o);
3858 0 : PyErr_SetString(PyExc_TypeError, "invalid coordinate");
3859 :
3860 0 : return FALSE;
3861 : }
3862 :
3863 6 : Py_DECREF(o);
3864 : }
3865 :
3866 3 : return TRUE;
3867 : }
3868 :
3869 : SWIGINTERN void OSRCoordinateTransformationShadow_TransformPoints(OSRCoordinateTransformationShadow *self,int nCount,double *x,double *y,double *z){
3870 3 : if (self == NULL)
3871 : return;
3872 3 : OCTTransform( self, nCount, x, y, z );
3873 : }
3874 :
3875 1 : OSRCoordinateTransformationShadow *CreateCoordinateTransformation( OSRSpatialReferenceShadow *src, OSRSpatialReferenceShadow *dst ) {
3876 1 : OSRCoordinateTransformationShadow *obj = (OSRCoordinateTransformationShadow*) OCTNewCoordinateTransformation( src, dst );
3877 1 : return obj;
3878 : }
3879 :
3880 : #ifdef __cplusplus
3881 : extern "C" {
3882 : #endif
3883 0 : SWIGINTERN PyObject *_wrap_GetUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3884 0 : PyObject *resultobj = 0;
3885 : int result;
3886 :
3887 0 : if (!PyArg_ParseTuple(args,(char *)":GetUseExceptions")) SWIG_fail;
3888 0 : result = (int)GetUseExceptions();
3889 0 : resultobj = SWIG_From_int(static_cast< int >(result));
3890 0 : return resultobj;
3891 : fail:
3892 0 : return NULL;
3893 : }
3894 :
3895 :
3896 0 : SWIGINTERN PyObject *_wrap_UseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3897 0 : PyObject *resultobj = 0;
3898 :
3899 0 : if (!PyArg_ParseTuple(args,(char *)":UseExceptions")) SWIG_fail;
3900 0 : UseExceptions();
3901 0 : resultobj = SWIG_Py_Void();
3902 0 : return resultobj;
3903 : fail:
3904 0 : return NULL;
3905 : }
3906 :
3907 :
3908 0 : SWIGINTERN PyObject *_wrap_DontUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3909 0 : PyObject *resultobj = 0;
3910 :
3911 0 : if (!PyArg_ParseTuple(args,(char *)":DontUseExceptions")) SWIG_fail;
3912 0 : DontUseExceptions();
3913 0 : resultobj = SWIG_Py_Void();
3914 0 : return resultobj;
3915 : fail:
3916 0 : return NULL;
3917 : }
3918 :
3919 :
3920 0 : SWIGINTERN PyObject *_wrap_GetWellKnownGeogCSAsWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3921 0 : PyObject *resultobj = 0;
3922 0 : char *arg1 = (char *) 0 ;
3923 0 : char **arg2 = (char **) 0 ;
3924 : int res1 ;
3925 0 : char *buf1 = 0 ;
3926 0 : int alloc1 = 0 ;
3927 0 : char *argout2 = 0 ;
3928 0 : PyObject * obj0 = 0 ;
3929 : OGRErr result;
3930 :
3931 : {
3932 : /* %typemap(in,numinputs=0) (char **argout2) */
3933 0 : arg2 = &argout2;
3934 : }
3935 0 : if (!PyArg_ParseTuple(args,(char *)"O:GetWellKnownGeogCSAsWKT",&obj0)) SWIG_fail;
3936 0 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
3937 0 : if (!SWIG_IsOK(res1)) {
3938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWellKnownGeogCSAsWKT" "', argument " "1"" of type '" "char const *""'");
3939 : }
3940 0 : arg1 = reinterpret_cast< char * >(buf1);
3941 : {
3942 0 : if (!arg1) {
3943 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
3944 : }
3945 : }
3946 : {
3947 0 : if ( bUseExceptions ) {
3948 0 : CPLErrorReset();
3949 : }
3950 0 : result = (OGRErr)GetWellKnownGeogCSAsWKT((char const *)arg1,arg2);
3951 0 : if ( bUseExceptions ) {
3952 0 : CPLErr eclass = CPLGetLastErrorType();
3953 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3954 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3955 : }
3956 : }
3957 : }
3958 : {
3959 : /* %typemap(out) OGRErr */
3960 0 : if ( result != 0 && bUseExceptions) {
3961 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
3962 0 : SWIG_fail;
3963 : }
3964 : }
3965 : {
3966 : /* %typemap(argout) (char **argout) */
3967 : PyObject *o;
3968 0 : if ( arg2 != NULL && *arg2 != NULL) {
3969 0 : o = GDALPythonObjectFromCStr( *arg2 );
3970 : }
3971 : else {
3972 0 : o = Py_None;
3973 0 : Py_INCREF( o );
3974 : }
3975 0 : resultobj = t_output_helper(resultobj, o);
3976 : }
3977 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
3978 : {
3979 : /* %typemap(freearg) (char **argout) */
3980 0 : if ( *arg2 )
3981 0 : CPLFree( *arg2 );
3982 : }
3983 : {
3984 : /* %typemap(ret) OGRErr */
3985 0 : if (resultobj == Py_None ) {
3986 0 : Py_DECREF(resultobj);
3987 0 : resultobj = 0;
3988 : }
3989 0 : if (resultobj == 0) {
3990 0 : resultobj = PyInt_FromLong( result );
3991 : }
3992 : }
3993 0 : return resultobj;
3994 : fail:
3995 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
3996 : {
3997 : /* %typemap(freearg) (char **argout) */
3998 0 : if ( *arg2 )
3999 0 : CPLFree( *arg2 );
4000 : }
4001 0 : return NULL;
4002 : }
4003 :
4004 :
4005 13 : SWIGINTERN PyObject *_wrap_GetUserInputAsWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4006 13 : PyObject *resultobj = 0;
4007 13 : char *arg1 = (char *) 0 ;
4008 13 : char **arg2 = (char **) 0 ;
4009 : int res1 ;
4010 13 : char *buf1 = 0 ;
4011 13 : int alloc1 = 0 ;
4012 13 : char *argout2 = 0 ;
4013 13 : PyObject * obj0 = 0 ;
4014 : OGRErr result;
4015 :
4016 : {
4017 : /* %typemap(in,numinputs=0) (char **argout2) */
4018 13 : arg2 = &argout2;
4019 : }
4020 13 : if (!PyArg_ParseTuple(args,(char *)"O:GetUserInputAsWKT",&obj0)) SWIG_fail;
4021 13 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
4022 13 : if (!SWIG_IsOK(res1)) {
4023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetUserInputAsWKT" "', argument " "1"" of type '" "char const *""'");
4024 : }
4025 13 : arg1 = reinterpret_cast< char * >(buf1);
4026 : {
4027 13 : if (!arg1) {
4028 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4029 : }
4030 : }
4031 : {
4032 13 : if ( bUseExceptions ) {
4033 0 : CPLErrorReset();
4034 : }
4035 13 : result = (OGRErr)GetUserInputAsWKT((char const *)arg1,arg2);
4036 13 : if ( bUseExceptions ) {
4037 0 : CPLErr eclass = CPLGetLastErrorType();
4038 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4039 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4040 : }
4041 : }
4042 : }
4043 : {
4044 : /* %typemap(out) OGRErr */
4045 13 : if ( result != 0 && bUseExceptions) {
4046 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
4047 0 : SWIG_fail;
4048 : }
4049 : }
4050 : {
4051 : /* %typemap(argout) (char **argout) */
4052 : PyObject *o;
4053 26 : if ( arg2 != NULL && *arg2 != NULL) {
4054 13 : o = GDALPythonObjectFromCStr( *arg2 );
4055 : }
4056 : else {
4057 0 : o = Py_None;
4058 0 : Py_INCREF( o );
4059 : }
4060 13 : resultobj = t_output_helper(resultobj, o);
4061 : }
4062 13 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
4063 : {
4064 : /* %typemap(freearg) (char **argout) */
4065 13 : if ( *arg2 )
4066 13 : CPLFree( *arg2 );
4067 : }
4068 : {
4069 : /* %typemap(ret) OGRErr */
4070 13 : if (resultobj == Py_None ) {
4071 0 : Py_DECREF(resultobj);
4072 0 : resultobj = 0;
4073 : }
4074 13 : if (resultobj == 0) {
4075 0 : resultobj = PyInt_FromLong( result );
4076 : }
4077 : }
4078 13 : return resultobj;
4079 : fail:
4080 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
4081 : {
4082 : /* %typemap(freearg) (char **argout) */
4083 0 : if ( *arg2 )
4084 0 : CPLFree( *arg2 );
4085 : }
4086 0 : return NULL;
4087 : }
4088 :
4089 :
4090 15812 : SWIGINTERN PyObject *_wrap_new_SpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4091 15812 : PyObject *resultobj = 0;
4092 15812 : char *arg1 = (char *) "" ;
4093 : int res1 ;
4094 15812 : char *buf1 = 0 ;
4095 15812 : int alloc1 = 0 ;
4096 15812 : PyObject * obj0 = 0 ;
4097 : char * kwnames[] = {
4098 : (char *) "wkt", NULL
4099 15812 : };
4100 15812 : OSRSpatialReferenceShadow *result = 0 ;
4101 :
4102 15812 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SpatialReference",kwnames,&obj0)) SWIG_fail;
4103 15812 : if (obj0) {
4104 195 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
4105 195 : if (!SWIG_IsOK(res1)) {
4106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialReference" "', argument " "1"" of type '" "char const *""'");
4107 : }
4108 195 : arg1 = reinterpret_cast< char * >(buf1);
4109 : }
4110 : {
4111 15812 : if ( bUseExceptions ) {
4112 0 : CPLErrorReset();
4113 : }
4114 15812 : result = (OSRSpatialReferenceShadow *)new_OSRSpatialReferenceShadow((char const *)arg1);
4115 15812 : if ( bUseExceptions ) {
4116 0 : CPLErr eclass = CPLGetLastErrorType();
4117 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4118 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4119 : }
4120 : }
4121 : }
4122 15812 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_NEW | 0 );
4123 15812 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
4124 15812 : return resultobj;
4125 : fail:
4126 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
4127 0 : return NULL;
4128 : }
4129 :
4130 :
4131 44900 : SWIGINTERN PyObject *_wrap_delete_SpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4132 44900 : PyObject *resultobj = 0;
4133 44900 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4134 44900 : void *argp1 = 0 ;
4135 44900 : int res1 = 0 ;
4136 44900 : PyObject * obj0 = 0 ;
4137 :
4138 44900 : if (!PyArg_ParseTuple(args,(char *)"O:delete_SpatialReference",&obj0)) SWIG_fail;
4139 44900 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_DISOWN | 0 );
4140 44900 : if (!SWIG_IsOK(res1)) {
4141 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialReference" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4142 : }
4143 44900 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4144 : {
4145 44900 : if ( bUseExceptions ) {
4146 0 : CPLErrorReset();
4147 : }
4148 : delete_OSRSpatialReferenceShadow(arg1);
4149 44900 : if ( bUseExceptions ) {
4150 0 : CPLErr eclass = CPLGetLastErrorType();
4151 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4152 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4153 : }
4154 : }
4155 : }
4156 44900 : resultobj = SWIG_Py_Void();
4157 44900 : return resultobj;
4158 : fail:
4159 0 : return NULL;
4160 : }
4161 :
4162 :
4163 4 : SWIGINTERN PyObject *_wrap_SpatialReference___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4164 4 : PyObject *resultobj = 0;
4165 4 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4166 4 : void *argp1 = 0 ;
4167 4 : int res1 = 0 ;
4168 4 : PyObject * obj0 = 0 ;
4169 4 : retStringAndCPLFree *result = 0 ;
4170 :
4171 4 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference___str__",&obj0)) SWIG_fail;
4172 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4173 4 : if (!SWIG_IsOK(res1)) {
4174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference___str__" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4175 : }
4176 4 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4177 : {
4178 4 : if ( bUseExceptions ) {
4179 0 : CPLErrorReset();
4180 : }
4181 4 : result = (retStringAndCPLFree *)OSRSpatialReferenceShadow___str__(arg1);
4182 4 : if ( bUseExceptions ) {
4183 0 : CPLErr eclass = CPLGetLastErrorType();
4184 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4185 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4186 : }
4187 : }
4188 : }
4189 : {
4190 : /* %typemap(out) (retStringAndCPLFree*) */
4191 4 : if(result)
4192 : {
4193 4 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
4194 4 : CPLFree(result);
4195 : }
4196 : }
4197 4 : return resultobj;
4198 : fail:
4199 0 : return NULL;
4200 : }
4201 :
4202 :
4203 14691 : SWIGINTERN PyObject *_wrap_SpatialReference_IsSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4204 14691 : PyObject *resultobj = 0;
4205 14691 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4206 14691 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
4207 14691 : void *argp1 = 0 ;
4208 14691 : int res1 = 0 ;
4209 14691 : void *argp2 = 0 ;
4210 14691 : int res2 = 0 ;
4211 14691 : PyObject * obj0 = 0 ;
4212 14691 : PyObject * obj1 = 0 ;
4213 : int result;
4214 :
4215 14691 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_IsSame",&obj0,&obj1)) SWIG_fail;
4216 14691 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4217 14691 : if (!SWIG_IsOK(res1)) {
4218 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsSame" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4219 : }
4220 14691 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4221 14691 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4222 14691 : if (!SWIG_IsOK(res2)) {
4223 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_IsSame" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
4224 : }
4225 14691 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
4226 : {
4227 14691 : if (!arg2) {
4228 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4229 : }
4230 : }
4231 : {
4232 14691 : if ( bUseExceptions ) {
4233 0 : CPLErrorReset();
4234 : }
4235 14691 : result = (int)OSRSpatialReferenceShadow_IsSame(arg1,arg2);
4236 14691 : if ( bUseExceptions ) {
4237 0 : CPLErr eclass = CPLGetLastErrorType();
4238 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4239 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4240 : }
4241 : }
4242 : }
4243 14691 : resultobj = SWIG_From_int(static_cast< int >(result));
4244 14691 : return resultobj;
4245 : fail:
4246 0 : return NULL;
4247 : }
4248 :
4249 :
4250 0 : SWIGINTERN PyObject *_wrap_SpatialReference_IsSameGeogCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4251 0 : PyObject *resultobj = 0;
4252 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4253 0 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
4254 0 : void *argp1 = 0 ;
4255 0 : int res1 = 0 ;
4256 0 : void *argp2 = 0 ;
4257 0 : int res2 = 0 ;
4258 0 : PyObject * obj0 = 0 ;
4259 0 : PyObject * obj1 = 0 ;
4260 : int result;
4261 :
4262 0 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_IsSameGeogCS",&obj0,&obj1)) SWIG_fail;
4263 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4264 0 : if (!SWIG_IsOK(res1)) {
4265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsSameGeogCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4266 : }
4267 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4268 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4269 0 : if (!SWIG_IsOK(res2)) {
4270 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_IsSameGeogCS" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
4271 : }
4272 0 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
4273 : {
4274 0 : if (!arg2) {
4275 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4276 : }
4277 : }
4278 : {
4279 0 : if ( bUseExceptions ) {
4280 0 : CPLErrorReset();
4281 : }
4282 0 : result = (int)OSRSpatialReferenceShadow_IsSameGeogCS(arg1,arg2);
4283 0 : if ( bUseExceptions ) {
4284 0 : CPLErr eclass = CPLGetLastErrorType();
4285 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4286 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4287 : }
4288 : }
4289 : }
4290 0 : resultobj = SWIG_From_int(static_cast< int >(result));
4291 0 : return resultobj;
4292 : fail:
4293 0 : return NULL;
4294 : }
4295 :
4296 :
4297 0 : SWIGINTERN PyObject *_wrap_SpatialReference_IsSameVertCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4298 0 : PyObject *resultobj = 0;
4299 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4300 0 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
4301 0 : void *argp1 = 0 ;
4302 0 : int res1 = 0 ;
4303 0 : void *argp2 = 0 ;
4304 0 : int res2 = 0 ;
4305 0 : PyObject * obj0 = 0 ;
4306 0 : PyObject * obj1 = 0 ;
4307 : int result;
4308 :
4309 0 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_IsSameVertCS",&obj0,&obj1)) SWIG_fail;
4310 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4311 0 : if (!SWIG_IsOK(res1)) {
4312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsSameVertCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4313 : }
4314 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4315 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4316 0 : if (!SWIG_IsOK(res2)) {
4317 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_IsSameVertCS" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
4318 : }
4319 0 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
4320 : {
4321 0 : if (!arg2) {
4322 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4323 : }
4324 : }
4325 : {
4326 0 : if ( bUseExceptions ) {
4327 0 : CPLErrorReset();
4328 : }
4329 0 : result = (int)OSRSpatialReferenceShadow_IsSameVertCS(arg1,arg2);
4330 0 : if ( bUseExceptions ) {
4331 0 : CPLErr eclass = CPLGetLastErrorType();
4332 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4333 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4334 : }
4335 : }
4336 : }
4337 0 : resultobj = SWIG_From_int(static_cast< int >(result));
4338 0 : return resultobj;
4339 : fail:
4340 0 : return NULL;
4341 : }
4342 :
4343 :
4344 1 : SWIGINTERN PyObject *_wrap_SpatialReference_IsGeographic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4345 1 : PyObject *resultobj = 0;
4346 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4347 1 : void *argp1 = 0 ;
4348 1 : int res1 = 0 ;
4349 1 : PyObject * obj0 = 0 ;
4350 : int result;
4351 :
4352 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsGeographic",&obj0)) SWIG_fail;
4353 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4354 1 : if (!SWIG_IsOK(res1)) {
4355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsGeographic" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4356 : }
4357 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4358 : {
4359 1 : if ( bUseExceptions ) {
4360 0 : CPLErrorReset();
4361 : }
4362 1 : result = (int)OSRSpatialReferenceShadow_IsGeographic(arg1);
4363 1 : if ( bUseExceptions ) {
4364 0 : CPLErr eclass = CPLGetLastErrorType();
4365 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4366 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4367 : }
4368 : }
4369 : }
4370 1 : resultobj = SWIG_From_int(static_cast< int >(result));
4371 1 : return resultobj;
4372 : fail:
4373 0 : return NULL;
4374 : }
4375 :
4376 :
4377 3 : SWIGINTERN PyObject *_wrap_SpatialReference_IsProjected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4378 3 : PyObject *resultobj = 0;
4379 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4380 3 : void *argp1 = 0 ;
4381 3 : int res1 = 0 ;
4382 3 : PyObject * obj0 = 0 ;
4383 : int result;
4384 :
4385 3 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsProjected",&obj0)) SWIG_fail;
4386 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4387 3 : if (!SWIG_IsOK(res1)) {
4388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsProjected" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4389 : }
4390 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4391 : {
4392 3 : if ( bUseExceptions ) {
4393 0 : CPLErrorReset();
4394 : }
4395 3 : result = (int)OSRSpatialReferenceShadow_IsProjected(arg1);
4396 3 : if ( bUseExceptions ) {
4397 0 : CPLErr eclass = CPLGetLastErrorType();
4398 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4399 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4400 : }
4401 : }
4402 : }
4403 3 : resultobj = SWIG_From_int(static_cast< int >(result));
4404 3 : return resultobj;
4405 : fail:
4406 0 : return NULL;
4407 : }
4408 :
4409 :
4410 1 : SWIGINTERN PyObject *_wrap_SpatialReference_IsCompound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4411 1 : PyObject *resultobj = 0;
4412 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4413 1 : void *argp1 = 0 ;
4414 1 : int res1 = 0 ;
4415 1 : PyObject * obj0 = 0 ;
4416 : int result;
4417 :
4418 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsCompound",&obj0)) SWIG_fail;
4419 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4420 1 : if (!SWIG_IsOK(res1)) {
4421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsCompound" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4422 : }
4423 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4424 : {
4425 1 : if ( bUseExceptions ) {
4426 0 : CPLErrorReset();
4427 : }
4428 1 : result = (int)OSRSpatialReferenceShadow_IsCompound(arg1);
4429 1 : if ( bUseExceptions ) {
4430 0 : CPLErr eclass = CPLGetLastErrorType();
4431 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4432 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4433 : }
4434 : }
4435 : }
4436 1 : resultobj = SWIG_From_int(static_cast< int >(result));
4437 1 : return resultobj;
4438 : fail:
4439 0 : return NULL;
4440 : }
4441 :
4442 :
4443 2 : SWIGINTERN PyObject *_wrap_SpatialReference_IsGeocentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4444 2 : PyObject *resultobj = 0;
4445 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4446 2 : void *argp1 = 0 ;
4447 2 : int res1 = 0 ;
4448 2 : PyObject * obj0 = 0 ;
4449 : int result;
4450 :
4451 2 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsGeocentric",&obj0)) SWIG_fail;
4452 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4453 2 : if (!SWIG_IsOK(res1)) {
4454 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsGeocentric" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4455 : }
4456 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4457 : {
4458 2 : if ( bUseExceptions ) {
4459 0 : CPLErrorReset();
4460 : }
4461 2 : result = (int)OSRSpatialReferenceShadow_IsGeocentric(arg1);
4462 2 : if ( bUseExceptions ) {
4463 0 : CPLErr eclass = CPLGetLastErrorType();
4464 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4465 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4466 : }
4467 : }
4468 : }
4469 2 : resultobj = SWIG_From_int(static_cast< int >(result));
4470 2 : return resultobj;
4471 : fail:
4472 0 : return NULL;
4473 : }
4474 :
4475 :
4476 1 : SWIGINTERN PyObject *_wrap_SpatialReference_IsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 1 : PyObject *resultobj = 0;
4478 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4479 1 : void *argp1 = 0 ;
4480 1 : int res1 = 0 ;
4481 1 : PyObject * obj0 = 0 ;
4482 : int result;
4483 :
4484 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsLocal",&obj0)) SWIG_fail;
4485 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4486 1 : if (!SWIG_IsOK(res1)) {
4487 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsLocal" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4488 : }
4489 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4490 : {
4491 1 : if ( bUseExceptions ) {
4492 0 : CPLErrorReset();
4493 : }
4494 1 : result = (int)OSRSpatialReferenceShadow_IsLocal(arg1);
4495 1 : if ( bUseExceptions ) {
4496 0 : CPLErr eclass = CPLGetLastErrorType();
4497 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4498 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4499 : }
4500 : }
4501 : }
4502 1 : resultobj = SWIG_From_int(static_cast< int >(result));
4503 1 : return resultobj;
4504 : fail:
4505 0 : return NULL;
4506 : }
4507 :
4508 :
4509 0 : SWIGINTERN PyObject *_wrap_SpatialReference_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4510 0 : PyObject *resultobj = 0;
4511 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4512 0 : void *argp1 = 0 ;
4513 0 : int res1 = 0 ;
4514 0 : PyObject * obj0 = 0 ;
4515 : int result;
4516 :
4517 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_IsVertical",&obj0)) SWIG_fail;
4518 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4519 0 : if (!SWIG_IsOK(res1)) {
4520 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_IsVertical" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4521 : }
4522 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4523 : {
4524 0 : if ( bUseExceptions ) {
4525 0 : CPLErrorReset();
4526 : }
4527 0 : result = (int)OSRSpatialReferenceShadow_IsVertical(arg1);
4528 0 : if ( bUseExceptions ) {
4529 0 : CPLErr eclass = CPLGetLastErrorType();
4530 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4531 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4532 : }
4533 : }
4534 : }
4535 0 : resultobj = SWIG_From_int(static_cast< int >(result));
4536 0 : return resultobj;
4537 : fail:
4538 0 : return NULL;
4539 : }
4540 :
4541 :
4542 4 : SWIGINTERN PyObject *_wrap_SpatialReference_EPSGTreatsAsLatLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4543 4 : PyObject *resultobj = 0;
4544 4 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4545 4 : void *argp1 = 0 ;
4546 4 : int res1 = 0 ;
4547 4 : PyObject * obj0 = 0 ;
4548 : int result;
4549 :
4550 4 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_EPSGTreatsAsLatLong",&obj0)) SWIG_fail;
4551 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4552 4 : if (!SWIG_IsOK(res1)) {
4553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_EPSGTreatsAsLatLong" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4554 : }
4555 4 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4556 : {
4557 4 : if ( bUseExceptions ) {
4558 0 : CPLErrorReset();
4559 : }
4560 4 : result = (int)OSRSpatialReferenceShadow_EPSGTreatsAsLatLong(arg1);
4561 4 : if ( bUseExceptions ) {
4562 0 : CPLErr eclass = CPLGetLastErrorType();
4563 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4564 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4565 : }
4566 : }
4567 : }
4568 4 : resultobj = SWIG_From_int(static_cast< int >(result));
4569 4 : return resultobj;
4570 : fail:
4571 0 : return NULL;
4572 : }
4573 :
4574 :
4575 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetAuthority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4576 0 : PyObject *resultobj = 0;
4577 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4578 0 : char *arg2 = (char *) 0 ;
4579 0 : char *arg3 = (char *) 0 ;
4580 : int arg4 ;
4581 0 : void *argp1 = 0 ;
4582 0 : int res1 = 0 ;
4583 : int res2 ;
4584 0 : char *buf2 = 0 ;
4585 0 : int alloc2 = 0 ;
4586 : int res3 ;
4587 0 : char *buf3 = 0 ;
4588 0 : int alloc3 = 0 ;
4589 : int val4 ;
4590 0 : int ecode4 = 0 ;
4591 0 : PyObject * obj0 = 0 ;
4592 0 : PyObject * obj1 = 0 ;
4593 0 : PyObject * obj2 = 0 ;
4594 0 : PyObject * obj3 = 0 ;
4595 : OGRErr result;
4596 :
4597 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:SpatialReference_SetAuthority",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4598 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4599 0 : if (!SWIG_IsOK(res1)) {
4600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetAuthority" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4601 : }
4602 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4603 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4604 0 : if (!SWIG_IsOK(res2)) {
4605 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetAuthority" "', argument " "2"" of type '" "char const *""'");
4606 : }
4607 0 : arg2 = reinterpret_cast< char * >(buf2);
4608 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4609 0 : if (!SWIG_IsOK(res3)) {
4610 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetAuthority" "', argument " "3"" of type '" "char const *""'");
4611 : }
4612 0 : arg3 = reinterpret_cast< char * >(buf3);
4613 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
4614 0 : if (!SWIG_IsOK(ecode4)) {
4615 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetAuthority" "', argument " "4"" of type '" "int""'");
4616 : }
4617 0 : arg4 = static_cast< int >(val4);
4618 : {
4619 0 : if ( bUseExceptions ) {
4620 0 : CPLErrorReset();
4621 : }
4622 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetAuthority(arg1,(char const *)arg2,(char const *)arg3,arg4);
4623 0 : if ( bUseExceptions ) {
4624 0 : CPLErr eclass = CPLGetLastErrorType();
4625 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4626 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4627 : }
4628 : }
4629 : }
4630 : {
4631 : /* %typemap(out) OGRErr */
4632 0 : if ( result != 0 && bUseExceptions) {
4633 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
4634 0 : SWIG_fail;
4635 : }
4636 : }
4637 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4638 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4639 : {
4640 : /* %typemap(ret) OGRErr */
4641 0 : if (resultobj == Py_None ) {
4642 0 : Py_DECREF(resultobj);
4643 0 : resultobj = 0;
4644 : }
4645 0 : if (resultobj == 0) {
4646 0 : resultobj = PyInt_FromLong( result );
4647 : }
4648 : }
4649 0 : return resultobj;
4650 : fail:
4651 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4652 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4653 0 : return NULL;
4654 : }
4655 :
4656 :
4657 20430 : SWIGINTERN PyObject *_wrap_SpatialReference_GetAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 20430 : PyObject *resultobj = 0;
4659 20430 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4660 20430 : char *arg2 = (char *) 0 ;
4661 20430 : int arg3 = (int) 0 ;
4662 20430 : void *argp1 = 0 ;
4663 20430 : int res1 = 0 ;
4664 : int res2 ;
4665 20430 : char *buf2 = 0 ;
4666 20430 : int alloc2 = 0 ;
4667 : int val3 ;
4668 20430 : int ecode3 = 0 ;
4669 20430 : PyObject * obj0 = 0 ;
4670 20430 : PyObject * obj1 = 0 ;
4671 20430 : PyObject * obj2 = 0 ;
4672 20430 : char *result = 0 ;
4673 :
4674 20430 : if (!PyArg_ParseTuple(args,(char *)"OO|O:SpatialReference_GetAttrValue",&obj0,&obj1,&obj2)) SWIG_fail;
4675 20430 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4676 20430 : if (!SWIG_IsOK(res1)) {
4677 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetAttrValue" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4678 : }
4679 20430 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4680 20430 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4681 20430 : if (!SWIG_IsOK(res2)) {
4682 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_GetAttrValue" "', argument " "2"" of type '" "char const *""'");
4683 : }
4684 20430 : arg2 = reinterpret_cast< char * >(buf2);
4685 20430 : if (obj2) {
4686 90 : ecode3 = SWIG_AsVal_int(obj2, &val3);
4687 90 : if (!SWIG_IsOK(ecode3)) {
4688 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_GetAttrValue" "', argument " "3"" of type '" "int""'");
4689 : }
4690 90 : arg3 = static_cast< int >(val3);
4691 : }
4692 : {
4693 20430 : if (!arg2) {
4694 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4695 : }
4696 : }
4697 : {
4698 20430 : if ( bUseExceptions ) {
4699 0 : CPLErrorReset();
4700 : }
4701 20430 : result = (char *)OSRSpatialReferenceShadow_GetAttrValue(arg1,(char const *)arg2,arg3);
4702 20430 : if ( bUseExceptions ) {
4703 0 : CPLErr eclass = CPLGetLastErrorType();
4704 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4705 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4706 : }
4707 : }
4708 : }
4709 20430 : resultobj = SWIG_FromCharPtr((const char *)result);
4710 20430 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4711 20430 : return resultobj;
4712 : fail:
4713 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4714 0 : return NULL;
4715 : }
4716 :
4717 :
4718 621 : SWIGINTERN PyObject *_wrap_SpatialReference_SetAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4719 621 : PyObject *resultobj = 0;
4720 621 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4721 621 : char *arg2 = (char *) 0 ;
4722 621 : char *arg3 = (char *) 0 ;
4723 621 : void *argp1 = 0 ;
4724 621 : int res1 = 0 ;
4725 : int res2 ;
4726 621 : char *buf2 = 0 ;
4727 621 : int alloc2 = 0 ;
4728 : int res3 ;
4729 621 : char *buf3 = 0 ;
4730 621 : int alloc3 = 0 ;
4731 621 : PyObject * obj0 = 0 ;
4732 621 : PyObject * obj1 = 0 ;
4733 621 : PyObject * obj2 = 0 ;
4734 : OGRErr result;
4735 :
4736 621 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetAttrValue",&obj0,&obj1,&obj2)) SWIG_fail;
4737 621 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4738 621 : if (!SWIG_IsOK(res1)) {
4739 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetAttrValue" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4740 : }
4741 621 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4742 621 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4743 621 : if (!SWIG_IsOK(res2)) {
4744 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetAttrValue" "', argument " "2"" of type '" "char const *""'");
4745 : }
4746 621 : arg2 = reinterpret_cast< char * >(buf2);
4747 621 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4748 621 : if (!SWIG_IsOK(res3)) {
4749 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetAttrValue" "', argument " "3"" of type '" "char const *""'");
4750 : }
4751 621 : arg3 = reinterpret_cast< char * >(buf3);
4752 : {
4753 621 : if (!arg2) {
4754 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4755 : }
4756 : }
4757 : {
4758 621 : if ( bUseExceptions ) {
4759 0 : CPLErrorReset();
4760 : }
4761 621 : result = (OGRErr)OSRSpatialReferenceShadow_SetAttrValue(arg1,(char const *)arg2,(char const *)arg3);
4762 621 : if ( bUseExceptions ) {
4763 0 : CPLErr eclass = CPLGetLastErrorType();
4764 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4765 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4766 : }
4767 : }
4768 : }
4769 : {
4770 : /* %typemap(out) OGRErr */
4771 621 : if ( result != 0 && bUseExceptions) {
4772 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
4773 0 : SWIG_fail;
4774 : }
4775 : }
4776 621 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4777 621 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4778 : {
4779 : /* %typemap(ret) OGRErr */
4780 621 : if (resultobj == Py_None ) {
4781 0 : Py_DECREF(resultobj);
4782 0 : resultobj = 0;
4783 : }
4784 621 : if (resultobj == 0) {
4785 621 : resultobj = PyInt_FromLong( result );
4786 : }
4787 : }
4788 621 : return resultobj;
4789 : fail:
4790 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4791 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4792 0 : return NULL;
4793 : }
4794 :
4795 :
4796 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetAngularUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4797 0 : PyObject *resultobj = 0;
4798 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4799 0 : char *arg2 = (char *) 0 ;
4800 : double arg3 ;
4801 0 : void *argp1 = 0 ;
4802 0 : int res1 = 0 ;
4803 : int res2 ;
4804 0 : char *buf2 = 0 ;
4805 0 : int alloc2 = 0 ;
4806 : double val3 ;
4807 0 : int ecode3 = 0 ;
4808 0 : PyObject * obj0 = 0 ;
4809 0 : PyObject * obj1 = 0 ;
4810 0 : PyObject * obj2 = 0 ;
4811 : OGRErr result;
4812 :
4813 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetAngularUnits",&obj0,&obj1,&obj2)) SWIG_fail;
4814 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4815 0 : if (!SWIG_IsOK(res1)) {
4816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetAngularUnits" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4817 : }
4818 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4819 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4820 0 : if (!SWIG_IsOK(res2)) {
4821 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetAngularUnits" "', argument " "2"" of type '" "char const *""'");
4822 : }
4823 0 : arg2 = reinterpret_cast< char * >(buf2);
4824 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
4825 0 : if (!SWIG_IsOK(ecode3)) {
4826 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetAngularUnits" "', argument " "3"" of type '" "double""'");
4827 : }
4828 0 : arg3 = static_cast< double >(val3);
4829 : {
4830 0 : if (!arg2) {
4831 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4832 : }
4833 : }
4834 : {
4835 0 : if ( bUseExceptions ) {
4836 0 : CPLErrorReset();
4837 : }
4838 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetAngularUnits(arg1,(char const *)arg2,arg3);
4839 0 : if ( bUseExceptions ) {
4840 0 : CPLErr eclass = CPLGetLastErrorType();
4841 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4842 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4843 : }
4844 : }
4845 : }
4846 : {
4847 : /* %typemap(out) OGRErr */
4848 0 : if ( result != 0 && bUseExceptions) {
4849 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
4850 0 : SWIG_fail;
4851 : }
4852 : }
4853 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4854 : {
4855 : /* %typemap(ret) OGRErr */
4856 0 : if (resultobj == Py_None ) {
4857 0 : Py_DECREF(resultobj);
4858 0 : resultobj = 0;
4859 : }
4860 0 : if (resultobj == 0) {
4861 0 : resultobj = PyInt_FromLong( result );
4862 : }
4863 : }
4864 0 : return resultobj;
4865 : fail:
4866 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4867 0 : return NULL;
4868 : }
4869 :
4870 :
4871 0 : SWIGINTERN PyObject *_wrap_SpatialReference_GetAngularUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4872 0 : PyObject *resultobj = 0;
4873 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4874 0 : void *argp1 = 0 ;
4875 0 : int res1 = 0 ;
4876 0 : PyObject * obj0 = 0 ;
4877 : double result;
4878 :
4879 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetAngularUnits",&obj0)) SWIG_fail;
4880 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4881 0 : if (!SWIG_IsOK(res1)) {
4882 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetAngularUnits" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4883 : }
4884 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4885 : {
4886 0 : if ( bUseExceptions ) {
4887 0 : CPLErrorReset();
4888 : }
4889 0 : result = (double)OSRSpatialReferenceShadow_GetAngularUnits(arg1);
4890 0 : if ( bUseExceptions ) {
4891 0 : CPLErr eclass = CPLGetLastErrorType();
4892 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4893 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4894 : }
4895 : }
4896 : }
4897 0 : resultobj = SWIG_From_double(static_cast< double >(result));
4898 0 : return resultobj;
4899 : fail:
4900 0 : return NULL;
4901 : }
4902 :
4903 :
4904 1 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTargetLinearUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905 1 : PyObject *resultobj = 0;
4906 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4907 1 : char *arg2 = (char *) 0 ;
4908 1 : char *arg3 = (char *) 0 ;
4909 : double arg4 ;
4910 1 : void *argp1 = 0 ;
4911 1 : int res1 = 0 ;
4912 : int res2 ;
4913 1 : char *buf2 = 0 ;
4914 1 : int alloc2 = 0 ;
4915 : int res3 ;
4916 1 : char *buf3 = 0 ;
4917 1 : int alloc3 = 0 ;
4918 : double val4 ;
4919 1 : int ecode4 = 0 ;
4920 1 : PyObject * obj0 = 0 ;
4921 1 : PyObject * obj1 = 0 ;
4922 1 : PyObject * obj2 = 0 ;
4923 1 : PyObject * obj3 = 0 ;
4924 : OGRErr result;
4925 :
4926 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:SpatialReference_SetTargetLinearUnits",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4927 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
4928 1 : if (!SWIG_IsOK(res1)) {
4929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTargetLinearUnits" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
4930 : }
4931 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
4932 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4933 1 : if (!SWIG_IsOK(res2)) {
4934 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetTargetLinearUnits" "', argument " "2"" of type '" "char const *""'");
4935 : }
4936 1 : arg2 = reinterpret_cast< char * >(buf2);
4937 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4938 1 : if (!SWIG_IsOK(res3)) {
4939 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetTargetLinearUnits" "', argument " "3"" of type '" "char const *""'");
4940 : }
4941 1 : arg3 = reinterpret_cast< char * >(buf3);
4942 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
4943 1 : if (!SWIG_IsOK(ecode4)) {
4944 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTargetLinearUnits" "', argument " "4"" of type '" "double""'");
4945 : }
4946 1 : arg4 = static_cast< double >(val4);
4947 : {
4948 1 : if (!arg3) {
4949 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
4950 : }
4951 : }
4952 : {
4953 1 : if ( bUseExceptions ) {
4954 0 : CPLErrorReset();
4955 : }
4956 1 : result = (OGRErr)OSRSpatialReferenceShadow_SetTargetLinearUnits(arg1,(char const *)arg2,(char const *)arg3,arg4);
4957 1 : if ( bUseExceptions ) {
4958 0 : CPLErr eclass = CPLGetLastErrorType();
4959 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4960 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4961 : }
4962 : }
4963 : }
4964 : {
4965 : /* %typemap(out) OGRErr */
4966 1 : if ( result != 0 && bUseExceptions) {
4967 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
4968 0 : SWIG_fail;
4969 : }
4970 : }
4971 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4972 1 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4973 : {
4974 : /* %typemap(ret) OGRErr */
4975 1 : if (resultobj == Py_None ) {
4976 0 : Py_DECREF(resultobj);
4977 0 : resultobj = 0;
4978 : }
4979 1 : if (resultobj == 0) {
4980 1 : resultobj = PyInt_FromLong( result );
4981 : }
4982 : }
4983 1 : return resultobj;
4984 : fail:
4985 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4986 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4987 0 : return NULL;
4988 : }
4989 :
4990 :
4991 2 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLinearUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 2 : PyObject *resultobj = 0;
4993 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
4994 2 : char *arg2 = (char *) 0 ;
4995 : double arg3 ;
4996 2 : void *argp1 = 0 ;
4997 2 : int res1 = 0 ;
4998 : int res2 ;
4999 2 : char *buf2 = 0 ;
5000 2 : int alloc2 = 0 ;
5001 : double val3 ;
5002 2 : int ecode3 = 0 ;
5003 2 : PyObject * obj0 = 0 ;
5004 2 : PyObject * obj1 = 0 ;
5005 2 : PyObject * obj2 = 0 ;
5006 : OGRErr result;
5007 :
5008 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetLinearUnits",&obj0,&obj1,&obj2)) SWIG_fail;
5009 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5010 2 : if (!SWIG_IsOK(res1)) {
5011 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLinearUnits" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5012 : }
5013 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5014 2 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5015 2 : if (!SWIG_IsOK(res2)) {
5016 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetLinearUnits" "', argument " "2"" of type '" "char const *""'");
5017 : }
5018 2 : arg2 = reinterpret_cast< char * >(buf2);
5019 2 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5020 2 : if (!SWIG_IsOK(ecode3)) {
5021 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLinearUnits" "', argument " "3"" of type '" "double""'");
5022 : }
5023 2 : arg3 = static_cast< double >(val3);
5024 : {
5025 2 : if (!arg2) {
5026 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5027 : }
5028 : }
5029 : {
5030 2 : if ( bUseExceptions ) {
5031 0 : CPLErrorReset();
5032 : }
5033 2 : result = (OGRErr)OSRSpatialReferenceShadow_SetLinearUnits(arg1,(char const *)arg2,arg3);
5034 2 : if ( bUseExceptions ) {
5035 0 : CPLErr eclass = CPLGetLastErrorType();
5036 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5037 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5038 : }
5039 : }
5040 : }
5041 : {
5042 : /* %typemap(out) OGRErr */
5043 2 : if ( result != 0 && bUseExceptions) {
5044 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5045 0 : SWIG_fail;
5046 : }
5047 : }
5048 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5049 : {
5050 : /* %typemap(ret) OGRErr */
5051 2 : if (resultobj == Py_None ) {
5052 0 : Py_DECREF(resultobj);
5053 0 : resultobj = 0;
5054 : }
5055 2 : if (resultobj == 0) {
5056 2 : resultobj = PyInt_FromLong( result );
5057 : }
5058 : }
5059 2 : return resultobj;
5060 : fail:
5061 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5062 0 : return NULL;
5063 : }
5064 :
5065 :
5066 1 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLinearUnitsAndUpdateParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 1 : PyObject *resultobj = 0;
5068 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5069 1 : char *arg2 = (char *) 0 ;
5070 : double arg3 ;
5071 1 : void *argp1 = 0 ;
5072 1 : int res1 = 0 ;
5073 : int res2 ;
5074 1 : char *buf2 = 0 ;
5075 1 : int alloc2 = 0 ;
5076 : double val3 ;
5077 1 : int ecode3 = 0 ;
5078 1 : PyObject * obj0 = 0 ;
5079 1 : PyObject * obj1 = 0 ;
5080 1 : PyObject * obj2 = 0 ;
5081 : OGRErr result;
5082 :
5083 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetLinearUnitsAndUpdateParameters",&obj0,&obj1,&obj2)) SWIG_fail;
5084 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5085 1 : if (!SWIG_IsOK(res1)) {
5086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLinearUnitsAndUpdateParameters" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5087 : }
5088 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5089 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5090 1 : if (!SWIG_IsOK(res2)) {
5091 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetLinearUnitsAndUpdateParameters" "', argument " "2"" of type '" "char const *""'");
5092 : }
5093 1 : arg2 = reinterpret_cast< char * >(buf2);
5094 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5095 1 : if (!SWIG_IsOK(ecode3)) {
5096 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLinearUnitsAndUpdateParameters" "', argument " "3"" of type '" "double""'");
5097 : }
5098 1 : arg3 = static_cast< double >(val3);
5099 : {
5100 1 : if (!arg2) {
5101 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5102 : }
5103 : }
5104 : {
5105 1 : if ( bUseExceptions ) {
5106 0 : CPLErrorReset();
5107 : }
5108 1 : result = (OGRErr)OSRSpatialReferenceShadow_SetLinearUnitsAndUpdateParameters(arg1,(char const *)arg2,arg3);
5109 1 : if ( bUseExceptions ) {
5110 0 : CPLErr eclass = CPLGetLastErrorType();
5111 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5112 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5113 : }
5114 : }
5115 : }
5116 : {
5117 : /* %typemap(out) OGRErr */
5118 1 : if ( result != 0 && bUseExceptions) {
5119 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5120 0 : SWIG_fail;
5121 : }
5122 : }
5123 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5124 : {
5125 : /* %typemap(ret) OGRErr */
5126 1 : if (resultobj == Py_None ) {
5127 0 : Py_DECREF(resultobj);
5128 0 : resultobj = 0;
5129 : }
5130 1 : if (resultobj == 0) {
5131 1 : resultobj = PyInt_FromLong( result );
5132 : }
5133 : }
5134 1 : return resultobj;
5135 : fail:
5136 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5137 0 : return NULL;
5138 : }
5139 :
5140 :
5141 0 : SWIGINTERN PyObject *_wrap_SpatialReference_GetLinearUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5142 0 : PyObject *resultobj = 0;
5143 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5144 0 : void *argp1 = 0 ;
5145 0 : int res1 = 0 ;
5146 0 : PyObject * obj0 = 0 ;
5147 : double result;
5148 :
5149 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetLinearUnits",&obj0)) SWIG_fail;
5150 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5151 0 : if (!SWIG_IsOK(res1)) {
5152 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetLinearUnits" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5153 : }
5154 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5155 : {
5156 0 : if ( bUseExceptions ) {
5157 0 : CPLErrorReset();
5158 : }
5159 0 : result = (double)OSRSpatialReferenceShadow_GetLinearUnits(arg1);
5160 0 : if ( bUseExceptions ) {
5161 0 : CPLErr eclass = CPLGetLastErrorType();
5162 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5163 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5164 : }
5165 : }
5166 : }
5167 0 : resultobj = SWIG_From_double(static_cast< double >(result));
5168 0 : return resultobj;
5169 : fail:
5170 0 : return NULL;
5171 : }
5172 :
5173 :
5174 2 : SWIGINTERN PyObject *_wrap_SpatialReference_GetLinearUnitsName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 2 : PyObject *resultobj = 0;
5176 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5177 2 : void *argp1 = 0 ;
5178 2 : int res1 = 0 ;
5179 2 : PyObject * obj0 = 0 ;
5180 2 : char *result = 0 ;
5181 :
5182 2 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetLinearUnitsName",&obj0)) SWIG_fail;
5183 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5184 2 : if (!SWIG_IsOK(res1)) {
5185 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetLinearUnitsName" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5186 : }
5187 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5188 : {
5189 2 : if ( bUseExceptions ) {
5190 0 : CPLErrorReset();
5191 : }
5192 2 : result = (char *)OSRSpatialReferenceShadow_GetLinearUnitsName(arg1);
5193 2 : if ( bUseExceptions ) {
5194 0 : CPLErr eclass = CPLGetLastErrorType();
5195 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5196 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5197 : }
5198 : }
5199 : }
5200 2 : resultobj = SWIG_FromCharPtr((const char *)result);
5201 2 : return resultobj;
5202 : fail:
5203 0 : return NULL;
5204 : }
5205 :
5206 :
5207 1259 : SWIGINTERN PyObject *_wrap_SpatialReference_GetAuthorityCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5208 1259 : PyObject *resultobj = 0;
5209 1259 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5210 1259 : char *arg2 = (char *) 0 ;
5211 1259 : void *argp1 = 0 ;
5212 1259 : int res1 = 0 ;
5213 : int res2 ;
5214 1259 : char *buf2 = 0 ;
5215 1259 : int alloc2 = 0 ;
5216 1259 : PyObject * obj0 = 0 ;
5217 1259 : PyObject * obj1 = 0 ;
5218 1259 : char *result = 0 ;
5219 :
5220 1259 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_GetAuthorityCode",&obj0,&obj1)) SWIG_fail;
5221 1259 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5222 1259 : if (!SWIG_IsOK(res1)) {
5223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetAuthorityCode" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5224 : }
5225 1259 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5226 1259 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5227 1259 : if (!SWIG_IsOK(res2)) {
5228 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_GetAuthorityCode" "', argument " "2"" of type '" "char const *""'");
5229 : }
5230 1259 : arg2 = reinterpret_cast< char * >(buf2);
5231 : {
5232 1259 : if ( bUseExceptions ) {
5233 0 : CPLErrorReset();
5234 : }
5235 1259 : result = (char *)OSRSpatialReferenceShadow_GetAuthorityCode(arg1,(char const *)arg2);
5236 1259 : if ( bUseExceptions ) {
5237 0 : CPLErr eclass = CPLGetLastErrorType();
5238 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5239 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5240 : }
5241 : }
5242 : }
5243 1259 : resultobj = SWIG_FromCharPtr((const char *)result);
5244 1259 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5245 1259 : return resultobj;
5246 : fail:
5247 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5248 0 : return NULL;
5249 : }
5250 :
5251 :
5252 9 : SWIGINTERN PyObject *_wrap_SpatialReference_GetAuthorityName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5253 9 : PyObject *resultobj = 0;
5254 9 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5255 9 : char *arg2 = (char *) 0 ;
5256 9 : void *argp1 = 0 ;
5257 9 : int res1 = 0 ;
5258 : int res2 ;
5259 9 : char *buf2 = 0 ;
5260 9 : int alloc2 = 0 ;
5261 9 : PyObject * obj0 = 0 ;
5262 9 : PyObject * obj1 = 0 ;
5263 9 : char *result = 0 ;
5264 :
5265 9 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_GetAuthorityName",&obj0,&obj1)) SWIG_fail;
5266 9 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5267 9 : if (!SWIG_IsOK(res1)) {
5268 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetAuthorityName" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5269 : }
5270 9 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5271 9 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5272 9 : if (!SWIG_IsOK(res2)) {
5273 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_GetAuthorityName" "', argument " "2"" of type '" "char const *""'");
5274 : }
5275 9 : arg2 = reinterpret_cast< char * >(buf2);
5276 : {
5277 9 : if ( bUseExceptions ) {
5278 0 : CPLErrorReset();
5279 : }
5280 9 : result = (char *)OSRSpatialReferenceShadow_GetAuthorityName(arg1,(char const *)arg2);
5281 9 : if ( bUseExceptions ) {
5282 0 : CPLErr eclass = CPLGetLastErrorType();
5283 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5284 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5285 : }
5286 : }
5287 : }
5288 9 : resultobj = SWIG_FromCharPtr((const char *)result);
5289 9 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5290 9 : return resultobj;
5291 : fail:
5292 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5293 0 : return NULL;
5294 : }
5295 :
5296 :
5297 12 : SWIGINTERN PyObject *_wrap_SpatialReference_SetUTM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 12 : PyObject *resultobj = 0;
5299 12 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5300 : int arg2 ;
5301 12 : int arg3 = (int) 1 ;
5302 12 : void *argp1 = 0 ;
5303 12 : int res1 = 0 ;
5304 : int val2 ;
5305 12 : int ecode2 = 0 ;
5306 : int val3 ;
5307 12 : int ecode3 = 0 ;
5308 12 : PyObject * obj0 = 0 ;
5309 12 : PyObject * obj1 = 0 ;
5310 12 : PyObject * obj2 = 0 ;
5311 : OGRErr result;
5312 :
5313 12 : if (!PyArg_ParseTuple(args,(char *)"OO|O:SpatialReference_SetUTM",&obj0,&obj1,&obj2)) SWIG_fail;
5314 12 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5315 12 : if (!SWIG_IsOK(res1)) {
5316 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetUTM" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5317 : }
5318 12 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5319 12 : ecode2 = SWIG_AsVal_int(obj1, &val2);
5320 12 : if (!SWIG_IsOK(ecode2)) {
5321 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetUTM" "', argument " "2"" of type '" "int""'");
5322 : }
5323 12 : arg2 = static_cast< int >(val2);
5324 12 : if (obj2) {
5325 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
5326 1 : if (!SWIG_IsOK(ecode3)) {
5327 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetUTM" "', argument " "3"" of type '" "int""'");
5328 : }
5329 1 : arg3 = static_cast< int >(val3);
5330 : }
5331 : {
5332 12 : if ( bUseExceptions ) {
5333 0 : CPLErrorReset();
5334 : }
5335 12 : result = (OGRErr)OSRSpatialReferenceShadow_SetUTM(arg1,arg2,arg3);
5336 12 : if ( bUseExceptions ) {
5337 0 : CPLErr eclass = CPLGetLastErrorType();
5338 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5339 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5340 : }
5341 : }
5342 : }
5343 : {
5344 : /* %typemap(out) OGRErr */
5345 12 : if ( result != 0 && bUseExceptions) {
5346 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5347 0 : SWIG_fail;
5348 : }
5349 : }
5350 : {
5351 : /* %typemap(ret) OGRErr */
5352 12 : if (resultobj == Py_None ) {
5353 0 : Py_DECREF(resultobj);
5354 0 : resultobj = 0;
5355 : }
5356 12 : if (resultobj == 0) {
5357 12 : resultobj = PyInt_FromLong( result );
5358 : }
5359 : }
5360 12 : return resultobj;
5361 : fail:
5362 0 : return NULL;
5363 : }
5364 :
5365 :
5366 2 : SWIGINTERN PyObject *_wrap_SpatialReference_GetUTMZone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5367 2 : PyObject *resultobj = 0;
5368 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5369 2 : void *argp1 = 0 ;
5370 2 : int res1 = 0 ;
5371 2 : PyObject * obj0 = 0 ;
5372 : int result;
5373 :
5374 2 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetUTMZone",&obj0)) SWIG_fail;
5375 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5376 2 : if (!SWIG_IsOK(res1)) {
5377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetUTMZone" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5378 : }
5379 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5380 : {
5381 2 : if ( bUseExceptions ) {
5382 0 : CPLErrorReset();
5383 : }
5384 2 : result = (int)OSRSpatialReferenceShadow_GetUTMZone(arg1);
5385 2 : if ( bUseExceptions ) {
5386 0 : CPLErr eclass = CPLGetLastErrorType();
5387 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5388 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5389 : }
5390 : }
5391 : }
5392 2 : resultobj = SWIG_From_int(static_cast< int >(result));
5393 2 : return resultobj;
5394 : fail:
5395 0 : return NULL;
5396 : }
5397 :
5398 :
5399 2 : SWIGINTERN PyObject *_wrap_SpatialReference_SetStatePlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5400 2 : PyObject *resultobj = 0;
5401 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5402 : int arg2 ;
5403 2 : int arg3 = (int) 1 ;
5404 2 : char *arg4 = (char *) "" ;
5405 2 : double arg5 = (double) 0.0 ;
5406 2 : void *argp1 = 0 ;
5407 2 : int res1 = 0 ;
5408 : int val2 ;
5409 2 : int ecode2 = 0 ;
5410 : int val3 ;
5411 2 : int ecode3 = 0 ;
5412 : int res4 ;
5413 2 : char *buf4 = 0 ;
5414 2 : int alloc4 = 0 ;
5415 : double val5 ;
5416 2 : int ecode5 = 0 ;
5417 2 : PyObject * obj0 = 0 ;
5418 2 : PyObject * obj1 = 0 ;
5419 2 : PyObject * obj2 = 0 ;
5420 2 : PyObject * obj3 = 0 ;
5421 2 : PyObject * obj4 = 0 ;
5422 : OGRErr result;
5423 :
5424 2 : if (!PyArg_ParseTuple(args,(char *)"OO|OOO:SpatialReference_SetStatePlane",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5425 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5426 2 : if (!SWIG_IsOK(res1)) {
5427 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetStatePlane" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5428 : }
5429 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5430 2 : ecode2 = SWIG_AsVal_int(obj1, &val2);
5431 2 : if (!SWIG_IsOK(ecode2)) {
5432 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetStatePlane" "', argument " "2"" of type '" "int""'");
5433 : }
5434 2 : arg2 = static_cast< int >(val2);
5435 2 : if (obj2) {
5436 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
5437 2 : if (!SWIG_IsOK(ecode3)) {
5438 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetStatePlane" "', argument " "3"" of type '" "int""'");
5439 : }
5440 2 : arg3 = static_cast< int >(val3);
5441 : }
5442 2 : if (obj3) {
5443 1 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5444 1 : if (!SWIG_IsOK(res4)) {
5445 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialReference_SetStatePlane" "', argument " "4"" of type '" "char const *""'");
5446 : }
5447 1 : arg4 = reinterpret_cast< char * >(buf4);
5448 : }
5449 2 : if (obj4) {
5450 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
5451 1 : if (!SWIG_IsOK(ecode5)) {
5452 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetStatePlane" "', argument " "5"" of type '" "double""'");
5453 : }
5454 1 : arg5 = static_cast< double >(val5);
5455 : }
5456 : {
5457 2 : if ( bUseExceptions ) {
5458 0 : CPLErrorReset();
5459 : }
5460 2 : result = (OGRErr)OSRSpatialReferenceShadow_SetStatePlane(arg1,arg2,arg3,(char const *)arg4,arg5);
5461 2 : if ( bUseExceptions ) {
5462 0 : CPLErr eclass = CPLGetLastErrorType();
5463 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5464 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5465 : }
5466 : }
5467 : }
5468 : {
5469 : /* %typemap(out) OGRErr */
5470 2 : if ( result != 0 && bUseExceptions) {
5471 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5472 0 : SWIG_fail;
5473 : }
5474 : }
5475 2 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
5476 : {
5477 : /* %typemap(ret) OGRErr */
5478 2 : if (resultobj == Py_None ) {
5479 0 : Py_DECREF(resultobj);
5480 0 : resultobj = 0;
5481 : }
5482 2 : if (resultobj == 0) {
5483 2 : resultobj = PyInt_FromLong( result );
5484 : }
5485 : }
5486 2 : return resultobj;
5487 : fail:
5488 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
5489 0 : return NULL;
5490 : }
5491 :
5492 :
5493 0 : SWIGINTERN PyObject *_wrap_SpatialReference_AutoIdentifyEPSG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5494 0 : PyObject *resultobj = 0;
5495 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5496 0 : void *argp1 = 0 ;
5497 0 : int res1 = 0 ;
5498 0 : PyObject * obj0 = 0 ;
5499 : OGRErr result;
5500 :
5501 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_AutoIdentifyEPSG",&obj0)) SWIG_fail;
5502 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5503 0 : if (!SWIG_IsOK(res1)) {
5504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_AutoIdentifyEPSG" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5505 : }
5506 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5507 : {
5508 0 : if ( bUseExceptions ) {
5509 0 : CPLErrorReset();
5510 : }
5511 0 : result = (OGRErr)OSRSpatialReferenceShadow_AutoIdentifyEPSG(arg1);
5512 0 : if ( bUseExceptions ) {
5513 0 : CPLErr eclass = CPLGetLastErrorType();
5514 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5515 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5516 : }
5517 : }
5518 : }
5519 : {
5520 : /* %typemap(out) OGRErr */
5521 0 : if ( result != 0 && bUseExceptions) {
5522 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5523 0 : SWIG_fail;
5524 : }
5525 : }
5526 : {
5527 : /* %typemap(ret) OGRErr */
5528 0 : if (resultobj == Py_None ) {
5529 0 : Py_DECREF(resultobj);
5530 0 : resultobj = 0;
5531 : }
5532 0 : if (resultobj == 0) {
5533 0 : resultobj = PyInt_FromLong( result );
5534 : }
5535 : }
5536 0 : return resultobj;
5537 : fail:
5538 0 : return NULL;
5539 : }
5540 :
5541 :
5542 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5543 0 : PyObject *resultobj = 0;
5544 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5545 0 : char *arg2 = (char *) 0 ;
5546 0 : void *argp1 = 0 ;
5547 0 : int res1 = 0 ;
5548 : int res2 ;
5549 0 : char *buf2 = 0 ;
5550 0 : int alloc2 = 0 ;
5551 0 : PyObject * obj0 = 0 ;
5552 0 : PyObject * obj1 = 0 ;
5553 : OGRErr result;
5554 :
5555 0 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_SetProjection",&obj0,&obj1)) SWIG_fail;
5556 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5557 0 : if (!SWIG_IsOK(res1)) {
5558 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetProjection" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5559 : }
5560 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5561 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5562 0 : if (!SWIG_IsOK(res2)) {
5563 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetProjection" "', argument " "2"" of type '" "char const *""'");
5564 : }
5565 0 : arg2 = reinterpret_cast< char * >(buf2);
5566 : {
5567 0 : if ( bUseExceptions ) {
5568 0 : CPLErrorReset();
5569 : }
5570 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetProjection(arg1,(char const *)arg2);
5571 0 : if ( bUseExceptions ) {
5572 0 : CPLErr eclass = CPLGetLastErrorType();
5573 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5574 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5575 : }
5576 : }
5577 : }
5578 : {
5579 : /* %typemap(out) OGRErr */
5580 0 : if ( result != 0 && bUseExceptions) {
5581 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5582 0 : SWIG_fail;
5583 : }
5584 : }
5585 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5586 : {
5587 : /* %typemap(ret) OGRErr */
5588 0 : if (resultobj == Py_None ) {
5589 0 : Py_DECREF(resultobj);
5590 0 : resultobj = 0;
5591 : }
5592 0 : if (resultobj == 0) {
5593 0 : resultobj = PyInt_FromLong( result );
5594 : }
5595 : }
5596 0 : return resultobj;
5597 : fail:
5598 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5599 0 : return NULL;
5600 : }
5601 :
5602 :
5603 142 : SWIGINTERN PyObject *_wrap_SpatialReference_SetProjParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5604 142 : PyObject *resultobj = 0;
5605 142 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5606 142 : char *arg2 = (char *) 0 ;
5607 : double arg3 ;
5608 142 : void *argp1 = 0 ;
5609 142 : int res1 = 0 ;
5610 : int res2 ;
5611 142 : char *buf2 = 0 ;
5612 142 : int alloc2 = 0 ;
5613 : double val3 ;
5614 142 : int ecode3 = 0 ;
5615 142 : PyObject * obj0 = 0 ;
5616 142 : PyObject * obj1 = 0 ;
5617 142 : PyObject * obj2 = 0 ;
5618 : OGRErr result;
5619 :
5620 142 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetProjParm",&obj0,&obj1,&obj2)) SWIG_fail;
5621 142 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5622 142 : if (!SWIG_IsOK(res1)) {
5623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetProjParm" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5624 : }
5625 142 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5626 142 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5627 142 : if (!SWIG_IsOK(res2)) {
5628 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetProjParm" "', argument " "2"" of type '" "char const *""'");
5629 : }
5630 142 : arg2 = reinterpret_cast< char * >(buf2);
5631 142 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5632 142 : if (!SWIG_IsOK(ecode3)) {
5633 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetProjParm" "', argument " "3"" of type '" "double""'");
5634 : }
5635 142 : arg3 = static_cast< double >(val3);
5636 : {
5637 142 : if (!arg2) {
5638 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5639 : }
5640 : }
5641 : {
5642 142 : if ( bUseExceptions ) {
5643 0 : CPLErrorReset();
5644 : }
5645 142 : result = (OGRErr)OSRSpatialReferenceShadow_SetProjParm(arg1,(char const *)arg2,arg3);
5646 142 : if ( bUseExceptions ) {
5647 0 : CPLErr eclass = CPLGetLastErrorType();
5648 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5649 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5650 : }
5651 : }
5652 : }
5653 : {
5654 : /* %typemap(out) OGRErr */
5655 142 : if ( result != 0 && bUseExceptions) {
5656 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5657 0 : SWIG_fail;
5658 : }
5659 : }
5660 142 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5661 : {
5662 : /* %typemap(ret) OGRErr */
5663 142 : if (resultobj == Py_None ) {
5664 0 : Py_DECREF(resultobj);
5665 0 : resultobj = 0;
5666 : }
5667 142 : if (resultobj == 0) {
5668 142 : resultobj = PyInt_FromLong( result );
5669 : }
5670 : }
5671 142 : return resultobj;
5672 : fail:
5673 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5674 0 : return NULL;
5675 : }
5676 :
5677 :
5678 8815 : SWIGINTERN PyObject *_wrap_SpatialReference_GetProjParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679 8815 : PyObject *resultobj = 0;
5680 8815 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5681 8815 : char *arg2 = (char *) 0 ;
5682 8815 : double arg3 = (double) 0.0 ;
5683 8815 : void *argp1 = 0 ;
5684 8815 : int res1 = 0 ;
5685 : int res2 ;
5686 8815 : char *buf2 = 0 ;
5687 8815 : int alloc2 = 0 ;
5688 : double val3 ;
5689 8815 : int ecode3 = 0 ;
5690 8815 : PyObject * obj0 = 0 ;
5691 8815 : PyObject * obj1 = 0 ;
5692 8815 : PyObject * obj2 = 0 ;
5693 : double result;
5694 :
5695 8815 : if (!PyArg_ParseTuple(args,(char *)"OO|O:SpatialReference_GetProjParm",&obj0,&obj1,&obj2)) SWIG_fail;
5696 8815 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5697 8815 : if (!SWIG_IsOK(res1)) {
5698 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetProjParm" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5699 : }
5700 8815 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5701 8815 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5702 8815 : if (!SWIG_IsOK(res2)) {
5703 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_GetProjParm" "', argument " "2"" of type '" "char const *""'");
5704 : }
5705 8815 : arg2 = reinterpret_cast< char * >(buf2);
5706 8815 : if (obj2) {
5707 17 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5708 17 : if (!SWIG_IsOK(ecode3)) {
5709 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_GetProjParm" "', argument " "3"" of type '" "double""'");
5710 : }
5711 17 : arg3 = static_cast< double >(val3);
5712 : }
5713 : {
5714 8815 : if (!arg2) {
5715 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5716 : }
5717 : }
5718 : {
5719 8815 : if ( bUseExceptions ) {
5720 0 : CPLErrorReset();
5721 : }
5722 8815 : result = (double)OSRSpatialReferenceShadow_GetProjParm(arg1,(char const *)arg2,arg3);
5723 8815 : if ( bUseExceptions ) {
5724 0 : CPLErr eclass = CPLGetLastErrorType();
5725 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5726 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5727 : }
5728 : }
5729 : }
5730 8815 : resultobj = SWIG_From_double(static_cast< double >(result));
5731 8815 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5732 8815 : return resultobj;
5733 : fail:
5734 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5735 0 : return NULL;
5736 : }
5737 :
5738 :
5739 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetNormProjParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740 0 : PyObject *resultobj = 0;
5741 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5742 0 : char *arg2 = (char *) 0 ;
5743 : double arg3 ;
5744 0 : void *argp1 = 0 ;
5745 0 : int res1 = 0 ;
5746 : int res2 ;
5747 0 : char *buf2 = 0 ;
5748 0 : int alloc2 = 0 ;
5749 : double val3 ;
5750 0 : int ecode3 = 0 ;
5751 0 : PyObject * obj0 = 0 ;
5752 0 : PyObject * obj1 = 0 ;
5753 0 : PyObject * obj2 = 0 ;
5754 : OGRErr result;
5755 :
5756 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:SpatialReference_SetNormProjParm",&obj0,&obj1,&obj2)) SWIG_fail;
5757 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5758 0 : if (!SWIG_IsOK(res1)) {
5759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetNormProjParm" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5760 : }
5761 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5762 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5763 0 : if (!SWIG_IsOK(res2)) {
5764 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetNormProjParm" "', argument " "2"" of type '" "char const *""'");
5765 : }
5766 0 : arg2 = reinterpret_cast< char * >(buf2);
5767 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5768 0 : if (!SWIG_IsOK(ecode3)) {
5769 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetNormProjParm" "', argument " "3"" of type '" "double""'");
5770 : }
5771 0 : arg3 = static_cast< double >(val3);
5772 : {
5773 0 : if (!arg2) {
5774 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5775 : }
5776 : }
5777 : {
5778 0 : if ( bUseExceptions ) {
5779 0 : CPLErrorReset();
5780 : }
5781 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetNormProjParm(arg1,(char const *)arg2,arg3);
5782 0 : if ( bUseExceptions ) {
5783 0 : CPLErr eclass = CPLGetLastErrorType();
5784 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5785 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5786 : }
5787 : }
5788 : }
5789 : {
5790 : /* %typemap(out) OGRErr */
5791 0 : if ( result != 0 && bUseExceptions) {
5792 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
5793 0 : SWIG_fail;
5794 : }
5795 : }
5796 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5797 : {
5798 : /* %typemap(ret) OGRErr */
5799 0 : if (resultobj == Py_None ) {
5800 0 : Py_DECREF(resultobj);
5801 0 : resultobj = 0;
5802 : }
5803 0 : if (resultobj == 0) {
5804 0 : resultobj = PyInt_FromLong( result );
5805 : }
5806 : }
5807 0 : return resultobj;
5808 : fail:
5809 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5810 0 : return NULL;
5811 : }
5812 :
5813 :
5814 0 : SWIGINTERN PyObject *_wrap_SpatialReference_GetNormProjParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5815 0 : PyObject *resultobj = 0;
5816 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5817 0 : char *arg2 = (char *) 0 ;
5818 0 : double arg3 = (double) 0.0 ;
5819 0 : void *argp1 = 0 ;
5820 0 : int res1 = 0 ;
5821 : int res2 ;
5822 0 : char *buf2 = 0 ;
5823 0 : int alloc2 = 0 ;
5824 : double val3 ;
5825 0 : int ecode3 = 0 ;
5826 0 : PyObject * obj0 = 0 ;
5827 0 : PyObject * obj1 = 0 ;
5828 0 : PyObject * obj2 = 0 ;
5829 : double result;
5830 :
5831 0 : if (!PyArg_ParseTuple(args,(char *)"OO|O:SpatialReference_GetNormProjParm",&obj0,&obj1,&obj2)) SWIG_fail;
5832 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5833 0 : if (!SWIG_IsOK(res1)) {
5834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetNormProjParm" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5835 : }
5836 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5837 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5838 0 : if (!SWIG_IsOK(res2)) {
5839 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_GetNormProjParm" "', argument " "2"" of type '" "char const *""'");
5840 : }
5841 0 : arg2 = reinterpret_cast< char * >(buf2);
5842 0 : if (obj2) {
5843 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
5844 0 : if (!SWIG_IsOK(ecode3)) {
5845 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_GetNormProjParm" "', argument " "3"" of type '" "double""'");
5846 : }
5847 0 : arg3 = static_cast< double >(val3);
5848 : }
5849 : {
5850 0 : if (!arg2) {
5851 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
5852 : }
5853 : }
5854 : {
5855 0 : if ( bUseExceptions ) {
5856 0 : CPLErrorReset();
5857 : }
5858 0 : result = (double)OSRSpatialReferenceShadow_GetNormProjParm(arg1,(char const *)arg2,arg3);
5859 0 : if ( bUseExceptions ) {
5860 0 : CPLErr eclass = CPLGetLastErrorType();
5861 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5862 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5863 : }
5864 : }
5865 : }
5866 0 : resultobj = SWIG_From_double(static_cast< double >(result));
5867 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5868 0 : return resultobj;
5869 : fail:
5870 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5871 0 : return NULL;
5872 : }
5873 :
5874 :
5875 3 : SWIGINTERN PyObject *_wrap_SpatialReference_GetSemiMajor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5876 3 : PyObject *resultobj = 0;
5877 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5878 3 : void *argp1 = 0 ;
5879 3 : int res1 = 0 ;
5880 3 : PyObject * obj0 = 0 ;
5881 : double result;
5882 :
5883 3 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetSemiMajor",&obj0)) SWIG_fail;
5884 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5885 3 : if (!SWIG_IsOK(res1)) {
5886 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetSemiMajor" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5887 : }
5888 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5889 : {
5890 3 : if ( bUseExceptions ) {
5891 0 : CPLErrorReset();
5892 : }
5893 3 : result = (double)OSRSpatialReferenceShadow_GetSemiMajor(arg1);
5894 3 : if ( bUseExceptions ) {
5895 0 : CPLErr eclass = CPLGetLastErrorType();
5896 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5897 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5898 : }
5899 : }
5900 : }
5901 3 : resultobj = SWIG_From_double(static_cast< double >(result));
5902 3 : return resultobj;
5903 : fail:
5904 0 : return NULL;
5905 : }
5906 :
5907 :
5908 3 : SWIGINTERN PyObject *_wrap_SpatialReference_GetSemiMinor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5909 3 : PyObject *resultobj = 0;
5910 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5911 3 : void *argp1 = 0 ;
5912 3 : int res1 = 0 ;
5913 3 : PyObject * obj0 = 0 ;
5914 : double result;
5915 :
5916 3 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetSemiMinor",&obj0)) SWIG_fail;
5917 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5918 3 : if (!SWIG_IsOK(res1)) {
5919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetSemiMinor" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5920 : }
5921 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5922 : {
5923 3 : if ( bUseExceptions ) {
5924 0 : CPLErrorReset();
5925 : }
5926 3 : result = (double)OSRSpatialReferenceShadow_GetSemiMinor(arg1);
5927 3 : if ( bUseExceptions ) {
5928 0 : CPLErr eclass = CPLGetLastErrorType();
5929 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5930 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5931 : }
5932 : }
5933 : }
5934 3 : resultobj = SWIG_From_double(static_cast< double >(result));
5935 3 : return resultobj;
5936 : fail:
5937 0 : return NULL;
5938 : }
5939 :
5940 :
5941 3 : SWIGINTERN PyObject *_wrap_SpatialReference_GetInvFlattening(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5942 3 : PyObject *resultobj = 0;
5943 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5944 3 : void *argp1 = 0 ;
5945 3 : int res1 = 0 ;
5946 3 : PyObject * obj0 = 0 ;
5947 : double result;
5948 :
5949 3 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetInvFlattening",&obj0)) SWIG_fail;
5950 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
5951 3 : if (!SWIG_IsOK(res1)) {
5952 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetInvFlattening" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
5953 : }
5954 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
5955 : {
5956 3 : if ( bUseExceptions ) {
5957 0 : CPLErrorReset();
5958 : }
5959 3 : result = (double)OSRSpatialReferenceShadow_GetInvFlattening(arg1);
5960 3 : if ( bUseExceptions ) {
5961 0 : CPLErr eclass = CPLGetLastErrorType();
5962 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5963 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5964 : }
5965 : }
5966 : }
5967 3 : resultobj = SWIG_From_double(static_cast< double >(result));
5968 3 : return resultobj;
5969 : fail:
5970 0 : return NULL;
5971 : }
5972 :
5973 :
5974 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetACEA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5975 0 : PyObject *resultobj = 0;
5976 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
5977 : double arg2 ;
5978 : double arg3 ;
5979 : double arg4 ;
5980 : double arg5 ;
5981 : double arg6 ;
5982 : double arg7 ;
5983 0 : void *argp1 = 0 ;
5984 0 : int res1 = 0 ;
5985 : double val2 ;
5986 0 : int ecode2 = 0 ;
5987 : double val3 ;
5988 0 : int ecode3 = 0 ;
5989 : double val4 ;
5990 0 : int ecode4 = 0 ;
5991 : double val5 ;
5992 0 : int ecode5 = 0 ;
5993 : double val6 ;
5994 0 : int ecode6 = 0 ;
5995 : double val7 ;
5996 0 : int ecode7 = 0 ;
5997 0 : PyObject * obj0 = 0 ;
5998 0 : PyObject * obj1 = 0 ;
5999 0 : PyObject * obj2 = 0 ;
6000 0 : PyObject * obj3 = 0 ;
6001 0 : PyObject * obj4 = 0 ;
6002 0 : PyObject * obj5 = 0 ;
6003 0 : PyObject * obj6 = 0 ;
6004 : char * kwnames[] = {
6005 : (char *) "self",(char *) "stdp1",(char *) "stdp2",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
6006 0 : };
6007 : OGRErr result;
6008 :
6009 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:SpatialReference_SetACEA",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6010 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6011 0 : if (!SWIG_IsOK(res1)) {
6012 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetACEA" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6013 : }
6014 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6015 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6016 0 : if (!SWIG_IsOK(ecode2)) {
6017 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetACEA" "', argument " "2"" of type '" "double""'");
6018 : }
6019 0 : arg2 = static_cast< double >(val2);
6020 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6021 0 : if (!SWIG_IsOK(ecode3)) {
6022 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetACEA" "', argument " "3"" of type '" "double""'");
6023 : }
6024 0 : arg3 = static_cast< double >(val3);
6025 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6026 0 : if (!SWIG_IsOK(ecode4)) {
6027 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetACEA" "', argument " "4"" of type '" "double""'");
6028 : }
6029 0 : arg4 = static_cast< double >(val4);
6030 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6031 0 : if (!SWIG_IsOK(ecode5)) {
6032 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetACEA" "', argument " "5"" of type '" "double""'");
6033 : }
6034 0 : arg5 = static_cast< double >(val5);
6035 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
6036 0 : if (!SWIG_IsOK(ecode6)) {
6037 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetACEA" "', argument " "6"" of type '" "double""'");
6038 : }
6039 0 : arg6 = static_cast< double >(val6);
6040 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
6041 0 : if (!SWIG_IsOK(ecode7)) {
6042 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetACEA" "', argument " "7"" of type '" "double""'");
6043 : }
6044 0 : arg7 = static_cast< double >(val7);
6045 : {
6046 0 : if ( bUseExceptions ) {
6047 0 : CPLErrorReset();
6048 : }
6049 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetACEA(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6050 0 : if ( bUseExceptions ) {
6051 0 : CPLErr eclass = CPLGetLastErrorType();
6052 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6053 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6054 : }
6055 : }
6056 : }
6057 : {
6058 : /* %typemap(out) OGRErr */
6059 0 : if ( result != 0 && bUseExceptions) {
6060 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6061 0 : SWIG_fail;
6062 : }
6063 : }
6064 : {
6065 : /* %typemap(ret) OGRErr */
6066 0 : if (resultobj == Py_None ) {
6067 0 : Py_DECREF(resultobj);
6068 0 : resultobj = 0;
6069 : }
6070 0 : if (resultobj == 0) {
6071 0 : resultobj = PyInt_FromLong( result );
6072 : }
6073 : }
6074 0 : return resultobj;
6075 : fail:
6076 0 : return NULL;
6077 : }
6078 :
6079 :
6080 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetAE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6081 0 : PyObject *resultobj = 0;
6082 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6083 : double arg2 ;
6084 : double arg3 ;
6085 : double arg4 ;
6086 : double arg5 ;
6087 0 : void *argp1 = 0 ;
6088 0 : int res1 = 0 ;
6089 : double val2 ;
6090 0 : int ecode2 = 0 ;
6091 : double val3 ;
6092 0 : int ecode3 = 0 ;
6093 : double val4 ;
6094 0 : int ecode4 = 0 ;
6095 : double val5 ;
6096 0 : int ecode5 = 0 ;
6097 0 : PyObject * obj0 = 0 ;
6098 0 : PyObject * obj1 = 0 ;
6099 0 : PyObject * obj2 = 0 ;
6100 0 : PyObject * obj3 = 0 ;
6101 0 : PyObject * obj4 = 0 ;
6102 : char * kwnames[] = {
6103 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
6104 0 : };
6105 : OGRErr result;
6106 :
6107 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetAE",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6108 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6109 0 : if (!SWIG_IsOK(res1)) {
6110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetAE" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6111 : }
6112 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6113 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6114 0 : if (!SWIG_IsOK(ecode2)) {
6115 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetAE" "', argument " "2"" of type '" "double""'");
6116 : }
6117 0 : arg2 = static_cast< double >(val2);
6118 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6119 0 : if (!SWIG_IsOK(ecode3)) {
6120 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetAE" "', argument " "3"" of type '" "double""'");
6121 : }
6122 0 : arg3 = static_cast< double >(val3);
6123 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6124 0 : if (!SWIG_IsOK(ecode4)) {
6125 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetAE" "', argument " "4"" of type '" "double""'");
6126 : }
6127 0 : arg4 = static_cast< double >(val4);
6128 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6129 0 : if (!SWIG_IsOK(ecode5)) {
6130 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetAE" "', argument " "5"" of type '" "double""'");
6131 : }
6132 0 : arg5 = static_cast< double >(val5);
6133 : {
6134 0 : if ( bUseExceptions ) {
6135 0 : CPLErrorReset();
6136 : }
6137 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetAE(arg1,arg2,arg3,arg4,arg5);
6138 0 : if ( bUseExceptions ) {
6139 0 : CPLErr eclass = CPLGetLastErrorType();
6140 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6141 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6142 : }
6143 : }
6144 : }
6145 : {
6146 : /* %typemap(out) OGRErr */
6147 0 : if ( result != 0 && bUseExceptions) {
6148 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6149 0 : SWIG_fail;
6150 : }
6151 : }
6152 : {
6153 : /* %typemap(ret) OGRErr */
6154 0 : if (resultobj == Py_None ) {
6155 0 : Py_DECREF(resultobj);
6156 0 : resultobj = 0;
6157 : }
6158 0 : if (resultobj == 0) {
6159 0 : resultobj = PyInt_FromLong( result );
6160 : }
6161 : }
6162 0 : return resultobj;
6163 : fail:
6164 0 : return NULL;
6165 : }
6166 :
6167 :
6168 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetBonne(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 0 : PyObject *resultobj = 0;
6170 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6171 : double arg2 ;
6172 : double arg3 ;
6173 : double arg4 ;
6174 : double arg5 ;
6175 0 : void *argp1 = 0 ;
6176 0 : int res1 = 0 ;
6177 : double val2 ;
6178 0 : int ecode2 = 0 ;
6179 : double val3 ;
6180 0 : int ecode3 = 0 ;
6181 : double val4 ;
6182 0 : int ecode4 = 0 ;
6183 : double val5 ;
6184 0 : int ecode5 = 0 ;
6185 0 : PyObject * obj0 = 0 ;
6186 0 : PyObject * obj1 = 0 ;
6187 0 : PyObject * obj2 = 0 ;
6188 0 : PyObject * obj3 = 0 ;
6189 0 : PyObject * obj4 = 0 ;
6190 : char * kwnames[] = {
6191 : (char *) "self",(char *) "stdp",(char *) "cm",(char *) "fe",(char *) "fn", NULL
6192 0 : };
6193 : OGRErr result;
6194 :
6195 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetBonne",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6196 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6197 0 : if (!SWIG_IsOK(res1)) {
6198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetBonne" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6199 : }
6200 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6201 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6202 0 : if (!SWIG_IsOK(ecode2)) {
6203 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetBonne" "', argument " "2"" of type '" "double""'");
6204 : }
6205 0 : arg2 = static_cast< double >(val2);
6206 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6207 0 : if (!SWIG_IsOK(ecode3)) {
6208 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetBonne" "', argument " "3"" of type '" "double""'");
6209 : }
6210 0 : arg3 = static_cast< double >(val3);
6211 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6212 0 : if (!SWIG_IsOK(ecode4)) {
6213 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetBonne" "', argument " "4"" of type '" "double""'");
6214 : }
6215 0 : arg4 = static_cast< double >(val4);
6216 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6217 0 : if (!SWIG_IsOK(ecode5)) {
6218 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetBonne" "', argument " "5"" of type '" "double""'");
6219 : }
6220 0 : arg5 = static_cast< double >(val5);
6221 : {
6222 0 : if ( bUseExceptions ) {
6223 0 : CPLErrorReset();
6224 : }
6225 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetBonne(arg1,arg2,arg3,arg4,arg5);
6226 0 : if ( bUseExceptions ) {
6227 0 : CPLErr eclass = CPLGetLastErrorType();
6228 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6229 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6230 : }
6231 : }
6232 : }
6233 : {
6234 : /* %typemap(out) OGRErr */
6235 0 : if ( result != 0 && bUseExceptions) {
6236 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6237 0 : SWIG_fail;
6238 : }
6239 : }
6240 : {
6241 : /* %typemap(ret) OGRErr */
6242 0 : if (resultobj == Py_None ) {
6243 0 : Py_DECREF(resultobj);
6244 0 : resultobj = 0;
6245 : }
6246 0 : if (resultobj == 0) {
6247 0 : resultobj = PyInt_FromLong( result );
6248 : }
6249 : }
6250 0 : return resultobj;
6251 : fail:
6252 0 : return NULL;
6253 : }
6254 :
6255 :
6256 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetCEA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6257 0 : PyObject *resultobj = 0;
6258 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6259 : double arg2 ;
6260 : double arg3 ;
6261 : double arg4 ;
6262 : double arg5 ;
6263 0 : void *argp1 = 0 ;
6264 0 : int res1 = 0 ;
6265 : double val2 ;
6266 0 : int ecode2 = 0 ;
6267 : double val3 ;
6268 0 : int ecode3 = 0 ;
6269 : double val4 ;
6270 0 : int ecode4 = 0 ;
6271 : double val5 ;
6272 0 : int ecode5 = 0 ;
6273 0 : PyObject * obj0 = 0 ;
6274 0 : PyObject * obj1 = 0 ;
6275 0 : PyObject * obj2 = 0 ;
6276 0 : PyObject * obj3 = 0 ;
6277 0 : PyObject * obj4 = 0 ;
6278 : char * kwnames[] = {
6279 : (char *) "self",(char *) "stdp1",(char *) "cm",(char *) "fe",(char *) "fn", NULL
6280 0 : };
6281 : OGRErr result;
6282 :
6283 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetCEA",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6284 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6285 0 : if (!SWIG_IsOK(res1)) {
6286 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetCEA" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6287 : }
6288 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6289 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6290 0 : if (!SWIG_IsOK(ecode2)) {
6291 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetCEA" "', argument " "2"" of type '" "double""'");
6292 : }
6293 0 : arg2 = static_cast< double >(val2);
6294 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6295 0 : if (!SWIG_IsOK(ecode3)) {
6296 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetCEA" "', argument " "3"" of type '" "double""'");
6297 : }
6298 0 : arg3 = static_cast< double >(val3);
6299 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6300 0 : if (!SWIG_IsOK(ecode4)) {
6301 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetCEA" "', argument " "4"" of type '" "double""'");
6302 : }
6303 0 : arg4 = static_cast< double >(val4);
6304 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6305 0 : if (!SWIG_IsOK(ecode5)) {
6306 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetCEA" "', argument " "5"" of type '" "double""'");
6307 : }
6308 0 : arg5 = static_cast< double >(val5);
6309 : {
6310 0 : if ( bUseExceptions ) {
6311 0 : CPLErrorReset();
6312 : }
6313 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetCEA(arg1,arg2,arg3,arg4,arg5);
6314 0 : if ( bUseExceptions ) {
6315 0 : CPLErr eclass = CPLGetLastErrorType();
6316 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6317 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6318 : }
6319 : }
6320 : }
6321 : {
6322 : /* %typemap(out) OGRErr */
6323 0 : if ( result != 0 && bUseExceptions) {
6324 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6325 0 : SWIG_fail;
6326 : }
6327 : }
6328 : {
6329 : /* %typemap(ret) OGRErr */
6330 0 : if (resultobj == Py_None ) {
6331 0 : Py_DECREF(resultobj);
6332 0 : resultobj = 0;
6333 : }
6334 0 : if (resultobj == 0) {
6335 0 : resultobj = PyInt_FromLong( result );
6336 : }
6337 : }
6338 0 : return resultobj;
6339 : fail:
6340 0 : return NULL;
6341 : }
6342 :
6343 :
6344 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6345 0 : PyObject *resultobj = 0;
6346 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6347 : double arg2 ;
6348 : double arg3 ;
6349 : double arg4 ;
6350 : double arg5 ;
6351 0 : void *argp1 = 0 ;
6352 0 : int res1 = 0 ;
6353 : double val2 ;
6354 0 : int ecode2 = 0 ;
6355 : double val3 ;
6356 0 : int ecode3 = 0 ;
6357 : double val4 ;
6358 0 : int ecode4 = 0 ;
6359 : double val5 ;
6360 0 : int ecode5 = 0 ;
6361 0 : PyObject * obj0 = 0 ;
6362 0 : PyObject * obj1 = 0 ;
6363 0 : PyObject * obj2 = 0 ;
6364 0 : PyObject * obj3 = 0 ;
6365 0 : PyObject * obj4 = 0 ;
6366 : char * kwnames[] = {
6367 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
6368 0 : };
6369 : OGRErr result;
6370 :
6371 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetCS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6372 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6373 0 : if (!SWIG_IsOK(res1)) {
6374 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6375 : }
6376 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6377 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6378 0 : if (!SWIG_IsOK(ecode2)) {
6379 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetCS" "', argument " "2"" of type '" "double""'");
6380 : }
6381 0 : arg2 = static_cast< double >(val2);
6382 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6383 0 : if (!SWIG_IsOK(ecode3)) {
6384 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetCS" "', argument " "3"" of type '" "double""'");
6385 : }
6386 0 : arg3 = static_cast< double >(val3);
6387 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6388 0 : if (!SWIG_IsOK(ecode4)) {
6389 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetCS" "', argument " "4"" of type '" "double""'");
6390 : }
6391 0 : arg4 = static_cast< double >(val4);
6392 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6393 0 : if (!SWIG_IsOK(ecode5)) {
6394 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetCS" "', argument " "5"" of type '" "double""'");
6395 : }
6396 0 : arg5 = static_cast< double >(val5);
6397 : {
6398 0 : if ( bUseExceptions ) {
6399 0 : CPLErrorReset();
6400 : }
6401 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetCS(arg1,arg2,arg3,arg4,arg5);
6402 0 : if ( bUseExceptions ) {
6403 0 : CPLErr eclass = CPLGetLastErrorType();
6404 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6405 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6406 : }
6407 : }
6408 : }
6409 : {
6410 : /* %typemap(out) OGRErr */
6411 0 : if ( result != 0 && bUseExceptions) {
6412 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6413 0 : SWIG_fail;
6414 : }
6415 : }
6416 : {
6417 : /* %typemap(ret) OGRErr */
6418 0 : if (resultobj == Py_None ) {
6419 0 : Py_DECREF(resultobj);
6420 0 : resultobj = 0;
6421 : }
6422 0 : if (resultobj == 0) {
6423 0 : resultobj = PyInt_FromLong( result );
6424 : }
6425 : }
6426 0 : return resultobj;
6427 : fail:
6428 0 : return NULL;
6429 : }
6430 :
6431 :
6432 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetEC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6433 0 : PyObject *resultobj = 0;
6434 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6435 : double arg2 ;
6436 : double arg3 ;
6437 : double arg4 ;
6438 : double arg5 ;
6439 : double arg6 ;
6440 : double arg7 ;
6441 0 : void *argp1 = 0 ;
6442 0 : int res1 = 0 ;
6443 : double val2 ;
6444 0 : int ecode2 = 0 ;
6445 : double val3 ;
6446 0 : int ecode3 = 0 ;
6447 : double val4 ;
6448 0 : int ecode4 = 0 ;
6449 : double val5 ;
6450 0 : int ecode5 = 0 ;
6451 : double val6 ;
6452 0 : int ecode6 = 0 ;
6453 : double val7 ;
6454 0 : int ecode7 = 0 ;
6455 0 : PyObject * obj0 = 0 ;
6456 0 : PyObject * obj1 = 0 ;
6457 0 : PyObject * obj2 = 0 ;
6458 0 : PyObject * obj3 = 0 ;
6459 0 : PyObject * obj4 = 0 ;
6460 0 : PyObject * obj5 = 0 ;
6461 0 : PyObject * obj6 = 0 ;
6462 : char * kwnames[] = {
6463 : (char *) "self",(char *) "stdp1",(char *) "stdp2",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
6464 0 : };
6465 : OGRErr result;
6466 :
6467 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:SpatialReference_SetEC",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6468 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6469 0 : if (!SWIG_IsOK(res1)) {
6470 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetEC" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6471 : }
6472 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6473 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6474 0 : if (!SWIG_IsOK(ecode2)) {
6475 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetEC" "', argument " "2"" of type '" "double""'");
6476 : }
6477 0 : arg2 = static_cast< double >(val2);
6478 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6479 0 : if (!SWIG_IsOK(ecode3)) {
6480 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetEC" "', argument " "3"" of type '" "double""'");
6481 : }
6482 0 : arg3 = static_cast< double >(val3);
6483 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6484 0 : if (!SWIG_IsOK(ecode4)) {
6485 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetEC" "', argument " "4"" of type '" "double""'");
6486 : }
6487 0 : arg4 = static_cast< double >(val4);
6488 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6489 0 : if (!SWIG_IsOK(ecode5)) {
6490 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetEC" "', argument " "5"" of type '" "double""'");
6491 : }
6492 0 : arg5 = static_cast< double >(val5);
6493 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
6494 0 : if (!SWIG_IsOK(ecode6)) {
6495 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetEC" "', argument " "6"" of type '" "double""'");
6496 : }
6497 0 : arg6 = static_cast< double >(val6);
6498 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
6499 0 : if (!SWIG_IsOK(ecode7)) {
6500 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetEC" "', argument " "7"" of type '" "double""'");
6501 : }
6502 0 : arg7 = static_cast< double >(val7);
6503 : {
6504 0 : if ( bUseExceptions ) {
6505 0 : CPLErrorReset();
6506 : }
6507 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetEC(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6508 0 : if ( bUseExceptions ) {
6509 0 : CPLErr eclass = CPLGetLastErrorType();
6510 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6511 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6512 : }
6513 : }
6514 : }
6515 : {
6516 : /* %typemap(out) OGRErr */
6517 0 : if ( result != 0 && bUseExceptions) {
6518 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6519 0 : SWIG_fail;
6520 : }
6521 : }
6522 : {
6523 : /* %typemap(ret) OGRErr */
6524 0 : if (resultobj == Py_None ) {
6525 0 : Py_DECREF(resultobj);
6526 0 : resultobj = 0;
6527 : }
6528 0 : if (resultobj == 0) {
6529 0 : resultobj = PyInt_FromLong( result );
6530 : }
6531 : }
6532 0 : return resultobj;
6533 : fail:
6534 0 : return NULL;
6535 : }
6536 :
6537 :
6538 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetEckertIV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 0 : PyObject *resultobj = 0;
6540 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6541 : double arg2 ;
6542 : double arg3 ;
6543 : double arg4 ;
6544 0 : void *argp1 = 0 ;
6545 0 : int res1 = 0 ;
6546 : double val2 ;
6547 0 : int ecode2 = 0 ;
6548 : double val3 ;
6549 0 : int ecode3 = 0 ;
6550 : double val4 ;
6551 0 : int ecode4 = 0 ;
6552 0 : PyObject * obj0 = 0 ;
6553 0 : PyObject * obj1 = 0 ;
6554 0 : PyObject * obj2 = 0 ;
6555 0 : PyObject * obj3 = 0 ;
6556 : char * kwnames[] = {
6557 : (char *) "self",(char *) "cm",(char *) "fe",(char *) "fn", NULL
6558 0 : };
6559 : OGRErr result;
6560 :
6561 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetEckertIV",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6562 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6563 0 : if (!SWIG_IsOK(res1)) {
6564 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetEckertIV" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6565 : }
6566 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6567 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6568 0 : if (!SWIG_IsOK(ecode2)) {
6569 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetEckertIV" "', argument " "2"" of type '" "double""'");
6570 : }
6571 0 : arg2 = static_cast< double >(val2);
6572 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6573 0 : if (!SWIG_IsOK(ecode3)) {
6574 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetEckertIV" "', argument " "3"" of type '" "double""'");
6575 : }
6576 0 : arg3 = static_cast< double >(val3);
6577 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6578 0 : if (!SWIG_IsOK(ecode4)) {
6579 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetEckertIV" "', argument " "4"" of type '" "double""'");
6580 : }
6581 0 : arg4 = static_cast< double >(val4);
6582 : {
6583 0 : if ( bUseExceptions ) {
6584 0 : CPLErrorReset();
6585 : }
6586 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetEckertIV(arg1,arg2,arg3,arg4);
6587 0 : if ( bUseExceptions ) {
6588 0 : CPLErr eclass = CPLGetLastErrorType();
6589 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6590 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6591 : }
6592 : }
6593 : }
6594 : {
6595 : /* %typemap(out) OGRErr */
6596 0 : if ( result != 0 && bUseExceptions) {
6597 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6598 0 : SWIG_fail;
6599 : }
6600 : }
6601 : {
6602 : /* %typemap(ret) OGRErr */
6603 0 : if (resultobj == Py_None ) {
6604 0 : Py_DECREF(resultobj);
6605 0 : resultobj = 0;
6606 : }
6607 0 : if (resultobj == 0) {
6608 0 : resultobj = PyInt_FromLong( result );
6609 : }
6610 : }
6611 0 : return resultobj;
6612 : fail:
6613 0 : return NULL;
6614 : }
6615 :
6616 :
6617 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetEckertVI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6618 0 : PyObject *resultobj = 0;
6619 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6620 : double arg2 ;
6621 : double arg3 ;
6622 : double arg4 ;
6623 0 : void *argp1 = 0 ;
6624 0 : int res1 = 0 ;
6625 : double val2 ;
6626 0 : int ecode2 = 0 ;
6627 : double val3 ;
6628 0 : int ecode3 = 0 ;
6629 : double val4 ;
6630 0 : int ecode4 = 0 ;
6631 0 : PyObject * obj0 = 0 ;
6632 0 : PyObject * obj1 = 0 ;
6633 0 : PyObject * obj2 = 0 ;
6634 0 : PyObject * obj3 = 0 ;
6635 : char * kwnames[] = {
6636 : (char *) "self",(char *) "cm",(char *) "fe",(char *) "fn", NULL
6637 0 : };
6638 : OGRErr result;
6639 :
6640 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetEckertVI",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6641 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6642 0 : if (!SWIG_IsOK(res1)) {
6643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetEckertVI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6644 : }
6645 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6646 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6647 0 : if (!SWIG_IsOK(ecode2)) {
6648 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetEckertVI" "', argument " "2"" of type '" "double""'");
6649 : }
6650 0 : arg2 = static_cast< double >(val2);
6651 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6652 0 : if (!SWIG_IsOK(ecode3)) {
6653 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetEckertVI" "', argument " "3"" of type '" "double""'");
6654 : }
6655 0 : arg3 = static_cast< double >(val3);
6656 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6657 0 : if (!SWIG_IsOK(ecode4)) {
6658 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetEckertVI" "', argument " "4"" of type '" "double""'");
6659 : }
6660 0 : arg4 = static_cast< double >(val4);
6661 : {
6662 0 : if ( bUseExceptions ) {
6663 0 : CPLErrorReset();
6664 : }
6665 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetEckertVI(arg1,arg2,arg3,arg4);
6666 0 : if ( bUseExceptions ) {
6667 0 : CPLErr eclass = CPLGetLastErrorType();
6668 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6669 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6670 : }
6671 : }
6672 : }
6673 : {
6674 : /* %typemap(out) OGRErr */
6675 0 : if ( result != 0 && bUseExceptions) {
6676 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6677 0 : SWIG_fail;
6678 : }
6679 : }
6680 : {
6681 : /* %typemap(ret) OGRErr */
6682 0 : if (resultobj == Py_None ) {
6683 0 : Py_DECREF(resultobj);
6684 0 : resultobj = 0;
6685 : }
6686 0 : if (resultobj == 0) {
6687 0 : resultobj = PyInt_FromLong( result );
6688 : }
6689 : }
6690 0 : return resultobj;
6691 : fail:
6692 0 : return NULL;
6693 : }
6694 :
6695 :
6696 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetEquirectangular(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6697 0 : PyObject *resultobj = 0;
6698 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6699 : double arg2 ;
6700 : double arg3 ;
6701 : double arg4 ;
6702 : double arg5 ;
6703 0 : void *argp1 = 0 ;
6704 0 : int res1 = 0 ;
6705 : double val2 ;
6706 0 : int ecode2 = 0 ;
6707 : double val3 ;
6708 0 : int ecode3 = 0 ;
6709 : double val4 ;
6710 0 : int ecode4 = 0 ;
6711 : double val5 ;
6712 0 : int ecode5 = 0 ;
6713 0 : PyObject * obj0 = 0 ;
6714 0 : PyObject * obj1 = 0 ;
6715 0 : PyObject * obj2 = 0 ;
6716 0 : PyObject * obj3 = 0 ;
6717 0 : PyObject * obj4 = 0 ;
6718 : char * kwnames[] = {
6719 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
6720 0 : };
6721 : OGRErr result;
6722 :
6723 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetEquirectangular",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6724 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6725 0 : if (!SWIG_IsOK(res1)) {
6726 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetEquirectangular" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6727 : }
6728 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6729 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6730 0 : if (!SWIG_IsOK(ecode2)) {
6731 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetEquirectangular" "', argument " "2"" of type '" "double""'");
6732 : }
6733 0 : arg2 = static_cast< double >(val2);
6734 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6735 0 : if (!SWIG_IsOK(ecode3)) {
6736 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetEquirectangular" "', argument " "3"" of type '" "double""'");
6737 : }
6738 0 : arg3 = static_cast< double >(val3);
6739 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6740 0 : if (!SWIG_IsOK(ecode4)) {
6741 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetEquirectangular" "', argument " "4"" of type '" "double""'");
6742 : }
6743 0 : arg4 = static_cast< double >(val4);
6744 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6745 0 : if (!SWIG_IsOK(ecode5)) {
6746 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetEquirectangular" "', argument " "5"" of type '" "double""'");
6747 : }
6748 0 : arg5 = static_cast< double >(val5);
6749 : {
6750 0 : if ( bUseExceptions ) {
6751 0 : CPLErrorReset();
6752 : }
6753 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetEquirectangular(arg1,arg2,arg3,arg4,arg5);
6754 0 : if ( bUseExceptions ) {
6755 0 : CPLErr eclass = CPLGetLastErrorType();
6756 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6757 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6758 : }
6759 : }
6760 : }
6761 : {
6762 : /* %typemap(out) OGRErr */
6763 0 : if ( result != 0 && bUseExceptions) {
6764 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6765 0 : SWIG_fail;
6766 : }
6767 : }
6768 : {
6769 : /* %typemap(ret) OGRErr */
6770 0 : if (resultobj == Py_None ) {
6771 0 : Py_DECREF(resultobj);
6772 0 : resultobj = 0;
6773 : }
6774 0 : if (resultobj == 0) {
6775 0 : resultobj = PyInt_FromLong( result );
6776 : }
6777 : }
6778 0 : return resultobj;
6779 : fail:
6780 0 : return NULL;
6781 : }
6782 :
6783 :
6784 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetEquirectangular2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6785 0 : PyObject *resultobj = 0;
6786 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6787 : double arg2 ;
6788 : double arg3 ;
6789 : double arg4 ;
6790 : double arg5 ;
6791 : double arg6 ;
6792 0 : void *argp1 = 0 ;
6793 0 : int res1 = 0 ;
6794 : double val2 ;
6795 0 : int ecode2 = 0 ;
6796 : double val3 ;
6797 0 : int ecode3 = 0 ;
6798 : double val4 ;
6799 0 : int ecode4 = 0 ;
6800 : double val5 ;
6801 0 : int ecode5 = 0 ;
6802 : double val6 ;
6803 0 : int ecode6 = 0 ;
6804 0 : PyObject * obj0 = 0 ;
6805 0 : PyObject * obj1 = 0 ;
6806 0 : PyObject * obj2 = 0 ;
6807 0 : PyObject * obj3 = 0 ;
6808 0 : PyObject * obj4 = 0 ;
6809 0 : PyObject * obj5 = 0 ;
6810 : char * kwnames[] = {
6811 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "pseudostdparallellat",(char *) "fe",(char *) "fn", NULL
6812 0 : };
6813 : OGRErr result;
6814 :
6815 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetEquirectangular2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6816 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6817 0 : if (!SWIG_IsOK(res1)) {
6818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6819 : }
6820 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6821 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6822 0 : if (!SWIG_IsOK(ecode2)) {
6823 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "2"" of type '" "double""'");
6824 : }
6825 0 : arg2 = static_cast< double >(val2);
6826 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6827 0 : if (!SWIG_IsOK(ecode3)) {
6828 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "3"" of type '" "double""'");
6829 : }
6830 0 : arg3 = static_cast< double >(val3);
6831 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6832 0 : if (!SWIG_IsOK(ecode4)) {
6833 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "4"" of type '" "double""'");
6834 : }
6835 0 : arg4 = static_cast< double >(val4);
6836 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6837 0 : if (!SWIG_IsOK(ecode5)) {
6838 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "5"" of type '" "double""'");
6839 : }
6840 0 : arg5 = static_cast< double >(val5);
6841 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
6842 0 : if (!SWIG_IsOK(ecode6)) {
6843 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetEquirectangular2" "', argument " "6"" of type '" "double""'");
6844 : }
6845 0 : arg6 = static_cast< double >(val6);
6846 : {
6847 0 : if ( bUseExceptions ) {
6848 0 : CPLErrorReset();
6849 : }
6850 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetEquirectangular2(arg1,arg2,arg3,arg4,arg5,arg6);
6851 0 : if ( bUseExceptions ) {
6852 0 : CPLErr eclass = CPLGetLastErrorType();
6853 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6854 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6855 : }
6856 : }
6857 : }
6858 : {
6859 : /* %typemap(out) OGRErr */
6860 0 : if ( result != 0 && bUseExceptions) {
6861 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6862 0 : SWIG_fail;
6863 : }
6864 : }
6865 : {
6866 : /* %typemap(ret) OGRErr */
6867 0 : if (resultobj == Py_None ) {
6868 0 : Py_DECREF(resultobj);
6869 0 : resultobj = 0;
6870 : }
6871 0 : if (resultobj == 0) {
6872 0 : resultobj = PyInt_FromLong( result );
6873 : }
6874 : }
6875 0 : return resultobj;
6876 : fail:
6877 0 : return NULL;
6878 : }
6879 :
6880 :
6881 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGaussSchreiberTMercator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6882 0 : PyObject *resultobj = 0;
6883 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6884 : double arg2 ;
6885 : double arg3 ;
6886 : double arg4 ;
6887 : double arg5 ;
6888 : double arg6 ;
6889 0 : void *argp1 = 0 ;
6890 0 : int res1 = 0 ;
6891 : double val2 ;
6892 0 : int ecode2 = 0 ;
6893 : double val3 ;
6894 0 : int ecode3 = 0 ;
6895 : double val4 ;
6896 0 : int ecode4 = 0 ;
6897 : double val5 ;
6898 0 : int ecode5 = 0 ;
6899 : double val6 ;
6900 0 : int ecode6 = 0 ;
6901 0 : PyObject * obj0 = 0 ;
6902 0 : PyObject * obj1 = 0 ;
6903 0 : PyObject * obj2 = 0 ;
6904 0 : PyObject * obj3 = 0 ;
6905 0 : PyObject * obj4 = 0 ;
6906 0 : PyObject * obj5 = 0 ;
6907 : char * kwnames[] = {
6908 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "sc",(char *) "fe",(char *) "fn", NULL
6909 0 : };
6910 : OGRErr result;
6911 :
6912 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetGaussSchreiberTMercator",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6913 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
6914 0 : if (!SWIG_IsOK(res1)) {
6915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
6916 : }
6917 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
6918 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
6919 0 : if (!SWIG_IsOK(ecode2)) {
6920 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "2"" of type '" "double""'");
6921 : }
6922 0 : arg2 = static_cast< double >(val2);
6923 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
6924 0 : if (!SWIG_IsOK(ecode3)) {
6925 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "3"" of type '" "double""'");
6926 : }
6927 0 : arg3 = static_cast< double >(val3);
6928 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
6929 0 : if (!SWIG_IsOK(ecode4)) {
6930 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "4"" of type '" "double""'");
6931 : }
6932 0 : arg4 = static_cast< double >(val4);
6933 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
6934 0 : if (!SWIG_IsOK(ecode5)) {
6935 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "5"" of type '" "double""'");
6936 : }
6937 0 : arg5 = static_cast< double >(val5);
6938 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
6939 0 : if (!SWIG_IsOK(ecode6)) {
6940 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetGaussSchreiberTMercator" "', argument " "6"" of type '" "double""'");
6941 : }
6942 0 : arg6 = static_cast< double >(val6);
6943 : {
6944 0 : if ( bUseExceptions ) {
6945 0 : CPLErrorReset();
6946 : }
6947 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetGaussSchreiberTMercator(arg1,arg2,arg3,arg4,arg5,arg6);
6948 0 : if ( bUseExceptions ) {
6949 0 : CPLErr eclass = CPLGetLastErrorType();
6950 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6951 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6952 : }
6953 : }
6954 : }
6955 : {
6956 : /* %typemap(out) OGRErr */
6957 0 : if ( result != 0 && bUseExceptions) {
6958 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
6959 0 : SWIG_fail;
6960 : }
6961 : }
6962 : {
6963 : /* %typemap(ret) OGRErr */
6964 0 : if (resultobj == Py_None ) {
6965 0 : Py_DECREF(resultobj);
6966 0 : resultobj = 0;
6967 : }
6968 0 : if (resultobj == 0) {
6969 0 : resultobj = PyInt_FromLong( result );
6970 : }
6971 : }
6972 0 : return resultobj;
6973 : fail:
6974 0 : return NULL;
6975 : }
6976 :
6977 :
6978 1 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 1 : PyObject *resultobj = 0;
6980 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
6981 : double arg2 ;
6982 : double arg3 ;
6983 : double arg4 ;
6984 1 : void *argp1 = 0 ;
6985 1 : int res1 = 0 ;
6986 : double val2 ;
6987 1 : int ecode2 = 0 ;
6988 : double val3 ;
6989 1 : int ecode3 = 0 ;
6990 : double val4 ;
6991 1 : int ecode4 = 0 ;
6992 1 : PyObject * obj0 = 0 ;
6993 1 : PyObject * obj1 = 0 ;
6994 1 : PyObject * obj2 = 0 ;
6995 1 : PyObject * obj3 = 0 ;
6996 : char * kwnames[] = {
6997 : (char *) "self",(char *) "cm",(char *) "fe",(char *) "fn", NULL
6998 1 : };
6999 : OGRErr result;
7000 :
7001 1 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetGS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7002 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7003 1 : if (!SWIG_IsOK(res1)) {
7004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7005 : }
7006 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7007 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7008 1 : if (!SWIG_IsOK(ecode2)) {
7009 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetGS" "', argument " "2"" of type '" "double""'");
7010 : }
7011 1 : arg2 = static_cast< double >(val2);
7012 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7013 1 : if (!SWIG_IsOK(ecode3)) {
7014 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetGS" "', argument " "3"" of type '" "double""'");
7015 : }
7016 1 : arg3 = static_cast< double >(val3);
7017 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7018 1 : if (!SWIG_IsOK(ecode4)) {
7019 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetGS" "', argument " "4"" of type '" "double""'");
7020 : }
7021 1 : arg4 = static_cast< double >(val4);
7022 : {
7023 1 : if ( bUseExceptions ) {
7024 0 : CPLErrorReset();
7025 : }
7026 1 : result = (OGRErr)OSRSpatialReferenceShadow_SetGS(arg1,arg2,arg3,arg4);
7027 1 : if ( bUseExceptions ) {
7028 0 : CPLErr eclass = CPLGetLastErrorType();
7029 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7030 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7031 : }
7032 : }
7033 : }
7034 : {
7035 : /* %typemap(out) OGRErr */
7036 1 : if ( result != 0 && bUseExceptions) {
7037 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7038 0 : SWIG_fail;
7039 : }
7040 : }
7041 : {
7042 : /* %typemap(ret) OGRErr */
7043 1 : if (resultobj == Py_None ) {
7044 0 : Py_DECREF(resultobj);
7045 0 : resultobj = 0;
7046 : }
7047 1 : if (resultobj == 0) {
7048 1 : resultobj = PyInt_FromLong( result );
7049 : }
7050 : }
7051 1 : return resultobj;
7052 : fail:
7053 0 : return NULL;
7054 : }
7055 :
7056 :
7057 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 0 : PyObject *resultobj = 0;
7059 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7060 : double arg2 ;
7061 : double arg3 ;
7062 : double arg4 ;
7063 0 : void *argp1 = 0 ;
7064 0 : int res1 = 0 ;
7065 : double val2 ;
7066 0 : int ecode2 = 0 ;
7067 : double val3 ;
7068 0 : int ecode3 = 0 ;
7069 : double val4 ;
7070 0 : int ecode4 = 0 ;
7071 0 : PyObject * obj0 = 0 ;
7072 0 : PyObject * obj1 = 0 ;
7073 0 : PyObject * obj2 = 0 ;
7074 0 : PyObject * obj3 = 0 ;
7075 : char * kwnames[] = {
7076 : (char *) "self",(char *) "cm",(char *) "fe",(char *) "fn", NULL
7077 0 : };
7078 : OGRErr result;
7079 :
7080 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetGH",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7081 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7082 0 : if (!SWIG_IsOK(res1)) {
7083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGH" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7084 : }
7085 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7086 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7087 0 : if (!SWIG_IsOK(ecode2)) {
7088 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetGH" "', argument " "2"" of type '" "double""'");
7089 : }
7090 0 : arg2 = static_cast< double >(val2);
7091 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7092 0 : if (!SWIG_IsOK(ecode3)) {
7093 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetGH" "', argument " "3"" of type '" "double""'");
7094 : }
7095 0 : arg3 = static_cast< double >(val3);
7096 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7097 0 : if (!SWIG_IsOK(ecode4)) {
7098 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetGH" "', argument " "4"" of type '" "double""'");
7099 : }
7100 0 : arg4 = static_cast< double >(val4);
7101 : {
7102 0 : if ( bUseExceptions ) {
7103 0 : CPLErrorReset();
7104 : }
7105 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetGH(arg1,arg2,arg3,arg4);
7106 0 : if ( bUseExceptions ) {
7107 0 : CPLErr eclass = CPLGetLastErrorType();
7108 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7109 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7110 : }
7111 : }
7112 : }
7113 : {
7114 : /* %typemap(out) OGRErr */
7115 0 : if ( result != 0 && bUseExceptions) {
7116 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7117 0 : SWIG_fail;
7118 : }
7119 : }
7120 : {
7121 : /* %typemap(ret) OGRErr */
7122 0 : if (resultobj == Py_None ) {
7123 0 : Py_DECREF(resultobj);
7124 0 : resultobj = 0;
7125 : }
7126 0 : if (resultobj == 0) {
7127 0 : resultobj = PyInt_FromLong( result );
7128 : }
7129 : }
7130 0 : return resultobj;
7131 : fail:
7132 0 : return NULL;
7133 : }
7134 :
7135 :
7136 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetIGH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 0 : PyObject *resultobj = 0;
7138 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7139 0 : void *argp1 = 0 ;
7140 0 : int res1 = 0 ;
7141 0 : PyObject * obj0 = 0 ;
7142 : OGRErr result;
7143 :
7144 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_SetIGH",&obj0)) SWIG_fail;
7145 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7146 0 : if (!SWIG_IsOK(res1)) {
7147 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetIGH" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7148 : }
7149 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7150 : {
7151 0 : if ( bUseExceptions ) {
7152 0 : CPLErrorReset();
7153 : }
7154 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetIGH(arg1);
7155 0 : if ( bUseExceptions ) {
7156 0 : CPLErr eclass = CPLGetLastErrorType();
7157 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7158 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7159 : }
7160 : }
7161 : }
7162 : {
7163 : /* %typemap(out) OGRErr */
7164 0 : if ( result != 0 && bUseExceptions) {
7165 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7166 0 : SWIG_fail;
7167 : }
7168 : }
7169 : {
7170 : /* %typemap(ret) OGRErr */
7171 0 : if (resultobj == Py_None ) {
7172 0 : Py_DECREF(resultobj);
7173 0 : resultobj = 0;
7174 : }
7175 0 : if (resultobj == 0) {
7176 0 : resultobj = PyInt_FromLong( result );
7177 : }
7178 : }
7179 0 : return resultobj;
7180 : fail:
7181 0 : return NULL;
7182 : }
7183 :
7184 :
7185 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGEOS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7186 0 : PyObject *resultobj = 0;
7187 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7188 : double arg2 ;
7189 : double arg3 ;
7190 : double arg4 ;
7191 : double arg5 ;
7192 0 : void *argp1 = 0 ;
7193 0 : int res1 = 0 ;
7194 : double val2 ;
7195 0 : int ecode2 = 0 ;
7196 : double val3 ;
7197 0 : int ecode3 = 0 ;
7198 : double val4 ;
7199 0 : int ecode4 = 0 ;
7200 : double val5 ;
7201 0 : int ecode5 = 0 ;
7202 0 : PyObject * obj0 = 0 ;
7203 0 : PyObject * obj1 = 0 ;
7204 0 : PyObject * obj2 = 0 ;
7205 0 : PyObject * obj3 = 0 ;
7206 0 : PyObject * obj4 = 0 ;
7207 : char * kwnames[] = {
7208 : (char *) "self",(char *) "cm",(char *) "satelliteheight",(char *) "fe",(char *) "fn", NULL
7209 0 : };
7210 : OGRErr result;
7211 :
7212 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetGEOS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7213 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7214 0 : if (!SWIG_IsOK(res1)) {
7215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGEOS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7216 : }
7217 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7218 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7219 0 : if (!SWIG_IsOK(ecode2)) {
7220 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetGEOS" "', argument " "2"" of type '" "double""'");
7221 : }
7222 0 : arg2 = static_cast< double >(val2);
7223 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7224 0 : if (!SWIG_IsOK(ecode3)) {
7225 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetGEOS" "', argument " "3"" of type '" "double""'");
7226 : }
7227 0 : arg3 = static_cast< double >(val3);
7228 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7229 0 : if (!SWIG_IsOK(ecode4)) {
7230 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetGEOS" "', argument " "4"" of type '" "double""'");
7231 : }
7232 0 : arg4 = static_cast< double >(val4);
7233 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7234 0 : if (!SWIG_IsOK(ecode5)) {
7235 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetGEOS" "', argument " "5"" of type '" "double""'");
7236 : }
7237 0 : arg5 = static_cast< double >(val5);
7238 : {
7239 0 : if ( bUseExceptions ) {
7240 0 : CPLErrorReset();
7241 : }
7242 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetGEOS(arg1,arg2,arg3,arg4,arg5);
7243 0 : if ( bUseExceptions ) {
7244 0 : CPLErr eclass = CPLGetLastErrorType();
7245 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7246 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7247 : }
7248 : }
7249 : }
7250 : {
7251 : /* %typemap(out) OGRErr */
7252 0 : if ( result != 0 && bUseExceptions) {
7253 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7254 0 : SWIG_fail;
7255 : }
7256 : }
7257 : {
7258 : /* %typemap(ret) OGRErr */
7259 0 : if (resultobj == Py_None ) {
7260 0 : Py_DECREF(resultobj);
7261 0 : resultobj = 0;
7262 : }
7263 0 : if (resultobj == 0) {
7264 0 : resultobj = PyInt_FromLong( result );
7265 : }
7266 : }
7267 0 : return resultobj;
7268 : fail:
7269 0 : return NULL;
7270 : }
7271 :
7272 :
7273 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGnomonic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 0 : PyObject *resultobj = 0;
7275 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7276 : double arg2 ;
7277 : double arg3 ;
7278 : double arg4 ;
7279 : double arg5 ;
7280 0 : void *argp1 = 0 ;
7281 0 : int res1 = 0 ;
7282 : double val2 ;
7283 0 : int ecode2 = 0 ;
7284 : double val3 ;
7285 0 : int ecode3 = 0 ;
7286 : double val4 ;
7287 0 : int ecode4 = 0 ;
7288 : double val5 ;
7289 0 : int ecode5 = 0 ;
7290 0 : PyObject * obj0 = 0 ;
7291 0 : PyObject * obj1 = 0 ;
7292 0 : PyObject * obj2 = 0 ;
7293 0 : PyObject * obj3 = 0 ;
7294 0 : PyObject * obj4 = 0 ;
7295 : char * kwnames[] = {
7296 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
7297 0 : };
7298 : OGRErr result;
7299 :
7300 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetGnomonic",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7301 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7302 0 : if (!SWIG_IsOK(res1)) {
7303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGnomonic" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7304 : }
7305 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7306 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7307 0 : if (!SWIG_IsOK(ecode2)) {
7308 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetGnomonic" "', argument " "2"" of type '" "double""'");
7309 : }
7310 0 : arg2 = static_cast< double >(val2);
7311 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7312 0 : if (!SWIG_IsOK(ecode3)) {
7313 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetGnomonic" "', argument " "3"" of type '" "double""'");
7314 : }
7315 0 : arg3 = static_cast< double >(val3);
7316 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7317 0 : if (!SWIG_IsOK(ecode4)) {
7318 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetGnomonic" "', argument " "4"" of type '" "double""'");
7319 : }
7320 0 : arg4 = static_cast< double >(val4);
7321 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7322 0 : if (!SWIG_IsOK(ecode5)) {
7323 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetGnomonic" "', argument " "5"" of type '" "double""'");
7324 : }
7325 0 : arg5 = static_cast< double >(val5);
7326 : {
7327 0 : if ( bUseExceptions ) {
7328 0 : CPLErrorReset();
7329 : }
7330 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetGnomonic(arg1,arg2,arg3,arg4,arg5);
7331 0 : if ( bUseExceptions ) {
7332 0 : CPLErr eclass = CPLGetLastErrorType();
7333 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7334 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7335 : }
7336 : }
7337 : }
7338 : {
7339 : /* %typemap(out) OGRErr */
7340 0 : if ( result != 0 && bUseExceptions) {
7341 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7342 0 : SWIG_fail;
7343 : }
7344 : }
7345 : {
7346 : /* %typemap(ret) OGRErr */
7347 0 : if (resultobj == Py_None ) {
7348 0 : Py_DECREF(resultobj);
7349 0 : resultobj = 0;
7350 : }
7351 0 : if (resultobj == 0) {
7352 0 : resultobj = PyInt_FromLong( result );
7353 : }
7354 : }
7355 0 : return resultobj;
7356 : fail:
7357 0 : return NULL;
7358 : }
7359 :
7360 :
7361 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetHOM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7362 0 : PyObject *resultobj = 0;
7363 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7364 : double arg2 ;
7365 : double arg3 ;
7366 : double arg4 ;
7367 : double arg5 ;
7368 : double arg6 ;
7369 : double arg7 ;
7370 : double arg8 ;
7371 0 : void *argp1 = 0 ;
7372 0 : int res1 = 0 ;
7373 : double val2 ;
7374 0 : int ecode2 = 0 ;
7375 : double val3 ;
7376 0 : int ecode3 = 0 ;
7377 : double val4 ;
7378 0 : int ecode4 = 0 ;
7379 : double val5 ;
7380 0 : int ecode5 = 0 ;
7381 : double val6 ;
7382 0 : int ecode6 = 0 ;
7383 : double val7 ;
7384 0 : int ecode7 = 0 ;
7385 : double val8 ;
7386 0 : int ecode8 = 0 ;
7387 0 : PyObject * obj0 = 0 ;
7388 0 : PyObject * obj1 = 0 ;
7389 0 : PyObject * obj2 = 0 ;
7390 0 : PyObject * obj3 = 0 ;
7391 0 : PyObject * obj4 = 0 ;
7392 0 : PyObject * obj5 = 0 ;
7393 0 : PyObject * obj6 = 0 ;
7394 0 : PyObject * obj7 = 0 ;
7395 : char * kwnames[] = {
7396 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "azimuth",(char *) "recttoskew",(char *) "scale",(char *) "fe",(char *) "fn", NULL
7397 0 : };
7398 : OGRErr result;
7399 :
7400 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:SpatialReference_SetHOM",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
7401 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7402 0 : if (!SWIG_IsOK(res1)) {
7403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetHOM" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7404 : }
7405 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7406 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7407 0 : if (!SWIG_IsOK(ecode2)) {
7408 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetHOM" "', argument " "2"" of type '" "double""'");
7409 : }
7410 0 : arg2 = static_cast< double >(val2);
7411 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7412 0 : if (!SWIG_IsOK(ecode3)) {
7413 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetHOM" "', argument " "3"" of type '" "double""'");
7414 : }
7415 0 : arg3 = static_cast< double >(val3);
7416 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7417 0 : if (!SWIG_IsOK(ecode4)) {
7418 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetHOM" "', argument " "4"" of type '" "double""'");
7419 : }
7420 0 : arg4 = static_cast< double >(val4);
7421 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7422 0 : if (!SWIG_IsOK(ecode5)) {
7423 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetHOM" "', argument " "5"" of type '" "double""'");
7424 : }
7425 0 : arg5 = static_cast< double >(val5);
7426 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
7427 0 : if (!SWIG_IsOK(ecode6)) {
7428 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetHOM" "', argument " "6"" of type '" "double""'");
7429 : }
7430 0 : arg6 = static_cast< double >(val6);
7431 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
7432 0 : if (!SWIG_IsOK(ecode7)) {
7433 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetHOM" "', argument " "7"" of type '" "double""'");
7434 : }
7435 0 : arg7 = static_cast< double >(val7);
7436 0 : ecode8 = SWIG_AsVal_double(obj7, &val8);
7437 0 : if (!SWIG_IsOK(ecode8)) {
7438 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpatialReference_SetHOM" "', argument " "8"" of type '" "double""'");
7439 : }
7440 0 : arg8 = static_cast< double >(val8);
7441 : {
7442 0 : if ( bUseExceptions ) {
7443 0 : CPLErrorReset();
7444 : }
7445 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetHOM(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
7446 0 : if ( bUseExceptions ) {
7447 0 : CPLErr eclass = CPLGetLastErrorType();
7448 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7449 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7450 : }
7451 : }
7452 : }
7453 : {
7454 : /* %typemap(out) OGRErr */
7455 0 : if ( result != 0 && bUseExceptions) {
7456 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7457 0 : SWIG_fail;
7458 : }
7459 : }
7460 : {
7461 : /* %typemap(ret) OGRErr */
7462 0 : if (resultobj == Py_None ) {
7463 0 : Py_DECREF(resultobj);
7464 0 : resultobj = 0;
7465 : }
7466 0 : if (resultobj == 0) {
7467 0 : resultobj = PyInt_FromLong( result );
7468 : }
7469 : }
7470 0 : return resultobj;
7471 : fail:
7472 0 : return NULL;
7473 : }
7474 :
7475 :
7476 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetHOM2PNO(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7477 0 : PyObject *resultobj = 0;
7478 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7479 : double arg2 ;
7480 : double arg3 ;
7481 : double arg4 ;
7482 : double arg5 ;
7483 : double arg6 ;
7484 : double arg7 ;
7485 : double arg8 ;
7486 : double arg9 ;
7487 0 : void *argp1 = 0 ;
7488 0 : int res1 = 0 ;
7489 : double val2 ;
7490 0 : int ecode2 = 0 ;
7491 : double val3 ;
7492 0 : int ecode3 = 0 ;
7493 : double val4 ;
7494 0 : int ecode4 = 0 ;
7495 : double val5 ;
7496 0 : int ecode5 = 0 ;
7497 : double val6 ;
7498 0 : int ecode6 = 0 ;
7499 : double val7 ;
7500 0 : int ecode7 = 0 ;
7501 : double val8 ;
7502 0 : int ecode8 = 0 ;
7503 : double val9 ;
7504 0 : int ecode9 = 0 ;
7505 0 : PyObject * obj0 = 0 ;
7506 0 : PyObject * obj1 = 0 ;
7507 0 : PyObject * obj2 = 0 ;
7508 0 : PyObject * obj3 = 0 ;
7509 0 : PyObject * obj4 = 0 ;
7510 0 : PyObject * obj5 = 0 ;
7511 0 : PyObject * obj6 = 0 ;
7512 0 : PyObject * obj7 = 0 ;
7513 0 : PyObject * obj8 = 0 ;
7514 : char * kwnames[] = {
7515 : (char *) "self",(char *) "clat",(char *) "dfLat1",(char *) "dfLong1",(char *) "dfLat2",(char *) "dfLong2",(char *) "scale",(char *) "fe",(char *) "fn", NULL
7516 0 : };
7517 : OGRErr result;
7518 :
7519 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOOO:SpatialReference_SetHOM2PNO",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
7520 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7521 0 : if (!SWIG_IsOK(res1)) {
7522 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7523 : }
7524 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7525 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7526 0 : if (!SWIG_IsOK(ecode2)) {
7527 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "2"" of type '" "double""'");
7528 : }
7529 0 : arg2 = static_cast< double >(val2);
7530 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7531 0 : if (!SWIG_IsOK(ecode3)) {
7532 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "3"" of type '" "double""'");
7533 : }
7534 0 : arg3 = static_cast< double >(val3);
7535 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7536 0 : if (!SWIG_IsOK(ecode4)) {
7537 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "4"" of type '" "double""'");
7538 : }
7539 0 : arg4 = static_cast< double >(val4);
7540 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7541 0 : if (!SWIG_IsOK(ecode5)) {
7542 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "5"" of type '" "double""'");
7543 : }
7544 0 : arg5 = static_cast< double >(val5);
7545 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
7546 0 : if (!SWIG_IsOK(ecode6)) {
7547 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "6"" of type '" "double""'");
7548 : }
7549 0 : arg6 = static_cast< double >(val6);
7550 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
7551 0 : if (!SWIG_IsOK(ecode7)) {
7552 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "7"" of type '" "double""'");
7553 : }
7554 0 : arg7 = static_cast< double >(val7);
7555 0 : ecode8 = SWIG_AsVal_double(obj7, &val8);
7556 0 : if (!SWIG_IsOK(ecode8)) {
7557 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "8"" of type '" "double""'");
7558 : }
7559 0 : arg8 = static_cast< double >(val8);
7560 0 : ecode9 = SWIG_AsVal_double(obj8, &val9);
7561 0 : if (!SWIG_IsOK(ecode9)) {
7562 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SpatialReference_SetHOM2PNO" "', argument " "9"" of type '" "double""'");
7563 : }
7564 0 : arg9 = static_cast< double >(val9);
7565 : {
7566 0 : if ( bUseExceptions ) {
7567 0 : CPLErrorReset();
7568 : }
7569 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetHOM2PNO(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
7570 0 : if ( bUseExceptions ) {
7571 0 : CPLErr eclass = CPLGetLastErrorType();
7572 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7573 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7574 : }
7575 : }
7576 : }
7577 : {
7578 : /* %typemap(out) OGRErr */
7579 0 : if ( result != 0 && bUseExceptions) {
7580 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7581 0 : SWIG_fail;
7582 : }
7583 : }
7584 : {
7585 : /* %typemap(ret) OGRErr */
7586 0 : if (resultobj == Py_None ) {
7587 0 : Py_DECREF(resultobj);
7588 0 : resultobj = 0;
7589 : }
7590 0 : if (resultobj == 0) {
7591 0 : resultobj = PyInt_FromLong( result );
7592 : }
7593 : }
7594 0 : return resultobj;
7595 : fail:
7596 0 : return NULL;
7597 : }
7598 :
7599 :
7600 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetKrovak(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7601 0 : PyObject *resultobj = 0;
7602 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7603 : double arg2 ;
7604 : double arg3 ;
7605 : double arg4 ;
7606 : double arg5 ;
7607 : double arg6 ;
7608 : double arg7 ;
7609 : double arg8 ;
7610 0 : void *argp1 = 0 ;
7611 0 : int res1 = 0 ;
7612 : double val2 ;
7613 0 : int ecode2 = 0 ;
7614 : double val3 ;
7615 0 : int ecode3 = 0 ;
7616 : double val4 ;
7617 0 : int ecode4 = 0 ;
7618 : double val5 ;
7619 0 : int ecode5 = 0 ;
7620 : double val6 ;
7621 0 : int ecode6 = 0 ;
7622 : double val7 ;
7623 0 : int ecode7 = 0 ;
7624 : double val8 ;
7625 0 : int ecode8 = 0 ;
7626 0 : PyObject * obj0 = 0 ;
7627 0 : PyObject * obj1 = 0 ;
7628 0 : PyObject * obj2 = 0 ;
7629 0 : PyObject * obj3 = 0 ;
7630 0 : PyObject * obj4 = 0 ;
7631 0 : PyObject * obj5 = 0 ;
7632 0 : PyObject * obj6 = 0 ;
7633 0 : PyObject * obj7 = 0 ;
7634 : char * kwnames[] = {
7635 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "azimuth",(char *) "pseudostdparallellat",(char *) "scale",(char *) "fe",(char *) "fn", NULL
7636 0 : };
7637 : OGRErr result;
7638 :
7639 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:SpatialReference_SetKrovak",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
7640 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7641 0 : if (!SWIG_IsOK(res1)) {
7642 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetKrovak" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7643 : }
7644 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7645 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7646 0 : if (!SWIG_IsOK(ecode2)) {
7647 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetKrovak" "', argument " "2"" of type '" "double""'");
7648 : }
7649 0 : arg2 = static_cast< double >(val2);
7650 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7651 0 : if (!SWIG_IsOK(ecode3)) {
7652 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetKrovak" "', argument " "3"" of type '" "double""'");
7653 : }
7654 0 : arg3 = static_cast< double >(val3);
7655 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7656 0 : if (!SWIG_IsOK(ecode4)) {
7657 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetKrovak" "', argument " "4"" of type '" "double""'");
7658 : }
7659 0 : arg4 = static_cast< double >(val4);
7660 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7661 0 : if (!SWIG_IsOK(ecode5)) {
7662 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetKrovak" "', argument " "5"" of type '" "double""'");
7663 : }
7664 0 : arg5 = static_cast< double >(val5);
7665 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
7666 0 : if (!SWIG_IsOK(ecode6)) {
7667 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetKrovak" "', argument " "6"" of type '" "double""'");
7668 : }
7669 0 : arg6 = static_cast< double >(val6);
7670 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
7671 0 : if (!SWIG_IsOK(ecode7)) {
7672 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetKrovak" "', argument " "7"" of type '" "double""'");
7673 : }
7674 0 : arg7 = static_cast< double >(val7);
7675 0 : ecode8 = SWIG_AsVal_double(obj7, &val8);
7676 0 : if (!SWIG_IsOK(ecode8)) {
7677 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpatialReference_SetKrovak" "', argument " "8"" of type '" "double""'");
7678 : }
7679 0 : arg8 = static_cast< double >(val8);
7680 : {
7681 0 : if ( bUseExceptions ) {
7682 0 : CPLErrorReset();
7683 : }
7684 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetKrovak(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
7685 0 : if ( bUseExceptions ) {
7686 0 : CPLErr eclass = CPLGetLastErrorType();
7687 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7688 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7689 : }
7690 : }
7691 : }
7692 : {
7693 : /* %typemap(out) OGRErr */
7694 0 : if ( result != 0 && bUseExceptions) {
7695 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7696 0 : SWIG_fail;
7697 : }
7698 : }
7699 : {
7700 : /* %typemap(ret) OGRErr */
7701 0 : if (resultobj == Py_None ) {
7702 0 : Py_DECREF(resultobj);
7703 0 : resultobj = 0;
7704 : }
7705 0 : if (resultobj == 0) {
7706 0 : resultobj = PyInt_FromLong( result );
7707 : }
7708 : }
7709 0 : return resultobj;
7710 : fail:
7711 0 : return NULL;
7712 : }
7713 :
7714 :
7715 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLAEA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7716 0 : PyObject *resultobj = 0;
7717 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7718 : double arg2 ;
7719 : double arg3 ;
7720 : double arg4 ;
7721 : double arg5 ;
7722 0 : void *argp1 = 0 ;
7723 0 : int res1 = 0 ;
7724 : double val2 ;
7725 0 : int ecode2 = 0 ;
7726 : double val3 ;
7727 0 : int ecode3 = 0 ;
7728 : double val4 ;
7729 0 : int ecode4 = 0 ;
7730 : double val5 ;
7731 0 : int ecode5 = 0 ;
7732 0 : PyObject * obj0 = 0 ;
7733 0 : PyObject * obj1 = 0 ;
7734 0 : PyObject * obj2 = 0 ;
7735 0 : PyObject * obj3 = 0 ;
7736 0 : PyObject * obj4 = 0 ;
7737 : char * kwnames[] = {
7738 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
7739 0 : };
7740 : OGRErr result;
7741 :
7742 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetLAEA",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7743 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7744 0 : if (!SWIG_IsOK(res1)) {
7745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLAEA" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7746 : }
7747 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7748 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7749 0 : if (!SWIG_IsOK(ecode2)) {
7750 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetLAEA" "', argument " "2"" of type '" "double""'");
7751 : }
7752 0 : arg2 = static_cast< double >(val2);
7753 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7754 0 : if (!SWIG_IsOK(ecode3)) {
7755 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLAEA" "', argument " "3"" of type '" "double""'");
7756 : }
7757 0 : arg3 = static_cast< double >(val3);
7758 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7759 0 : if (!SWIG_IsOK(ecode4)) {
7760 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetLAEA" "', argument " "4"" of type '" "double""'");
7761 : }
7762 0 : arg4 = static_cast< double >(val4);
7763 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7764 0 : if (!SWIG_IsOK(ecode5)) {
7765 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetLAEA" "', argument " "5"" of type '" "double""'");
7766 : }
7767 0 : arg5 = static_cast< double >(val5);
7768 : {
7769 0 : if ( bUseExceptions ) {
7770 0 : CPLErrorReset();
7771 : }
7772 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetLAEA(arg1,arg2,arg3,arg4,arg5);
7773 0 : if ( bUseExceptions ) {
7774 0 : CPLErr eclass = CPLGetLastErrorType();
7775 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7776 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7777 : }
7778 : }
7779 : }
7780 : {
7781 : /* %typemap(out) OGRErr */
7782 0 : if ( result != 0 && bUseExceptions) {
7783 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7784 0 : SWIG_fail;
7785 : }
7786 : }
7787 : {
7788 : /* %typemap(ret) OGRErr */
7789 0 : if (resultobj == Py_None ) {
7790 0 : Py_DECREF(resultobj);
7791 0 : resultobj = 0;
7792 : }
7793 0 : if (resultobj == 0) {
7794 0 : resultobj = PyInt_FromLong( result );
7795 : }
7796 : }
7797 0 : return resultobj;
7798 : fail:
7799 0 : return NULL;
7800 : }
7801 :
7802 :
7803 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLCC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7804 0 : PyObject *resultobj = 0;
7805 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7806 : double arg2 ;
7807 : double arg3 ;
7808 : double arg4 ;
7809 : double arg5 ;
7810 : double arg6 ;
7811 : double arg7 ;
7812 0 : void *argp1 = 0 ;
7813 0 : int res1 = 0 ;
7814 : double val2 ;
7815 0 : int ecode2 = 0 ;
7816 : double val3 ;
7817 0 : int ecode3 = 0 ;
7818 : double val4 ;
7819 0 : int ecode4 = 0 ;
7820 : double val5 ;
7821 0 : int ecode5 = 0 ;
7822 : double val6 ;
7823 0 : int ecode6 = 0 ;
7824 : double val7 ;
7825 0 : int ecode7 = 0 ;
7826 0 : PyObject * obj0 = 0 ;
7827 0 : PyObject * obj1 = 0 ;
7828 0 : PyObject * obj2 = 0 ;
7829 0 : PyObject * obj3 = 0 ;
7830 0 : PyObject * obj4 = 0 ;
7831 0 : PyObject * obj5 = 0 ;
7832 0 : PyObject * obj6 = 0 ;
7833 : char * kwnames[] = {
7834 : (char *) "self",(char *) "stdp1",(char *) "stdp2",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
7835 0 : };
7836 : OGRErr result;
7837 :
7838 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:SpatialReference_SetLCC",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7839 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7840 0 : if (!SWIG_IsOK(res1)) {
7841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLCC" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7842 : }
7843 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7844 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7845 0 : if (!SWIG_IsOK(ecode2)) {
7846 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetLCC" "', argument " "2"" of type '" "double""'");
7847 : }
7848 0 : arg2 = static_cast< double >(val2);
7849 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7850 0 : if (!SWIG_IsOK(ecode3)) {
7851 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLCC" "', argument " "3"" of type '" "double""'");
7852 : }
7853 0 : arg3 = static_cast< double >(val3);
7854 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7855 0 : if (!SWIG_IsOK(ecode4)) {
7856 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetLCC" "', argument " "4"" of type '" "double""'");
7857 : }
7858 0 : arg4 = static_cast< double >(val4);
7859 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7860 0 : if (!SWIG_IsOK(ecode5)) {
7861 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetLCC" "', argument " "5"" of type '" "double""'");
7862 : }
7863 0 : arg5 = static_cast< double >(val5);
7864 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
7865 0 : if (!SWIG_IsOK(ecode6)) {
7866 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetLCC" "', argument " "6"" of type '" "double""'");
7867 : }
7868 0 : arg6 = static_cast< double >(val6);
7869 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
7870 0 : if (!SWIG_IsOK(ecode7)) {
7871 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetLCC" "', argument " "7"" of type '" "double""'");
7872 : }
7873 0 : arg7 = static_cast< double >(val7);
7874 : {
7875 0 : if ( bUseExceptions ) {
7876 0 : CPLErrorReset();
7877 : }
7878 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
7879 0 : if ( bUseExceptions ) {
7880 0 : CPLErr eclass = CPLGetLastErrorType();
7881 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7882 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7883 : }
7884 : }
7885 : }
7886 : {
7887 : /* %typemap(out) OGRErr */
7888 0 : if ( result != 0 && bUseExceptions) {
7889 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7890 0 : SWIG_fail;
7891 : }
7892 : }
7893 : {
7894 : /* %typemap(ret) OGRErr */
7895 0 : if (resultobj == Py_None ) {
7896 0 : Py_DECREF(resultobj);
7897 0 : resultobj = 0;
7898 : }
7899 0 : if (resultobj == 0) {
7900 0 : resultobj = PyInt_FromLong( result );
7901 : }
7902 : }
7903 0 : return resultobj;
7904 : fail:
7905 0 : return NULL;
7906 : }
7907 :
7908 :
7909 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLCC1SP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7910 0 : PyObject *resultobj = 0;
7911 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
7912 : double arg2 ;
7913 : double arg3 ;
7914 : double arg4 ;
7915 : double arg5 ;
7916 : double arg6 ;
7917 0 : void *argp1 = 0 ;
7918 0 : int res1 = 0 ;
7919 : double val2 ;
7920 0 : int ecode2 = 0 ;
7921 : double val3 ;
7922 0 : int ecode3 = 0 ;
7923 : double val4 ;
7924 0 : int ecode4 = 0 ;
7925 : double val5 ;
7926 0 : int ecode5 = 0 ;
7927 : double val6 ;
7928 0 : int ecode6 = 0 ;
7929 0 : PyObject * obj0 = 0 ;
7930 0 : PyObject * obj1 = 0 ;
7931 0 : PyObject * obj2 = 0 ;
7932 0 : PyObject * obj3 = 0 ;
7933 0 : PyObject * obj4 = 0 ;
7934 0 : PyObject * obj5 = 0 ;
7935 : char * kwnames[] = {
7936 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
7937 0 : };
7938 : OGRErr result;
7939 :
7940 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetLCC1SP",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
7941 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
7942 0 : if (!SWIG_IsOK(res1)) {
7943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLCC1SP" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
7944 : }
7945 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
7946 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7947 0 : if (!SWIG_IsOK(ecode2)) {
7948 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetLCC1SP" "', argument " "2"" of type '" "double""'");
7949 : }
7950 0 : arg2 = static_cast< double >(val2);
7951 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
7952 0 : if (!SWIG_IsOK(ecode3)) {
7953 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLCC1SP" "', argument " "3"" of type '" "double""'");
7954 : }
7955 0 : arg3 = static_cast< double >(val3);
7956 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
7957 0 : if (!SWIG_IsOK(ecode4)) {
7958 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetLCC1SP" "', argument " "4"" of type '" "double""'");
7959 : }
7960 0 : arg4 = static_cast< double >(val4);
7961 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
7962 0 : if (!SWIG_IsOK(ecode5)) {
7963 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetLCC1SP" "', argument " "5"" of type '" "double""'");
7964 : }
7965 0 : arg5 = static_cast< double >(val5);
7966 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
7967 0 : if (!SWIG_IsOK(ecode6)) {
7968 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetLCC1SP" "', argument " "6"" of type '" "double""'");
7969 : }
7970 0 : arg6 = static_cast< double >(val6);
7971 : {
7972 0 : if ( bUseExceptions ) {
7973 0 : CPLErrorReset();
7974 : }
7975 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetLCC1SP(arg1,arg2,arg3,arg4,arg5,arg6);
7976 0 : if ( bUseExceptions ) {
7977 0 : CPLErr eclass = CPLGetLastErrorType();
7978 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7979 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7980 : }
7981 : }
7982 : }
7983 : {
7984 : /* %typemap(out) OGRErr */
7985 0 : if ( result != 0 && bUseExceptions) {
7986 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
7987 0 : SWIG_fail;
7988 : }
7989 : }
7990 : {
7991 : /* %typemap(ret) OGRErr */
7992 0 : if (resultobj == Py_None ) {
7993 0 : Py_DECREF(resultobj);
7994 0 : resultobj = 0;
7995 : }
7996 0 : if (resultobj == 0) {
7997 0 : resultobj = PyInt_FromLong( result );
7998 : }
7999 : }
8000 0 : return resultobj;
8001 : fail:
8002 0 : return NULL;
8003 : }
8004 :
8005 :
8006 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLCCB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8007 0 : PyObject *resultobj = 0;
8008 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8009 : double arg2 ;
8010 : double arg3 ;
8011 : double arg4 ;
8012 : double arg5 ;
8013 : double arg6 ;
8014 : double arg7 ;
8015 0 : void *argp1 = 0 ;
8016 0 : int res1 = 0 ;
8017 : double val2 ;
8018 0 : int ecode2 = 0 ;
8019 : double val3 ;
8020 0 : int ecode3 = 0 ;
8021 : double val4 ;
8022 0 : int ecode4 = 0 ;
8023 : double val5 ;
8024 0 : int ecode5 = 0 ;
8025 : double val6 ;
8026 0 : int ecode6 = 0 ;
8027 : double val7 ;
8028 0 : int ecode7 = 0 ;
8029 0 : PyObject * obj0 = 0 ;
8030 0 : PyObject * obj1 = 0 ;
8031 0 : PyObject * obj2 = 0 ;
8032 0 : PyObject * obj3 = 0 ;
8033 0 : PyObject * obj4 = 0 ;
8034 0 : PyObject * obj5 = 0 ;
8035 0 : PyObject * obj6 = 0 ;
8036 : char * kwnames[] = {
8037 : (char *) "self",(char *) "stdp1",(char *) "stdp2",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8038 0 : };
8039 : OGRErr result;
8040 :
8041 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:SpatialReference_SetLCCB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
8042 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8043 0 : if (!SWIG_IsOK(res1)) {
8044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLCCB" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8045 : }
8046 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8047 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8048 0 : if (!SWIG_IsOK(ecode2)) {
8049 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetLCCB" "', argument " "2"" of type '" "double""'");
8050 : }
8051 0 : arg2 = static_cast< double >(val2);
8052 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8053 0 : if (!SWIG_IsOK(ecode3)) {
8054 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetLCCB" "', argument " "3"" of type '" "double""'");
8055 : }
8056 0 : arg3 = static_cast< double >(val3);
8057 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8058 0 : if (!SWIG_IsOK(ecode4)) {
8059 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetLCCB" "', argument " "4"" of type '" "double""'");
8060 : }
8061 0 : arg4 = static_cast< double >(val4);
8062 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8063 0 : if (!SWIG_IsOK(ecode5)) {
8064 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetLCCB" "', argument " "5"" of type '" "double""'");
8065 : }
8066 0 : arg5 = static_cast< double >(val5);
8067 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
8068 0 : if (!SWIG_IsOK(ecode6)) {
8069 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetLCCB" "', argument " "6"" of type '" "double""'");
8070 : }
8071 0 : arg6 = static_cast< double >(val6);
8072 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
8073 0 : if (!SWIG_IsOK(ecode7)) {
8074 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetLCCB" "', argument " "7"" of type '" "double""'");
8075 : }
8076 0 : arg7 = static_cast< double >(val7);
8077 : {
8078 0 : if ( bUseExceptions ) {
8079 0 : CPLErrorReset();
8080 : }
8081 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetLCCB(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
8082 0 : if ( bUseExceptions ) {
8083 0 : CPLErr eclass = CPLGetLastErrorType();
8084 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8085 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8086 : }
8087 : }
8088 : }
8089 : {
8090 : /* %typemap(out) OGRErr */
8091 0 : if ( result != 0 && bUseExceptions) {
8092 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8093 0 : SWIG_fail;
8094 : }
8095 : }
8096 : {
8097 : /* %typemap(ret) OGRErr */
8098 0 : if (resultobj == Py_None ) {
8099 0 : Py_DECREF(resultobj);
8100 0 : resultobj = 0;
8101 : }
8102 0 : if (resultobj == 0) {
8103 0 : resultobj = PyInt_FromLong( result );
8104 : }
8105 : }
8106 0 : return resultobj;
8107 : fail:
8108 0 : return NULL;
8109 : }
8110 :
8111 :
8112 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetMC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8113 0 : PyObject *resultobj = 0;
8114 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8115 : double arg2 ;
8116 : double arg3 ;
8117 : double arg4 ;
8118 : double arg5 ;
8119 0 : void *argp1 = 0 ;
8120 0 : int res1 = 0 ;
8121 : double val2 ;
8122 0 : int ecode2 = 0 ;
8123 : double val3 ;
8124 0 : int ecode3 = 0 ;
8125 : double val4 ;
8126 0 : int ecode4 = 0 ;
8127 : double val5 ;
8128 0 : int ecode5 = 0 ;
8129 0 : PyObject * obj0 = 0 ;
8130 0 : PyObject * obj1 = 0 ;
8131 0 : PyObject * obj2 = 0 ;
8132 0 : PyObject * obj3 = 0 ;
8133 0 : PyObject * obj4 = 0 ;
8134 : char * kwnames[] = {
8135 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8136 0 : };
8137 : OGRErr result;
8138 :
8139 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetMC",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8140 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8141 0 : if (!SWIG_IsOK(res1)) {
8142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetMC" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8143 : }
8144 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8145 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8146 0 : if (!SWIG_IsOK(ecode2)) {
8147 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetMC" "', argument " "2"" of type '" "double""'");
8148 : }
8149 0 : arg2 = static_cast< double >(val2);
8150 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8151 0 : if (!SWIG_IsOK(ecode3)) {
8152 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetMC" "', argument " "3"" of type '" "double""'");
8153 : }
8154 0 : arg3 = static_cast< double >(val3);
8155 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8156 0 : if (!SWIG_IsOK(ecode4)) {
8157 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetMC" "', argument " "4"" of type '" "double""'");
8158 : }
8159 0 : arg4 = static_cast< double >(val4);
8160 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8161 0 : if (!SWIG_IsOK(ecode5)) {
8162 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetMC" "', argument " "5"" of type '" "double""'");
8163 : }
8164 0 : arg5 = static_cast< double >(val5);
8165 : {
8166 0 : if ( bUseExceptions ) {
8167 0 : CPLErrorReset();
8168 : }
8169 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetMC(arg1,arg2,arg3,arg4,arg5);
8170 0 : if ( bUseExceptions ) {
8171 0 : CPLErr eclass = CPLGetLastErrorType();
8172 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8173 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8174 : }
8175 : }
8176 : }
8177 : {
8178 : /* %typemap(out) OGRErr */
8179 0 : if ( result != 0 && bUseExceptions) {
8180 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8181 0 : SWIG_fail;
8182 : }
8183 : }
8184 : {
8185 : /* %typemap(ret) OGRErr */
8186 0 : if (resultobj == Py_None ) {
8187 0 : Py_DECREF(resultobj);
8188 0 : resultobj = 0;
8189 : }
8190 0 : if (resultobj == 0) {
8191 0 : resultobj = PyInt_FromLong( result );
8192 : }
8193 : }
8194 0 : return resultobj;
8195 : fail:
8196 0 : return NULL;
8197 : }
8198 :
8199 :
8200 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetMercator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 0 : PyObject *resultobj = 0;
8202 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8203 : double arg2 ;
8204 : double arg3 ;
8205 : double arg4 ;
8206 : double arg5 ;
8207 : double arg6 ;
8208 0 : void *argp1 = 0 ;
8209 0 : int res1 = 0 ;
8210 : double val2 ;
8211 0 : int ecode2 = 0 ;
8212 : double val3 ;
8213 0 : int ecode3 = 0 ;
8214 : double val4 ;
8215 0 : int ecode4 = 0 ;
8216 : double val5 ;
8217 0 : int ecode5 = 0 ;
8218 : double val6 ;
8219 0 : int ecode6 = 0 ;
8220 0 : PyObject * obj0 = 0 ;
8221 0 : PyObject * obj1 = 0 ;
8222 0 : PyObject * obj2 = 0 ;
8223 0 : PyObject * obj3 = 0 ;
8224 0 : PyObject * obj4 = 0 ;
8225 0 : PyObject * obj5 = 0 ;
8226 : char * kwnames[] = {
8227 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
8228 0 : };
8229 : OGRErr result;
8230 :
8231 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetMercator",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
8232 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8233 0 : if (!SWIG_IsOK(res1)) {
8234 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetMercator" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8235 : }
8236 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8237 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8238 0 : if (!SWIG_IsOK(ecode2)) {
8239 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetMercator" "', argument " "2"" of type '" "double""'");
8240 : }
8241 0 : arg2 = static_cast< double >(val2);
8242 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8243 0 : if (!SWIG_IsOK(ecode3)) {
8244 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetMercator" "', argument " "3"" of type '" "double""'");
8245 : }
8246 0 : arg3 = static_cast< double >(val3);
8247 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8248 0 : if (!SWIG_IsOK(ecode4)) {
8249 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetMercator" "', argument " "4"" of type '" "double""'");
8250 : }
8251 0 : arg4 = static_cast< double >(val4);
8252 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8253 0 : if (!SWIG_IsOK(ecode5)) {
8254 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetMercator" "', argument " "5"" of type '" "double""'");
8255 : }
8256 0 : arg5 = static_cast< double >(val5);
8257 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
8258 0 : if (!SWIG_IsOK(ecode6)) {
8259 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetMercator" "', argument " "6"" of type '" "double""'");
8260 : }
8261 0 : arg6 = static_cast< double >(val6);
8262 : {
8263 0 : if ( bUseExceptions ) {
8264 0 : CPLErrorReset();
8265 : }
8266 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetMercator(arg1,arg2,arg3,arg4,arg5,arg6);
8267 0 : if ( bUseExceptions ) {
8268 0 : CPLErr eclass = CPLGetLastErrorType();
8269 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8270 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8271 : }
8272 : }
8273 : }
8274 : {
8275 : /* %typemap(out) OGRErr */
8276 0 : if ( result != 0 && bUseExceptions) {
8277 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8278 0 : SWIG_fail;
8279 : }
8280 : }
8281 : {
8282 : /* %typemap(ret) OGRErr */
8283 0 : if (resultobj == Py_None ) {
8284 0 : Py_DECREF(resultobj);
8285 0 : resultobj = 0;
8286 : }
8287 0 : if (resultobj == 0) {
8288 0 : resultobj = PyInt_FromLong( result );
8289 : }
8290 : }
8291 0 : return resultobj;
8292 : fail:
8293 0 : return NULL;
8294 : }
8295 :
8296 :
8297 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetMollweide(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8298 0 : PyObject *resultobj = 0;
8299 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8300 : double arg2 ;
8301 : double arg3 ;
8302 : double arg4 ;
8303 0 : void *argp1 = 0 ;
8304 0 : int res1 = 0 ;
8305 : double val2 ;
8306 0 : int ecode2 = 0 ;
8307 : double val3 ;
8308 0 : int ecode3 = 0 ;
8309 : double val4 ;
8310 0 : int ecode4 = 0 ;
8311 0 : PyObject * obj0 = 0 ;
8312 0 : PyObject * obj1 = 0 ;
8313 0 : PyObject * obj2 = 0 ;
8314 0 : PyObject * obj3 = 0 ;
8315 : char * kwnames[] = {
8316 : (char *) "self",(char *) "cm",(char *) "fe",(char *) "fn", NULL
8317 0 : };
8318 : OGRErr result;
8319 :
8320 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetMollweide",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8321 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8322 0 : if (!SWIG_IsOK(res1)) {
8323 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetMollweide" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8324 : }
8325 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8326 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8327 0 : if (!SWIG_IsOK(ecode2)) {
8328 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetMollweide" "', argument " "2"" of type '" "double""'");
8329 : }
8330 0 : arg2 = static_cast< double >(val2);
8331 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8332 0 : if (!SWIG_IsOK(ecode3)) {
8333 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetMollweide" "', argument " "3"" of type '" "double""'");
8334 : }
8335 0 : arg3 = static_cast< double >(val3);
8336 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8337 0 : if (!SWIG_IsOK(ecode4)) {
8338 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetMollweide" "', argument " "4"" of type '" "double""'");
8339 : }
8340 0 : arg4 = static_cast< double >(val4);
8341 : {
8342 0 : if ( bUseExceptions ) {
8343 0 : CPLErrorReset();
8344 : }
8345 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetMollweide(arg1,arg2,arg3,arg4);
8346 0 : if ( bUseExceptions ) {
8347 0 : CPLErr eclass = CPLGetLastErrorType();
8348 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8349 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8350 : }
8351 : }
8352 : }
8353 : {
8354 : /* %typemap(out) OGRErr */
8355 0 : if ( result != 0 && bUseExceptions) {
8356 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8357 0 : SWIG_fail;
8358 : }
8359 : }
8360 : {
8361 : /* %typemap(ret) OGRErr */
8362 0 : if (resultobj == Py_None ) {
8363 0 : Py_DECREF(resultobj);
8364 0 : resultobj = 0;
8365 : }
8366 0 : if (resultobj == 0) {
8367 0 : resultobj = PyInt_FromLong( result );
8368 : }
8369 : }
8370 0 : return resultobj;
8371 : fail:
8372 0 : return NULL;
8373 : }
8374 :
8375 :
8376 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetNZMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 0 : PyObject *resultobj = 0;
8378 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8379 : double arg2 ;
8380 : double arg3 ;
8381 : double arg4 ;
8382 : double arg5 ;
8383 0 : void *argp1 = 0 ;
8384 0 : int res1 = 0 ;
8385 : double val2 ;
8386 0 : int ecode2 = 0 ;
8387 : double val3 ;
8388 0 : int ecode3 = 0 ;
8389 : double val4 ;
8390 0 : int ecode4 = 0 ;
8391 : double val5 ;
8392 0 : int ecode5 = 0 ;
8393 0 : PyObject * obj0 = 0 ;
8394 0 : PyObject * obj1 = 0 ;
8395 0 : PyObject * obj2 = 0 ;
8396 0 : PyObject * obj3 = 0 ;
8397 0 : PyObject * obj4 = 0 ;
8398 : char * kwnames[] = {
8399 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8400 0 : };
8401 : OGRErr result;
8402 :
8403 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetNZMG",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8404 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8405 0 : if (!SWIG_IsOK(res1)) {
8406 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetNZMG" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8407 : }
8408 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8409 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8410 0 : if (!SWIG_IsOK(ecode2)) {
8411 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetNZMG" "', argument " "2"" of type '" "double""'");
8412 : }
8413 0 : arg2 = static_cast< double >(val2);
8414 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8415 0 : if (!SWIG_IsOK(ecode3)) {
8416 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetNZMG" "', argument " "3"" of type '" "double""'");
8417 : }
8418 0 : arg3 = static_cast< double >(val3);
8419 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8420 0 : if (!SWIG_IsOK(ecode4)) {
8421 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetNZMG" "', argument " "4"" of type '" "double""'");
8422 : }
8423 0 : arg4 = static_cast< double >(val4);
8424 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8425 0 : if (!SWIG_IsOK(ecode5)) {
8426 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetNZMG" "', argument " "5"" of type '" "double""'");
8427 : }
8428 0 : arg5 = static_cast< double >(val5);
8429 : {
8430 0 : if ( bUseExceptions ) {
8431 0 : CPLErrorReset();
8432 : }
8433 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetNZMG(arg1,arg2,arg3,arg4,arg5);
8434 0 : if ( bUseExceptions ) {
8435 0 : CPLErr eclass = CPLGetLastErrorType();
8436 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8437 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8438 : }
8439 : }
8440 : }
8441 : {
8442 : /* %typemap(out) OGRErr */
8443 0 : if ( result != 0 && bUseExceptions) {
8444 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8445 0 : SWIG_fail;
8446 : }
8447 : }
8448 : {
8449 : /* %typemap(ret) OGRErr */
8450 0 : if (resultobj == Py_None ) {
8451 0 : Py_DECREF(resultobj);
8452 0 : resultobj = 0;
8453 : }
8454 0 : if (resultobj == 0) {
8455 0 : resultobj = PyInt_FromLong( result );
8456 : }
8457 : }
8458 0 : return resultobj;
8459 : fail:
8460 0 : return NULL;
8461 : }
8462 :
8463 :
8464 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetOS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8465 0 : PyObject *resultobj = 0;
8466 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8467 : double arg2 ;
8468 : double arg3 ;
8469 : double arg4 ;
8470 : double arg5 ;
8471 : double arg6 ;
8472 0 : void *argp1 = 0 ;
8473 0 : int res1 = 0 ;
8474 : double val2 ;
8475 0 : int ecode2 = 0 ;
8476 : double val3 ;
8477 0 : int ecode3 = 0 ;
8478 : double val4 ;
8479 0 : int ecode4 = 0 ;
8480 : double val5 ;
8481 0 : int ecode5 = 0 ;
8482 : double val6 ;
8483 0 : int ecode6 = 0 ;
8484 0 : PyObject * obj0 = 0 ;
8485 0 : PyObject * obj1 = 0 ;
8486 0 : PyObject * obj2 = 0 ;
8487 0 : PyObject * obj3 = 0 ;
8488 0 : PyObject * obj4 = 0 ;
8489 0 : PyObject * obj5 = 0 ;
8490 : char * kwnames[] = {
8491 : (char *) "self",(char *) "dfOriginLat",(char *) "dfCMeridian",(char *) "scale",(char *) "fe",(char *) "fn", NULL
8492 0 : };
8493 : OGRErr result;
8494 :
8495 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetOS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
8496 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8497 0 : if (!SWIG_IsOK(res1)) {
8498 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetOS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8499 : }
8500 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8501 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8502 0 : if (!SWIG_IsOK(ecode2)) {
8503 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetOS" "', argument " "2"" of type '" "double""'");
8504 : }
8505 0 : arg2 = static_cast< double >(val2);
8506 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8507 0 : if (!SWIG_IsOK(ecode3)) {
8508 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetOS" "', argument " "3"" of type '" "double""'");
8509 : }
8510 0 : arg3 = static_cast< double >(val3);
8511 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8512 0 : if (!SWIG_IsOK(ecode4)) {
8513 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetOS" "', argument " "4"" of type '" "double""'");
8514 : }
8515 0 : arg4 = static_cast< double >(val4);
8516 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8517 0 : if (!SWIG_IsOK(ecode5)) {
8518 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetOS" "', argument " "5"" of type '" "double""'");
8519 : }
8520 0 : arg5 = static_cast< double >(val5);
8521 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
8522 0 : if (!SWIG_IsOK(ecode6)) {
8523 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetOS" "', argument " "6"" of type '" "double""'");
8524 : }
8525 0 : arg6 = static_cast< double >(val6);
8526 : {
8527 0 : if ( bUseExceptions ) {
8528 0 : CPLErrorReset();
8529 : }
8530 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetOS(arg1,arg2,arg3,arg4,arg5,arg6);
8531 0 : if ( bUseExceptions ) {
8532 0 : CPLErr eclass = CPLGetLastErrorType();
8533 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8534 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8535 : }
8536 : }
8537 : }
8538 : {
8539 : /* %typemap(out) OGRErr */
8540 0 : if ( result != 0 && bUseExceptions) {
8541 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8542 0 : SWIG_fail;
8543 : }
8544 : }
8545 : {
8546 : /* %typemap(ret) OGRErr */
8547 0 : if (resultobj == Py_None ) {
8548 0 : Py_DECREF(resultobj);
8549 0 : resultobj = 0;
8550 : }
8551 0 : if (resultobj == 0) {
8552 0 : resultobj = PyInt_FromLong( result );
8553 : }
8554 : }
8555 0 : return resultobj;
8556 : fail:
8557 0 : return NULL;
8558 : }
8559 :
8560 :
8561 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetOrthographic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8562 0 : PyObject *resultobj = 0;
8563 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8564 : double arg2 ;
8565 : double arg3 ;
8566 : double arg4 ;
8567 : double arg5 ;
8568 0 : void *argp1 = 0 ;
8569 0 : int res1 = 0 ;
8570 : double val2 ;
8571 0 : int ecode2 = 0 ;
8572 : double val3 ;
8573 0 : int ecode3 = 0 ;
8574 : double val4 ;
8575 0 : int ecode4 = 0 ;
8576 : double val5 ;
8577 0 : int ecode5 = 0 ;
8578 0 : PyObject * obj0 = 0 ;
8579 0 : PyObject * obj1 = 0 ;
8580 0 : PyObject * obj2 = 0 ;
8581 0 : PyObject * obj3 = 0 ;
8582 0 : PyObject * obj4 = 0 ;
8583 : char * kwnames[] = {
8584 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8585 0 : };
8586 : OGRErr result;
8587 :
8588 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetOrthographic",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8589 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8590 0 : if (!SWIG_IsOK(res1)) {
8591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetOrthographic" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8592 : }
8593 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8594 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8595 0 : if (!SWIG_IsOK(ecode2)) {
8596 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetOrthographic" "', argument " "2"" of type '" "double""'");
8597 : }
8598 0 : arg2 = static_cast< double >(val2);
8599 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8600 0 : if (!SWIG_IsOK(ecode3)) {
8601 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetOrthographic" "', argument " "3"" of type '" "double""'");
8602 : }
8603 0 : arg3 = static_cast< double >(val3);
8604 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8605 0 : if (!SWIG_IsOK(ecode4)) {
8606 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetOrthographic" "', argument " "4"" of type '" "double""'");
8607 : }
8608 0 : arg4 = static_cast< double >(val4);
8609 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8610 0 : if (!SWIG_IsOK(ecode5)) {
8611 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetOrthographic" "', argument " "5"" of type '" "double""'");
8612 : }
8613 0 : arg5 = static_cast< double >(val5);
8614 : {
8615 0 : if ( bUseExceptions ) {
8616 0 : CPLErrorReset();
8617 : }
8618 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetOrthographic(arg1,arg2,arg3,arg4,arg5);
8619 0 : if ( bUseExceptions ) {
8620 0 : CPLErr eclass = CPLGetLastErrorType();
8621 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8622 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8623 : }
8624 : }
8625 : }
8626 : {
8627 : /* %typemap(out) OGRErr */
8628 0 : if ( result != 0 && bUseExceptions) {
8629 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8630 0 : SWIG_fail;
8631 : }
8632 : }
8633 : {
8634 : /* %typemap(ret) OGRErr */
8635 0 : if (resultobj == Py_None ) {
8636 0 : Py_DECREF(resultobj);
8637 0 : resultobj = 0;
8638 : }
8639 0 : if (resultobj == 0) {
8640 0 : resultobj = PyInt_FromLong( result );
8641 : }
8642 : }
8643 0 : return resultobj;
8644 : fail:
8645 0 : return NULL;
8646 : }
8647 :
8648 :
8649 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetPolyconic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 0 : PyObject *resultobj = 0;
8651 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8652 : double arg2 ;
8653 : double arg3 ;
8654 : double arg4 ;
8655 : double arg5 ;
8656 0 : void *argp1 = 0 ;
8657 0 : int res1 = 0 ;
8658 : double val2 ;
8659 0 : int ecode2 = 0 ;
8660 : double val3 ;
8661 0 : int ecode3 = 0 ;
8662 : double val4 ;
8663 0 : int ecode4 = 0 ;
8664 : double val5 ;
8665 0 : int ecode5 = 0 ;
8666 0 : PyObject * obj0 = 0 ;
8667 0 : PyObject * obj1 = 0 ;
8668 0 : PyObject * obj2 = 0 ;
8669 0 : PyObject * obj3 = 0 ;
8670 0 : PyObject * obj4 = 0 ;
8671 : char * kwnames[] = {
8672 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8673 0 : };
8674 : OGRErr result;
8675 :
8676 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetPolyconic",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8677 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8678 0 : if (!SWIG_IsOK(res1)) {
8679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetPolyconic" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8680 : }
8681 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8682 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8683 0 : if (!SWIG_IsOK(ecode2)) {
8684 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetPolyconic" "', argument " "2"" of type '" "double""'");
8685 : }
8686 0 : arg2 = static_cast< double >(val2);
8687 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8688 0 : if (!SWIG_IsOK(ecode3)) {
8689 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetPolyconic" "', argument " "3"" of type '" "double""'");
8690 : }
8691 0 : arg3 = static_cast< double >(val3);
8692 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8693 0 : if (!SWIG_IsOK(ecode4)) {
8694 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetPolyconic" "', argument " "4"" of type '" "double""'");
8695 : }
8696 0 : arg4 = static_cast< double >(val4);
8697 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8698 0 : if (!SWIG_IsOK(ecode5)) {
8699 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetPolyconic" "', argument " "5"" of type '" "double""'");
8700 : }
8701 0 : arg5 = static_cast< double >(val5);
8702 : {
8703 0 : if ( bUseExceptions ) {
8704 0 : CPLErrorReset();
8705 : }
8706 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetPolyconic(arg1,arg2,arg3,arg4,arg5);
8707 0 : if ( bUseExceptions ) {
8708 0 : CPLErr eclass = CPLGetLastErrorType();
8709 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8710 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8711 : }
8712 : }
8713 : }
8714 : {
8715 : /* %typemap(out) OGRErr */
8716 0 : if ( result != 0 && bUseExceptions) {
8717 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8718 0 : SWIG_fail;
8719 : }
8720 : }
8721 : {
8722 : /* %typemap(ret) OGRErr */
8723 0 : if (resultobj == Py_None ) {
8724 0 : Py_DECREF(resultobj);
8725 0 : resultobj = 0;
8726 : }
8727 0 : if (resultobj == 0) {
8728 0 : resultobj = PyInt_FromLong( result );
8729 : }
8730 : }
8731 0 : return resultobj;
8732 : fail:
8733 0 : return NULL;
8734 : }
8735 :
8736 :
8737 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8738 0 : PyObject *resultobj = 0;
8739 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8740 : double arg2 ;
8741 : double arg3 ;
8742 : double arg4 ;
8743 : double arg5 ;
8744 : double arg6 ;
8745 0 : void *argp1 = 0 ;
8746 0 : int res1 = 0 ;
8747 : double val2 ;
8748 0 : int ecode2 = 0 ;
8749 : double val3 ;
8750 0 : int ecode3 = 0 ;
8751 : double val4 ;
8752 0 : int ecode4 = 0 ;
8753 : double val5 ;
8754 0 : int ecode5 = 0 ;
8755 : double val6 ;
8756 0 : int ecode6 = 0 ;
8757 0 : PyObject * obj0 = 0 ;
8758 0 : PyObject * obj1 = 0 ;
8759 0 : PyObject * obj2 = 0 ;
8760 0 : PyObject * obj3 = 0 ;
8761 0 : PyObject * obj4 = 0 ;
8762 0 : PyObject * obj5 = 0 ;
8763 : char * kwnames[] = {
8764 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
8765 0 : };
8766 : OGRErr result;
8767 :
8768 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetPS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
8769 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8770 0 : if (!SWIG_IsOK(res1)) {
8771 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetPS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8772 : }
8773 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8774 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8775 0 : if (!SWIG_IsOK(ecode2)) {
8776 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetPS" "', argument " "2"" of type '" "double""'");
8777 : }
8778 0 : arg2 = static_cast< double >(val2);
8779 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8780 0 : if (!SWIG_IsOK(ecode3)) {
8781 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetPS" "', argument " "3"" of type '" "double""'");
8782 : }
8783 0 : arg3 = static_cast< double >(val3);
8784 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8785 0 : if (!SWIG_IsOK(ecode4)) {
8786 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetPS" "', argument " "4"" of type '" "double""'");
8787 : }
8788 0 : arg4 = static_cast< double >(val4);
8789 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
8790 0 : if (!SWIG_IsOK(ecode5)) {
8791 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetPS" "', argument " "5"" of type '" "double""'");
8792 : }
8793 0 : arg5 = static_cast< double >(val5);
8794 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
8795 0 : if (!SWIG_IsOK(ecode6)) {
8796 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetPS" "', argument " "6"" of type '" "double""'");
8797 : }
8798 0 : arg6 = static_cast< double >(val6);
8799 : {
8800 0 : if ( bUseExceptions ) {
8801 0 : CPLErrorReset();
8802 : }
8803 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetPS(arg1,arg2,arg3,arg4,arg5,arg6);
8804 0 : if ( bUseExceptions ) {
8805 0 : CPLErr eclass = CPLGetLastErrorType();
8806 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8807 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8808 : }
8809 : }
8810 : }
8811 : {
8812 : /* %typemap(out) OGRErr */
8813 0 : if ( result != 0 && bUseExceptions) {
8814 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8815 0 : SWIG_fail;
8816 : }
8817 : }
8818 : {
8819 : /* %typemap(ret) OGRErr */
8820 0 : if (resultobj == Py_None ) {
8821 0 : Py_DECREF(resultobj);
8822 0 : resultobj = 0;
8823 : }
8824 0 : if (resultobj == 0) {
8825 0 : resultobj = PyInt_FromLong( result );
8826 : }
8827 : }
8828 0 : return resultobj;
8829 : fail:
8830 0 : return NULL;
8831 : }
8832 :
8833 :
8834 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetRobinson(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8835 0 : PyObject *resultobj = 0;
8836 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8837 : double arg2 ;
8838 : double arg3 ;
8839 : double arg4 ;
8840 0 : void *argp1 = 0 ;
8841 0 : int res1 = 0 ;
8842 : double val2 ;
8843 0 : int ecode2 = 0 ;
8844 : double val3 ;
8845 0 : int ecode3 = 0 ;
8846 : double val4 ;
8847 0 : int ecode4 = 0 ;
8848 0 : PyObject * obj0 = 0 ;
8849 0 : PyObject * obj1 = 0 ;
8850 0 : PyObject * obj2 = 0 ;
8851 0 : PyObject * obj3 = 0 ;
8852 : char * kwnames[] = {
8853 : (char *) "self",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8854 0 : };
8855 : OGRErr result;
8856 :
8857 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetRobinson",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8858 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8859 0 : if (!SWIG_IsOK(res1)) {
8860 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetRobinson" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8861 : }
8862 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8863 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8864 0 : if (!SWIG_IsOK(ecode2)) {
8865 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetRobinson" "', argument " "2"" of type '" "double""'");
8866 : }
8867 0 : arg2 = static_cast< double >(val2);
8868 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8869 0 : if (!SWIG_IsOK(ecode3)) {
8870 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetRobinson" "', argument " "3"" of type '" "double""'");
8871 : }
8872 0 : arg3 = static_cast< double >(val3);
8873 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8874 0 : if (!SWIG_IsOK(ecode4)) {
8875 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetRobinson" "', argument " "4"" of type '" "double""'");
8876 : }
8877 0 : arg4 = static_cast< double >(val4);
8878 : {
8879 0 : if ( bUseExceptions ) {
8880 0 : CPLErrorReset();
8881 : }
8882 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetRobinson(arg1,arg2,arg3,arg4);
8883 0 : if ( bUseExceptions ) {
8884 0 : CPLErr eclass = CPLGetLastErrorType();
8885 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8886 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8887 : }
8888 : }
8889 : }
8890 : {
8891 : /* %typemap(out) OGRErr */
8892 0 : if ( result != 0 && bUseExceptions) {
8893 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8894 0 : SWIG_fail;
8895 : }
8896 : }
8897 : {
8898 : /* %typemap(ret) OGRErr */
8899 0 : if (resultobj == Py_None ) {
8900 0 : Py_DECREF(resultobj);
8901 0 : resultobj = 0;
8902 : }
8903 0 : if (resultobj == 0) {
8904 0 : resultobj = PyInt_FromLong( result );
8905 : }
8906 : }
8907 0 : return resultobj;
8908 : fail:
8909 0 : return NULL;
8910 : }
8911 :
8912 :
8913 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetSinusoidal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8914 0 : PyObject *resultobj = 0;
8915 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8916 : double arg2 ;
8917 : double arg3 ;
8918 : double arg4 ;
8919 0 : void *argp1 = 0 ;
8920 0 : int res1 = 0 ;
8921 : double val2 ;
8922 0 : int ecode2 = 0 ;
8923 : double val3 ;
8924 0 : int ecode3 = 0 ;
8925 : double val4 ;
8926 0 : int ecode4 = 0 ;
8927 0 : PyObject * obj0 = 0 ;
8928 0 : PyObject * obj1 = 0 ;
8929 0 : PyObject * obj2 = 0 ;
8930 0 : PyObject * obj3 = 0 ;
8931 : char * kwnames[] = {
8932 : (char *) "self",(char *) "clong",(char *) "fe",(char *) "fn", NULL
8933 0 : };
8934 : OGRErr result;
8935 :
8936 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetSinusoidal",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8937 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
8938 0 : if (!SWIG_IsOK(res1)) {
8939 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetSinusoidal" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
8940 : }
8941 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
8942 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
8943 0 : if (!SWIG_IsOK(ecode2)) {
8944 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetSinusoidal" "', argument " "2"" of type '" "double""'");
8945 : }
8946 0 : arg2 = static_cast< double >(val2);
8947 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
8948 0 : if (!SWIG_IsOK(ecode3)) {
8949 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetSinusoidal" "', argument " "3"" of type '" "double""'");
8950 : }
8951 0 : arg3 = static_cast< double >(val3);
8952 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
8953 0 : if (!SWIG_IsOK(ecode4)) {
8954 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetSinusoidal" "', argument " "4"" of type '" "double""'");
8955 : }
8956 0 : arg4 = static_cast< double >(val4);
8957 : {
8958 0 : if ( bUseExceptions ) {
8959 0 : CPLErrorReset();
8960 : }
8961 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetSinusoidal(arg1,arg2,arg3,arg4);
8962 0 : if ( bUseExceptions ) {
8963 0 : CPLErr eclass = CPLGetLastErrorType();
8964 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8965 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8966 : }
8967 : }
8968 : }
8969 : {
8970 : /* %typemap(out) OGRErr */
8971 0 : if ( result != 0 && bUseExceptions) {
8972 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8973 0 : SWIG_fail;
8974 : }
8975 : }
8976 : {
8977 : /* %typemap(ret) OGRErr */
8978 0 : if (resultobj == Py_None ) {
8979 0 : Py_DECREF(resultobj);
8980 0 : resultobj = 0;
8981 : }
8982 0 : if (resultobj == 0) {
8983 0 : resultobj = PyInt_FromLong( result );
8984 : }
8985 : }
8986 0 : return resultobj;
8987 : fail:
8988 0 : return NULL;
8989 : }
8990 :
8991 :
8992 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetStereographic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8993 0 : PyObject *resultobj = 0;
8994 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
8995 : double arg2 ;
8996 : double arg3 ;
8997 : double arg4 ;
8998 : double arg5 ;
8999 : double arg6 ;
9000 0 : void *argp1 = 0 ;
9001 0 : int res1 = 0 ;
9002 : double val2 ;
9003 0 : int ecode2 = 0 ;
9004 : double val3 ;
9005 0 : int ecode3 = 0 ;
9006 : double val4 ;
9007 0 : int ecode4 = 0 ;
9008 : double val5 ;
9009 0 : int ecode5 = 0 ;
9010 : double val6 ;
9011 0 : int ecode6 = 0 ;
9012 0 : PyObject * obj0 = 0 ;
9013 0 : PyObject * obj1 = 0 ;
9014 0 : PyObject * obj2 = 0 ;
9015 0 : PyObject * obj3 = 0 ;
9016 0 : PyObject * obj4 = 0 ;
9017 0 : PyObject * obj5 = 0 ;
9018 : char * kwnames[] = {
9019 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
9020 0 : };
9021 : OGRErr result;
9022 :
9023 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetStereographic",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
9024 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9025 0 : if (!SWIG_IsOK(res1)) {
9026 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetStereographic" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9027 : }
9028 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9029 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9030 0 : if (!SWIG_IsOK(ecode2)) {
9031 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetStereographic" "', argument " "2"" of type '" "double""'");
9032 : }
9033 0 : arg2 = static_cast< double >(val2);
9034 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9035 0 : if (!SWIG_IsOK(ecode3)) {
9036 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetStereographic" "', argument " "3"" of type '" "double""'");
9037 : }
9038 0 : arg3 = static_cast< double >(val3);
9039 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9040 0 : if (!SWIG_IsOK(ecode4)) {
9041 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetStereographic" "', argument " "4"" of type '" "double""'");
9042 : }
9043 0 : arg4 = static_cast< double >(val4);
9044 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9045 0 : if (!SWIG_IsOK(ecode5)) {
9046 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetStereographic" "', argument " "5"" of type '" "double""'");
9047 : }
9048 0 : arg5 = static_cast< double >(val5);
9049 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
9050 0 : if (!SWIG_IsOK(ecode6)) {
9051 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetStereographic" "', argument " "6"" of type '" "double""'");
9052 : }
9053 0 : arg6 = static_cast< double >(val6);
9054 : {
9055 0 : if ( bUseExceptions ) {
9056 0 : CPLErrorReset();
9057 : }
9058 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetStereographic(arg1,arg2,arg3,arg4,arg5,arg6);
9059 0 : if ( bUseExceptions ) {
9060 0 : CPLErr eclass = CPLGetLastErrorType();
9061 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9062 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9063 : }
9064 : }
9065 : }
9066 : {
9067 : /* %typemap(out) OGRErr */
9068 0 : if ( result != 0 && bUseExceptions) {
9069 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9070 0 : SWIG_fail;
9071 : }
9072 : }
9073 : {
9074 : /* %typemap(ret) OGRErr */
9075 0 : if (resultobj == Py_None ) {
9076 0 : Py_DECREF(resultobj);
9077 0 : resultobj = 0;
9078 : }
9079 0 : if (resultobj == 0) {
9080 0 : resultobj = PyInt_FromLong( result );
9081 : }
9082 : }
9083 0 : return resultobj;
9084 : fail:
9085 0 : return NULL;
9086 : }
9087 :
9088 :
9089 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetSOC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9090 0 : PyObject *resultobj = 0;
9091 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9092 : double arg2 ;
9093 : double arg3 ;
9094 : double arg4 ;
9095 : double arg5 ;
9096 0 : void *argp1 = 0 ;
9097 0 : int res1 = 0 ;
9098 : double val2 ;
9099 0 : int ecode2 = 0 ;
9100 : double val3 ;
9101 0 : int ecode3 = 0 ;
9102 : double val4 ;
9103 0 : int ecode4 = 0 ;
9104 : double val5 ;
9105 0 : int ecode5 = 0 ;
9106 0 : PyObject * obj0 = 0 ;
9107 0 : PyObject * obj1 = 0 ;
9108 0 : PyObject * obj2 = 0 ;
9109 0 : PyObject * obj3 = 0 ;
9110 0 : PyObject * obj4 = 0 ;
9111 : char * kwnames[] = {
9112 : (char *) "self",(char *) "latitudeoforigin",(char *) "cm",(char *) "fe",(char *) "fn", NULL
9113 0 : };
9114 : OGRErr result;
9115 :
9116 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetSOC",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9118 0 : if (!SWIG_IsOK(res1)) {
9119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetSOC" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9120 : }
9121 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9122 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9123 0 : if (!SWIG_IsOK(ecode2)) {
9124 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetSOC" "', argument " "2"" of type '" "double""'");
9125 : }
9126 0 : arg2 = static_cast< double >(val2);
9127 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9128 0 : if (!SWIG_IsOK(ecode3)) {
9129 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetSOC" "', argument " "3"" of type '" "double""'");
9130 : }
9131 0 : arg3 = static_cast< double >(val3);
9132 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9133 0 : if (!SWIG_IsOK(ecode4)) {
9134 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetSOC" "', argument " "4"" of type '" "double""'");
9135 : }
9136 0 : arg4 = static_cast< double >(val4);
9137 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9138 0 : if (!SWIG_IsOK(ecode5)) {
9139 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetSOC" "', argument " "5"" of type '" "double""'");
9140 : }
9141 0 : arg5 = static_cast< double >(val5);
9142 : {
9143 0 : if ( bUseExceptions ) {
9144 0 : CPLErrorReset();
9145 : }
9146 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetSOC(arg1,arg2,arg3,arg4,arg5);
9147 0 : if ( bUseExceptions ) {
9148 0 : CPLErr eclass = CPLGetLastErrorType();
9149 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9150 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9151 : }
9152 : }
9153 : }
9154 : {
9155 : /* %typemap(out) OGRErr */
9156 0 : if ( result != 0 && bUseExceptions) {
9157 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9158 0 : SWIG_fail;
9159 : }
9160 : }
9161 : {
9162 : /* %typemap(ret) OGRErr */
9163 0 : if (resultobj == Py_None ) {
9164 0 : Py_DECREF(resultobj);
9165 0 : resultobj = 0;
9166 : }
9167 0 : if (resultobj == 0) {
9168 0 : resultobj = PyInt_FromLong( result );
9169 : }
9170 : }
9171 0 : return resultobj;
9172 : fail:
9173 0 : return NULL;
9174 : }
9175 :
9176 :
9177 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 0 : PyObject *resultobj = 0;
9179 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9180 : double arg2 ;
9181 : double arg3 ;
9182 : double arg4 ;
9183 : double arg5 ;
9184 : double arg6 ;
9185 0 : void *argp1 = 0 ;
9186 0 : int res1 = 0 ;
9187 : double val2 ;
9188 0 : int ecode2 = 0 ;
9189 : double val3 ;
9190 0 : int ecode3 = 0 ;
9191 : double val4 ;
9192 0 : int ecode4 = 0 ;
9193 : double val5 ;
9194 0 : int ecode5 = 0 ;
9195 : double val6 ;
9196 0 : int ecode6 = 0 ;
9197 0 : PyObject * obj0 = 0 ;
9198 0 : PyObject * obj1 = 0 ;
9199 0 : PyObject * obj2 = 0 ;
9200 0 : PyObject * obj3 = 0 ;
9201 0 : PyObject * obj4 = 0 ;
9202 0 : PyObject * obj5 = 0 ;
9203 : char * kwnames[] = {
9204 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
9205 0 : };
9206 : OGRErr result;
9207 :
9208 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetTM",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
9209 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9210 0 : if (!SWIG_IsOK(res1)) {
9211 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTM" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9212 : }
9213 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9214 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9215 0 : if (!SWIG_IsOK(ecode2)) {
9216 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetTM" "', argument " "2"" of type '" "double""'");
9217 : }
9218 0 : arg2 = static_cast< double >(val2);
9219 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9220 0 : if (!SWIG_IsOK(ecode3)) {
9221 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetTM" "', argument " "3"" of type '" "double""'");
9222 : }
9223 0 : arg3 = static_cast< double >(val3);
9224 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9225 0 : if (!SWIG_IsOK(ecode4)) {
9226 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTM" "', argument " "4"" of type '" "double""'");
9227 : }
9228 0 : arg4 = static_cast< double >(val4);
9229 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9230 0 : if (!SWIG_IsOK(ecode5)) {
9231 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetTM" "', argument " "5"" of type '" "double""'");
9232 : }
9233 0 : arg5 = static_cast< double >(val5);
9234 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
9235 0 : if (!SWIG_IsOK(ecode6)) {
9236 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetTM" "', argument " "6"" of type '" "double""'");
9237 : }
9238 0 : arg6 = static_cast< double >(val6);
9239 : {
9240 0 : if ( bUseExceptions ) {
9241 0 : CPLErrorReset();
9242 : }
9243 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetTM(arg1,arg2,arg3,arg4,arg5,arg6);
9244 0 : if ( bUseExceptions ) {
9245 0 : CPLErr eclass = CPLGetLastErrorType();
9246 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9247 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9248 : }
9249 : }
9250 : }
9251 : {
9252 : /* %typemap(out) OGRErr */
9253 0 : if ( result != 0 && bUseExceptions) {
9254 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9255 0 : SWIG_fail;
9256 : }
9257 : }
9258 : {
9259 : /* %typemap(ret) OGRErr */
9260 0 : if (resultobj == Py_None ) {
9261 0 : Py_DECREF(resultobj);
9262 0 : resultobj = 0;
9263 : }
9264 0 : if (resultobj == 0) {
9265 0 : resultobj = PyInt_FromLong( result );
9266 : }
9267 : }
9268 0 : return resultobj;
9269 : fail:
9270 0 : return NULL;
9271 : }
9272 :
9273 :
9274 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTMVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9275 0 : PyObject *resultobj = 0;
9276 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9277 0 : char *arg2 = (char *) 0 ;
9278 : double arg3 ;
9279 : double arg4 ;
9280 : double arg5 ;
9281 : double arg6 ;
9282 : double arg7 ;
9283 0 : void *argp1 = 0 ;
9284 0 : int res1 = 0 ;
9285 : int res2 ;
9286 0 : char *buf2 = 0 ;
9287 0 : int alloc2 = 0 ;
9288 : double val3 ;
9289 0 : int ecode3 = 0 ;
9290 : double val4 ;
9291 0 : int ecode4 = 0 ;
9292 : double val5 ;
9293 0 : int ecode5 = 0 ;
9294 : double val6 ;
9295 0 : int ecode6 = 0 ;
9296 : double val7 ;
9297 0 : int ecode7 = 0 ;
9298 0 : PyObject * obj0 = 0 ;
9299 0 : PyObject * obj1 = 0 ;
9300 0 : PyObject * obj2 = 0 ;
9301 0 : PyObject * obj3 = 0 ;
9302 0 : PyObject * obj4 = 0 ;
9303 0 : PyObject * obj5 = 0 ;
9304 0 : PyObject * obj6 = 0 ;
9305 : char * kwnames[] = {
9306 : (char *) "self",(char *) "pszVariantName",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
9307 0 : };
9308 : OGRErr result;
9309 :
9310 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:SpatialReference_SetTMVariant",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
9311 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9312 0 : if (!SWIG_IsOK(res1)) {
9313 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTMVariant" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9314 : }
9315 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9316 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9317 0 : if (!SWIG_IsOK(res2)) {
9318 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetTMVariant" "', argument " "2"" of type '" "char const *""'");
9319 : }
9320 0 : arg2 = reinterpret_cast< char * >(buf2);
9321 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9322 0 : if (!SWIG_IsOK(ecode3)) {
9323 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetTMVariant" "', argument " "3"" of type '" "double""'");
9324 : }
9325 0 : arg3 = static_cast< double >(val3);
9326 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9327 0 : if (!SWIG_IsOK(ecode4)) {
9328 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTMVariant" "', argument " "4"" of type '" "double""'");
9329 : }
9330 0 : arg4 = static_cast< double >(val4);
9331 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9332 0 : if (!SWIG_IsOK(ecode5)) {
9333 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetTMVariant" "', argument " "5"" of type '" "double""'");
9334 : }
9335 0 : arg5 = static_cast< double >(val5);
9336 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
9337 0 : if (!SWIG_IsOK(ecode6)) {
9338 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetTMVariant" "', argument " "6"" of type '" "double""'");
9339 : }
9340 0 : arg6 = static_cast< double >(val6);
9341 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
9342 0 : if (!SWIG_IsOK(ecode7)) {
9343 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetTMVariant" "', argument " "7"" of type '" "double""'");
9344 : }
9345 0 : arg7 = static_cast< double >(val7);
9346 : {
9347 0 : if ( bUseExceptions ) {
9348 0 : CPLErrorReset();
9349 : }
9350 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetTMVariant(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
9351 0 : if ( bUseExceptions ) {
9352 0 : CPLErr eclass = CPLGetLastErrorType();
9353 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9354 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9355 : }
9356 : }
9357 : }
9358 : {
9359 : /* %typemap(out) OGRErr */
9360 0 : if ( result != 0 && bUseExceptions) {
9361 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9362 0 : SWIG_fail;
9363 : }
9364 : }
9365 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9366 : {
9367 : /* %typemap(ret) OGRErr */
9368 0 : if (resultobj == Py_None ) {
9369 0 : Py_DECREF(resultobj);
9370 0 : resultobj = 0;
9371 : }
9372 0 : if (resultobj == 0) {
9373 0 : resultobj = PyInt_FromLong( result );
9374 : }
9375 : }
9376 0 : return resultobj;
9377 : fail:
9378 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9379 0 : return NULL;
9380 : }
9381 :
9382 :
9383 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9384 0 : PyObject *resultobj = 0;
9385 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9386 : double arg2 ;
9387 : double arg3 ;
9388 : double arg4 ;
9389 : double arg5 ;
9390 0 : void *argp1 = 0 ;
9391 0 : int res1 = 0 ;
9392 : double val2 ;
9393 0 : int ecode2 = 0 ;
9394 : double val3 ;
9395 0 : int ecode3 = 0 ;
9396 : double val4 ;
9397 0 : int ecode4 = 0 ;
9398 : double val5 ;
9399 0 : int ecode5 = 0 ;
9400 0 : PyObject * obj0 = 0 ;
9401 0 : PyObject * obj1 = 0 ;
9402 0 : PyObject * obj2 = 0 ;
9403 0 : PyObject * obj3 = 0 ;
9404 0 : PyObject * obj4 = 0 ;
9405 : char * kwnames[] = {
9406 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "fe",(char *) "fn", NULL
9407 0 : };
9408 : OGRErr result;
9409 :
9410 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:SpatialReference_SetTMG",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9411 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9412 0 : if (!SWIG_IsOK(res1)) {
9413 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTMG" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9414 : }
9415 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9416 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9417 0 : if (!SWIG_IsOK(ecode2)) {
9418 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetTMG" "', argument " "2"" of type '" "double""'");
9419 : }
9420 0 : arg2 = static_cast< double >(val2);
9421 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9422 0 : if (!SWIG_IsOK(ecode3)) {
9423 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetTMG" "', argument " "3"" of type '" "double""'");
9424 : }
9425 0 : arg3 = static_cast< double >(val3);
9426 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9427 0 : if (!SWIG_IsOK(ecode4)) {
9428 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTMG" "', argument " "4"" of type '" "double""'");
9429 : }
9430 0 : arg4 = static_cast< double >(val4);
9431 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9432 0 : if (!SWIG_IsOK(ecode5)) {
9433 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetTMG" "', argument " "5"" of type '" "double""'");
9434 : }
9435 0 : arg5 = static_cast< double >(val5);
9436 : {
9437 0 : if ( bUseExceptions ) {
9438 0 : CPLErrorReset();
9439 : }
9440 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetTMG(arg1,arg2,arg3,arg4,arg5);
9441 0 : if ( bUseExceptions ) {
9442 0 : CPLErr eclass = CPLGetLastErrorType();
9443 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9444 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9445 : }
9446 : }
9447 : }
9448 : {
9449 : /* %typemap(out) OGRErr */
9450 0 : if ( result != 0 && bUseExceptions) {
9451 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9452 0 : SWIG_fail;
9453 : }
9454 : }
9455 : {
9456 : /* %typemap(ret) OGRErr */
9457 0 : if (resultobj == Py_None ) {
9458 0 : Py_DECREF(resultobj);
9459 0 : resultobj = 0;
9460 : }
9461 0 : if (resultobj == 0) {
9462 0 : resultobj = PyInt_FromLong( result );
9463 : }
9464 : }
9465 0 : return resultobj;
9466 : fail:
9467 0 : return NULL;
9468 : }
9469 :
9470 :
9471 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTMSO(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9472 0 : PyObject *resultobj = 0;
9473 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9474 : double arg2 ;
9475 : double arg3 ;
9476 : double arg4 ;
9477 : double arg5 ;
9478 : double arg6 ;
9479 0 : void *argp1 = 0 ;
9480 0 : int res1 = 0 ;
9481 : double val2 ;
9482 0 : int ecode2 = 0 ;
9483 : double val3 ;
9484 0 : int ecode3 = 0 ;
9485 : double val4 ;
9486 0 : int ecode4 = 0 ;
9487 : double val5 ;
9488 0 : int ecode5 = 0 ;
9489 : double val6 ;
9490 0 : int ecode6 = 0 ;
9491 0 : PyObject * obj0 = 0 ;
9492 0 : PyObject * obj1 = 0 ;
9493 0 : PyObject * obj2 = 0 ;
9494 0 : PyObject * obj3 = 0 ;
9495 0 : PyObject * obj4 = 0 ;
9496 0 : PyObject * obj5 = 0 ;
9497 : char * kwnames[] = {
9498 : (char *) "self",(char *) "clat",(char *) "clong",(char *) "scale",(char *) "fe",(char *) "fn", NULL
9499 0 : };
9500 : OGRErr result;
9501 :
9502 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:SpatialReference_SetTMSO",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
9503 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9504 0 : if (!SWIG_IsOK(res1)) {
9505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTMSO" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9506 : }
9507 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9508 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9509 0 : if (!SWIG_IsOK(ecode2)) {
9510 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetTMSO" "', argument " "2"" of type '" "double""'");
9511 : }
9512 0 : arg2 = static_cast< double >(val2);
9513 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9514 0 : if (!SWIG_IsOK(ecode3)) {
9515 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetTMSO" "', argument " "3"" of type '" "double""'");
9516 : }
9517 0 : arg3 = static_cast< double >(val3);
9518 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9519 0 : if (!SWIG_IsOK(ecode4)) {
9520 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTMSO" "', argument " "4"" of type '" "double""'");
9521 : }
9522 0 : arg4 = static_cast< double >(val4);
9523 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9524 0 : if (!SWIG_IsOK(ecode5)) {
9525 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetTMSO" "', argument " "5"" of type '" "double""'");
9526 : }
9527 0 : arg5 = static_cast< double >(val5);
9528 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
9529 0 : if (!SWIG_IsOK(ecode6)) {
9530 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetTMSO" "', argument " "6"" of type '" "double""'");
9531 : }
9532 0 : arg6 = static_cast< double >(val6);
9533 : {
9534 0 : if ( bUseExceptions ) {
9535 0 : CPLErrorReset();
9536 : }
9537 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetTMSO(arg1,arg2,arg3,arg4,arg5,arg6);
9538 0 : if ( bUseExceptions ) {
9539 0 : CPLErr eclass = CPLGetLastErrorType();
9540 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9541 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9542 : }
9543 : }
9544 : }
9545 : {
9546 : /* %typemap(out) OGRErr */
9547 0 : if ( result != 0 && bUseExceptions) {
9548 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9549 0 : SWIG_fail;
9550 : }
9551 : }
9552 : {
9553 : /* %typemap(ret) OGRErr */
9554 0 : if (resultobj == Py_None ) {
9555 0 : Py_DECREF(resultobj);
9556 0 : resultobj = 0;
9557 : }
9558 0 : if (resultobj == 0) {
9559 0 : resultobj = PyInt_FromLong( result );
9560 : }
9561 : }
9562 0 : return resultobj;
9563 : fail:
9564 0 : return NULL;
9565 : }
9566 :
9567 :
9568 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetVDG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9569 0 : PyObject *resultobj = 0;
9570 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9571 : double arg2 ;
9572 : double arg3 ;
9573 : double arg4 ;
9574 0 : void *argp1 = 0 ;
9575 0 : int res1 = 0 ;
9576 : double val2 ;
9577 0 : int ecode2 = 0 ;
9578 : double val3 ;
9579 0 : int ecode3 = 0 ;
9580 : double val4 ;
9581 0 : int ecode4 = 0 ;
9582 0 : PyObject * obj0 = 0 ;
9583 0 : PyObject * obj1 = 0 ;
9584 0 : PyObject * obj2 = 0 ;
9585 0 : PyObject * obj3 = 0 ;
9586 : char * kwnames[] = {
9587 : (char *) "self",(char *) "clong",(char *) "fe",(char *) "fn", NULL
9588 0 : };
9589 : OGRErr result;
9590 :
9591 0 : if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:SpatialReference_SetVDG",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9592 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9593 0 : if (!SWIG_IsOK(res1)) {
9594 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetVDG" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9595 : }
9596 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9597 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9598 0 : if (!SWIG_IsOK(ecode2)) {
9599 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetVDG" "', argument " "2"" of type '" "double""'");
9600 : }
9601 0 : arg2 = static_cast< double >(val2);
9602 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9603 0 : if (!SWIG_IsOK(ecode3)) {
9604 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetVDG" "', argument " "3"" of type '" "double""'");
9605 : }
9606 0 : arg3 = static_cast< double >(val3);
9607 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9608 0 : if (!SWIG_IsOK(ecode4)) {
9609 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetVDG" "', argument " "4"" of type '" "double""'");
9610 : }
9611 0 : arg4 = static_cast< double >(val4);
9612 : {
9613 0 : if ( bUseExceptions ) {
9614 0 : CPLErrorReset();
9615 : }
9616 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetVDG(arg1,arg2,arg3,arg4);
9617 0 : if ( bUseExceptions ) {
9618 0 : CPLErr eclass = CPLGetLastErrorType();
9619 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9620 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9621 : }
9622 : }
9623 : }
9624 : {
9625 : /* %typemap(out) OGRErr */
9626 0 : if ( result != 0 && bUseExceptions) {
9627 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9628 0 : SWIG_fail;
9629 : }
9630 : }
9631 : {
9632 : /* %typemap(ret) OGRErr */
9633 0 : if (resultobj == Py_None ) {
9634 0 : Py_DECREF(resultobj);
9635 0 : resultobj = 0;
9636 : }
9637 0 : if (resultobj == 0) {
9638 0 : resultobj = PyInt_FromLong( result );
9639 : }
9640 : }
9641 0 : return resultobj;
9642 : fail:
9643 0 : return NULL;
9644 : }
9645 :
9646 :
9647 41 : SWIGINTERN PyObject *_wrap_SpatialReference_SetWellKnownGeogCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9648 41 : PyObject *resultobj = 0;
9649 41 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9650 41 : char *arg2 = (char *) 0 ;
9651 41 : void *argp1 = 0 ;
9652 41 : int res1 = 0 ;
9653 : int res2 ;
9654 41 : char *buf2 = 0 ;
9655 41 : int alloc2 = 0 ;
9656 41 : PyObject * obj0 = 0 ;
9657 41 : PyObject * obj1 = 0 ;
9658 : OGRErr result;
9659 :
9660 41 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_SetWellKnownGeogCS",&obj0,&obj1)) SWIG_fail;
9661 41 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9662 41 : if (!SWIG_IsOK(res1)) {
9663 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetWellKnownGeogCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9664 : }
9665 41 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9666 41 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9667 41 : if (!SWIG_IsOK(res2)) {
9668 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetWellKnownGeogCS" "', argument " "2"" of type '" "char const *""'");
9669 : }
9670 41 : arg2 = reinterpret_cast< char * >(buf2);
9671 : {
9672 41 : if (!arg2) {
9673 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9674 : }
9675 : }
9676 : {
9677 41 : if ( bUseExceptions ) {
9678 0 : CPLErrorReset();
9679 : }
9680 41 : result = (OGRErr)OSRSpatialReferenceShadow_SetWellKnownGeogCS(arg1,(char const *)arg2);
9681 41 : if ( bUseExceptions ) {
9682 0 : CPLErr eclass = CPLGetLastErrorType();
9683 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9684 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9685 : }
9686 : }
9687 : }
9688 : {
9689 : /* %typemap(out) OGRErr */
9690 41 : if ( result != 0 && bUseExceptions) {
9691 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9692 0 : SWIG_fail;
9693 : }
9694 : }
9695 41 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9696 : {
9697 : /* %typemap(ret) OGRErr */
9698 41 : if (resultobj == Py_None ) {
9699 0 : Py_DECREF(resultobj);
9700 0 : resultobj = 0;
9701 : }
9702 41 : if (resultobj == 0) {
9703 41 : resultobj = PyInt_FromLong( result );
9704 : }
9705 : }
9706 41 : return resultobj;
9707 : fail:
9708 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9709 0 : return NULL;
9710 : }
9711 :
9712 :
9713 251 : SWIGINTERN PyObject *_wrap_SpatialReference_SetFromUserInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9714 251 : PyObject *resultobj = 0;
9715 251 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9716 251 : char *arg2 = (char *) 0 ;
9717 251 : void *argp1 = 0 ;
9718 251 : int res1 = 0 ;
9719 : int res2 ;
9720 251 : char *buf2 = 0 ;
9721 251 : int alloc2 = 0 ;
9722 251 : PyObject * obj0 = 0 ;
9723 251 : PyObject * obj1 = 0 ;
9724 : OGRErr result;
9725 :
9726 251 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_SetFromUserInput",&obj0,&obj1)) SWIG_fail;
9727 251 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9728 251 : if (!SWIG_IsOK(res1)) {
9729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetFromUserInput" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9730 : }
9731 251 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9732 251 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9733 251 : if (!SWIG_IsOK(res2)) {
9734 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetFromUserInput" "', argument " "2"" of type '" "char const *""'");
9735 : }
9736 251 : arg2 = reinterpret_cast< char * >(buf2);
9737 : {
9738 251 : if (!arg2) {
9739 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9740 : }
9741 : }
9742 : {
9743 251 : if ( bUseExceptions ) {
9744 0 : CPLErrorReset();
9745 : }
9746 251 : result = (OGRErr)OSRSpatialReferenceShadow_SetFromUserInput(arg1,(char const *)arg2);
9747 251 : if ( bUseExceptions ) {
9748 0 : CPLErr eclass = CPLGetLastErrorType();
9749 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9750 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9751 : }
9752 : }
9753 : }
9754 : {
9755 : /* %typemap(out) OGRErr */
9756 251 : if ( result != 0 && bUseExceptions) {
9757 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9758 0 : SWIG_fail;
9759 : }
9760 : }
9761 251 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9762 : {
9763 : /* %typemap(ret) OGRErr */
9764 251 : if (resultobj == Py_None ) {
9765 0 : Py_DECREF(resultobj);
9766 0 : resultobj = 0;
9767 : }
9768 251 : if (resultobj == 0) {
9769 251 : resultobj = PyInt_FromLong( result );
9770 : }
9771 : }
9772 251 : return resultobj;
9773 : fail:
9774 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9775 0 : return NULL;
9776 : }
9777 :
9778 :
9779 0 : SWIGINTERN PyObject *_wrap_SpatialReference_CopyGeogCSFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780 0 : PyObject *resultobj = 0;
9781 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9782 0 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
9783 0 : void *argp1 = 0 ;
9784 0 : int res1 = 0 ;
9785 0 : void *argp2 = 0 ;
9786 0 : int res2 = 0 ;
9787 0 : PyObject * obj0 = 0 ;
9788 0 : PyObject * obj1 = 0 ;
9789 : OGRErr result;
9790 :
9791 0 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_CopyGeogCSFrom",&obj0,&obj1)) SWIG_fail;
9792 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9793 0 : if (!SWIG_IsOK(res1)) {
9794 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_CopyGeogCSFrom" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9795 : }
9796 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9797 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9798 0 : if (!SWIG_IsOK(res2)) {
9799 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_CopyGeogCSFrom" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
9800 : }
9801 0 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
9802 : {
9803 0 : if (!arg2) {
9804 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9805 : }
9806 : }
9807 : {
9808 0 : if ( bUseExceptions ) {
9809 0 : CPLErrorReset();
9810 : }
9811 0 : result = (OGRErr)OSRSpatialReferenceShadow_CopyGeogCSFrom(arg1,arg2);
9812 0 : if ( bUseExceptions ) {
9813 0 : CPLErr eclass = CPLGetLastErrorType();
9814 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9815 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9816 : }
9817 : }
9818 : }
9819 : {
9820 : /* %typemap(out) OGRErr */
9821 0 : if ( result != 0 && bUseExceptions) {
9822 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9823 0 : SWIG_fail;
9824 : }
9825 : }
9826 : {
9827 : /* %typemap(ret) OGRErr */
9828 0 : if (resultobj == Py_None ) {
9829 0 : Py_DECREF(resultobj);
9830 0 : resultobj = 0;
9831 : }
9832 0 : if (resultobj == 0) {
9833 0 : resultobj = PyInt_FromLong( result );
9834 : }
9835 : }
9836 0 : return resultobj;
9837 : fail:
9838 0 : return NULL;
9839 : }
9840 :
9841 :
9842 20 : SWIGINTERN PyObject *_wrap_SpatialReference_SetTOWGS84(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9843 20 : PyObject *resultobj = 0;
9844 20 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9845 : double arg2 ;
9846 : double arg3 ;
9847 : double arg4 ;
9848 20 : double arg5 = (double) 0.0 ;
9849 20 : double arg6 = (double) 0.0 ;
9850 20 : double arg7 = (double) 0.0 ;
9851 20 : double arg8 = (double) 0.0 ;
9852 20 : void *argp1 = 0 ;
9853 20 : int res1 = 0 ;
9854 : double val2 ;
9855 20 : int ecode2 = 0 ;
9856 : double val3 ;
9857 20 : int ecode3 = 0 ;
9858 : double val4 ;
9859 20 : int ecode4 = 0 ;
9860 : double val5 ;
9861 20 : int ecode5 = 0 ;
9862 : double val6 ;
9863 20 : int ecode6 = 0 ;
9864 : double val7 ;
9865 20 : int ecode7 = 0 ;
9866 : double val8 ;
9867 20 : int ecode8 = 0 ;
9868 20 : PyObject * obj0 = 0 ;
9869 20 : PyObject * obj1 = 0 ;
9870 20 : PyObject * obj2 = 0 ;
9871 20 : PyObject * obj3 = 0 ;
9872 20 : PyObject * obj4 = 0 ;
9873 20 : PyObject * obj5 = 0 ;
9874 20 : PyObject * obj6 = 0 ;
9875 20 : PyObject * obj7 = 0 ;
9876 : OGRErr result;
9877 :
9878 20 : if (!PyArg_ParseTuple(args,(char *)"OOOO|OOOO:SpatialReference_SetTOWGS84",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9879 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9880 20 : if (!SWIG_IsOK(res1)) {
9881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetTOWGS84" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9882 : }
9883 20 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9884 20 : ecode2 = SWIG_AsVal_double(obj1, &val2);
9885 20 : if (!SWIG_IsOK(ecode2)) {
9886 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_SetTOWGS84" "', argument " "2"" of type '" "double""'");
9887 : }
9888 20 : arg2 = static_cast< double >(val2);
9889 20 : ecode3 = SWIG_AsVal_double(obj2, &val3);
9890 20 : if (!SWIG_IsOK(ecode3)) {
9891 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_SetTOWGS84" "', argument " "3"" of type '" "double""'");
9892 : }
9893 20 : arg3 = static_cast< double >(val3);
9894 20 : ecode4 = SWIG_AsVal_double(obj3, &val4);
9895 20 : if (!SWIG_IsOK(ecode4)) {
9896 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetTOWGS84" "', argument " "4"" of type '" "double""'");
9897 : }
9898 20 : arg4 = static_cast< double >(val4);
9899 20 : if (obj4) {
9900 19 : ecode5 = SWIG_AsVal_double(obj4, &val5);
9901 19 : if (!SWIG_IsOK(ecode5)) {
9902 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetTOWGS84" "', argument " "5"" of type '" "double""'");
9903 : }
9904 19 : arg5 = static_cast< double >(val5);
9905 : }
9906 20 : if (obj5) {
9907 19 : ecode6 = SWIG_AsVal_double(obj5, &val6);
9908 19 : if (!SWIG_IsOK(ecode6)) {
9909 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetTOWGS84" "', argument " "6"" of type '" "double""'");
9910 : }
9911 19 : arg6 = static_cast< double >(val6);
9912 : }
9913 20 : if (obj6) {
9914 19 : ecode7 = SWIG_AsVal_double(obj6, &val7);
9915 19 : if (!SWIG_IsOK(ecode7)) {
9916 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpatialReference_SetTOWGS84" "', argument " "7"" of type '" "double""'");
9917 : }
9918 19 : arg7 = static_cast< double >(val7);
9919 : }
9920 20 : if (obj7) {
9921 19 : ecode8 = SWIG_AsVal_double(obj7, &val8);
9922 19 : if (!SWIG_IsOK(ecode8)) {
9923 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpatialReference_SetTOWGS84" "', argument " "8"" of type '" "double""'");
9924 : }
9925 19 : arg8 = static_cast< double >(val8);
9926 : }
9927 : {
9928 20 : if ( bUseExceptions ) {
9929 0 : CPLErrorReset();
9930 : }
9931 20 : result = (OGRErr)OSRSpatialReferenceShadow_SetTOWGS84(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
9932 20 : if ( bUseExceptions ) {
9933 0 : CPLErr eclass = CPLGetLastErrorType();
9934 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9935 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9936 : }
9937 : }
9938 : }
9939 : {
9940 : /* %typemap(out) OGRErr */
9941 20 : if ( result != 0 && bUseExceptions) {
9942 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9943 0 : SWIG_fail;
9944 : }
9945 : }
9946 : {
9947 : /* %typemap(ret) OGRErr */
9948 20 : if (resultobj == Py_None ) {
9949 0 : Py_DECREF(resultobj);
9950 0 : resultobj = 0;
9951 : }
9952 20 : if (resultobj == 0) {
9953 20 : resultobj = PyInt_FromLong( result );
9954 : }
9955 : }
9956 20 : return resultobj;
9957 : fail:
9958 0 : return NULL;
9959 : }
9960 :
9961 :
9962 2 : SWIGINTERN PyObject *_wrap_SpatialReference_GetTOWGS84(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9963 2 : PyObject *resultobj = 0;
9964 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
9965 : double *arg2 ;
9966 2 : void *argp1 = 0 ;
9967 2 : int res1 = 0 ;
9968 : double argout2[7] ;
9969 2 : PyObject * obj0 = 0 ;
9970 : OGRErr result;
9971 :
9972 : {
9973 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
9974 2 : arg2 = argout2;
9975 : }
9976 2 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_GetTOWGS84",&obj0)) SWIG_fail;
9977 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
9978 2 : if (!SWIG_IsOK(res1)) {
9979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_GetTOWGS84" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
9980 : }
9981 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
9982 : {
9983 2 : if ( bUseExceptions ) {
9984 0 : CPLErrorReset();
9985 : }
9986 2 : result = (OGRErr)OSRSpatialReferenceShadow_GetTOWGS84(arg1,arg2);
9987 2 : if ( bUseExceptions ) {
9988 0 : CPLErr eclass = CPLGetLastErrorType();
9989 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9990 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9991 : }
9992 : }
9993 : }
9994 : {
9995 : /* %typemap(out) OGRErr */
9996 2 : if ( result != 0 && bUseExceptions) {
9997 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9998 0 : SWIG_fail;
9999 : }
10000 : }
10001 : {
10002 : /* %typemap(argout) (double argout[ANY]) */
10003 2 : PyObject *out = CreateTupleFromDoubleArray( arg2, 7 );
10004 2 : resultobj = t_output_helper(resultobj,out);
10005 : }
10006 : {
10007 : /* %typemap(ret) OGRErr */
10008 2 : if (resultobj == Py_None ) {
10009 0 : Py_DECREF(resultobj);
10010 0 : resultobj = 0;
10011 : }
10012 2 : if (resultobj == 0) {
10013 0 : resultobj = PyInt_FromLong( result );
10014 : }
10015 : }
10016 2 : return resultobj;
10017 : fail:
10018 0 : return NULL;
10019 : }
10020 :
10021 :
10022 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetLocalCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10023 0 : PyObject *resultobj = 0;
10024 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10025 0 : char *arg2 = (char *) 0 ;
10026 0 : void *argp1 = 0 ;
10027 0 : int res1 = 0 ;
10028 : int res2 ;
10029 0 : char *buf2 = 0 ;
10030 0 : int alloc2 = 0 ;
10031 0 : PyObject * obj0 = 0 ;
10032 0 : PyObject * obj1 = 0 ;
10033 : OGRErr result;
10034 :
10035 0 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_SetLocalCS",&obj0,&obj1)) SWIG_fail;
10036 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10037 0 : if (!SWIG_IsOK(res1)) {
10038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetLocalCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10039 : }
10040 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10041 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10042 0 : if (!SWIG_IsOK(res2)) {
10043 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetLocalCS" "', argument " "2"" of type '" "char const *""'");
10044 : }
10045 0 : arg2 = reinterpret_cast< char * >(buf2);
10046 : {
10047 0 : if ( bUseExceptions ) {
10048 0 : CPLErrorReset();
10049 : }
10050 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetLocalCS(arg1,(char const *)arg2);
10051 0 : if ( bUseExceptions ) {
10052 0 : CPLErr eclass = CPLGetLastErrorType();
10053 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10054 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10055 : }
10056 : }
10057 : }
10058 : {
10059 : /* %typemap(out) OGRErr */
10060 0 : if ( result != 0 && bUseExceptions) {
10061 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10062 0 : SWIG_fail;
10063 : }
10064 : }
10065 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10066 : {
10067 : /* %typemap(ret) OGRErr */
10068 0 : if (resultobj == Py_None ) {
10069 0 : Py_DECREF(resultobj);
10070 0 : resultobj = 0;
10071 : }
10072 0 : if (resultobj == 0) {
10073 0 : resultobj = PyInt_FromLong( result );
10074 : }
10075 : }
10076 0 : return resultobj;
10077 : fail:
10078 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10079 0 : return NULL;
10080 : }
10081 :
10082 :
10083 1 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGeogCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10084 1 : PyObject *resultobj = 0;
10085 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10086 1 : char *arg2 = (char *) 0 ;
10087 1 : char *arg3 = (char *) 0 ;
10088 1 : char *arg4 = (char *) 0 ;
10089 : double arg5 ;
10090 : double arg6 ;
10091 1 : char *arg7 = (char *) "Greenwich" ;
10092 1 : double arg8 = (double) 0.0 ;
10093 1 : char *arg9 = (char *) "degree" ;
10094 1 : double arg10 = (double) 0.0174532925199433 ;
10095 1 : void *argp1 = 0 ;
10096 1 : int res1 = 0 ;
10097 : int res2 ;
10098 1 : char *buf2 = 0 ;
10099 1 : int alloc2 = 0 ;
10100 : int res3 ;
10101 1 : char *buf3 = 0 ;
10102 1 : int alloc3 = 0 ;
10103 : int res4 ;
10104 1 : char *buf4 = 0 ;
10105 1 : int alloc4 = 0 ;
10106 : double val5 ;
10107 1 : int ecode5 = 0 ;
10108 : double val6 ;
10109 1 : int ecode6 = 0 ;
10110 : int res7 ;
10111 1 : char *buf7 = 0 ;
10112 1 : int alloc7 = 0 ;
10113 : double val8 ;
10114 1 : int ecode8 = 0 ;
10115 : int res9 ;
10116 1 : char *buf9 = 0 ;
10117 1 : int alloc9 = 0 ;
10118 : double val10 ;
10119 1 : int ecode10 = 0 ;
10120 1 : PyObject * obj0 = 0 ;
10121 1 : PyObject * obj1 = 0 ;
10122 1 : PyObject * obj2 = 0 ;
10123 1 : PyObject * obj3 = 0 ;
10124 1 : PyObject * obj4 = 0 ;
10125 1 : PyObject * obj5 = 0 ;
10126 1 : PyObject * obj6 = 0 ;
10127 1 : PyObject * obj7 = 0 ;
10128 1 : PyObject * obj8 = 0 ;
10129 1 : PyObject * obj9 = 0 ;
10130 : OGRErr result;
10131 :
10132 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OOOO:SpatialReference_SetGeogCS",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
10133 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10134 1 : if (!SWIG_IsOK(res1)) {
10135 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGeogCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10136 : }
10137 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10138 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10139 1 : if (!SWIG_IsOK(res2)) {
10140 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetGeogCS" "', argument " "2"" of type '" "char const *""'");
10141 : }
10142 1 : arg2 = reinterpret_cast< char * >(buf2);
10143 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
10144 1 : if (!SWIG_IsOK(res3)) {
10145 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetGeogCS" "', argument " "3"" of type '" "char const *""'");
10146 : }
10147 1 : arg3 = reinterpret_cast< char * >(buf3);
10148 1 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10149 1 : if (!SWIG_IsOK(res4)) {
10150 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialReference_SetGeogCS" "', argument " "4"" of type '" "char const *""'");
10151 : }
10152 1 : arg4 = reinterpret_cast< char * >(buf4);
10153 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
10154 1 : if (!SWIG_IsOK(ecode5)) {
10155 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_SetGeogCS" "', argument " "5"" of type '" "double""'");
10156 : }
10157 1 : arg5 = static_cast< double >(val5);
10158 1 : ecode6 = SWIG_AsVal_double(obj5, &val6);
10159 1 : if (!SWIG_IsOK(ecode6)) {
10160 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpatialReference_SetGeogCS" "', argument " "6"" of type '" "double""'");
10161 : }
10162 1 : arg6 = static_cast< double >(val6);
10163 1 : if (obj6) {
10164 0 : res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
10165 0 : if (!SWIG_IsOK(res7)) {
10166 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SpatialReference_SetGeogCS" "', argument " "7"" of type '" "char const *""'");
10167 : }
10168 0 : arg7 = reinterpret_cast< char * >(buf7);
10169 : }
10170 1 : if (obj7) {
10171 0 : ecode8 = SWIG_AsVal_double(obj7, &val8);
10172 0 : if (!SWIG_IsOK(ecode8)) {
10173 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpatialReference_SetGeogCS" "', argument " "8"" of type '" "double""'");
10174 : }
10175 0 : arg8 = static_cast< double >(val8);
10176 : }
10177 1 : if (obj8) {
10178 0 : res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
10179 0 : if (!SWIG_IsOK(res9)) {
10180 0 : SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SpatialReference_SetGeogCS" "', argument " "9"" of type '" "char const *""'");
10181 : }
10182 0 : arg9 = reinterpret_cast< char * >(buf9);
10183 : }
10184 1 : if (obj9) {
10185 0 : ecode10 = SWIG_AsVal_double(obj9, &val10);
10186 0 : if (!SWIG_IsOK(ecode10)) {
10187 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SpatialReference_SetGeogCS" "', argument " "10"" of type '" "double""'");
10188 : }
10189 0 : arg10 = static_cast< double >(val10);
10190 : }
10191 : {
10192 1 : if ( bUseExceptions ) {
10193 0 : CPLErrorReset();
10194 : }
10195 1 : result = (OGRErr)OSRSpatialReferenceShadow_SetGeogCS(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,(char const *)arg7,arg8,(char const *)arg9,arg10);
10196 1 : if ( bUseExceptions ) {
10197 0 : CPLErr eclass = CPLGetLastErrorType();
10198 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10199 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10200 : }
10201 : }
10202 : }
10203 : {
10204 : /* %typemap(out) OGRErr */
10205 1 : if ( result != 0 && bUseExceptions) {
10206 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10207 0 : SWIG_fail;
10208 : }
10209 : }
10210 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10211 1 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10212 1 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10213 1 : if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
10214 1 : if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
10215 : {
10216 : /* %typemap(ret) OGRErr */
10217 1 : if (resultobj == Py_None ) {
10218 0 : Py_DECREF(resultobj);
10219 0 : resultobj = 0;
10220 : }
10221 1 : if (resultobj == 0) {
10222 1 : resultobj = PyInt_FromLong( result );
10223 : }
10224 : }
10225 1 : return resultobj;
10226 : fail:
10227 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10228 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10229 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10230 0 : if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
10231 0 : if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
10232 0 : return NULL;
10233 : }
10234 :
10235 :
10236 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetProjCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10237 0 : PyObject *resultobj = 0;
10238 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10239 0 : char *arg2 = (char *) "unnamed" ;
10240 0 : void *argp1 = 0 ;
10241 0 : int res1 = 0 ;
10242 : int res2 ;
10243 0 : char *buf2 = 0 ;
10244 0 : int alloc2 = 0 ;
10245 0 : PyObject * obj0 = 0 ;
10246 0 : PyObject * obj1 = 0 ;
10247 : OGRErr result;
10248 :
10249 0 : if (!PyArg_ParseTuple(args,(char *)"O|O:SpatialReference_SetProjCS",&obj0,&obj1)) SWIG_fail;
10250 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10251 0 : if (!SWIG_IsOK(res1)) {
10252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetProjCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10253 : }
10254 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10255 0 : if (obj1) {
10256 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10257 0 : if (!SWIG_IsOK(res2)) {
10258 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetProjCS" "', argument " "2"" of type '" "char const *""'");
10259 : }
10260 0 : arg2 = reinterpret_cast< char * >(buf2);
10261 : }
10262 : {
10263 0 : if (!arg2) {
10264 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10265 : }
10266 : }
10267 : {
10268 0 : if ( bUseExceptions ) {
10269 0 : CPLErrorReset();
10270 : }
10271 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetProjCS(arg1,(char const *)arg2);
10272 0 : if ( bUseExceptions ) {
10273 0 : CPLErr eclass = CPLGetLastErrorType();
10274 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10275 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10276 : }
10277 : }
10278 : }
10279 : {
10280 : /* %typemap(out) OGRErr */
10281 0 : if ( result != 0 && bUseExceptions) {
10282 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10283 0 : SWIG_fail;
10284 : }
10285 : }
10286 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10287 : {
10288 : /* %typemap(ret) OGRErr */
10289 0 : if (resultobj == Py_None ) {
10290 0 : Py_DECREF(resultobj);
10291 0 : resultobj = 0;
10292 : }
10293 0 : if (resultobj == 0) {
10294 0 : resultobj = PyInt_FromLong( result );
10295 : }
10296 : }
10297 0 : return resultobj;
10298 : fail:
10299 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10300 0 : return NULL;
10301 : }
10302 :
10303 :
10304 5 : SWIGINTERN PyObject *_wrap_SpatialReference_SetGeocCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10305 5 : PyObject *resultobj = 0;
10306 5 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10307 5 : char *arg2 = (char *) "unnamed" ;
10308 5 : void *argp1 = 0 ;
10309 5 : int res1 = 0 ;
10310 : int res2 ;
10311 5 : char *buf2 = 0 ;
10312 5 : int alloc2 = 0 ;
10313 5 : PyObject * obj0 = 0 ;
10314 5 : PyObject * obj1 = 0 ;
10315 : OGRErr result;
10316 :
10317 5 : if (!PyArg_ParseTuple(args,(char *)"O|O:SpatialReference_SetGeocCS",&obj0,&obj1)) SWIG_fail;
10318 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10319 5 : if (!SWIG_IsOK(res1)) {
10320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetGeocCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10321 : }
10322 5 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10323 5 : if (obj1) {
10324 5 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10325 5 : if (!SWIG_IsOK(res2)) {
10326 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetGeocCS" "', argument " "2"" of type '" "char const *""'");
10327 : }
10328 5 : arg2 = reinterpret_cast< char * >(buf2);
10329 : }
10330 : {
10331 5 : if (!arg2) {
10332 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10333 : }
10334 : }
10335 : {
10336 5 : if ( bUseExceptions ) {
10337 0 : CPLErrorReset();
10338 : }
10339 5 : result = (OGRErr)OSRSpatialReferenceShadow_SetGeocCS(arg1,(char const *)arg2);
10340 5 : if ( bUseExceptions ) {
10341 0 : CPLErr eclass = CPLGetLastErrorType();
10342 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10343 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10344 : }
10345 : }
10346 : }
10347 : {
10348 : /* %typemap(out) OGRErr */
10349 5 : if ( result != 0 && bUseExceptions) {
10350 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10351 0 : SWIG_fail;
10352 : }
10353 : }
10354 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10355 : {
10356 : /* %typemap(ret) OGRErr */
10357 5 : if (resultobj == Py_None ) {
10358 0 : Py_DECREF(resultobj);
10359 0 : resultobj = 0;
10360 : }
10361 5 : if (resultobj == 0) {
10362 5 : resultobj = PyInt_FromLong( result );
10363 : }
10364 : }
10365 5 : return resultobj;
10366 : fail:
10367 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10368 0 : return NULL;
10369 : }
10370 :
10371 :
10372 0 : SWIGINTERN PyObject *_wrap_SpatialReference_SetVertCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10373 0 : PyObject *resultobj = 0;
10374 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10375 0 : char *arg2 = (char *) "unnamed" ;
10376 0 : char *arg3 = (char *) "unnamed" ;
10377 0 : int arg4 = (int) 0 ;
10378 0 : void *argp1 = 0 ;
10379 0 : int res1 = 0 ;
10380 : int res2 ;
10381 0 : char *buf2 = 0 ;
10382 0 : int alloc2 = 0 ;
10383 : int res3 ;
10384 0 : char *buf3 = 0 ;
10385 0 : int alloc3 = 0 ;
10386 : int val4 ;
10387 0 : int ecode4 = 0 ;
10388 0 : PyObject * obj0 = 0 ;
10389 0 : PyObject * obj1 = 0 ;
10390 0 : PyObject * obj2 = 0 ;
10391 0 : PyObject * obj3 = 0 ;
10392 : OGRErr result;
10393 :
10394 0 : if (!PyArg_ParseTuple(args,(char *)"O|OOO:SpatialReference_SetVertCS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10395 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10396 0 : if (!SWIG_IsOK(res1)) {
10397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetVertCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10398 : }
10399 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10400 0 : if (obj1) {
10401 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10402 0 : if (!SWIG_IsOK(res2)) {
10403 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetVertCS" "', argument " "2"" of type '" "char const *""'");
10404 : }
10405 0 : arg2 = reinterpret_cast< char * >(buf2);
10406 : }
10407 0 : if (obj2) {
10408 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
10409 0 : if (!SWIG_IsOK(res3)) {
10410 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetVertCS" "', argument " "3"" of type '" "char const *""'");
10411 : }
10412 0 : arg3 = reinterpret_cast< char * >(buf3);
10413 : }
10414 0 : if (obj3) {
10415 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
10416 0 : if (!SWIG_IsOK(ecode4)) {
10417 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpatialReference_SetVertCS" "', argument " "4"" of type '" "int""'");
10418 : }
10419 0 : arg4 = static_cast< int >(val4);
10420 : }
10421 : {
10422 0 : if ( bUseExceptions ) {
10423 0 : CPLErrorReset();
10424 : }
10425 0 : result = (OGRErr)OSRSpatialReferenceShadow_SetVertCS(arg1,(char const *)arg2,(char const *)arg3,arg4);
10426 0 : if ( bUseExceptions ) {
10427 0 : CPLErr eclass = CPLGetLastErrorType();
10428 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10429 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10430 : }
10431 : }
10432 : }
10433 : {
10434 : /* %typemap(out) OGRErr */
10435 0 : if ( result != 0 && bUseExceptions) {
10436 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10437 0 : SWIG_fail;
10438 : }
10439 : }
10440 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10441 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10442 : {
10443 : /* %typemap(ret) OGRErr */
10444 0 : if (resultobj == Py_None ) {
10445 0 : Py_DECREF(resultobj);
10446 0 : resultobj = 0;
10447 : }
10448 0 : if (resultobj == 0) {
10449 0 : resultobj = PyInt_FromLong( result );
10450 : }
10451 : }
10452 0 : return resultobj;
10453 : fail:
10454 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10455 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10456 0 : return NULL;
10457 : }
10458 :
10459 :
10460 1 : SWIGINTERN PyObject *_wrap_SpatialReference_SetCompoundCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10461 1 : PyObject *resultobj = 0;
10462 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10463 1 : char *arg2 = (char *) 0 ;
10464 1 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
10465 1 : OSRSpatialReferenceShadow *arg4 = (OSRSpatialReferenceShadow *) 0 ;
10466 1 : void *argp1 = 0 ;
10467 1 : int res1 = 0 ;
10468 : int res2 ;
10469 1 : char *buf2 = 0 ;
10470 1 : int alloc2 = 0 ;
10471 1 : void *argp3 = 0 ;
10472 1 : int res3 = 0 ;
10473 1 : void *argp4 = 0 ;
10474 1 : int res4 = 0 ;
10475 1 : PyObject * obj0 = 0 ;
10476 1 : PyObject * obj1 = 0 ;
10477 1 : PyObject * obj2 = 0 ;
10478 1 : PyObject * obj3 = 0 ;
10479 : OGRErr result;
10480 :
10481 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:SpatialReference_SetCompoundCS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10482 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10483 1 : if (!SWIG_IsOK(res1)) {
10484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_SetCompoundCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10485 : }
10486 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10487 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10488 1 : if (!SWIG_IsOK(res2)) {
10489 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_SetCompoundCS" "', argument " "2"" of type '" "char const *""'");
10490 : }
10491 1 : arg2 = reinterpret_cast< char * >(buf2);
10492 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10493 1 : if (!SWIG_IsOK(res3)) {
10494 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_SetCompoundCS" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
10495 : }
10496 1 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
10497 1 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10498 1 : if (!SWIG_IsOK(res4)) {
10499 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialReference_SetCompoundCS" "', argument " "4"" of type '" "OSRSpatialReferenceShadow *""'");
10500 : }
10501 1 : arg4 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp4);
10502 : {
10503 1 : if (!arg2) {
10504 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10505 : }
10506 : }
10507 : {
10508 1 : if (!arg3) {
10509 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10510 : }
10511 : }
10512 : {
10513 1 : if (!arg4) {
10514 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10515 : }
10516 : }
10517 : {
10518 1 : if ( bUseExceptions ) {
10519 0 : CPLErrorReset();
10520 : }
10521 1 : result = (OGRErr)OSRSpatialReferenceShadow_SetCompoundCS(arg1,(char const *)arg2,arg3,arg4);
10522 1 : if ( bUseExceptions ) {
10523 0 : CPLErr eclass = CPLGetLastErrorType();
10524 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10525 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10526 : }
10527 : }
10528 : }
10529 : {
10530 : /* %typemap(out) OGRErr */
10531 1 : if ( result != 0 && bUseExceptions) {
10532 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10533 0 : SWIG_fail;
10534 : }
10535 : }
10536 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10537 : {
10538 : /* %typemap(ret) OGRErr */
10539 1 : if (resultobj == Py_None ) {
10540 0 : Py_DECREF(resultobj);
10541 0 : resultobj = 0;
10542 : }
10543 1 : if (resultobj == 0) {
10544 1 : resultobj = PyInt_FromLong( result );
10545 : }
10546 : }
10547 1 : return resultobj;
10548 : fail:
10549 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10550 0 : return NULL;
10551 : }
10552 :
10553 :
10554 6022 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10555 6022 : PyObject *resultobj = 0;
10556 6022 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10557 6022 : char **arg2 = (char **) 0 ;
10558 6022 : void *argp1 = 0 ;
10559 6022 : int res1 = 0 ;
10560 : char *val2 ;
10561 6022 : PyObject * obj0 = 0 ;
10562 6022 : PyObject * obj1 = 0 ;
10563 : OGRErr result;
10564 :
10565 6022 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromWkt",&obj0,&obj1)) SWIG_fail;
10566 6022 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10567 6022 : if (!SWIG_IsOK(res1)) {
10568 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromWkt" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10569 : }
10570 6022 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10571 : {
10572 : /* %typemap(in) (char **ignorechange) */
10573 6022 : PyArg_Parse( obj1, "s", &val2 );
10574 6022 : arg2 = &val2;
10575 : }
10576 : {
10577 6022 : if ( bUseExceptions ) {
10578 0 : CPLErrorReset();
10579 : }
10580 6022 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromWkt(arg1,arg2);
10581 6022 : if ( bUseExceptions ) {
10582 0 : CPLErr eclass = CPLGetLastErrorType();
10583 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10584 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10585 : }
10586 : }
10587 : }
10588 : {
10589 : /* %typemap(out) OGRErr */
10590 6022 : if ( result != 0 && bUseExceptions) {
10591 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10592 0 : SWIG_fail;
10593 : }
10594 : }
10595 : {
10596 : /* %typemap(ret) OGRErr */
10597 6022 : if (resultobj == Py_None ) {
10598 0 : Py_DECREF(resultobj);
10599 0 : resultobj = 0;
10600 : }
10601 6022 : if (resultobj == 0) {
10602 6022 : resultobj = PyInt_FromLong( result );
10603 : }
10604 : }
10605 6022 : return resultobj;
10606 : fail:
10607 0 : return NULL;
10608 : }
10609 :
10610 :
10611 73 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromProj4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10612 73 : PyObject *resultobj = 0;
10613 73 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10614 73 : char *arg2 = (char *) 0 ;
10615 73 : void *argp1 = 0 ;
10616 73 : int res1 = 0 ;
10617 : int res2 ;
10618 73 : char *buf2 = 0 ;
10619 73 : int alloc2 = 0 ;
10620 73 : PyObject * obj0 = 0 ;
10621 73 : PyObject * obj1 = 0 ;
10622 : OGRErr result;
10623 :
10624 73 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromProj4",&obj0,&obj1)) SWIG_fail;
10625 73 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10626 73 : if (!SWIG_IsOK(res1)) {
10627 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromProj4" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10628 : }
10629 73 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10630 73 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10631 73 : if (!SWIG_IsOK(res2)) {
10632 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromProj4" "', argument " "2"" of type '" "char *""'");
10633 : }
10634 73 : arg2 = reinterpret_cast< char * >(buf2);
10635 : {
10636 73 : if ( bUseExceptions ) {
10637 0 : CPLErrorReset();
10638 : }
10639 73 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromProj4(arg1,arg2);
10640 73 : if ( bUseExceptions ) {
10641 0 : CPLErr eclass = CPLGetLastErrorType();
10642 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10643 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10644 : }
10645 : }
10646 : }
10647 : {
10648 : /* %typemap(out) OGRErr */
10649 73 : if ( result != 0 && bUseExceptions) {
10650 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10651 0 : SWIG_fail;
10652 : }
10653 : }
10654 73 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10655 : {
10656 : /* %typemap(ret) OGRErr */
10657 73 : if (resultobj == Py_None ) {
10658 0 : Py_DECREF(resultobj);
10659 0 : resultobj = 0;
10660 : }
10661 73 : if (resultobj == 0) {
10662 73 : resultobj = PyInt_FromLong( result );
10663 : }
10664 : }
10665 73 : return resultobj;
10666 : fail:
10667 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10668 0 : return NULL;
10669 : }
10670 :
10671 :
10672 2 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromUrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 2 : PyObject *resultobj = 0;
10674 2 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10675 2 : char *arg2 = (char *) 0 ;
10676 2 : void *argp1 = 0 ;
10677 2 : int res1 = 0 ;
10678 : int res2 ;
10679 2 : char *buf2 = 0 ;
10680 2 : int alloc2 = 0 ;
10681 2 : PyObject * obj0 = 0 ;
10682 2 : PyObject * obj1 = 0 ;
10683 : OGRErr result;
10684 :
10685 2 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromUrl",&obj0,&obj1)) SWIG_fail;
10686 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10687 2 : if (!SWIG_IsOK(res1)) {
10688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromUrl" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10689 : }
10690 2 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10691 2 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10692 2 : if (!SWIG_IsOK(res2)) {
10693 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromUrl" "', argument " "2"" of type '" "char *""'");
10694 : }
10695 2 : arg2 = reinterpret_cast< char * >(buf2);
10696 : {
10697 2 : if (!arg2) {
10698 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10699 : }
10700 : }
10701 : {
10702 2 : if ( bUseExceptions ) {
10703 0 : CPLErrorReset();
10704 : }
10705 2 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromUrl(arg1,arg2);
10706 2 : if ( bUseExceptions ) {
10707 0 : CPLErr eclass = CPLGetLastErrorType();
10708 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10709 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10710 : }
10711 : }
10712 : }
10713 : {
10714 : /* %typemap(out) OGRErr */
10715 2 : if ( result != 0 && bUseExceptions) {
10716 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10717 0 : SWIG_fail;
10718 : }
10719 : }
10720 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10721 : {
10722 : /* %typemap(ret) OGRErr */
10723 2 : if (resultobj == Py_None ) {
10724 0 : Py_DECREF(resultobj);
10725 0 : resultobj = 0;
10726 : }
10727 2 : if (resultobj == 0) {
10728 2 : resultobj = PyInt_FromLong( result );
10729 : }
10730 : }
10731 2 : return resultobj;
10732 : fail:
10733 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10734 0 : return NULL;
10735 : }
10736 :
10737 :
10738 5 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromESRI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10739 5 : PyObject *resultobj = 0;
10740 5 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10741 5 : char **arg2 = (char **) 0 ;
10742 5 : void *argp1 = 0 ;
10743 5 : int res1 = 0 ;
10744 5 : PyObject * obj0 = 0 ;
10745 5 : PyObject * obj1 = 0 ;
10746 : OGRErr result;
10747 :
10748 5 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromESRI",&obj0,&obj1)) SWIG_fail;
10749 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10750 5 : if (!SWIG_IsOK(res1)) {
10751 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromESRI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10752 : }
10753 5 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10754 : {
10755 : /* %typemap(in) char **options */
10756 : /* Check if is a list (and reject strings, that are seen as sequence of characters) */
10757 5 : if ( ! PySequence_Check(obj1) || PyUnicode_Check(obj1)
10758 : #if PY_VERSION_HEX < 0x03000000
10759 : || PyString_Check(obj1)
10760 : #endif
10761 : ) {
10762 0 : PyErr_SetString(PyExc_TypeError,"not a sequence");
10763 0 : SWIG_fail;
10764 : }
10765 :
10766 5 : int size = PySequence_Size(obj1);
10767 48 : for (int i = 0; i < size; i++) {
10768 43 : PyObject* pyObj = PySequence_GetItem(obj1,i);
10769 43 : if (PyUnicode_Check(pyObj))
10770 : {
10771 : char *pszStr;
10772 : Py_ssize_t nLen;
10773 0 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObj);
10774 : #if PY_VERSION_HEX >= 0x03000000
10775 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
10776 : #else
10777 0 : PyString_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
10778 : #endif
10779 0 : arg2 = CSLAddString( arg2, pszStr );
10780 0 : Py_XDECREF(pyUTF8Str);
10781 : }
10782 : #if PY_VERSION_HEX >= 0x03000000
10783 : else if (PyBytes_Check(pyObj))
10784 : arg2 = CSLAddString( arg2, PyBytes_AsString(pyObj) );
10785 : #else
10786 43 : else if (PyString_Check(pyObj))
10787 43 : arg2 = CSLAddString( arg2, PyString_AsString(pyObj) );
10788 : #endif
10789 : else
10790 : {
10791 0 : Py_DECREF(pyObj);
10792 0 : PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
10793 0 : SWIG_fail;
10794 : }
10795 43 : Py_DECREF(pyObj);
10796 : }
10797 : }
10798 : {
10799 5 : if ( bUseExceptions ) {
10800 0 : CPLErrorReset();
10801 : }
10802 5 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromESRI(arg1,arg2);
10803 5 : if ( bUseExceptions ) {
10804 0 : CPLErr eclass = CPLGetLastErrorType();
10805 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10806 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10807 : }
10808 : }
10809 : }
10810 : {
10811 : /* %typemap(out) OGRErr */
10812 5 : if ( result != 0 && bUseExceptions) {
10813 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10814 0 : SWIG_fail;
10815 : }
10816 : }
10817 : {
10818 : /* %typemap(freearg) char **options */
10819 5 : CSLDestroy( arg2 );
10820 : }
10821 : {
10822 : /* %typemap(ret) OGRErr */
10823 5 : if (resultobj == Py_None ) {
10824 0 : Py_DECREF(resultobj);
10825 0 : resultobj = 0;
10826 : }
10827 5 : if (resultobj == 0) {
10828 5 : resultobj = PyInt_FromLong( result );
10829 : }
10830 : }
10831 5 : return resultobj;
10832 : fail:
10833 : {
10834 : /* %typemap(freearg) char **options */
10835 0 : CSLDestroy( arg2 );
10836 : }
10837 0 : return NULL;
10838 : }
10839 :
10840 :
10841 9211 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromEPSG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10842 9211 : PyObject *resultobj = 0;
10843 9211 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10844 : int arg2 ;
10845 9211 : void *argp1 = 0 ;
10846 9211 : int res1 = 0 ;
10847 : int val2 ;
10848 9211 : int ecode2 = 0 ;
10849 9211 : PyObject * obj0 = 0 ;
10850 9211 : PyObject * obj1 = 0 ;
10851 : OGRErr result;
10852 :
10853 9211 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromEPSG",&obj0,&obj1)) SWIG_fail;
10854 9211 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10855 9211 : if (!SWIG_IsOK(res1)) {
10856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromEPSG" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10857 : }
10858 9211 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10859 9211 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10860 9211 : if (!SWIG_IsOK(ecode2)) {
10861 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_ImportFromEPSG" "', argument " "2"" of type '" "int""'");
10862 : }
10863 9211 : arg2 = static_cast< int >(val2);
10864 : {
10865 9211 : if ( bUseExceptions ) {
10866 0 : CPLErrorReset();
10867 : }
10868 9211 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromEPSG(arg1,arg2);
10869 9211 : if ( bUseExceptions ) {
10870 0 : CPLErr eclass = CPLGetLastErrorType();
10871 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10872 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10873 : }
10874 : }
10875 : }
10876 : {
10877 : /* %typemap(out) OGRErr */
10878 9211 : if ( result != 0 && bUseExceptions) {
10879 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10880 0 : SWIG_fail;
10881 : }
10882 : }
10883 : {
10884 : /* %typemap(ret) OGRErr */
10885 9211 : if (resultobj == Py_None ) {
10886 0 : Py_DECREF(resultobj);
10887 0 : resultobj = 0;
10888 : }
10889 9211 : if (resultobj == 0) {
10890 9211 : resultobj = PyInt_FromLong( result );
10891 : }
10892 : }
10893 9211 : return resultobj;
10894 : fail:
10895 0 : return NULL;
10896 : }
10897 :
10898 :
10899 3 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromEPSGA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10900 3 : PyObject *resultobj = 0;
10901 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10902 : int arg2 ;
10903 3 : void *argp1 = 0 ;
10904 3 : int res1 = 0 ;
10905 : int val2 ;
10906 3 : int ecode2 = 0 ;
10907 3 : PyObject * obj0 = 0 ;
10908 3 : PyObject * obj1 = 0 ;
10909 : OGRErr result;
10910 :
10911 3 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromEPSGA",&obj0,&obj1)) SWIG_fail;
10912 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10913 3 : if (!SWIG_IsOK(res1)) {
10914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromEPSGA" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10915 : }
10916 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10917 3 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10918 3 : if (!SWIG_IsOK(ecode2)) {
10919 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_ImportFromEPSGA" "', argument " "2"" of type '" "int""'");
10920 : }
10921 3 : arg2 = static_cast< int >(val2);
10922 : {
10923 3 : if ( bUseExceptions ) {
10924 0 : CPLErrorReset();
10925 : }
10926 3 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromEPSGA(arg1,arg2);
10927 3 : if ( bUseExceptions ) {
10928 0 : CPLErr eclass = CPLGetLastErrorType();
10929 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10930 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10931 : }
10932 : }
10933 : }
10934 : {
10935 : /* %typemap(out) OGRErr */
10936 3 : if ( result != 0 && bUseExceptions) {
10937 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10938 0 : SWIG_fail;
10939 : }
10940 : }
10941 : {
10942 : /* %typemap(ret) OGRErr */
10943 3 : if (resultobj == Py_None ) {
10944 0 : Py_DECREF(resultobj);
10945 0 : resultobj = 0;
10946 : }
10947 3 : if (resultobj == 0) {
10948 3 : resultobj = PyInt_FromLong( result );
10949 : }
10950 : }
10951 3 : return resultobj;
10952 : fail:
10953 0 : return NULL;
10954 : }
10955 :
10956 :
10957 7 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromPCI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10958 7 : PyObject *resultobj = 0;
10959 7 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
10960 7 : char *arg2 = (char *) 0 ;
10961 7 : char *arg3 = (char *) "METRE" ;
10962 7 : double *arg4 = (double *) (double *)0 ;
10963 7 : void *argp1 = 0 ;
10964 7 : int res1 = 0 ;
10965 : int res2 ;
10966 7 : char *buf2 = 0 ;
10967 7 : int alloc2 = 0 ;
10968 : int res3 ;
10969 7 : char *buf3 = 0 ;
10970 7 : int alloc3 = 0 ;
10971 : double argin4[17] ;
10972 7 : PyObject * obj0 = 0 ;
10973 7 : PyObject * obj1 = 0 ;
10974 7 : PyObject * obj2 = 0 ;
10975 7 : PyObject * obj3 = 0 ;
10976 : OGRErr result;
10977 :
10978 7 : if (!PyArg_ParseTuple(args,(char *)"OO|OO:SpatialReference_ImportFromPCI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10979 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
10980 7 : if (!SWIG_IsOK(res1)) {
10981 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromPCI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
10982 : }
10983 7 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
10984 7 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10985 7 : if (!SWIG_IsOK(res2)) {
10986 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromPCI" "', argument " "2"" of type '" "char const *""'");
10987 : }
10988 7 : arg2 = reinterpret_cast< char * >(buf2);
10989 7 : if (obj2) {
10990 7 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
10991 7 : if (!SWIG_IsOK(res3)) {
10992 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_ImportFromPCI" "', argument " "3"" of type '" "char const *""'");
10993 : }
10994 7 : arg3 = reinterpret_cast< char * >(buf3);
10995 : }
10996 7 : if (obj3) {
10997 : {
10998 : /* %typemap(in) (double argin4[ANY]) */
10999 7 : arg4 = argin4;
11000 7 : if (! PySequence_Check(obj3) ) {
11001 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
11002 0 : SWIG_fail;
11003 : }
11004 7 : int seq_size = PySequence_Size(obj3);
11005 7 : if ( seq_size != 17 ) {
11006 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
11007 0 : SWIG_fail;
11008 : }
11009 126 : for (unsigned int i=0; i<17; i++) {
11010 119 : PyObject *o = PySequence_GetItem(obj3,i);
11011 : double val;
11012 119 : if ( !PyArg_Parse(o, "d", &val ) ) {
11013 0 : PyErr_SetString(PyExc_TypeError, "not a number");
11014 0 : Py_DECREF(o);
11015 : SWIG_fail;
11016 : }
11017 119 : arg4[i] = val;
11018 119 : Py_DECREF(o);
11019 : }
11020 : }
11021 : }
11022 : {
11023 7 : if ( bUseExceptions ) {
11024 0 : CPLErrorReset();
11025 : }
11026 7 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromPCI(arg1,(char const *)arg2,(char const *)arg3,arg4);
11027 7 : if ( bUseExceptions ) {
11028 0 : CPLErr eclass = CPLGetLastErrorType();
11029 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11030 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11031 : }
11032 : }
11033 : }
11034 : {
11035 : /* %typemap(out) OGRErr */
11036 7 : if ( result != 0 && bUseExceptions) {
11037 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11038 0 : SWIG_fail;
11039 : }
11040 : }
11041 7 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11042 7 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11043 : {
11044 : /* %typemap(ret) OGRErr */
11045 7 : if (resultobj == Py_None ) {
11046 0 : Py_DECREF(resultobj);
11047 0 : resultobj = 0;
11048 : }
11049 7 : if (resultobj == 0) {
11050 7 : resultobj = PyInt_FromLong( result );
11051 : }
11052 : }
11053 7 : return resultobj;
11054 : fail:
11055 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11056 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11057 0 : return NULL;
11058 : }
11059 :
11060 :
11061 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromUSGS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 1 : PyObject *resultobj = 0;
11063 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11064 : long arg2 ;
11065 1 : long arg3 = (long) 0 ;
11066 1 : double *arg4 = (double *) (double *)0 ;
11067 1 : long arg5 = (long) 0 ;
11068 1 : void *argp1 = 0 ;
11069 1 : int res1 = 0 ;
11070 : long val2 ;
11071 1 : int ecode2 = 0 ;
11072 : long val3 ;
11073 1 : int ecode3 = 0 ;
11074 : double argin4[15] ;
11075 : long val5 ;
11076 1 : int ecode5 = 0 ;
11077 1 : PyObject * obj0 = 0 ;
11078 1 : PyObject * obj1 = 0 ;
11079 1 : PyObject * obj2 = 0 ;
11080 1 : PyObject * obj3 = 0 ;
11081 1 : PyObject * obj4 = 0 ;
11082 : OGRErr result;
11083 :
11084 1 : if (!PyArg_ParseTuple(args,(char *)"OO|OOO:SpatialReference_ImportFromUSGS",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11085 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11086 1 : if (!SWIG_IsOK(res1)) {
11087 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromUSGS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11088 : }
11089 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11090 1 : ecode2 = SWIG_AsVal_long(obj1, &val2);
11091 1 : if (!SWIG_IsOK(ecode2)) {
11092 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialReference_ImportFromUSGS" "', argument " "2"" of type '" "long""'");
11093 : }
11094 1 : arg2 = static_cast< long >(val2);
11095 1 : if (obj2) {
11096 1 : ecode3 = SWIG_AsVal_long(obj2, &val3);
11097 1 : if (!SWIG_IsOK(ecode3)) {
11098 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_ImportFromUSGS" "', argument " "3"" of type '" "long""'");
11099 : }
11100 1 : arg3 = static_cast< long >(val3);
11101 : }
11102 1 : if (obj3) {
11103 : {
11104 : /* %typemap(in) (double argin4[ANY]) */
11105 1 : arg4 = argin4;
11106 1 : if (! PySequence_Check(obj3) ) {
11107 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
11108 0 : SWIG_fail;
11109 : }
11110 1 : int seq_size = PySequence_Size(obj3);
11111 1 : if ( seq_size != 15 ) {
11112 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
11113 0 : SWIG_fail;
11114 : }
11115 16 : for (unsigned int i=0; i<15; i++) {
11116 15 : PyObject *o = PySequence_GetItem(obj3,i);
11117 : double val;
11118 15 : if ( !PyArg_Parse(o, "d", &val ) ) {
11119 0 : PyErr_SetString(PyExc_TypeError, "not a number");
11120 0 : Py_DECREF(o);
11121 : SWIG_fail;
11122 : }
11123 15 : arg4[i] = val;
11124 15 : Py_DECREF(o);
11125 : }
11126 : }
11127 : }
11128 1 : if (obj4) {
11129 1 : ecode5 = SWIG_AsVal_long(obj4, &val5);
11130 1 : if (!SWIG_IsOK(ecode5)) {
11131 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpatialReference_ImportFromUSGS" "', argument " "5"" of type '" "long""'");
11132 : }
11133 1 : arg5 = static_cast< long >(val5);
11134 : }
11135 : {
11136 1 : if ( bUseExceptions ) {
11137 0 : CPLErrorReset();
11138 : }
11139 1 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromUSGS(arg1,arg2,arg3,arg4,arg5);
11140 1 : if ( bUseExceptions ) {
11141 0 : CPLErr eclass = CPLGetLastErrorType();
11142 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11143 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11144 : }
11145 : }
11146 : }
11147 : {
11148 : /* %typemap(out) OGRErr */
11149 1 : if ( result != 0 && bUseExceptions) {
11150 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11151 0 : SWIG_fail;
11152 : }
11153 : }
11154 : {
11155 : /* %typemap(ret) OGRErr */
11156 1 : if (resultobj == Py_None ) {
11157 0 : Py_DECREF(resultobj);
11158 0 : resultobj = 0;
11159 : }
11160 1 : if (resultobj == 0) {
11161 1 : resultobj = PyInt_FromLong( result );
11162 : }
11163 : }
11164 1 : return resultobj;
11165 : fail:
11166 0 : return NULL;
11167 : }
11168 :
11169 :
11170 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11171 1 : PyObject *resultobj = 0;
11172 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11173 1 : char *arg2 = (char *) 0 ;
11174 1 : void *argp1 = 0 ;
11175 1 : int res1 = 0 ;
11176 : int res2 ;
11177 1 : char *buf2 = 0 ;
11178 1 : int alloc2 = 0 ;
11179 1 : PyObject * obj0 = 0 ;
11180 1 : PyObject * obj1 = 0 ;
11181 : OGRErr result;
11182 :
11183 1 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromXML",&obj0,&obj1)) SWIG_fail;
11184 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11185 1 : if (!SWIG_IsOK(res1)) {
11186 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromXML" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11187 : }
11188 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11189 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11190 1 : if (!SWIG_IsOK(res2)) {
11191 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromXML" "', argument " "2"" of type '" "char const *""'");
11192 : }
11193 1 : arg2 = reinterpret_cast< char * >(buf2);
11194 : {
11195 1 : if ( bUseExceptions ) {
11196 0 : CPLErrorReset();
11197 : }
11198 1 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromXML(arg1,(char const *)arg2);
11199 1 : if ( bUseExceptions ) {
11200 0 : CPLErr eclass = CPLGetLastErrorType();
11201 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11202 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11203 : }
11204 : }
11205 : }
11206 : {
11207 : /* %typemap(out) OGRErr */
11208 1 : if ( result != 0 && bUseExceptions) {
11209 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11210 0 : SWIG_fail;
11211 : }
11212 : }
11213 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11214 : {
11215 : /* %typemap(ret) OGRErr */
11216 1 : if (resultobj == Py_None ) {
11217 0 : Py_DECREF(resultobj);
11218 0 : resultobj = 0;
11219 : }
11220 1 : if (resultobj == 0) {
11221 1 : resultobj = PyInt_FromLong( result );
11222 : }
11223 : }
11224 1 : return resultobj;
11225 : fail:
11226 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11227 0 : return NULL;
11228 : }
11229 :
11230 :
11231 6 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromERM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11232 6 : PyObject *resultobj = 0;
11233 6 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11234 6 : char *arg2 = (char *) 0 ;
11235 6 : char *arg3 = (char *) 0 ;
11236 6 : char *arg4 = (char *) 0 ;
11237 6 : void *argp1 = 0 ;
11238 6 : int res1 = 0 ;
11239 : int res2 ;
11240 6 : char *buf2 = 0 ;
11241 6 : int alloc2 = 0 ;
11242 : int res3 ;
11243 6 : char *buf3 = 0 ;
11244 6 : int alloc3 = 0 ;
11245 : int res4 ;
11246 6 : char *buf4 = 0 ;
11247 6 : int alloc4 = 0 ;
11248 6 : PyObject * obj0 = 0 ;
11249 6 : PyObject * obj1 = 0 ;
11250 6 : PyObject * obj2 = 0 ;
11251 6 : PyObject * obj3 = 0 ;
11252 : OGRErr result;
11253 :
11254 6 : if (!PyArg_ParseTuple(args,(char *)"OOOO:SpatialReference_ImportFromERM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11255 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11256 6 : if (!SWIG_IsOK(res1)) {
11257 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromERM" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11258 : }
11259 6 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11260 6 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11261 6 : if (!SWIG_IsOK(res2)) {
11262 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromERM" "', argument " "2"" of type '" "char const *""'");
11263 : }
11264 6 : arg2 = reinterpret_cast< char * >(buf2);
11265 6 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
11266 6 : if (!SWIG_IsOK(res3)) {
11267 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_ImportFromERM" "', argument " "3"" of type '" "char const *""'");
11268 : }
11269 6 : arg3 = reinterpret_cast< char * >(buf3);
11270 6 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
11271 6 : if (!SWIG_IsOK(res4)) {
11272 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialReference_ImportFromERM" "', argument " "4"" of type '" "char const *""'");
11273 : }
11274 6 : arg4 = reinterpret_cast< char * >(buf4);
11275 : {
11276 6 : if (!arg2) {
11277 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11278 : }
11279 : }
11280 : {
11281 6 : if (!arg3) {
11282 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11283 : }
11284 : }
11285 : {
11286 6 : if ( bUseExceptions ) {
11287 0 : CPLErrorReset();
11288 : }
11289 6 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromERM(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
11290 6 : if ( bUseExceptions ) {
11291 0 : CPLErr eclass = CPLGetLastErrorType();
11292 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11293 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11294 : }
11295 : }
11296 : }
11297 : {
11298 : /* %typemap(out) OGRErr */
11299 6 : if ( result != 0 && bUseExceptions) {
11300 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11301 0 : SWIG_fail;
11302 : }
11303 : }
11304 6 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11305 6 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11306 6 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
11307 : {
11308 : /* %typemap(ret) OGRErr */
11309 6 : if (resultobj == Py_None ) {
11310 0 : Py_DECREF(resultobj);
11311 0 : resultobj = 0;
11312 : }
11313 6 : if (resultobj == 0) {
11314 6 : resultobj = PyInt_FromLong( result );
11315 : }
11316 : }
11317 6 : return resultobj;
11318 : fail:
11319 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11320 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11321 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
11322 0 : return NULL;
11323 : }
11324 :
11325 :
11326 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromMICoordSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11327 1 : PyObject *resultobj = 0;
11328 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11329 1 : char *arg2 = (char *) 0 ;
11330 1 : void *argp1 = 0 ;
11331 1 : int res1 = 0 ;
11332 : int res2 ;
11333 1 : char *buf2 = 0 ;
11334 1 : int alloc2 = 0 ;
11335 1 : PyObject * obj0 = 0 ;
11336 1 : PyObject * obj1 = 0 ;
11337 : OGRErr result;
11338 :
11339 1 : if (!PyArg_ParseTuple(args,(char *)"OO:SpatialReference_ImportFromMICoordSys",&obj0,&obj1)) SWIG_fail;
11340 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11341 1 : if (!SWIG_IsOK(res1)) {
11342 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromMICoordSys" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11343 : }
11344 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11345 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11346 1 : if (!SWIG_IsOK(res2)) {
11347 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromMICoordSys" "', argument " "2"" of type '" "char const *""'");
11348 : }
11349 1 : arg2 = reinterpret_cast< char * >(buf2);
11350 : {
11351 1 : if ( bUseExceptions ) {
11352 0 : CPLErrorReset();
11353 : }
11354 1 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromMICoordSys(arg1,(char const *)arg2);
11355 1 : if ( bUseExceptions ) {
11356 0 : CPLErr eclass = CPLGetLastErrorType();
11357 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11358 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11359 : }
11360 : }
11361 : }
11362 : {
11363 : /* %typemap(out) OGRErr */
11364 1 : if ( result != 0 && bUseExceptions) {
11365 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11366 0 : SWIG_fail;
11367 : }
11368 : }
11369 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11370 : {
11371 : /* %typemap(ret) OGRErr */
11372 1 : if (resultobj == Py_None ) {
11373 0 : Py_DECREF(resultobj);
11374 0 : resultobj = 0;
11375 : }
11376 1 : if (resultobj == 0) {
11377 1 : resultobj = PyInt_FromLong( result );
11378 : }
11379 : }
11380 1 : return resultobj;
11381 : fail:
11382 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11383 0 : return NULL;
11384 : }
11385 :
11386 :
11387 3 : SWIGINTERN PyObject *_wrap_SpatialReference_ImportFromOzi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11388 3 : PyObject *resultobj = 0;
11389 3 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11390 3 : char *arg2 = (char *) 0 ;
11391 3 : char *arg3 = (char *) 0 ;
11392 3 : char *arg4 = (char *) 0 ;
11393 3 : void *argp1 = 0 ;
11394 3 : int res1 = 0 ;
11395 : int res2 ;
11396 3 : char *buf2 = 0 ;
11397 3 : int alloc2 = 0 ;
11398 : int res3 ;
11399 3 : char *buf3 = 0 ;
11400 3 : int alloc3 = 0 ;
11401 : int res4 ;
11402 3 : char *buf4 = 0 ;
11403 3 : int alloc4 = 0 ;
11404 3 : PyObject * obj0 = 0 ;
11405 3 : PyObject * obj1 = 0 ;
11406 3 : PyObject * obj2 = 0 ;
11407 3 : PyObject * obj3 = 0 ;
11408 : OGRErr result;
11409 :
11410 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:SpatialReference_ImportFromOzi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11411 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11412 3 : if (!SWIG_IsOK(res1)) {
11413 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ImportFromOzi" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11414 : }
11415 3 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11416 3 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11417 3 : if (!SWIG_IsOK(res2)) {
11418 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialReference_ImportFromOzi" "', argument " "2"" of type '" "char const *""'");
11419 : }
11420 3 : arg2 = reinterpret_cast< char * >(buf2);
11421 3 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
11422 3 : if (!SWIG_IsOK(res3)) {
11423 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_ImportFromOzi" "', argument " "3"" of type '" "char const *""'");
11424 : }
11425 3 : arg3 = reinterpret_cast< char * >(buf3);
11426 3 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
11427 3 : if (!SWIG_IsOK(res4)) {
11428 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialReference_ImportFromOzi" "', argument " "4"" of type '" "char const *""'");
11429 : }
11430 3 : arg4 = reinterpret_cast< char * >(buf4);
11431 : {
11432 3 : if (!arg2) {
11433 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11434 : }
11435 : }
11436 : {
11437 3 : if (!arg3) {
11438 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11439 : }
11440 : }
11441 : {
11442 3 : if (!arg4) {
11443 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11444 : }
11445 : }
11446 : {
11447 3 : if ( bUseExceptions ) {
11448 0 : CPLErrorReset();
11449 : }
11450 3 : result = (OGRErr)OSRSpatialReferenceShadow_ImportFromOzi(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
11451 3 : if ( bUseExceptions ) {
11452 0 : CPLErr eclass = CPLGetLastErrorType();
11453 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11454 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11455 : }
11456 : }
11457 : }
11458 : {
11459 : /* %typemap(out) OGRErr */
11460 3 : if ( result != 0 && bUseExceptions) {
11461 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11462 0 : SWIG_fail;
11463 : }
11464 : }
11465 3 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11466 3 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11467 3 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
11468 : {
11469 : /* %typemap(ret) OGRErr */
11470 3 : if (resultobj == Py_None ) {
11471 0 : Py_DECREF(resultobj);
11472 0 : resultobj = 0;
11473 : }
11474 3 : if (resultobj == 0) {
11475 3 : resultobj = PyInt_FromLong( result );
11476 : }
11477 : }
11478 3 : return resultobj;
11479 : fail:
11480 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11481 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11482 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
11483 0 : return NULL;
11484 : }
11485 :
11486 :
11487 61279 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11488 61279 : PyObject *resultobj = 0;
11489 61279 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11490 61279 : char **arg2 = (char **) 0 ;
11491 61279 : void *argp1 = 0 ;
11492 61279 : int res1 = 0 ;
11493 61279 : char *argout2 = 0 ;
11494 61279 : PyObject * obj0 = 0 ;
11495 : OGRErr result;
11496 :
11497 : {
11498 : /* %typemap(in,numinputs=0) (char **argout2) */
11499 61279 : arg2 = &argout2;
11500 : }
11501 61279 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_ExportToWkt",&obj0)) SWIG_fail;
11502 61279 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11503 61279 : if (!SWIG_IsOK(res1)) {
11504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToWkt" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11505 : }
11506 61279 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11507 : {
11508 61279 : if ( bUseExceptions ) {
11509 0 : CPLErrorReset();
11510 : }
11511 61279 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToWkt(arg1,arg2);
11512 61279 : if ( bUseExceptions ) {
11513 0 : CPLErr eclass = CPLGetLastErrorType();
11514 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11515 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11516 : }
11517 : }
11518 : }
11519 : {
11520 : /* %typemap(out) OGRErr */
11521 61279 : if ( result != 0 && bUseExceptions) {
11522 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11523 0 : SWIG_fail;
11524 : }
11525 : }
11526 : {
11527 : /* %typemap(argout) (char **argout) */
11528 : PyObject *o;
11529 122558 : if ( arg2 != NULL && *arg2 != NULL) {
11530 61279 : o = GDALPythonObjectFromCStr( *arg2 );
11531 : }
11532 : else {
11533 0 : o = Py_None;
11534 0 : Py_INCREF( o );
11535 : }
11536 61279 : resultobj = t_output_helper(resultobj, o);
11537 : }
11538 : {
11539 : /* %typemap(freearg) (char **argout) */
11540 61279 : if ( *arg2 )
11541 61279 : CPLFree( *arg2 );
11542 : }
11543 : {
11544 : /* %typemap(ret) OGRErr */
11545 61279 : if (resultobj == Py_None ) {
11546 0 : Py_DECREF(resultobj);
11547 0 : resultobj = 0;
11548 : }
11549 61279 : if (resultobj == 0) {
11550 0 : resultobj = PyInt_FromLong( result );
11551 : }
11552 : }
11553 61279 : return resultobj;
11554 : fail:
11555 : {
11556 : /* %typemap(freearg) (char **argout) */
11557 0 : if ( *arg2 )
11558 0 : CPLFree( *arg2 );
11559 : }
11560 0 : return NULL;
11561 : }
11562 :
11563 :
11564 35 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToPrettyWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11565 35 : PyObject *resultobj = 0;
11566 35 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11567 35 : char **arg2 = (char **) 0 ;
11568 35 : int arg3 = (int) 0 ;
11569 35 : void *argp1 = 0 ;
11570 35 : int res1 = 0 ;
11571 35 : char *argout2 = 0 ;
11572 : int val3 ;
11573 35 : int ecode3 = 0 ;
11574 35 : PyObject * obj0 = 0 ;
11575 35 : PyObject * obj1 = 0 ;
11576 : OGRErr result;
11577 :
11578 : {
11579 : /* %typemap(in,numinputs=0) (char **argout2) */
11580 35 : arg2 = &argout2;
11581 : }
11582 35 : if (!PyArg_ParseTuple(args,(char *)"O|O:SpatialReference_ExportToPrettyWkt",&obj0,&obj1)) SWIG_fail;
11583 35 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11584 35 : if (!SWIG_IsOK(res1)) {
11585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToPrettyWkt" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11586 : }
11587 35 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11588 35 : if (obj1) {
11589 14 : ecode3 = SWIG_AsVal_int(obj1, &val3);
11590 14 : if (!SWIG_IsOK(ecode3)) {
11591 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialReference_ExportToPrettyWkt" "', argument " "3"" of type '" "int""'");
11592 : }
11593 14 : arg3 = static_cast< int >(val3);
11594 : }
11595 : {
11596 35 : if ( bUseExceptions ) {
11597 0 : CPLErrorReset();
11598 : }
11599 35 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToPrettyWkt(arg1,arg2,arg3);
11600 35 : if ( bUseExceptions ) {
11601 0 : CPLErr eclass = CPLGetLastErrorType();
11602 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11603 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11604 : }
11605 : }
11606 : }
11607 : {
11608 : /* %typemap(out) OGRErr */
11609 35 : if ( result != 0 && bUseExceptions) {
11610 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11611 0 : SWIG_fail;
11612 : }
11613 : }
11614 : {
11615 : /* %typemap(argout) (char **argout) */
11616 : PyObject *o;
11617 70 : if ( arg2 != NULL && *arg2 != NULL) {
11618 35 : o = GDALPythonObjectFromCStr( *arg2 );
11619 : }
11620 : else {
11621 0 : o = Py_None;
11622 0 : Py_INCREF( o );
11623 : }
11624 35 : resultobj = t_output_helper(resultobj, o);
11625 : }
11626 : {
11627 : /* %typemap(freearg) (char **argout) */
11628 35 : if ( *arg2 )
11629 35 : CPLFree( *arg2 );
11630 : }
11631 : {
11632 : /* %typemap(ret) OGRErr */
11633 35 : if (resultobj == Py_None ) {
11634 0 : Py_DECREF(resultobj);
11635 0 : resultobj = 0;
11636 : }
11637 35 : if (resultobj == 0) {
11638 0 : resultobj = PyInt_FromLong( result );
11639 : }
11640 : }
11641 35 : return resultobj;
11642 : fail:
11643 : {
11644 : /* %typemap(freearg) (char **argout) */
11645 0 : if ( *arg2 )
11646 0 : CPLFree( *arg2 );
11647 : }
11648 0 : return NULL;
11649 : }
11650 :
11651 :
11652 107 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToProj4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11653 107 : PyObject *resultobj = 0;
11654 107 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11655 107 : char **arg2 = (char **) 0 ;
11656 107 : void *argp1 = 0 ;
11657 107 : int res1 = 0 ;
11658 107 : char *argout2 = 0 ;
11659 107 : PyObject * obj0 = 0 ;
11660 : OGRErr result;
11661 :
11662 : {
11663 : /* %typemap(in,numinputs=0) (char **argout2) */
11664 107 : arg2 = &argout2;
11665 : }
11666 107 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_ExportToProj4",&obj0)) SWIG_fail;
11667 107 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11668 107 : if (!SWIG_IsOK(res1)) {
11669 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToProj4" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11670 : }
11671 107 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11672 : {
11673 107 : if ( bUseExceptions ) {
11674 0 : CPLErrorReset();
11675 : }
11676 107 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToProj4(arg1,arg2);
11677 107 : if ( bUseExceptions ) {
11678 0 : CPLErr eclass = CPLGetLastErrorType();
11679 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11680 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11681 : }
11682 : }
11683 : }
11684 : {
11685 : /* %typemap(out) OGRErr */
11686 107 : if ( result != 0 && bUseExceptions) {
11687 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11688 0 : SWIG_fail;
11689 : }
11690 : }
11691 : {
11692 : /* %typemap(argout) (char **argout) */
11693 : PyObject *o;
11694 214 : if ( arg2 != NULL && *arg2 != NULL) {
11695 107 : o = GDALPythonObjectFromCStr( *arg2 );
11696 : }
11697 : else {
11698 0 : o = Py_None;
11699 0 : Py_INCREF( o );
11700 : }
11701 107 : resultobj = t_output_helper(resultobj, o);
11702 : }
11703 : {
11704 : /* %typemap(freearg) (char **argout) */
11705 107 : if ( *arg2 )
11706 107 : CPLFree( *arg2 );
11707 : }
11708 : {
11709 : /* %typemap(ret) OGRErr */
11710 107 : if (resultobj == Py_None ) {
11711 0 : Py_DECREF(resultobj);
11712 0 : resultobj = 0;
11713 : }
11714 107 : if (resultobj == 0) {
11715 0 : resultobj = PyInt_FromLong( result );
11716 : }
11717 : }
11718 107 : return resultobj;
11719 : fail:
11720 : {
11721 : /* %typemap(freearg) (char **argout) */
11722 0 : if ( *arg2 )
11723 0 : CPLFree( *arg2 );
11724 : }
11725 0 : return NULL;
11726 : }
11727 :
11728 :
11729 6 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToPCI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 6 : PyObject *resultobj = 0;
11731 6 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11732 6 : char **arg2 = (char **) 0 ;
11733 6 : char **arg3 = (char **) 0 ;
11734 : double **arg4 ;
11735 6 : void *argp1 = 0 ;
11736 6 : int res1 = 0 ;
11737 6 : char *argout2 = 0 ;
11738 6 : char *argout3 = 0 ;
11739 : double *argout4 ;
11740 6 : PyObject * obj0 = 0 ;
11741 : OGRErr result;
11742 :
11743 : {
11744 : /* %typemap(in,numinputs=0) (char **argout2) */
11745 6 : arg2 = &argout2;
11746 : }
11747 : {
11748 : /* %typemap(in,numinputs=0) (char **argout3) */
11749 6 : arg3 = &argout3;
11750 : }
11751 : {
11752 : /* %typemap(in,numinputs=0) (double *argout4[ANY]) */
11753 6 : arg4 = &argout4;
11754 : }
11755 6 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_ExportToPCI",&obj0)) SWIG_fail;
11756 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11757 6 : if (!SWIG_IsOK(res1)) {
11758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToPCI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11759 : }
11760 6 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11761 : {
11762 6 : if ( bUseExceptions ) {
11763 0 : CPLErrorReset();
11764 : }
11765 6 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToPCI(arg1,arg2,arg3,arg4);
11766 6 : if ( bUseExceptions ) {
11767 0 : CPLErr eclass = CPLGetLastErrorType();
11768 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11769 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11770 : }
11771 : }
11772 : }
11773 : {
11774 : /* %typemap(out) OGRErr */
11775 6 : if ( result != 0 && bUseExceptions) {
11776 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11777 0 : SWIG_fail;
11778 : }
11779 : }
11780 : {
11781 : /* %typemap(argout) (char **argout) */
11782 : PyObject *o;
11783 12 : if ( arg2 != NULL && *arg2 != NULL) {
11784 6 : o = GDALPythonObjectFromCStr( *arg2 );
11785 : }
11786 : else {
11787 0 : o = Py_None;
11788 0 : Py_INCREF( o );
11789 : }
11790 6 : resultobj = t_output_helper(resultobj, o);
11791 : }
11792 : {
11793 : /* %typemap(argout) (char **argout) */
11794 : PyObject *o;
11795 12 : if ( arg3 != NULL && *arg3 != NULL) {
11796 6 : o = GDALPythonObjectFromCStr( *arg3 );
11797 : }
11798 : else {
11799 0 : o = Py_None;
11800 0 : Py_INCREF( o );
11801 : }
11802 6 : resultobj = t_output_helper(resultobj, o);
11803 : }
11804 : {
11805 : /* %typemap(argout) (double *argout[ANY]) */
11806 6 : PyObject *out = CreateTupleFromDoubleArray( *arg4, 17 );
11807 6 : resultobj = t_output_helper(resultobj,out);
11808 : }
11809 : {
11810 : /* %typemap(freearg) (char **argout) */
11811 6 : if ( *arg2 )
11812 6 : CPLFree( *arg2 );
11813 : }
11814 : {
11815 : /* %typemap(freearg) (char **argout) */
11816 6 : if ( *arg3 )
11817 6 : CPLFree( *arg3 );
11818 : }
11819 : {
11820 : /* %typemap(freearg) (double *argout[ANY]) */
11821 6 : CPLFree(*arg4);
11822 : }
11823 : {
11824 : /* %typemap(ret) OGRErr */
11825 6 : if (resultobj == Py_None ) {
11826 0 : Py_DECREF(resultobj);
11827 0 : resultobj = 0;
11828 : }
11829 6 : if (resultobj == 0) {
11830 0 : resultobj = PyInt_FromLong( result );
11831 : }
11832 : }
11833 6 : return resultobj;
11834 : fail:
11835 : {
11836 : /* %typemap(freearg) (char **argout) */
11837 0 : if ( *arg2 )
11838 0 : CPLFree( *arg2 );
11839 : }
11840 : {
11841 : /* %typemap(freearg) (char **argout) */
11842 0 : if ( *arg3 )
11843 0 : CPLFree( *arg3 );
11844 : }
11845 : {
11846 : /* %typemap(freearg) (double *argout[ANY]) */
11847 0 : CPLFree(*arg4);
11848 : }
11849 0 : return NULL;
11850 : }
11851 :
11852 :
11853 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToUSGS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11854 1 : PyObject *resultobj = 0;
11855 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11856 1 : long *arg2 = (long *) 0 ;
11857 1 : long *arg3 = (long *) 0 ;
11858 : double **arg4 ;
11859 1 : long *arg5 = (long *) 0 ;
11860 1 : void *argp1 = 0 ;
11861 1 : int res1 = 0 ;
11862 : long temp2 ;
11863 1 : int res2 = SWIG_TMPOBJ ;
11864 : long temp3 ;
11865 1 : int res3 = SWIG_TMPOBJ ;
11866 : double *argout4 ;
11867 : long temp5 ;
11868 1 : int res5 = SWIG_TMPOBJ ;
11869 1 : PyObject * obj0 = 0 ;
11870 : OGRErr result;
11871 :
11872 1 : arg2 = &temp2;
11873 1 : arg3 = &temp3;
11874 : {
11875 : /* %typemap(in,numinputs=0) (double *argout4[ANY]) */
11876 1 : arg4 = &argout4;
11877 : }
11878 1 : arg5 = &temp5;
11879 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_ExportToUSGS",&obj0)) SWIG_fail;
11880 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11881 1 : if (!SWIG_IsOK(res1)) {
11882 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToUSGS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11883 : }
11884 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11885 : {
11886 1 : if ( bUseExceptions ) {
11887 0 : CPLErrorReset();
11888 : }
11889 1 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToUSGS(arg1,arg2,arg3,arg4,arg5);
11890 1 : if ( bUseExceptions ) {
11891 0 : CPLErr eclass = CPLGetLastErrorType();
11892 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11893 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11894 : }
11895 : }
11896 : }
11897 : {
11898 : /* %typemap(out) OGRErr */
11899 1 : if ( result != 0 && bUseExceptions) {
11900 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11901 0 : SWIG_fail;
11902 : }
11903 : }
11904 2 : if (SWIG_IsTmpObj(res2)) {
11905 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
11906 : } else {
11907 0 : int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11908 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
11909 : }
11910 2 : if (SWIG_IsTmpObj(res3)) {
11911 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
11912 : } else {
11913 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11914 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
11915 : }
11916 : {
11917 : /* %typemap(argout) (double *argout[ANY]) */
11918 1 : PyObject *out = CreateTupleFromDoubleArray( *arg4, 15 );
11919 1 : resultobj = t_output_helper(resultobj,out);
11920 : }
11921 2 : if (SWIG_IsTmpObj(res5)) {
11922 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11923 : } else {
11924 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11925 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11926 : }
11927 : {
11928 : /* %typemap(freearg) (double *argout[ANY]) */
11929 1 : CPLFree(*arg4);
11930 : }
11931 : {
11932 : /* %typemap(ret) OGRErr */
11933 1 : if (resultobj == Py_None ) {
11934 0 : Py_DECREF(resultobj);
11935 0 : resultobj = 0;
11936 : }
11937 1 : if (resultobj == 0) {
11938 0 : resultobj = PyInt_FromLong( result );
11939 : }
11940 : }
11941 1 : return resultobj;
11942 : fail:
11943 : {
11944 : /* %typemap(freearg) (double *argout[ANY]) */
11945 0 : CPLFree(*arg4);
11946 : }
11947 0 : return NULL;
11948 : }
11949 :
11950 :
11951 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952 1 : PyObject *resultobj = 0;
11953 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
11954 1 : char **arg2 = (char **) 0 ;
11955 1 : char *arg3 = (char *) "" ;
11956 1 : void *argp1 = 0 ;
11957 1 : int res1 = 0 ;
11958 1 : char *argout2 = 0 ;
11959 : int res3 ;
11960 1 : char *buf3 = 0 ;
11961 1 : int alloc3 = 0 ;
11962 1 : PyObject * obj0 = 0 ;
11963 1 : PyObject * obj1 = 0 ;
11964 : OGRErr result;
11965 :
11966 : {
11967 : /* %typemap(in,numinputs=0) (char **argout2) */
11968 1 : arg2 = &argout2;
11969 : }
11970 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:SpatialReference_ExportToXML",&obj0,&obj1)) SWIG_fail;
11971 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
11972 1 : if (!SWIG_IsOK(res1)) {
11973 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToXML" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
11974 : }
11975 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
11976 1 : if (obj1) {
11977 0 : res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
11978 0 : if (!SWIG_IsOK(res3)) {
11979 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialReference_ExportToXML" "', argument " "3"" of type '" "char const *""'");
11980 : }
11981 0 : arg3 = reinterpret_cast< char * >(buf3);
11982 : }
11983 : {
11984 1 : if ( bUseExceptions ) {
11985 0 : CPLErrorReset();
11986 : }
11987 1 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToXML(arg1,arg2,(char const *)arg3);
11988 1 : if ( bUseExceptions ) {
11989 0 : CPLErr eclass = CPLGetLastErrorType();
11990 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11991 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11992 : }
11993 : }
11994 : }
11995 : {
11996 : /* %typemap(out) OGRErr */
11997 1 : if ( result != 0 && bUseExceptions) {
11998 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11999 0 : SWIG_fail;
12000 : }
12001 : }
12002 : {
12003 : /* %typemap(argout) (char **argout) */
12004 : PyObject *o;
12005 2 : if ( arg2 != NULL && *arg2 != NULL) {
12006 1 : o = GDALPythonObjectFromCStr( *arg2 );
12007 : }
12008 : else {
12009 0 : o = Py_None;
12010 0 : Py_INCREF( o );
12011 : }
12012 1 : resultobj = t_output_helper(resultobj, o);
12013 : }
12014 : {
12015 : /* %typemap(freearg) (char **argout) */
12016 1 : if ( *arg2 )
12017 1 : CPLFree( *arg2 );
12018 : }
12019 1 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12020 : {
12021 : /* %typemap(ret) OGRErr */
12022 1 : if (resultobj == Py_None ) {
12023 0 : Py_DECREF(resultobj);
12024 0 : resultobj = 0;
12025 : }
12026 1 : if (resultobj == 0) {
12027 0 : resultobj = PyInt_FromLong( result );
12028 : }
12029 : }
12030 1 : return resultobj;
12031 : fail:
12032 : {
12033 : /* %typemap(freearg) (char **argout) */
12034 0 : if ( *arg2 )
12035 0 : CPLFree( *arg2 );
12036 : }
12037 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12038 0 : return NULL;
12039 : }
12040 :
12041 :
12042 1 : SWIGINTERN PyObject *_wrap_SpatialReference_ExportToMICoordSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12043 1 : PyObject *resultobj = 0;
12044 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12045 1 : char **arg2 = (char **) 0 ;
12046 1 : void *argp1 = 0 ;
12047 1 : int res1 = 0 ;
12048 1 : char *argout2 = 0 ;
12049 1 : PyObject * obj0 = 0 ;
12050 : OGRErr result;
12051 :
12052 : {
12053 : /* %typemap(in,numinputs=0) (char **argout2) */
12054 1 : arg2 = &argout2;
12055 : }
12056 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_ExportToMICoordSys",&obj0)) SWIG_fail;
12057 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12058 1 : if (!SWIG_IsOK(res1)) {
12059 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_ExportToMICoordSys" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12060 : }
12061 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12062 : {
12063 1 : if ( bUseExceptions ) {
12064 0 : CPLErrorReset();
12065 : }
12066 1 : result = (OGRErr)OSRSpatialReferenceShadow_ExportToMICoordSys(arg1,arg2);
12067 1 : if ( bUseExceptions ) {
12068 0 : CPLErr eclass = CPLGetLastErrorType();
12069 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12070 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12071 : }
12072 : }
12073 : }
12074 : {
12075 : /* %typemap(out) OGRErr */
12076 1 : if ( result != 0 && bUseExceptions) {
12077 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12078 0 : SWIG_fail;
12079 : }
12080 : }
12081 : {
12082 : /* %typemap(argout) (char **argout) */
12083 : PyObject *o;
12084 2 : if ( arg2 != NULL && *arg2 != NULL) {
12085 1 : o = GDALPythonObjectFromCStr( *arg2 );
12086 : }
12087 : else {
12088 0 : o = Py_None;
12089 0 : Py_INCREF( o );
12090 : }
12091 1 : resultobj = t_output_helper(resultobj, o);
12092 : }
12093 : {
12094 : /* %typemap(freearg) (char **argout) */
12095 1 : if ( *arg2 )
12096 1 : CPLFree( *arg2 );
12097 : }
12098 : {
12099 : /* %typemap(ret) OGRErr */
12100 1 : if (resultobj == Py_None ) {
12101 0 : Py_DECREF(resultobj);
12102 0 : resultobj = 0;
12103 : }
12104 1 : if (resultobj == 0) {
12105 0 : resultobj = PyInt_FromLong( result );
12106 : }
12107 : }
12108 1 : return resultobj;
12109 : fail:
12110 : {
12111 : /* %typemap(freearg) (char **argout) */
12112 0 : if ( *arg2 )
12113 0 : CPLFree( *arg2 );
12114 : }
12115 0 : return NULL;
12116 : }
12117 :
12118 :
12119 14 : SWIGINTERN PyObject *_wrap_SpatialReference_CloneGeogCS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12120 14 : PyObject *resultobj = 0;
12121 14 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12122 14 : void *argp1 = 0 ;
12123 14 : int res1 = 0 ;
12124 14 : PyObject * obj0 = 0 ;
12125 14 : OSRSpatialReferenceShadow *result = 0 ;
12126 :
12127 14 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_CloneGeogCS",&obj0)) SWIG_fail;
12128 14 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12129 14 : if (!SWIG_IsOK(res1)) {
12130 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_CloneGeogCS" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12131 : }
12132 14 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12133 : {
12134 14 : if ( bUseExceptions ) {
12135 0 : CPLErrorReset();
12136 : }
12137 14 : result = (OSRSpatialReferenceShadow *)OSRSpatialReferenceShadow_CloneGeogCS(arg1);
12138 14 : if ( bUseExceptions ) {
12139 0 : CPLErr eclass = CPLGetLastErrorType();
12140 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12141 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12142 : }
12143 : }
12144 : }
12145 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
12146 14 : return resultobj;
12147 : fail:
12148 0 : return NULL;
12149 : }
12150 :
12151 :
12152 28841 : SWIGINTERN PyObject *_wrap_SpatialReference_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 28841 : PyObject *resultobj = 0;
12154 28841 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12155 28841 : void *argp1 = 0 ;
12156 28841 : int res1 = 0 ;
12157 28841 : PyObject * obj0 = 0 ;
12158 28841 : OSRSpatialReferenceShadow *result = 0 ;
12159 :
12160 28841 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_Clone",&obj0)) SWIG_fail;
12161 28841 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12162 28841 : if (!SWIG_IsOK(res1)) {
12163 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_Clone" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12164 : }
12165 28841 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12166 : {
12167 28841 : if ( bUseExceptions ) {
12168 0 : CPLErrorReset();
12169 : }
12170 28841 : result = (OSRSpatialReferenceShadow *)OSRSpatialReferenceShadow_Clone(arg1);
12171 28841 : if ( bUseExceptions ) {
12172 0 : CPLErr eclass = CPLGetLastErrorType();
12173 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12174 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12175 : }
12176 : }
12177 : }
12178 28841 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
12179 28841 : return resultobj;
12180 : fail:
12181 0 : return NULL;
12182 : }
12183 :
12184 :
12185 61 : SWIGINTERN PyObject *_wrap_SpatialReference_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12186 61 : PyObject *resultobj = 0;
12187 61 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12188 61 : void *argp1 = 0 ;
12189 61 : int res1 = 0 ;
12190 61 : PyObject * obj0 = 0 ;
12191 : OGRErr result;
12192 :
12193 61 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_Validate",&obj0)) SWIG_fail;
12194 61 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12195 61 : if (!SWIG_IsOK(res1)) {
12196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_Validate" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12197 : }
12198 61 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12199 : {
12200 61 : if ( bUseExceptions ) {
12201 0 : CPLErrorReset();
12202 : }
12203 61 : result = (OGRErr)OSRSpatialReferenceShadow_Validate(arg1);
12204 61 : if ( bUseExceptions ) {
12205 0 : CPLErr eclass = CPLGetLastErrorType();
12206 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12207 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12208 : }
12209 : }
12210 : }
12211 : {
12212 : /* %typemap(out) OGRErr */
12213 61 : if ( result != 0 && bUseExceptions) {
12214 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12215 0 : SWIG_fail;
12216 : }
12217 : }
12218 : {
12219 : /* %typemap(ret) OGRErr */
12220 61 : if (resultobj == Py_None ) {
12221 0 : Py_DECREF(resultobj);
12222 0 : resultobj = 0;
12223 : }
12224 61 : if (resultobj == 0) {
12225 61 : resultobj = PyInt_FromLong( result );
12226 : }
12227 : }
12228 61 : return resultobj;
12229 : fail:
12230 0 : return NULL;
12231 : }
12232 :
12233 :
12234 17037 : SWIGINTERN PyObject *_wrap_SpatialReference_StripCTParms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12235 17037 : PyObject *resultobj = 0;
12236 17037 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12237 17037 : void *argp1 = 0 ;
12238 17037 : int res1 = 0 ;
12239 17037 : PyObject * obj0 = 0 ;
12240 : OGRErr result;
12241 :
12242 17037 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_StripCTParms",&obj0)) SWIG_fail;
12243 17037 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12244 17037 : if (!SWIG_IsOK(res1)) {
12245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_StripCTParms" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12246 : }
12247 17037 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12248 : {
12249 17037 : if ( bUseExceptions ) {
12250 0 : CPLErrorReset();
12251 : }
12252 17037 : result = (OGRErr)OSRSpatialReferenceShadow_StripCTParms(arg1);
12253 17037 : if ( bUseExceptions ) {
12254 0 : CPLErr eclass = CPLGetLastErrorType();
12255 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12256 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12257 : }
12258 : }
12259 : }
12260 : {
12261 : /* %typemap(out) OGRErr */
12262 17037 : if ( result != 0 && bUseExceptions) {
12263 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12264 0 : SWIG_fail;
12265 : }
12266 : }
12267 : {
12268 : /* %typemap(ret) OGRErr */
12269 17037 : if (resultobj == Py_None ) {
12270 0 : Py_DECREF(resultobj);
12271 0 : resultobj = 0;
12272 : }
12273 17037 : if (resultobj == 0) {
12274 17037 : resultobj = PyInt_FromLong( result );
12275 : }
12276 : }
12277 17037 : return resultobj;
12278 : fail:
12279 0 : return NULL;
12280 : }
12281 :
12282 :
12283 0 : SWIGINTERN PyObject *_wrap_SpatialReference_FixupOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12284 0 : PyObject *resultobj = 0;
12285 0 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12286 0 : void *argp1 = 0 ;
12287 0 : int res1 = 0 ;
12288 0 : PyObject * obj0 = 0 ;
12289 : OGRErr result;
12290 :
12291 0 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_FixupOrdering",&obj0)) SWIG_fail;
12292 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12293 0 : if (!SWIG_IsOK(res1)) {
12294 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_FixupOrdering" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12295 : }
12296 0 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12297 : {
12298 0 : if ( bUseExceptions ) {
12299 0 : CPLErrorReset();
12300 : }
12301 0 : result = (OGRErr)OSRSpatialReferenceShadow_FixupOrdering(arg1);
12302 0 : if ( bUseExceptions ) {
12303 0 : CPLErr eclass = CPLGetLastErrorType();
12304 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12305 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12306 : }
12307 : }
12308 : }
12309 : {
12310 : /* %typemap(out) OGRErr */
12311 0 : if ( result != 0 && bUseExceptions) {
12312 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12313 0 : SWIG_fail;
12314 : }
12315 : }
12316 : {
12317 : /* %typemap(ret) OGRErr */
12318 0 : if (resultobj == Py_None ) {
12319 0 : Py_DECREF(resultobj);
12320 0 : resultobj = 0;
12321 : }
12322 0 : if (resultobj == 0) {
12323 0 : resultobj = PyInt_FromLong( result );
12324 : }
12325 : }
12326 0 : return resultobj;
12327 : fail:
12328 0 : return NULL;
12329 : }
12330 :
12331 :
12332 1 : SWIGINTERN PyObject *_wrap_SpatialReference_Fixup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12333 1 : PyObject *resultobj = 0;
12334 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12335 1 : void *argp1 = 0 ;
12336 1 : int res1 = 0 ;
12337 1 : PyObject * obj0 = 0 ;
12338 : OGRErr result;
12339 :
12340 1 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_Fixup",&obj0)) SWIG_fail;
12341 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12342 1 : if (!SWIG_IsOK(res1)) {
12343 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_Fixup" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12344 : }
12345 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12346 : {
12347 1 : if ( bUseExceptions ) {
12348 0 : CPLErrorReset();
12349 : }
12350 1 : result = (OGRErr)OSRSpatialReferenceShadow_Fixup(arg1);
12351 1 : if ( bUseExceptions ) {
12352 0 : CPLErr eclass = CPLGetLastErrorType();
12353 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12354 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12355 : }
12356 : }
12357 : }
12358 : {
12359 : /* %typemap(out) OGRErr */
12360 1 : if ( result != 0 && bUseExceptions) {
12361 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12362 0 : SWIG_fail;
12363 : }
12364 : }
12365 : {
12366 : /* %typemap(ret) OGRErr */
12367 1 : if (resultobj == Py_None ) {
12368 0 : Py_DECREF(resultobj);
12369 0 : resultobj = 0;
12370 : }
12371 1 : if (resultobj == 0) {
12372 1 : resultobj = PyInt_FromLong( result );
12373 : }
12374 : }
12375 1 : return resultobj;
12376 : fail:
12377 0 : return NULL;
12378 : }
12379 :
12380 :
12381 14437 : SWIGINTERN PyObject *_wrap_SpatialReference_MorphToESRI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12382 14437 : PyObject *resultobj = 0;
12383 14437 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12384 14437 : void *argp1 = 0 ;
12385 14437 : int res1 = 0 ;
12386 14437 : PyObject * obj0 = 0 ;
12387 : OGRErr result;
12388 :
12389 14437 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_MorphToESRI",&obj0)) SWIG_fail;
12390 14437 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12391 14437 : if (!SWIG_IsOK(res1)) {
12392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_MorphToESRI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12393 : }
12394 14437 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12395 : {
12396 14437 : if ( bUseExceptions ) {
12397 0 : CPLErrorReset();
12398 : }
12399 14437 : result = (OGRErr)OSRSpatialReferenceShadow_MorphToESRI(arg1);
12400 14437 : if ( bUseExceptions ) {
12401 0 : CPLErr eclass = CPLGetLastErrorType();
12402 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12403 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12404 : }
12405 : }
12406 : }
12407 : {
12408 : /* %typemap(out) OGRErr */
12409 14437 : if ( result != 0 && bUseExceptions) {
12410 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12411 0 : SWIG_fail;
12412 : }
12413 : }
12414 : {
12415 : /* %typemap(ret) OGRErr */
12416 14437 : if (resultobj == Py_None ) {
12417 0 : Py_DECREF(resultobj);
12418 0 : resultobj = 0;
12419 : }
12420 14437 : if (resultobj == 0) {
12421 14437 : resultobj = PyInt_FromLong( result );
12422 : }
12423 : }
12424 14437 : return resultobj;
12425 : fail:
12426 0 : return NULL;
12427 : }
12428 :
12429 :
12430 14440 : SWIGINTERN PyObject *_wrap_SpatialReference_MorphFromESRI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12431 14440 : PyObject *resultobj = 0;
12432 14440 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12433 14440 : void *argp1 = 0 ;
12434 14440 : int res1 = 0 ;
12435 14440 : PyObject * obj0 = 0 ;
12436 : OGRErr result;
12437 :
12438 14440 : if (!PyArg_ParseTuple(args,(char *)"O:SpatialReference_MorphFromESRI",&obj0)) SWIG_fail;
12439 14440 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12440 14440 : if (!SWIG_IsOK(res1)) {
12441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialReference_MorphFromESRI" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12442 : }
12443 14440 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12444 : {
12445 14440 : if ( bUseExceptions ) {
12446 0 : CPLErrorReset();
12447 : }
12448 14440 : result = (OGRErr)OSRSpatialReferenceShadow_MorphFromESRI(arg1);
12449 14440 : if ( bUseExceptions ) {
12450 0 : CPLErr eclass = CPLGetLastErrorType();
12451 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12452 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12453 : }
12454 : }
12455 : }
12456 : {
12457 : /* %typemap(out) OGRErr */
12458 14440 : if ( result != 0 && bUseExceptions) {
12459 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12460 0 : SWIG_fail;
12461 : }
12462 : }
12463 : {
12464 : /* %typemap(ret) OGRErr */
12465 14440 : if (resultobj == Py_None ) {
12466 0 : Py_DECREF(resultobj);
12467 0 : resultobj = 0;
12468 : }
12469 14440 : if (resultobj == 0) {
12470 14440 : resultobj = PyInt_FromLong( result );
12471 : }
12472 : }
12473 14440 : return resultobj;
12474 : fail:
12475 0 : return NULL;
12476 : }
12477 :
12478 :
12479 4 : SWIGINTERN PyObject *SpatialReference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12480 : PyObject *obj;
12481 4 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12482 4 : SWIG_TypeNewClientData(SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_NewClientData(obj));
12483 4 : return SWIG_Py_Void();
12484 : }
12485 :
12486 40 : SWIGINTERN PyObject *_wrap_new_CoordinateTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 40 : PyObject *resultobj = 0;
12488 40 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12489 40 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
12490 40 : void *argp1 = 0 ;
12491 40 : int res1 = 0 ;
12492 40 : void *argp2 = 0 ;
12493 40 : int res2 = 0 ;
12494 40 : PyObject * obj0 = 0 ;
12495 40 : PyObject * obj1 = 0 ;
12496 40 : OSRCoordinateTransformationShadow *result = 0 ;
12497 :
12498 40 : if (!PyArg_ParseTuple(args,(char *)"OO:new_CoordinateTransformation",&obj0,&obj1)) SWIG_fail;
12499 40 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12500 40 : if (!SWIG_IsOK(res1)) {
12501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CoordinateTransformation" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12502 : }
12503 40 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12504 40 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12505 40 : if (!SWIG_IsOK(res2)) {
12506 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CoordinateTransformation" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
12507 : }
12508 40 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
12509 : {
12510 40 : if ( bUseExceptions ) {
12511 0 : CPLErrorReset();
12512 : }
12513 40 : result = (OSRCoordinateTransformationShadow *)new_OSRCoordinateTransformationShadow(arg1,arg2);
12514 40 : if ( bUseExceptions ) {
12515 0 : CPLErr eclass = CPLGetLastErrorType();
12516 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12517 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12518 : }
12519 : }
12520 : }
12521 40 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRCoordinateTransformationShadow, SWIG_POINTER_NEW | 0 );
12522 40 : return resultobj;
12523 : fail:
12524 0 : return NULL;
12525 : }
12526 :
12527 :
12528 40 : SWIGINTERN PyObject *_wrap_delete_CoordinateTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12529 40 : PyObject *resultobj = 0;
12530 40 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
12531 40 : void *argp1 = 0 ;
12532 40 : int res1 = 0 ;
12533 40 : PyObject * obj0 = 0 ;
12534 :
12535 40 : if (!PyArg_ParseTuple(args,(char *)"O:delete_CoordinateTransformation",&obj0)) SWIG_fail;
12536 40 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, SWIG_POINTER_DISOWN | 0 );
12537 40 : if (!SWIG_IsOK(res1)) {
12538 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoordinateTransformation" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
12539 : }
12540 40 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
12541 : {
12542 40 : if ( bUseExceptions ) {
12543 0 : CPLErrorReset();
12544 : }
12545 : delete_OSRCoordinateTransformationShadow(arg1);
12546 40 : if ( bUseExceptions ) {
12547 0 : CPLErr eclass = CPLGetLastErrorType();
12548 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12549 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12550 : }
12551 : }
12552 : }
12553 40 : resultobj = SWIG_Py_Void();
12554 40 : return resultobj;
12555 : fail:
12556 0 : return NULL;
12557 : }
12558 :
12559 :
12560 0 : SWIGINTERN PyObject *_wrap_CoordinateTransformation_TransformPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12561 0 : PyObject *resultobj = 0;
12562 0 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
12563 : double *arg2 ;
12564 0 : void *argp1 = 0 ;
12565 0 : int res1 = 0 ;
12566 : double argin2[3] ;
12567 0 : PyObject * obj0 = 0 ;
12568 0 : PyObject * obj1 = 0 ;
12569 :
12570 0 : if (!PyArg_ParseTuple(args,(char *)"OO:CoordinateTransformation_TransformPoint",&obj0,&obj1)) SWIG_fail;
12571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
12572 0 : if (!SWIG_IsOK(res1)) {
12573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateTransformation_TransformPoint" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
12574 : }
12575 0 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
12576 : {
12577 : /* %typemap(in) (double argin2[ANY]) */
12578 0 : arg2 = argin2;
12579 0 : if (! PySequence_Check(obj1) ) {
12580 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
12581 0 : SWIG_fail;
12582 : }
12583 0 : int seq_size = PySequence_Size(obj1);
12584 0 : if ( seq_size != 3 ) {
12585 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
12586 0 : SWIG_fail;
12587 : }
12588 0 : for (unsigned int i=0; i<3; i++) {
12589 0 : PyObject *o = PySequence_GetItem(obj1,i);
12590 : double val;
12591 0 : if ( !PyArg_Parse(o, "d", &val ) ) {
12592 0 : PyErr_SetString(PyExc_TypeError, "not a number");
12593 0 : Py_DECREF(o);
12594 : SWIG_fail;
12595 : }
12596 0 : arg2[i] = val;
12597 0 : Py_DECREF(o);
12598 : }
12599 : }
12600 : {
12601 0 : if ( bUseExceptions ) {
12602 0 : CPLErrorReset();
12603 : }
12604 : OSRCoordinateTransformationShadow_TransformPoint__SWIG_0(arg1,arg2);
12605 0 : if ( bUseExceptions ) {
12606 0 : CPLErr eclass = CPLGetLastErrorType();
12607 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12608 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12609 : }
12610 : }
12611 : }
12612 0 : resultobj = SWIG_Py_Void();
12613 : {
12614 : /* %typemap(argout) (double argout[ANY]) */
12615 0 : PyObject *out = CreateTupleFromDoubleArray( arg2, 3 );
12616 0 : resultobj = t_output_helper(resultobj,out);
12617 : }
12618 0 : return resultobj;
12619 : fail:
12620 0 : return NULL;
12621 : }
12622 :
12623 :
12624 83 : SWIGINTERN PyObject *_wrap_CoordinateTransformation_TransformPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625 83 : PyObject *resultobj = 0;
12626 83 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
12627 : double *arg2 ;
12628 : double arg3 ;
12629 : double arg4 ;
12630 83 : double arg5 = (double) 0.0 ;
12631 83 : void *argp1 = 0 ;
12632 83 : int res1 = 0 ;
12633 : double argout2[3] ;
12634 : double val3 ;
12635 83 : int ecode3 = 0 ;
12636 : double val4 ;
12637 83 : int ecode4 = 0 ;
12638 : double val5 ;
12639 83 : int ecode5 = 0 ;
12640 83 : PyObject * obj0 = 0 ;
12641 83 : PyObject * obj1 = 0 ;
12642 83 : PyObject * obj2 = 0 ;
12643 83 : PyObject * obj3 = 0 ;
12644 :
12645 : {
12646 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
12647 83 : arg2 = argout2;
12648 : }
12649 83 : if (!PyArg_ParseTuple(args,(char *)"OOO|O:CoordinateTransformation_TransformPoint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12650 83 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
12651 83 : if (!SWIG_IsOK(res1)) {
12652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateTransformation_TransformPoint" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
12653 : }
12654 83 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
12655 83 : ecode3 = SWIG_AsVal_double(obj1, &val3);
12656 83 : if (!SWIG_IsOK(ecode3)) {
12657 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateTransformation_TransformPoint" "', argument " "3"" of type '" "double""'");
12658 : }
12659 83 : arg3 = static_cast< double >(val3);
12660 83 : ecode4 = SWIG_AsVal_double(obj2, &val4);
12661 83 : if (!SWIG_IsOK(ecode4)) {
12662 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoordinateTransformation_TransformPoint" "', argument " "4"" of type '" "double""'");
12663 : }
12664 83 : arg4 = static_cast< double >(val4);
12665 83 : if (obj3) {
12666 83 : ecode5 = SWIG_AsVal_double(obj3, &val5);
12667 83 : if (!SWIG_IsOK(ecode5)) {
12668 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoordinateTransformation_TransformPoint" "', argument " "5"" of type '" "double""'");
12669 : }
12670 83 : arg5 = static_cast< double >(val5);
12671 : }
12672 : {
12673 83 : if ( bUseExceptions ) {
12674 0 : CPLErrorReset();
12675 : }
12676 : OSRCoordinateTransformationShadow_TransformPoint__SWIG_1(arg1,arg2,arg3,arg4,arg5);
12677 83 : if ( bUseExceptions ) {
12678 0 : CPLErr eclass = CPLGetLastErrorType();
12679 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12680 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12681 : }
12682 : }
12683 : }
12684 83 : resultobj = SWIG_Py_Void();
12685 : {
12686 : /* %typemap(argout) (double argout[ANY]) */
12687 83 : PyObject *out = CreateTupleFromDoubleArray( arg2, 3 );
12688 83 : resultobj = t_output_helper(resultobj,out);
12689 : }
12690 83 : return resultobj;
12691 : fail:
12692 0 : return NULL;
12693 : }
12694 :
12695 :
12696 83 : SWIGINTERN PyObject *_wrap_CoordinateTransformation_TransformPoint(PyObject *self, PyObject *args) {
12697 : int argc;
12698 : PyObject *argv[5];
12699 : int ii;
12700 :
12701 83 : if (!PyTuple_Check(args)) SWIG_fail;
12702 83 : argc = (int)PyObject_Length(args);
12703 415 : for (ii = 0; (ii < argc) && (ii < 4); ii++) {
12704 332 : argv[ii] = PyTuple_GET_ITEM(args,ii);
12705 : }
12706 83 : if (argc == 2) {
12707 : int _v;
12708 0 : void *vptr = 0;
12709 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0);
12710 0 : _v = SWIG_CheckState(res);
12711 0 : if (_v) {
12712 0 : void *vptr = 0;
12713 0 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
12714 0 : _v = SWIG_CheckState(res);
12715 0 : if (_v) {
12716 0 : return _wrap_CoordinateTransformation_TransformPoint__SWIG_0(self, args);
12717 : }
12718 : }
12719 : }
12720 83 : if ((argc >= 3) && (argc <= 4)) {
12721 : int _v;
12722 83 : void *vptr = 0;
12723 83 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0);
12724 83 : _v = SWIG_CheckState(res);
12725 83 : if (_v) {
12726 : {
12727 83 : int res = SWIG_AsVal_double(argv[1], NULL);
12728 83 : _v = SWIG_CheckState(res);
12729 : }
12730 83 : if (_v) {
12731 : {
12732 83 : int res = SWIG_AsVal_double(argv[2], NULL);
12733 83 : _v = SWIG_CheckState(res);
12734 : }
12735 83 : if (_v) {
12736 83 : if (argc <= 3) {
12737 0 : return _wrap_CoordinateTransformation_TransformPoint__SWIG_1(self, args);
12738 : }
12739 : {
12740 83 : int res = SWIG_AsVal_double(argv[3], NULL);
12741 83 : _v = SWIG_CheckState(res);
12742 : }
12743 83 : if (_v) {
12744 83 : return _wrap_CoordinateTransformation_TransformPoint__SWIG_1(self, args);
12745 : }
12746 : }
12747 : }
12748 : }
12749 : }
12750 :
12751 : fail:
12752 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoordinateTransformation_TransformPoint'.\n"
12753 : " Possible C/C++ prototypes are:\n"
12754 : " TransformPoint(OSRCoordinateTransformationShadow *,double [3])\n"
12755 0 : " TransformPoint(OSRCoordinateTransformationShadow *,double [3],double,double,double)\n");
12756 0 : return NULL;
12757 : }
12758 :
12759 :
12760 3 : SWIGINTERN PyObject *_wrap_CoordinateTransformation_TransformPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12761 3 : PyObject *resultobj = 0;
12762 3 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
12763 : int arg2 ;
12764 3 : double *arg3 = (double *) 0 ;
12765 3 : double *arg4 = (double *) 0 ;
12766 3 : double *arg5 = (double *) 0 ;
12767 3 : void *argp1 = 0 ;
12768 3 : int res1 = 0 ;
12769 3 : PyObject * obj0 = 0 ;
12770 3 : PyObject * obj1 = 0 ;
12771 :
12772 3 : if (!PyArg_ParseTuple(args,(char *)"OO:CoordinateTransformation_TransformPoints",&obj0,&obj1)) SWIG_fail;
12773 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
12774 3 : if (!SWIG_IsOK(res1)) {
12775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateTransformation_TransformPoints" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
12776 : }
12777 3 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
12778 : {
12779 3 : if ( !PySequence_Check(obj1) ) {
12780 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
12781 0 : SWIG_fail;
12782 : }
12783 :
12784 3 : arg2 = PySequence_Size(obj1);
12785 3 : arg3 = (double*) VSIMalloc(arg2*sizeof(double));
12786 3 : arg4 = (double*) VSIMalloc(arg2*sizeof(double));
12787 3 : arg5 = (double*) VSIMalloc(arg2*sizeof(double));
12788 :
12789 3 : if (arg3 == NULL || arg4 == NULL || arg5 == NULL)
12790 : {
12791 0 : PyErr_SetString( PyExc_RuntimeError, "Out of memory" );
12792 0 : SWIG_fail;
12793 : }
12794 :
12795 3 : if (!DecomposeSequenceOfCoordinates(obj1,arg2,arg3,arg4,arg5)) {
12796 : SWIG_fail;
12797 : }
12798 : }
12799 : {
12800 3 : if ( bUseExceptions ) {
12801 0 : CPLErrorReset();
12802 : }
12803 : OSRCoordinateTransformationShadow_TransformPoints(arg1,arg2,arg3,arg4,arg5);
12804 3 : if ( bUseExceptions ) {
12805 0 : CPLErr eclass = CPLGetLastErrorType();
12806 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12807 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12808 : }
12809 : }
12810 : }
12811 3 : resultobj = SWIG_Py_Void();
12812 : {
12813 : /* %typemap(argout) (int nCount, double *x, double *y, double *z) */
12814 3 : Py_DECREF(resultobj);
12815 3 : PyObject *out = PyList_New( arg2 );
12816 9 : for( int i=0; i< arg2; i++ ) {
12817 6 : PyObject *tuple = PyTuple_New( 3 );
12818 6 : PyTuple_SetItem( tuple, 0, PyFloat_FromDouble( (arg3)[i] ) );
12819 6 : PyTuple_SetItem( tuple, 1, PyFloat_FromDouble( (arg4)[i] ) );
12820 6 : PyTuple_SetItem( tuple, 2, PyFloat_FromDouble( (arg5)[i] ) );
12821 6 : PyList_SetItem( out, i, tuple );
12822 : }
12823 3 : resultobj = out;
12824 : }
12825 : {
12826 : /* %typemap(freearg) (int nCount, double *x, double *y, double *z) */
12827 3 : VSIFree(arg3);
12828 3 : VSIFree(arg4);
12829 3 : VSIFree(arg5);
12830 : }
12831 3 : return resultobj;
12832 : fail:
12833 : {
12834 : /* %typemap(freearg) (int nCount, double *x, double *y, double *z) */
12835 0 : VSIFree(arg3);
12836 0 : VSIFree(arg4);
12837 0 : VSIFree(arg5);
12838 : }
12839 0 : return NULL;
12840 : }
12841 :
12842 :
12843 4 : SWIGINTERN PyObject *CoordinateTransformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12844 : PyObject *obj;
12845 4 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12846 4 : SWIG_TypeNewClientData(SWIGTYPE_p_OSRCoordinateTransformationShadow, SWIG_NewClientData(obj));
12847 4 : return SWIG_Py_Void();
12848 : }
12849 :
12850 1 : SWIGINTERN PyObject *_wrap_CreateCoordinateTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 1 : PyObject *resultobj = 0;
12852 1 : OSRSpatialReferenceShadow *arg1 = (OSRSpatialReferenceShadow *) 0 ;
12853 1 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
12854 1 : void *argp1 = 0 ;
12855 1 : int res1 = 0 ;
12856 1 : void *argp2 = 0 ;
12857 1 : int res2 = 0 ;
12858 1 : PyObject * obj0 = 0 ;
12859 1 : PyObject * obj1 = 0 ;
12860 1 : OSRCoordinateTransformationShadow *result = 0 ;
12861 :
12862 1 : if (!PyArg_ParseTuple(args,(char *)"OO:CreateCoordinateTransformation",&obj0,&obj1)) SWIG_fail;
12863 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12864 1 : if (!SWIG_IsOK(res1)) {
12865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateCoordinateTransformation" "', argument " "1"" of type '" "OSRSpatialReferenceShadow *""'");
12866 : }
12867 1 : arg1 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp1);
12868 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
12869 1 : if (!SWIG_IsOK(res2)) {
12870 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateCoordinateTransformation" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
12871 : }
12872 1 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
12873 : {
12874 1 : if ( bUseExceptions ) {
12875 0 : CPLErrorReset();
12876 : }
12877 1 : result = (OSRCoordinateTransformationShadow *)CreateCoordinateTransformation(arg1,arg2);
12878 1 : if ( bUseExceptions ) {
12879 0 : CPLErr eclass = CPLGetLastErrorType();
12880 0 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12881 0 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12882 : }
12883 : }
12884 : }
12885 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRCoordinateTransformationShadow, SWIG_POINTER_OWN | 0 );
12886 1 : return resultobj;
12887 : fail:
12888 0 : return NULL;
12889 : }
12890 :
12891 :
12892 : static PyMethodDef SwigMethods[] = {
12893 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
12894 : { (char *)"GetUseExceptions", _wrap_GetUseExceptions, METH_VARARGS, (char *)"GetUseExceptions() -> int"},
12895 : { (char *)"UseExceptions", _wrap_UseExceptions, METH_VARARGS, (char *)"UseExceptions()"},
12896 : { (char *)"DontUseExceptions", _wrap_DontUseExceptions, METH_VARARGS, (char *)"DontUseExceptions()"},
12897 : { (char *)"GetProjectionMethods", py_OPTGetProjectionMethods, METH_VARARGS, NULL},
12898 : { (char *)"GetWellKnownGeogCSAsWKT", _wrap_GetWellKnownGeogCSAsWKT, METH_VARARGS, (char *)"GetWellKnownGeogCSAsWKT(char name) -> OGRErr"},
12899 : { (char *)"GetUserInputAsWKT", _wrap_GetUserInputAsWKT, METH_VARARGS, (char *)"GetUserInputAsWKT(char name) -> OGRErr"},
12900 : { (char *)"new_SpatialReference", (PyCFunction) _wrap_new_SpatialReference, METH_VARARGS | METH_KEYWORDS, (char *)"new_SpatialReference(char wkt = \"\") -> SpatialReference"},
12901 : { (char *)"delete_SpatialReference", _wrap_delete_SpatialReference, METH_VARARGS, (char *)"delete_SpatialReference(SpatialReference self)"},
12902 : { (char *)"SpatialReference___str__", _wrap_SpatialReference___str__, METH_VARARGS, (char *)"SpatialReference___str__(SpatialReference self) -> retStringAndCPLFree"},
12903 : { (char *)"SpatialReference_IsSame", _wrap_SpatialReference_IsSame, METH_VARARGS, (char *)"SpatialReference_IsSame(SpatialReference self, SpatialReference rhs) -> int"},
12904 : { (char *)"SpatialReference_IsSameGeogCS", _wrap_SpatialReference_IsSameGeogCS, METH_VARARGS, (char *)"SpatialReference_IsSameGeogCS(SpatialReference self, SpatialReference rhs) -> int"},
12905 : { (char *)"SpatialReference_IsSameVertCS", _wrap_SpatialReference_IsSameVertCS, METH_VARARGS, (char *)"SpatialReference_IsSameVertCS(SpatialReference self, SpatialReference rhs) -> int"},
12906 : { (char *)"SpatialReference_IsGeographic", _wrap_SpatialReference_IsGeographic, METH_VARARGS, (char *)"SpatialReference_IsGeographic(SpatialReference self) -> int"},
12907 : { (char *)"SpatialReference_IsProjected", _wrap_SpatialReference_IsProjected, METH_VARARGS, (char *)"SpatialReference_IsProjected(SpatialReference self) -> int"},
12908 : { (char *)"SpatialReference_IsCompound", _wrap_SpatialReference_IsCompound, METH_VARARGS, (char *)"SpatialReference_IsCompound(SpatialReference self) -> int"},
12909 : { (char *)"SpatialReference_IsGeocentric", _wrap_SpatialReference_IsGeocentric, METH_VARARGS, (char *)"SpatialReference_IsGeocentric(SpatialReference self) -> int"},
12910 : { (char *)"SpatialReference_IsLocal", _wrap_SpatialReference_IsLocal, METH_VARARGS, (char *)"SpatialReference_IsLocal(SpatialReference self) -> int"},
12911 : { (char *)"SpatialReference_IsVertical", _wrap_SpatialReference_IsVertical, METH_VARARGS, (char *)"SpatialReference_IsVertical(SpatialReference self) -> int"},
12912 : { (char *)"SpatialReference_EPSGTreatsAsLatLong", _wrap_SpatialReference_EPSGTreatsAsLatLong, METH_VARARGS, (char *)"SpatialReference_EPSGTreatsAsLatLong(SpatialReference self) -> int"},
12913 : { (char *)"SpatialReference_SetAuthority", _wrap_SpatialReference_SetAuthority, METH_VARARGS, (char *)"\n"
12914 : "SpatialReference_SetAuthority(SpatialReference self, char pszTargetKey, char pszAuthority, \n"
12915 : " int nCode) -> OGRErr\n"
12916 : ""},
12917 : { (char *)"SpatialReference_GetAttrValue", _wrap_SpatialReference_GetAttrValue, METH_VARARGS, (char *)"SpatialReference_GetAttrValue(SpatialReference self, char name, int child = 0) -> char"},
12918 : { (char *)"SpatialReference_SetAttrValue", _wrap_SpatialReference_SetAttrValue, METH_VARARGS, (char *)"SpatialReference_SetAttrValue(SpatialReference self, char name, char value) -> OGRErr"},
12919 : { (char *)"SpatialReference_SetAngularUnits", _wrap_SpatialReference_SetAngularUnits, METH_VARARGS, (char *)"SpatialReference_SetAngularUnits(SpatialReference self, char name, double to_radians) -> OGRErr"},
12920 : { (char *)"SpatialReference_GetAngularUnits", _wrap_SpatialReference_GetAngularUnits, METH_VARARGS, (char *)"SpatialReference_GetAngularUnits(SpatialReference self) -> double"},
12921 : { (char *)"SpatialReference_SetTargetLinearUnits", _wrap_SpatialReference_SetTargetLinearUnits, METH_VARARGS, (char *)"SpatialReference_SetTargetLinearUnits(SpatialReference self, char target, char name, double to_meters) -> OGRErr"},
12922 : { (char *)"SpatialReference_SetLinearUnits", _wrap_SpatialReference_SetLinearUnits, METH_VARARGS, (char *)"SpatialReference_SetLinearUnits(SpatialReference self, char name, double to_meters) -> OGRErr"},
12923 : { (char *)"SpatialReference_SetLinearUnitsAndUpdateParameters", _wrap_SpatialReference_SetLinearUnitsAndUpdateParameters, METH_VARARGS, (char *)"SpatialReference_SetLinearUnitsAndUpdateParameters(SpatialReference self, char name, double to_meters) -> OGRErr"},
12924 : { (char *)"SpatialReference_GetLinearUnits", _wrap_SpatialReference_GetLinearUnits, METH_VARARGS, (char *)"SpatialReference_GetLinearUnits(SpatialReference self) -> double"},
12925 : { (char *)"SpatialReference_GetLinearUnitsName", _wrap_SpatialReference_GetLinearUnitsName, METH_VARARGS, (char *)"SpatialReference_GetLinearUnitsName(SpatialReference self) -> char"},
12926 : { (char *)"SpatialReference_GetAuthorityCode", _wrap_SpatialReference_GetAuthorityCode, METH_VARARGS, (char *)"SpatialReference_GetAuthorityCode(SpatialReference self, char target_key) -> char"},
12927 : { (char *)"SpatialReference_GetAuthorityName", _wrap_SpatialReference_GetAuthorityName, METH_VARARGS, (char *)"SpatialReference_GetAuthorityName(SpatialReference self, char target_key) -> char"},
12928 : { (char *)"SpatialReference_SetUTM", _wrap_SpatialReference_SetUTM, METH_VARARGS, (char *)"SpatialReference_SetUTM(SpatialReference self, int zone, int north = 1) -> OGRErr"},
12929 : { (char *)"SpatialReference_GetUTMZone", _wrap_SpatialReference_GetUTMZone, METH_VARARGS, (char *)"SpatialReference_GetUTMZone(SpatialReference self) -> int"},
12930 : { (char *)"SpatialReference_SetStatePlane", _wrap_SpatialReference_SetStatePlane, METH_VARARGS, (char *)"\n"
12931 : "SpatialReference_SetStatePlane(SpatialReference self, int zone, int is_nad83 = 1, \n"
12932 : " char unitsname = \"\", double units = 0.0) -> OGRErr\n"
12933 : ""},
12934 : { (char *)"SpatialReference_AutoIdentifyEPSG", _wrap_SpatialReference_AutoIdentifyEPSG, METH_VARARGS, (char *)"SpatialReference_AutoIdentifyEPSG(SpatialReference self) -> OGRErr"},
12935 : { (char *)"SpatialReference_SetProjection", _wrap_SpatialReference_SetProjection, METH_VARARGS, (char *)"SpatialReference_SetProjection(SpatialReference self, char arg) -> OGRErr"},
12936 : { (char *)"SpatialReference_SetProjParm", _wrap_SpatialReference_SetProjParm, METH_VARARGS, (char *)"SpatialReference_SetProjParm(SpatialReference self, char name, double val) -> OGRErr"},
12937 : { (char *)"SpatialReference_GetProjParm", _wrap_SpatialReference_GetProjParm, METH_VARARGS, (char *)"SpatialReference_GetProjParm(SpatialReference self, char name, double default_val = 0.0) -> double"},
12938 : { (char *)"SpatialReference_SetNormProjParm", _wrap_SpatialReference_SetNormProjParm, METH_VARARGS, (char *)"SpatialReference_SetNormProjParm(SpatialReference self, char name, double val) -> OGRErr"},
12939 : { (char *)"SpatialReference_GetNormProjParm", _wrap_SpatialReference_GetNormProjParm, METH_VARARGS, (char *)"SpatialReference_GetNormProjParm(SpatialReference self, char name, double default_val = 0.0) -> double"},
12940 : { (char *)"SpatialReference_GetSemiMajor", _wrap_SpatialReference_GetSemiMajor, METH_VARARGS, (char *)"SpatialReference_GetSemiMajor(SpatialReference self) -> double"},
12941 : { (char *)"SpatialReference_GetSemiMinor", _wrap_SpatialReference_GetSemiMinor, METH_VARARGS, (char *)"SpatialReference_GetSemiMinor(SpatialReference self) -> double"},
12942 : { (char *)"SpatialReference_GetInvFlattening", _wrap_SpatialReference_GetInvFlattening, METH_VARARGS, (char *)"SpatialReference_GetInvFlattening(SpatialReference self) -> double"},
12943 : { (char *)"SpatialReference_SetACEA", (PyCFunction) _wrap_SpatialReference_SetACEA, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12944 : "SpatialReference_SetACEA(SpatialReference self, double stdp1, double stdp2, \n"
12945 : " double clat, double clong, double fe, double fn) -> OGRErr\n"
12946 : ""},
12947 : { (char *)"SpatialReference_SetAE", (PyCFunction) _wrap_SpatialReference_SetAE, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12948 : "SpatialReference_SetAE(SpatialReference self, double clat, double clong, double fe, \n"
12949 : " double fn) -> OGRErr\n"
12950 : ""},
12951 : { (char *)"SpatialReference_SetBonne", (PyCFunction) _wrap_SpatialReference_SetBonne, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12952 : "SpatialReference_SetBonne(SpatialReference self, double stdp, double cm, double fe, \n"
12953 : " double fn) -> OGRErr\n"
12954 : ""},
12955 : { (char *)"SpatialReference_SetCEA", (PyCFunction) _wrap_SpatialReference_SetCEA, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12956 : "SpatialReference_SetCEA(SpatialReference self, double stdp1, double cm, double fe, \n"
12957 : " double fn) -> OGRErr\n"
12958 : ""},
12959 : { (char *)"SpatialReference_SetCS", (PyCFunction) _wrap_SpatialReference_SetCS, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12960 : "SpatialReference_SetCS(SpatialReference self, double clat, double clong, double fe, \n"
12961 : " double fn) -> OGRErr\n"
12962 : ""},
12963 : { (char *)"SpatialReference_SetEC", (PyCFunction) _wrap_SpatialReference_SetEC, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12964 : "SpatialReference_SetEC(SpatialReference self, double stdp1, double stdp2, \n"
12965 : " double clat, double clong, double fe, double fn) -> OGRErr\n"
12966 : ""},
12967 : { (char *)"SpatialReference_SetEckertIV", (PyCFunction) _wrap_SpatialReference_SetEckertIV, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetEckertIV(SpatialReference self, double cm, double fe, double fn) -> OGRErr"},
12968 : { (char *)"SpatialReference_SetEckertVI", (PyCFunction) _wrap_SpatialReference_SetEckertVI, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetEckertVI(SpatialReference self, double cm, double fe, double fn) -> OGRErr"},
12969 : { (char *)"SpatialReference_SetEquirectangular", (PyCFunction) _wrap_SpatialReference_SetEquirectangular, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12970 : "SpatialReference_SetEquirectangular(SpatialReference self, double clat, double clong, double fe, \n"
12971 : " double fn) -> OGRErr\n"
12972 : ""},
12973 : { (char *)"SpatialReference_SetEquirectangular2", (PyCFunction) _wrap_SpatialReference_SetEquirectangular2, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12974 : "SpatialReference_SetEquirectangular2(SpatialReference self, double clat, double clong, double pseudostdparallellat, \n"
12975 : " double fe, double fn) -> OGRErr\n"
12976 : ""},
12977 : { (char *)"SpatialReference_SetGaussSchreiberTMercator", (PyCFunction) _wrap_SpatialReference_SetGaussSchreiberTMercator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12978 : "SpatialReference_SetGaussSchreiberTMercator(SpatialReference self, double clat, double clong, double sc, \n"
12979 : " double fe, double fn) -> OGRErr\n"
12980 : ""},
12981 : { (char *)"SpatialReference_SetGS", (PyCFunction) _wrap_SpatialReference_SetGS, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetGS(SpatialReference self, double cm, double fe, double fn) -> OGRErr"},
12982 : { (char *)"SpatialReference_SetGH", (PyCFunction) _wrap_SpatialReference_SetGH, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetGH(SpatialReference self, double cm, double fe, double fn) -> OGRErr"},
12983 : { (char *)"SpatialReference_SetIGH", _wrap_SpatialReference_SetIGH, METH_VARARGS, (char *)"SpatialReference_SetIGH(SpatialReference self) -> OGRErr"},
12984 : { (char *)"SpatialReference_SetGEOS", (PyCFunction) _wrap_SpatialReference_SetGEOS, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12985 : "SpatialReference_SetGEOS(SpatialReference self, double cm, double satelliteheight, \n"
12986 : " double fe, double fn) -> OGRErr\n"
12987 : ""},
12988 : { (char *)"SpatialReference_SetGnomonic", (PyCFunction) _wrap_SpatialReference_SetGnomonic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12989 : "SpatialReference_SetGnomonic(SpatialReference self, double clat, double clong, double fe, \n"
12990 : " double fn) -> OGRErr\n"
12991 : ""},
12992 : { (char *)"SpatialReference_SetHOM", (PyCFunction) _wrap_SpatialReference_SetHOM, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12993 : "SpatialReference_SetHOM(SpatialReference self, double clat, double clong, double azimuth, \n"
12994 : " double recttoskew, double scale, \n"
12995 : " double fe, double fn) -> OGRErr\n"
12996 : ""},
12997 : { (char *)"SpatialReference_SetHOM2PNO", (PyCFunction) _wrap_SpatialReference_SetHOM2PNO, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
12998 : "SpatialReference_SetHOM2PNO(SpatialReference self, double clat, double dfLat1, \n"
12999 : " double dfLong1, double dfLat2, double dfLong2, \n"
13000 : " double scale, double fe, double fn) -> OGRErr\n"
13001 : ""},
13002 : { (char *)"SpatialReference_SetKrovak", (PyCFunction) _wrap_SpatialReference_SetKrovak, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13003 : "SpatialReference_SetKrovak(SpatialReference self, double clat, double clong, double azimuth, \n"
13004 : " double pseudostdparallellat, double scale, \n"
13005 : " double fe, double fn) -> OGRErr\n"
13006 : ""},
13007 : { (char *)"SpatialReference_SetLAEA", (PyCFunction) _wrap_SpatialReference_SetLAEA, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13008 : "SpatialReference_SetLAEA(SpatialReference self, double clat, double clong, double fe, \n"
13009 : " double fn) -> OGRErr\n"
13010 : ""},
13011 : { (char *)"SpatialReference_SetLCC", (PyCFunction) _wrap_SpatialReference_SetLCC, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13012 : "SpatialReference_SetLCC(SpatialReference self, double stdp1, double stdp2, \n"
13013 : " double clat, double clong, double fe, double fn) -> OGRErr\n"
13014 : ""},
13015 : { (char *)"SpatialReference_SetLCC1SP", (PyCFunction) _wrap_SpatialReference_SetLCC1SP, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13016 : "SpatialReference_SetLCC1SP(SpatialReference self, double clat, double clong, double scale, \n"
13017 : " double fe, double fn) -> OGRErr\n"
13018 : ""},
13019 : { (char *)"SpatialReference_SetLCCB", (PyCFunction) _wrap_SpatialReference_SetLCCB, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13020 : "SpatialReference_SetLCCB(SpatialReference self, double stdp1, double stdp2, \n"
13021 : " double clat, double clong, double fe, double fn) -> OGRErr\n"
13022 : ""},
13023 : { (char *)"SpatialReference_SetMC", (PyCFunction) _wrap_SpatialReference_SetMC, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13024 : "SpatialReference_SetMC(SpatialReference self, double clat, double clong, double fe, \n"
13025 : " double fn) -> OGRErr\n"
13026 : ""},
13027 : { (char *)"SpatialReference_SetMercator", (PyCFunction) _wrap_SpatialReference_SetMercator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13028 : "SpatialReference_SetMercator(SpatialReference self, double clat, double clong, double scale, \n"
13029 : " double fe, double fn) -> OGRErr\n"
13030 : ""},
13031 : { (char *)"SpatialReference_SetMollweide", (PyCFunction) _wrap_SpatialReference_SetMollweide, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetMollweide(SpatialReference self, double cm, double fe, double fn) -> OGRErr"},
13032 : { (char *)"SpatialReference_SetNZMG", (PyCFunction) _wrap_SpatialReference_SetNZMG, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13033 : "SpatialReference_SetNZMG(SpatialReference self, double clat, double clong, double fe, \n"
13034 : " double fn) -> OGRErr\n"
13035 : ""},
13036 : { (char *)"SpatialReference_SetOS", (PyCFunction) _wrap_SpatialReference_SetOS, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13037 : "SpatialReference_SetOS(SpatialReference self, double dfOriginLat, double dfCMeridian, \n"
13038 : " double scale, double fe, double fn) -> OGRErr\n"
13039 : ""},
13040 : { (char *)"SpatialReference_SetOrthographic", (PyCFunction) _wrap_SpatialReference_SetOrthographic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13041 : "SpatialReference_SetOrthographic(SpatialReference self, double clat, double clong, double fe, \n"
13042 : " double fn) -> OGRErr\n"
13043 : ""},
13044 : { (char *)"SpatialReference_SetPolyconic", (PyCFunction) _wrap_SpatialReference_SetPolyconic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13045 : "SpatialReference_SetPolyconic(SpatialReference self, double clat, double clong, double fe, \n"
13046 : " double fn) -> OGRErr\n"
13047 : ""},
13048 : { (char *)"SpatialReference_SetPS", (PyCFunction) _wrap_SpatialReference_SetPS, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13049 : "SpatialReference_SetPS(SpatialReference self, double clat, double clong, double scale, \n"
13050 : " double fe, double fn) -> OGRErr\n"
13051 : ""},
13052 : { (char *)"SpatialReference_SetRobinson", (PyCFunction) _wrap_SpatialReference_SetRobinson, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetRobinson(SpatialReference self, double clong, double fe, double fn) -> OGRErr"},
13053 : { (char *)"SpatialReference_SetSinusoidal", (PyCFunction) _wrap_SpatialReference_SetSinusoidal, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetSinusoidal(SpatialReference self, double clong, double fe, double fn) -> OGRErr"},
13054 : { (char *)"SpatialReference_SetStereographic", (PyCFunction) _wrap_SpatialReference_SetStereographic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13055 : "SpatialReference_SetStereographic(SpatialReference self, double clat, double clong, double scale, \n"
13056 : " double fe, double fn) -> OGRErr\n"
13057 : ""},
13058 : { (char *)"SpatialReference_SetSOC", (PyCFunction) _wrap_SpatialReference_SetSOC, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13059 : "SpatialReference_SetSOC(SpatialReference self, double latitudeoforigin, double cm, \n"
13060 : " double fe, double fn) -> OGRErr\n"
13061 : ""},
13062 : { (char *)"SpatialReference_SetTM", (PyCFunction) _wrap_SpatialReference_SetTM, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13063 : "SpatialReference_SetTM(SpatialReference self, double clat, double clong, double scale, \n"
13064 : " double fe, double fn) -> OGRErr\n"
13065 : ""},
13066 : { (char *)"SpatialReference_SetTMVariant", (PyCFunction) _wrap_SpatialReference_SetTMVariant, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13067 : "SpatialReference_SetTMVariant(SpatialReference self, char pszVariantName, double clat, \n"
13068 : " double clong, double scale, double fe, \n"
13069 : " double fn) -> OGRErr\n"
13070 : ""},
13071 : { (char *)"SpatialReference_SetTMG", (PyCFunction) _wrap_SpatialReference_SetTMG, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13072 : "SpatialReference_SetTMG(SpatialReference self, double clat, double clong, double fe, \n"
13073 : " double fn) -> OGRErr\n"
13074 : ""},
13075 : { (char *)"SpatialReference_SetTMSO", (PyCFunction) _wrap_SpatialReference_SetTMSO, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
13076 : "SpatialReference_SetTMSO(SpatialReference self, double clat, double clong, double scale, \n"
13077 : " double fe, double fn) -> OGRErr\n"
13078 : ""},
13079 : { (char *)"SpatialReference_SetVDG", (PyCFunction) _wrap_SpatialReference_SetVDG, METH_VARARGS | METH_KEYWORDS, (char *)"SpatialReference_SetVDG(SpatialReference self, double clong, double fe, double fn) -> OGRErr"},
13080 : { (char *)"SpatialReference_SetWellKnownGeogCS", _wrap_SpatialReference_SetWellKnownGeogCS, METH_VARARGS, (char *)"SpatialReference_SetWellKnownGeogCS(SpatialReference self, char name) -> OGRErr"},
13081 : { (char *)"SpatialReference_SetFromUserInput", _wrap_SpatialReference_SetFromUserInput, METH_VARARGS, (char *)"SpatialReference_SetFromUserInput(SpatialReference self, char name) -> OGRErr"},
13082 : { (char *)"SpatialReference_CopyGeogCSFrom", _wrap_SpatialReference_CopyGeogCSFrom, METH_VARARGS, (char *)"SpatialReference_CopyGeogCSFrom(SpatialReference self, SpatialReference rhs) -> OGRErr"},
13083 : { (char *)"SpatialReference_SetTOWGS84", _wrap_SpatialReference_SetTOWGS84, METH_VARARGS, (char *)"\n"
13084 : "SpatialReference_SetTOWGS84(SpatialReference self, double p1, double p2, double p3, \n"
13085 : " double p4 = 0.0, double p5 = 0.0, double p6 = 0.0, \n"
13086 : " double p7 = 0.0) -> OGRErr\n"
13087 : ""},
13088 : { (char *)"SpatialReference_GetTOWGS84", _wrap_SpatialReference_GetTOWGS84, METH_VARARGS, (char *)"SpatialReference_GetTOWGS84(SpatialReference self) -> OGRErr"},
13089 : { (char *)"SpatialReference_SetLocalCS", _wrap_SpatialReference_SetLocalCS, METH_VARARGS, (char *)"SpatialReference_SetLocalCS(SpatialReference self, char pszName) -> OGRErr"},
13090 : { (char *)"SpatialReference_SetGeogCS", _wrap_SpatialReference_SetGeogCS, METH_VARARGS, (char *)"\n"
13091 : "SpatialReference_SetGeogCS(SpatialReference self, char pszGeogName, char pszDatumName, \n"
13092 : " char pszEllipsoidName, double dfSemiMajor, \n"
13093 : " double dfInvFlattening, char pszPMName = \"Greenwich\", \n"
13094 : " double dfPMOffset = 0.0, char pszUnits = \"degree\", \n"
13095 : " double dfConvertToRadians = 0.0174532925199433) -> OGRErr\n"
13096 : ""},
13097 : { (char *)"SpatialReference_SetProjCS", _wrap_SpatialReference_SetProjCS, METH_VARARGS, (char *)"SpatialReference_SetProjCS(SpatialReference self, char name = \"unnamed\") -> OGRErr"},
13098 : { (char *)"SpatialReference_SetGeocCS", _wrap_SpatialReference_SetGeocCS, METH_VARARGS, (char *)"SpatialReference_SetGeocCS(SpatialReference self, char name = \"unnamed\") -> OGRErr"},
13099 : { (char *)"SpatialReference_SetVertCS", _wrap_SpatialReference_SetVertCS, METH_VARARGS, (char *)"\n"
13100 : "SpatialReference_SetVertCS(SpatialReference self, char VertCSName = \"unnamed\", \n"
13101 : " char VertDatumName = \"unnamed\", int VertDatumType = 0) -> OGRErr\n"
13102 : ""},
13103 : { (char *)"SpatialReference_SetCompoundCS", _wrap_SpatialReference_SetCompoundCS, METH_VARARGS, (char *)"\n"
13104 : "SpatialReference_SetCompoundCS(SpatialReference self, char name, SpatialReference horizcs, \n"
13105 : " SpatialReference vertcs) -> OGRErr\n"
13106 : ""},
13107 : { (char *)"SpatialReference_ImportFromWkt", _wrap_SpatialReference_ImportFromWkt, METH_VARARGS, (char *)"SpatialReference_ImportFromWkt(SpatialReference self, char ppszInput) -> OGRErr"},
13108 : { (char *)"SpatialReference_ImportFromProj4", _wrap_SpatialReference_ImportFromProj4, METH_VARARGS, (char *)"SpatialReference_ImportFromProj4(SpatialReference self, char ppszInput) -> OGRErr"},
13109 : { (char *)"SpatialReference_ImportFromUrl", _wrap_SpatialReference_ImportFromUrl, METH_VARARGS, (char *)"SpatialReference_ImportFromUrl(SpatialReference self, char url) -> OGRErr"},
13110 : { (char *)"SpatialReference_ImportFromESRI", _wrap_SpatialReference_ImportFromESRI, METH_VARARGS, (char *)"SpatialReference_ImportFromESRI(SpatialReference self, char ppszInput) -> OGRErr"},
13111 : { (char *)"SpatialReference_ImportFromEPSG", _wrap_SpatialReference_ImportFromEPSG, METH_VARARGS, (char *)"SpatialReference_ImportFromEPSG(SpatialReference self, int arg) -> OGRErr"},
13112 : { (char *)"SpatialReference_ImportFromEPSGA", _wrap_SpatialReference_ImportFromEPSGA, METH_VARARGS, (char *)"SpatialReference_ImportFromEPSGA(SpatialReference self, int arg) -> OGRErr"},
13113 : { (char *)"SpatialReference_ImportFromPCI", _wrap_SpatialReference_ImportFromPCI, METH_VARARGS, (char *)"\n"
13114 : "SpatialReference_ImportFromPCI(SpatialReference self, char proj, char units = \"METRE\", \n"
13115 : " double argin = 0) -> OGRErr\n"
13116 : ""},
13117 : { (char *)"SpatialReference_ImportFromUSGS", _wrap_SpatialReference_ImportFromUSGS, METH_VARARGS, (char *)"\n"
13118 : "SpatialReference_ImportFromUSGS(SpatialReference self, long proj_code, long zone = 0, \n"
13119 : " double argin = 0, long datum_code = 0) -> OGRErr\n"
13120 : ""},
13121 : { (char *)"SpatialReference_ImportFromXML", _wrap_SpatialReference_ImportFromXML, METH_VARARGS, (char *)"SpatialReference_ImportFromXML(SpatialReference self, char xmlString) -> OGRErr"},
13122 : { (char *)"SpatialReference_ImportFromERM", _wrap_SpatialReference_ImportFromERM, METH_VARARGS, (char *)"SpatialReference_ImportFromERM(SpatialReference self, char proj, char datum, char units) -> OGRErr"},
13123 : { (char *)"SpatialReference_ImportFromMICoordSys", _wrap_SpatialReference_ImportFromMICoordSys, METH_VARARGS, (char *)"SpatialReference_ImportFromMICoordSys(SpatialReference self, char pszCoordSys) -> OGRErr"},
13124 : { (char *)"SpatialReference_ImportFromOzi", _wrap_SpatialReference_ImportFromOzi, METH_VARARGS, (char *)"SpatialReference_ImportFromOzi(SpatialReference self, char datum, char proj, char projParms) -> OGRErr"},
13125 : { (char *)"SpatialReference_ExportToWkt", _wrap_SpatialReference_ExportToWkt, METH_VARARGS, (char *)"SpatialReference_ExportToWkt(SpatialReference self) -> OGRErr"},
13126 : { (char *)"SpatialReference_ExportToPrettyWkt", _wrap_SpatialReference_ExportToPrettyWkt, METH_VARARGS, (char *)"SpatialReference_ExportToPrettyWkt(SpatialReference self, int simplify = 0) -> OGRErr"},
13127 : { (char *)"SpatialReference_ExportToProj4", _wrap_SpatialReference_ExportToProj4, METH_VARARGS, (char *)"SpatialReference_ExportToProj4(SpatialReference self) -> OGRErr"},
13128 : { (char *)"SpatialReference_ExportToPCI", _wrap_SpatialReference_ExportToPCI, METH_VARARGS, (char *)"SpatialReference_ExportToPCI(SpatialReference self) -> OGRErr"},
13129 : { (char *)"SpatialReference_ExportToUSGS", _wrap_SpatialReference_ExportToUSGS, METH_VARARGS, (char *)"SpatialReference_ExportToUSGS(SpatialReference self) -> OGRErr"},
13130 : { (char *)"SpatialReference_ExportToXML", _wrap_SpatialReference_ExportToXML, METH_VARARGS, (char *)"SpatialReference_ExportToXML(SpatialReference self, char dialect = \"\") -> OGRErr"},
13131 : { (char *)"SpatialReference_ExportToMICoordSys", _wrap_SpatialReference_ExportToMICoordSys, METH_VARARGS, (char *)"SpatialReference_ExportToMICoordSys(SpatialReference self) -> OGRErr"},
13132 : { (char *)"SpatialReference_CloneGeogCS", _wrap_SpatialReference_CloneGeogCS, METH_VARARGS, (char *)"SpatialReference_CloneGeogCS(SpatialReference self) -> SpatialReference"},
13133 : { (char *)"SpatialReference_Clone", _wrap_SpatialReference_Clone, METH_VARARGS, (char *)"SpatialReference_Clone(SpatialReference self) -> SpatialReference"},
13134 : { (char *)"SpatialReference_Validate", _wrap_SpatialReference_Validate, METH_VARARGS, (char *)"SpatialReference_Validate(SpatialReference self) -> OGRErr"},
13135 : { (char *)"SpatialReference_StripCTParms", _wrap_SpatialReference_StripCTParms, METH_VARARGS, (char *)"SpatialReference_StripCTParms(SpatialReference self) -> OGRErr"},
13136 : { (char *)"SpatialReference_FixupOrdering", _wrap_SpatialReference_FixupOrdering, METH_VARARGS, (char *)"SpatialReference_FixupOrdering(SpatialReference self) -> OGRErr"},
13137 : { (char *)"SpatialReference_Fixup", _wrap_SpatialReference_Fixup, METH_VARARGS, (char *)"SpatialReference_Fixup(SpatialReference self) -> OGRErr"},
13138 : { (char *)"SpatialReference_MorphToESRI", _wrap_SpatialReference_MorphToESRI, METH_VARARGS, (char *)"SpatialReference_MorphToESRI(SpatialReference self) -> OGRErr"},
13139 : { (char *)"SpatialReference_MorphFromESRI", _wrap_SpatialReference_MorphFromESRI, METH_VARARGS, (char *)"SpatialReference_MorphFromESRI(SpatialReference self) -> OGRErr"},
13140 : { (char *)"SpatialReference_swigregister", SpatialReference_swigregister, METH_VARARGS, NULL},
13141 : { (char *)"new_CoordinateTransformation", _wrap_new_CoordinateTransformation, METH_VARARGS, (char *)"new_CoordinateTransformation(SpatialReference src, SpatialReference dst) -> CoordinateTransformation"},
13142 : { (char *)"delete_CoordinateTransformation", _wrap_delete_CoordinateTransformation, METH_VARARGS, (char *)"delete_CoordinateTransformation(CoordinateTransformation self)"},
13143 : { (char *)"CoordinateTransformation_TransformPoint", _wrap_CoordinateTransformation_TransformPoint, METH_VARARGS, (char *)"\n"
13144 : "TransformPoint(double inout)\n"
13145 : "CoordinateTransformation_TransformPoint(CoordinateTransformation self, double x, double y, \n"
13146 : " double z = 0.0)\n"
13147 : ""},
13148 : { (char *)"CoordinateTransformation_TransformPoints", _wrap_CoordinateTransformation_TransformPoints, METH_VARARGS, (char *)"CoordinateTransformation_TransformPoints(CoordinateTransformation self, int nCount)"},
13149 : { (char *)"CoordinateTransformation_swigregister", CoordinateTransformation_swigregister, METH_VARARGS, NULL},
13150 : { (char *)"CreateCoordinateTransformation", _wrap_CreateCoordinateTransformation, METH_VARARGS, (char *)"CreateCoordinateTransformation(SpatialReference src, SpatialReference dst) -> CoordinateTransformation"},
13151 : { NULL, NULL, 0, NULL }
13152 : };
13153 :
13154 :
13155 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
13156 :
13157 : static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, (void*)0, 0};
13158 : static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
13159 : static swig_type_info _swigt__p_char = {"_p_char", "char *|retStringAndCPLFree *", 0, 0, (void*)0, 0};
13160 : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
13161 : static swig_type_info _swigt__p_int = {"_p_int", "int *|OGRErr *", 0, 0, (void*)0, 0};
13162 : static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
13163 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
13164 : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
13165 :
13166 : static swig_type_info *swig_type_initial[] = {
13167 : &_swigt__p_OSRCoordinateTransformationShadow,
13168 : &_swigt__p_OSRSpatialReferenceShadow,
13169 : &_swigt__p_char,
13170 : &_swigt__p_double,
13171 : &_swigt__p_int,
13172 : &_swigt__p_long,
13173 : &_swigt__p_p_char,
13174 : &_swigt__p_p_double,
13175 : };
13176 :
13177 : static swig_cast_info _swigc__p_OSRCoordinateTransformationShadow[] = { {&_swigt__p_OSRCoordinateTransformationShadow, 0, 0, 0},{0, 0, 0, 0}};
13178 : static swig_cast_info _swigc__p_OSRSpatialReferenceShadow[] = { {&_swigt__p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
13179 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
13180 : static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
13181 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
13182 : static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
13183 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
13184 : static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
13185 :
13186 : static swig_cast_info *swig_cast_initial[] = {
13187 : _swigc__p_OSRCoordinateTransformationShadow,
13188 : _swigc__p_OSRSpatialReferenceShadow,
13189 : _swigc__p_char,
13190 : _swigc__p_double,
13191 : _swigc__p_int,
13192 : _swigc__p_long,
13193 : _swigc__p_p_char,
13194 : _swigc__p_p_double,
13195 : };
13196 :
13197 :
13198 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
13199 :
13200 : static swig_const_info swig_const_table[] = {
13201 : {0, 0, 0, 0.0, 0, 0}};
13202 :
13203 : #ifdef __cplusplus
13204 : }
13205 : #endif
13206 : /* -----------------------------------------------------------------------------
13207 : * Type initialization:
13208 : * This problem is tough by the requirement that no dynamic
13209 : * memory is used. Also, since swig_type_info structures store pointers to
13210 : * swig_cast_info structures and swig_cast_info structures store pointers back
13211 : * to swig_type_info structures, we need some lookup code at initialization.
13212 : * The idea is that swig generates all the structures that are needed.
13213 : * The runtime then collects these partially filled structures.
13214 : * The SWIG_InitializeModule function takes these initial arrays out of
13215 : * swig_module, and does all the lookup, filling in the swig_module.types
13216 : * array with the correct data and linking the correct swig_cast_info
13217 : * structures together.
13218 : *
13219 : * The generated swig_type_info structures are assigned staticly to an initial
13220 : * array. We just loop through that array, and handle each type individually.
13221 : * First we lookup if this type has been already loaded, and if so, use the
13222 : * loaded structure instead of the generated one. Then we have to fill in the
13223 : * cast linked list. The cast data is initially stored in something like a
13224 : * two-dimensional array. Each row corresponds to a type (there are the same
13225 : * number of rows as there are in the swig_type_initial array). Each entry in
13226 : * a column is one of the swig_cast_info structures for that type.
13227 : * The cast_initial array is actually an array of arrays, because each row has
13228 : * a variable number of columns. So to actually build the cast linked list,
13229 : * we find the array of casts associated with the type, and loop through it
13230 : * adding the casts to the list. The one last trick we need to do is making
13231 : * sure the type pointer in the swig_cast_info struct is correct.
13232 : *
13233 : * First off, we lookup the cast->type name to see if it is already loaded.
13234 : * There are three cases to handle:
13235 : * 1) If the cast->type has already been loaded AND the type we are adding
13236 : * casting info to has not been loaded (it is in this module), THEN we
13237 : * replace the cast->type pointer with the type pointer that has already
13238 : * been loaded.
13239 : * 2) If BOTH types (the one we are adding casting info to, and the
13240 : * cast->type) are loaded, THEN the cast info has already been loaded by
13241 : * the previous module so we just ignore it.
13242 : * 3) Finally, if cast->type has not already been loaded, then we add that
13243 : * swig_cast_info to the linked list (because the cast->type) pointer will
13244 : * be correct.
13245 : * ----------------------------------------------------------------------------- */
13246 :
13247 : #ifdef __cplusplus
13248 : extern "C" {
13249 : #if 0
13250 : } /* c-mode */
13251 : #endif
13252 : #endif
13253 :
13254 : #if 0
13255 : #define SWIGRUNTIME_DEBUG
13256 : #endif
13257 :
13258 :
13259 : SWIGRUNTIME void
13260 4 : SWIG_InitializeModule(void *clientdata) {
13261 : size_t i;
13262 : swig_module_info *module_head, *iter;
13263 : int found, init;
13264 :
13265 4 : clientdata = clientdata;
13266 :
13267 : /* check to see if the circular list has been setup, if not, set it up */
13268 4 : if (swig_module.next==0) {
13269 : /* Initialize the swig_module */
13270 4 : swig_module.type_initial = swig_type_initial;
13271 4 : swig_module.cast_initial = swig_cast_initial;
13272 4 : swig_module.next = &swig_module;
13273 4 : init = 1;
13274 : } else {
13275 0 : init = 0;
13276 : }
13277 :
13278 : /* Try and load any already created modules */
13279 4 : module_head = SWIG_GetModule(clientdata);
13280 4 : if (!module_head) {
13281 : /* This is the first module loaded for this interpreter */
13282 : /* so set the swig module into the interpreter */
13283 : SWIG_SetModule(clientdata, &swig_module);
13284 0 : module_head = &swig_module;
13285 : } else {
13286 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
13287 4 : found=0;
13288 4 : iter=module_head;
13289 8 : do {
13290 8 : if (iter==&swig_module) {
13291 0 : found=1;
13292 0 : break;
13293 : }
13294 8 : iter=iter->next;
13295 : } while (iter!= module_head);
13296 :
13297 : /* if the is found in the list, then all is done and we may leave */
13298 4 : if (found) return;
13299 : /* otherwise we must add out module into the list */
13300 4 : swig_module.next = module_head->next;
13301 4 : module_head->next = &swig_module;
13302 : }
13303 :
13304 : /* When multiple interpeters are used, a module could have already been initialized in
13305 : a different interpreter, but not yet have a pointer in this interpreter.
13306 : In this case, we do not want to continue adding types... everything should be
13307 : set up already */
13308 4 : if (init == 0) return;
13309 :
13310 : /* Now work on filling in swig_module.types */
13311 : #ifdef SWIGRUNTIME_DEBUG
13312 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
13313 : #endif
13314 36 : for (i = 0; i < swig_module.size; ++i) {
13315 32 : swig_type_info *type = 0;
13316 : swig_type_info *ret;
13317 : swig_cast_info *cast;
13318 :
13319 : #ifdef SWIGRUNTIME_DEBUG
13320 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
13321 : #endif
13322 :
13323 : /* if there is another module already loaded */
13324 32 : if (swig_module.next != &swig_module) {
13325 32 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
13326 : }
13327 32 : if (type) {
13328 : /* Overwrite clientdata field */
13329 : #ifdef SWIGRUNTIME_DEBUG
13330 : printf("SWIG_InitializeModule: found type %s\n", type->name);
13331 : #endif
13332 19 : if (swig_module.type_initial[i]->clientdata) {
13333 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
13334 : #ifdef SWIGRUNTIME_DEBUG
13335 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
13336 : #endif
13337 : }
13338 : } else {
13339 13 : type = swig_module.type_initial[i];
13340 : }
13341 :
13342 : /* Insert casting types */
13343 32 : cast = swig_module.cast_initial[i];
13344 96 : while (cast->type) {
13345 : /* Don't need to add information already in the list */
13346 32 : ret = 0;
13347 : #ifdef SWIGRUNTIME_DEBUG
13348 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
13349 : #endif
13350 32 : if (swig_module.next != &swig_module) {
13351 32 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
13352 : #ifdef SWIGRUNTIME_DEBUG
13353 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
13354 : #endif
13355 : }
13356 32 : if (ret) {
13357 19 : if (type == swig_module.type_initial[i]) {
13358 : #ifdef SWIGRUNTIME_DEBUG
13359 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
13360 : #endif
13361 0 : cast->type = ret;
13362 0 : ret = 0;
13363 : } else {
13364 : /* Check for casting already in the list */
13365 19 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
13366 : #ifdef SWIGRUNTIME_DEBUG
13367 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
13368 : #endif
13369 19 : if (!ocast) ret = 0;
13370 : }
13371 : }
13372 :
13373 32 : if (!ret) {
13374 : #ifdef SWIGRUNTIME_DEBUG
13375 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
13376 : #endif
13377 13 : if (type->cast) {
13378 0 : type->cast->prev = cast;
13379 0 : cast->next = type->cast;
13380 : }
13381 13 : type->cast = cast;
13382 : }
13383 32 : cast++;
13384 : }
13385 : /* Set entry in modules->types array equal to the type */
13386 32 : swig_module.types[i] = type;
13387 : }
13388 4 : swig_module.types[i] = 0;
13389 :
13390 : #ifdef SWIGRUNTIME_DEBUG
13391 : printf("**** SWIG_InitializeModule: Cast List ******\n");
13392 : for (i = 0; i < swig_module.size; ++i) {
13393 : int j = 0;
13394 : swig_cast_info *cast = swig_module.cast_initial[i];
13395 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
13396 : while (cast->type) {
13397 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
13398 : cast++;
13399 : ++j;
13400 : }
13401 : printf("---- Total casts: %d\n",j);
13402 : }
13403 : printf("**** SWIG_InitializeModule: Cast List ******\n");
13404 : #endif
13405 : }
13406 :
13407 : /* This function will propagate the clientdata field of type to
13408 : * any new swig_type_info structures that have been added into the list
13409 : * of equivalent types. It is like calling
13410 : * SWIG_TypeClientData(type, clientdata) a second time.
13411 : */
13412 : SWIGRUNTIME void
13413 : SWIG_PropagateClientData(void) {
13414 : size_t i;
13415 : swig_cast_info *equiv;
13416 : static int init_run = 0;
13417 :
13418 : if (init_run) return;
13419 : init_run = 1;
13420 :
13421 : for (i = 0; i < swig_module.size; i++) {
13422 : if (swig_module.types[i]->clientdata) {
13423 : equiv = swig_module.types[i]->cast;
13424 : while (equiv) {
13425 : if (!equiv->converter) {
13426 : if (equiv->type && !equiv->type->clientdata)
13427 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
13428 : }
13429 : equiv = equiv->next;
13430 : }
13431 : }
13432 : }
13433 : }
13434 :
13435 : #ifdef __cplusplus
13436 : #if 0
13437 : {
13438 : /* c-mode */
13439 : #endif
13440 : }
13441 : #endif
13442 :
13443 :
13444 :
13445 : #ifdef __cplusplus
13446 : extern "C" {
13447 : #endif
13448 :
13449 : /* Python-specific SWIG API */
13450 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
13451 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
13452 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
13453 :
13454 : /* -----------------------------------------------------------------------------
13455 : * global variable support code.
13456 : * ----------------------------------------------------------------------------- */
13457 :
13458 : typedef struct swig_globalvar {
13459 : char *name; /* Name of global variable */
13460 : PyObject *(*get_attr)(void); /* Return the current value */
13461 : int (*set_attr)(PyObject *); /* Set the value */
13462 : struct swig_globalvar *next;
13463 : } swig_globalvar;
13464 :
13465 : typedef struct swig_varlinkobject {
13466 : PyObject_HEAD
13467 : swig_globalvar *vars;
13468 : } swig_varlinkobject;
13469 :
13470 : SWIGINTERN PyObject *
13471 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
13472 : #if PY_VERSION_HEX >= 0x03000000
13473 : return PyUnicode_InternFromString("<Swig global variables>");
13474 : #else
13475 : return PyString_FromString("<Swig global variables>");
13476 : #endif
13477 : }
13478 :
13479 : SWIGINTERN PyObject *
13480 : swig_varlink_str(swig_varlinkobject *v) {
13481 : #if PY_VERSION_HEX >= 0x03000000
13482 : PyObject *str = PyUnicode_InternFromString("(");
13483 : PyObject *tail;
13484 : PyObject *joined;
13485 : swig_globalvar *var;
13486 : for (var = v->vars; var; var=var->next) {
13487 : tail = PyUnicode_FromString(var->name);
13488 : joined = PyUnicode_Concat(str, tail);
13489 : Py_DecRef(str);
13490 : Py_DecRef(tail);
13491 : str = joined;
13492 : if (var->next) {
13493 : tail = PyUnicode_InternFromString(", ");
13494 : joined = PyUnicode_Concat(str, tail);
13495 : Py_DecRef(str);
13496 : Py_DecRef(tail);
13497 : str = joined;
13498 : }
13499 : }
13500 : tail = PyUnicode_InternFromString(")");
13501 : joined = PyUnicode_Concat(str, tail);
13502 : Py_DecRef(str);
13503 : Py_DecRef(tail);
13504 : str = joined;
13505 : #else
13506 : PyObject *str = PyString_FromString("(");
13507 : swig_globalvar *var;
13508 : for (var = v->vars; var; var=var->next) {
13509 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
13510 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
13511 : }
13512 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
13513 : #endif
13514 : return str;
13515 : }
13516 :
13517 : SWIGINTERN int
13518 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
13519 : char *tmp;
13520 : PyObject *str = swig_varlink_str(v);
13521 : fprintf(fp,"Swig global variables ");
13522 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
13523 : SWIG_Python_str_DelForPy3(tmp);
13524 : Py_DECREF(str);
13525 : return 0;
13526 : }
13527 :
13528 : SWIGINTERN void
13529 : swig_varlink_dealloc(swig_varlinkobject *v) {
13530 : swig_globalvar *var = v->vars;
13531 : while (var) {
13532 : swig_globalvar *n = var->next;
13533 : free(var->name);
13534 : free(var);
13535 : var = n;
13536 : }
13537 : }
13538 :
13539 : SWIGINTERN PyObject *
13540 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
13541 : PyObject *res = NULL;
13542 : swig_globalvar *var = v->vars;
13543 : while (var) {
13544 : if (strcmp(var->name,n) == 0) {
13545 : res = (*var->get_attr)();
13546 : break;
13547 : }
13548 : var = var->next;
13549 : }
13550 : if (res == NULL && !PyErr_Occurred()) {
13551 : PyErr_SetString(PyExc_NameError,"Unknown C global variable");
13552 : }
13553 : return res;
13554 : }
13555 :
13556 : SWIGINTERN int
13557 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
13558 : int res = 1;
13559 : swig_globalvar *var = v->vars;
13560 : while (var) {
13561 : if (strcmp(var->name,n) == 0) {
13562 : res = (*var->set_attr)(p);
13563 : break;
13564 : }
13565 : var = var->next;
13566 : }
13567 : if (res == 1 && !PyErr_Occurred()) {
13568 : PyErr_SetString(PyExc_NameError,"Unknown C global variable");
13569 : }
13570 : return res;
13571 : }
13572 :
13573 : SWIGINTERN PyTypeObject*
13574 : swig_varlink_type(void) {
13575 : static char varlink__doc__[] = "Swig var link object";
13576 : static PyTypeObject varlink_type;
13577 : static int type_init = 0;
13578 : if (!type_init) {
13579 : const PyTypeObject tmp
13580 : = {
13581 : /* PyObject header changed in Python 3 */
13582 : #if PY_VERSION_HEX >= 0x03000000
13583 : PyVarObject_HEAD_INIT(&PyType_Type, 0)
13584 : #else
13585 : PyObject_HEAD_INIT(NULL)
13586 : 0, /* Number of items in variable part (ob_size) */
13587 : #endif
13588 : (char *)"swigvarlink", /* Type name (tp_name) */
13589 : sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
13590 : 0, /* Itemsize (tp_itemsize) */
13591 : (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
13592 : (printfunc) swig_varlink_print, /* Print (tp_print) */
13593 : (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
13594 : (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
13595 : 0, /* tp_compare */
13596 : (reprfunc) swig_varlink_repr, /* tp_repr */
13597 : 0, /* tp_as_number */
13598 : 0, /* tp_as_sequence */
13599 : 0, /* tp_as_mapping */
13600 : 0, /* tp_hash */
13601 : 0, /* tp_call */
13602 : (reprfunc) swig_varlink_str, /* tp_str */
13603 : 0, /* tp_getattro */
13604 : 0, /* tp_setattro */
13605 : 0, /* tp_as_buffer */
13606 : 0, /* tp_flags */
13607 : varlink__doc__, /* tp_doc */
13608 : 0, /* tp_traverse */
13609 : 0, /* tp_clear */
13610 : 0, /* tp_richcompare */
13611 : 0, /* tp_weaklistoffset */
13612 : #if PY_VERSION_HEX >= 0x02020000
13613 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
13614 : #endif
13615 : #if PY_VERSION_HEX >= 0x02030000
13616 : 0, /* tp_del */
13617 : #endif
13618 : #ifdef COUNT_ALLOCS
13619 : 0,0,0,0 /* tp_alloc -> tp_next */
13620 : #endif
13621 : };
13622 : varlink_type = tmp;
13623 : /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
13624 : #if PY_VERSION_HEX < 0x03000000
13625 : varlink_type.ob_type = &PyType_Type;
13626 : #endif
13627 : type_init = 1;
13628 : }
13629 : return &varlink_type;
13630 : }
13631 :
13632 : /* Create a variable linking object for use later */
13633 : SWIGINTERN PyObject *
13634 : SWIG_Python_newvarlink(void) {
13635 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
13636 : if (result) {
13637 : result->vars = 0;
13638 : }
13639 : return ((PyObject*) result);
13640 : }
13641 :
13642 : SWIGINTERN void
13643 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
13644 : swig_varlinkobject *v = (swig_varlinkobject *) p;
13645 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
13646 : if (gv) {
13647 : size_t size = strlen(name)+1;
13648 : gv->name = (char *)malloc(size);
13649 : if (gv->name) {
13650 : strncpy(gv->name,name,size);
13651 : gv->get_attr = get_attr;
13652 : gv->set_attr = set_attr;
13653 : gv->next = v->vars;
13654 : }
13655 : }
13656 : v->vars = gv;
13657 : }
13658 :
13659 : SWIGINTERN PyObject *
13660 : SWIG_globals(void) {
13661 : static PyObject *_SWIG_globals = 0;
13662 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
13663 : return _SWIG_globals;
13664 : }
13665 :
13666 : /* -----------------------------------------------------------------------------
13667 : * constants/methods manipulation
13668 : * ----------------------------------------------------------------------------- */
13669 :
13670 : /* Install Constants */
13671 : SWIGINTERN void
13672 4 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
13673 4 : PyObject *obj = 0;
13674 : size_t i;
13675 4 : for (i = 0; constants[i].type; ++i) {
13676 0 : switch(constants[i].type) {
13677 : case SWIG_PY_POINTER:
13678 0 : obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
13679 0 : break;
13680 : case SWIG_PY_BINARY:
13681 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
13682 0 : break;
13683 : default:
13684 0 : obj = 0;
13685 : break;
13686 : }
13687 0 : if (obj) {
13688 0 : PyDict_SetItemString(d, constants[i].name, obj);
13689 0 : Py_DECREF(obj);
13690 : }
13691 : }
13692 4 : }
13693 :
13694 : /* -----------------------------------------------------------------------------*/
13695 : /* Fix SwigMethods to carry the callback ptrs when needed */
13696 : /* -----------------------------------------------------------------------------*/
13697 :
13698 : SWIGINTERN void
13699 4 : SWIG_Python_FixMethods(PyMethodDef *methods,
13700 : swig_const_info *const_table,
13701 : swig_type_info **types,
13702 : swig_type_info **types_initial) {
13703 : size_t i;
13704 520 : for (i = 0; methods[i].ml_name; ++i) {
13705 516 : const char *c = methods[i].ml_doc;
13706 1016 : if (c && (c = strstr(c, "swig_ptr: "))) {
13707 : int j;
13708 0 : swig_const_info *ci = 0;
13709 0 : const char *name = c + 10;
13710 0 : for (j = 0; const_table[j].type; ++j) {
13711 0 : if (strncmp(const_table[j].name, name,
13712 0 : strlen(const_table[j].name)) == 0) {
13713 0 : ci = &(const_table[j]);
13714 0 : break;
13715 : }
13716 : }
13717 0 : if (ci) {
13718 0 : size_t shift = (ci->ptype) - types;
13719 0 : swig_type_info *ty = types_initial[shift];
13720 0 : size_t ldoc = (c - methods[i].ml_doc);
13721 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
13722 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
13723 0 : if (ndoc) {
13724 0 : char *buff = ndoc;
13725 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
13726 0 : if (ptr) {
13727 0 : strncpy(buff, methods[i].ml_doc, ldoc);
13728 0 : buff += ldoc;
13729 : strncpy(buff, "swig_ptr: ", 10);
13730 0 : buff += 10;
13731 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
13732 0 : methods[i].ml_doc = ndoc;
13733 : }
13734 : }
13735 : }
13736 : }
13737 : }
13738 4 : }
13739 :
13740 : #ifdef __cplusplus
13741 : }
13742 : #endif
13743 :
13744 : /* -----------------------------------------------------------------------------*
13745 : * Partial Init method
13746 : * -----------------------------------------------------------------------------*/
13747 :
13748 : #ifdef __cplusplus
13749 : extern "C"
13750 : #endif
13751 :
13752 : SWIGEXPORT
13753 : #if PY_VERSION_HEX >= 0x03000000
13754 : PyObject*
13755 : #else
13756 : void
13757 : #endif
13758 4 : SWIG_init(void) {
13759 : PyObject *m, *d;
13760 : #if PY_VERSION_HEX >= 0x03000000
13761 : static struct PyModuleDef SWIG_module = {
13762 : PyModuleDef_HEAD_INIT,
13763 : (char *) SWIG_name,
13764 : NULL,
13765 : -1,
13766 : SwigMethods,
13767 : NULL,
13768 : NULL,
13769 : NULL,
13770 : NULL
13771 : };
13772 : #endif
13773 :
13774 : /* Fix SwigMethods to carry the callback ptrs when needed */
13775 4 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
13776 :
13777 : #if PY_VERSION_HEX >= 0x03000000
13778 : m = PyModule_Create(&SWIG_module);
13779 : #else
13780 4 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
13781 : #endif
13782 4 : d = PyModule_GetDict(m);
13783 :
13784 4 : SWIG_InitializeModule(0);
13785 4 : SWIG_InstallConstants(d,swig_const_table);
13786 :
13787 :
13788 4 : SWIG_Python_SetConstant(d, "SRS_WKT_WGS84",SWIG_FromCharPtr("GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9108\"]],AUTHORITY[\"EPSG\",\"4326\"]]"));
13789 4 : SWIG_Python_SetConstant(d, "SRS_PT_ALBERS_CONIC_EQUAL_AREA",SWIG_FromCharPtr("Albers_Conic_Equal_Area"));
13790 4 : SWIG_Python_SetConstant(d, "SRS_PT_AZIMUTHAL_EQUIDISTANT",SWIG_FromCharPtr("Azimuthal_Equidistant"));
13791 4 : SWIG_Python_SetConstant(d, "SRS_PT_CASSINI_SOLDNER",SWIG_FromCharPtr("Cassini_Soldner"));
13792 4 : SWIG_Python_SetConstant(d, "SRS_PT_CYLINDRICAL_EQUAL_AREA",SWIG_FromCharPtr("Cylindrical_Equal_Area"));
13793 4 : SWIG_Python_SetConstant(d, "SRS_PT_BONNE",SWIG_FromCharPtr("Bonne"));
13794 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_I",SWIG_FromCharPtr("Eckert_I"));
13795 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_II",SWIG_FromCharPtr("Eckert_II"));
13796 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_III",SWIG_FromCharPtr("Eckert_III"));
13797 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_IV",SWIG_FromCharPtr("Eckert_IV"));
13798 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_V",SWIG_FromCharPtr("Eckert_V"));
13799 4 : SWIG_Python_SetConstant(d, "SRS_PT_ECKERT_VI",SWIG_FromCharPtr("Eckert_VI"));
13800 4 : SWIG_Python_SetConstant(d, "SRS_PT_EQUIDISTANT_CONIC",SWIG_FromCharPtr("Equidistant_Conic"));
13801 4 : SWIG_Python_SetConstant(d, "SRS_PT_EQUIRECTANGULAR",SWIG_FromCharPtr("Equirectangular"));
13802 4 : SWIG_Python_SetConstant(d, "SRS_PT_GALL_STEREOGRAPHIC",SWIG_FromCharPtr("Gall_Stereographic"));
13803 4 : SWIG_Python_SetConstant(d, "SRS_PT_GAUSSSCHREIBERTMERCATOR",SWIG_FromCharPtr("Gauss_Schreiber_Transverse_Mercator"));
13804 4 : SWIG_Python_SetConstant(d, "SRS_PT_GEOSTATIONARY_SATELLITE",SWIG_FromCharPtr("Geostationary_Satellite"));
13805 4 : SWIG_Python_SetConstant(d, "SRS_PT_GOODE_HOMOLOSINE",SWIG_FromCharPtr("Goode_Homolosine"));
13806 4 : SWIG_Python_SetConstant(d, "SRS_PT_IGH",SWIG_FromCharPtr("Interrupted_Goode_Homolosine"));
13807 4 : SWIG_Python_SetConstant(d, "SRS_PT_GNOMONIC",SWIG_FromCharPtr("Gnomonic"));
13808 4 : SWIG_Python_SetConstant(d, "SRS_PT_HOTINE_OBLIQUE_MERCATOR_AZIMUTH_CENTER",SWIG_FromCharPtr("Hotine_Oblique_Mercator_Azimuth_Center"));
13809 4 : SWIG_Python_SetConstant(d, "SRS_PT_HOTINE_OBLIQUE_MERCATOR",SWIG_FromCharPtr("Hotine_Oblique_Mercator"));
13810 4 : SWIG_Python_SetConstant(d, "SRS_PT_HOTINE_OBLIQUE_MERCATOR_TWO_POINT_NATURAL_ORIGIN",SWIG_FromCharPtr("Hotine_Oblique_Mercator_Two_Point_Natural_Origin"));
13811 4 : SWIG_Python_SetConstant(d, "SRS_PT_LABORDE_OBLIQUE_MERCATOR",SWIG_FromCharPtr("Laborde_Oblique_Mercator"));
13812 4 : SWIG_Python_SetConstant(d, "SRS_PT_LAMBERT_CONFORMAL_CONIC_1SP",SWIG_FromCharPtr("Lambert_Conformal_Conic_1SP"));
13813 4 : SWIG_Python_SetConstant(d, "SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP",SWIG_FromCharPtr("Lambert_Conformal_Conic_2SP"));
13814 4 : SWIG_Python_SetConstant(d, "SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP_BELGIUM",SWIG_FromCharPtr("Lambert_Conformal_Conic_2SP_Belgium"));
13815 4 : SWIG_Python_SetConstant(d, "SRS_PT_LAMBERT_AZIMUTHAL_EQUAL_AREA",SWIG_FromCharPtr("Lambert_Azimuthal_Equal_Area"));
13816 4 : SWIG_Python_SetConstant(d, "SRS_PT_MERCATOR_1SP",SWIG_FromCharPtr("Mercator_1SP"));
13817 4 : SWIG_Python_SetConstant(d, "SRS_PT_MERCATOR_2SP",SWIG_FromCharPtr("Mercator_2SP"));
13818 4 : SWIG_Python_SetConstant(d, "SRS_PT_MILLER_CYLINDRICAL",SWIG_FromCharPtr("Miller_Cylindrical"));
13819 4 : SWIG_Python_SetConstant(d, "SRS_PT_MOLLWEIDE",SWIG_FromCharPtr("Mollweide"));
13820 4 : SWIG_Python_SetConstant(d, "SRS_PT_NEW_ZEALAND_MAP_GRID",SWIG_FromCharPtr("New_Zealand_Map_Grid"));
13821 4 : SWIG_Python_SetConstant(d, "SRS_PT_OBLIQUE_STEREOGRAPHIC",SWIG_FromCharPtr("Oblique_Stereographic"));
13822 4 : SWIG_Python_SetConstant(d, "SRS_PT_ORTHOGRAPHIC",SWIG_FromCharPtr("Orthographic"));
13823 4 : SWIG_Python_SetConstant(d, "SRS_PT_POLAR_STEREOGRAPHIC",SWIG_FromCharPtr("Polar_Stereographic"));
13824 4 : SWIG_Python_SetConstant(d, "SRS_PT_POLYCONIC",SWIG_FromCharPtr("Polyconic"));
13825 4 : SWIG_Python_SetConstant(d, "SRS_PT_ROBINSON",SWIG_FromCharPtr("Robinson"));
13826 4 : SWIG_Python_SetConstant(d, "SRS_PT_SINUSOIDAL",SWIG_FromCharPtr("Sinusoidal"));
13827 4 : SWIG_Python_SetConstant(d, "SRS_PT_STEREOGRAPHIC",SWIG_FromCharPtr("Stereographic"));
13828 4 : SWIG_Python_SetConstant(d, "SRS_PT_SWISS_OBLIQUE_CYLINDRICAL",SWIG_FromCharPtr("Swiss_Oblique_Cylindrical"));
13829 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR",SWIG_FromCharPtr("Transverse_Mercator"));
13830 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED",SWIG_FromCharPtr("Transverse_Mercator_South_Orientated"));
13831 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_MI_21",SWIG_FromCharPtr("Transverse_Mercator_MapInfo_21"));
13832 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_MI_22",SWIG_FromCharPtr("Transverse_Mercator_MapInfo_22"));
13833 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_MI_23",SWIG_FromCharPtr("Transverse_Mercator_MapInfo_23"));
13834 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_MI_24",SWIG_FromCharPtr("Transverse_Mercator_MapInfo_24"));
13835 4 : SWIG_Python_SetConstant(d, "SRS_PT_TRANSVERSE_MERCATOR_MI_25",SWIG_FromCharPtr("Transverse_Mercator_MapInfo_25"));
13836 4 : SWIG_Python_SetConstant(d, "SRS_PT_TUNISIA_MINING_GRID",SWIG_FromCharPtr("Tunisia_Mining_Grid"));
13837 4 : SWIG_Python_SetConstant(d, "SRS_PT_TWO_POINT_EQUIDISTANT",SWIG_FromCharPtr("Two_Point_Equidistant"));
13838 4 : SWIG_Python_SetConstant(d, "SRS_PT_VANDERGRINTEN",SWIG_FromCharPtr("VanDerGrinten"));
13839 4 : SWIG_Python_SetConstant(d, "SRS_PT_KROVAK",SWIG_FromCharPtr("Krovak"));
13840 4 : SWIG_Python_SetConstant(d, "SRS_PT_IMW_POLYCONIC",SWIG_FromCharPtr("International_Map_of_the_World_Polyconic"));
13841 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_I",SWIG_FromCharPtr("Wagner_I"));
13842 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_II",SWIG_FromCharPtr("Wagner_II"));
13843 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_III",SWIG_FromCharPtr("Wagner_III"));
13844 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_IV",SWIG_FromCharPtr("Wagner_IV"));
13845 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_V",SWIG_FromCharPtr("Wagner_V"));
13846 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_VI",SWIG_FromCharPtr("Wagner_VI"));
13847 4 : SWIG_Python_SetConstant(d, "SRS_PT_WAGNER_VII",SWIG_FromCharPtr("Wagner_VII"));
13848 4 : SWIG_Python_SetConstant(d, "SRS_PP_CENTRAL_MERIDIAN",SWIG_FromCharPtr("central_meridian"));
13849 4 : SWIG_Python_SetConstant(d, "SRS_PP_SCALE_FACTOR",SWIG_FromCharPtr("scale_factor"));
13850 4 : SWIG_Python_SetConstant(d, "SRS_PP_STANDARD_PARALLEL_1",SWIG_FromCharPtr("standard_parallel_1"));
13851 4 : SWIG_Python_SetConstant(d, "SRS_PP_STANDARD_PARALLEL_2",SWIG_FromCharPtr("standard_parallel_2"));
13852 4 : SWIG_Python_SetConstant(d, "SRS_PP_PSEUDO_STD_PARALLEL_1",SWIG_FromCharPtr("pseudo_standard_parallel_1"));
13853 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_CENTER",SWIG_FromCharPtr("longitude_of_center"));
13854 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_CENTER",SWIG_FromCharPtr("latitude_of_center"));
13855 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_ORIGIN",SWIG_FromCharPtr("longitude_of_origin"));
13856 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_ORIGIN",SWIG_FromCharPtr("latitude_of_origin"));
13857 4 : SWIG_Python_SetConstant(d, "SRS_PP_FALSE_EASTING",SWIG_FromCharPtr("false_easting"));
13858 4 : SWIG_Python_SetConstant(d, "SRS_PP_FALSE_NORTHING",SWIG_FromCharPtr("false_northing"));
13859 4 : SWIG_Python_SetConstant(d, "SRS_PP_AZIMUTH",SWIG_FromCharPtr("azimuth"));
13860 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_POINT_1",SWIG_FromCharPtr("longitude_of_point_1"));
13861 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_POINT_1",SWIG_FromCharPtr("latitude_of_point_1"));
13862 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_POINT_2",SWIG_FromCharPtr("longitude_of_point_2"));
13863 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_POINT_2",SWIG_FromCharPtr("latitude_of_point_2"));
13864 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_POINT_3",SWIG_FromCharPtr("longitude_of_point_3"));
13865 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_POINT_3",SWIG_FromCharPtr("latitude_of_point_3"));
13866 4 : SWIG_Python_SetConstant(d, "SRS_PP_RECTIFIED_GRID_ANGLE",SWIG_FromCharPtr("rectified_grid_angle"));
13867 4 : SWIG_Python_SetConstant(d, "SRS_PP_LANDSAT_NUMBER",SWIG_FromCharPtr("landsat_number"));
13868 4 : SWIG_Python_SetConstant(d, "SRS_PP_PATH_NUMBER",SWIG_FromCharPtr("path_number"));
13869 4 : SWIG_Python_SetConstant(d, "SRS_PP_PERSPECTIVE_POINT_HEIGHT",SWIG_FromCharPtr("perspective_point_height"));
13870 4 : SWIG_Python_SetConstant(d, "SRS_PP_SATELLITE_HEIGHT",SWIG_FromCharPtr("satellite_height"));
13871 4 : SWIG_Python_SetConstant(d, "SRS_PP_FIPSZONE",SWIG_FromCharPtr("fipszone"));
13872 4 : SWIG_Python_SetConstant(d, "SRS_PP_ZONE",SWIG_FromCharPtr("zone"));
13873 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_1ST_POINT",SWIG_FromCharPtr("Latitude_Of_1st_Point"));
13874 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_1ST_POINT",SWIG_FromCharPtr("Longitude_Of_1st_Point"));
13875 4 : SWIG_Python_SetConstant(d, "SRS_PP_LATITUDE_OF_2ND_POINT",SWIG_FromCharPtr("Latitude_Of_2nd_Point"));
13876 4 : SWIG_Python_SetConstant(d, "SRS_PP_LONGITUDE_OF_2ND_POINT",SWIG_FromCharPtr("Longitude_Of_2nd_Point"));
13877 4 : SWIG_Python_SetConstant(d, "SRS_UL_METER",SWIG_FromCharPtr("Meter"));
13878 4 : SWIG_Python_SetConstant(d, "SRS_UL_FOOT",SWIG_FromCharPtr("Foot (International)"));
13879 4 : SWIG_Python_SetConstant(d, "SRS_UL_FOOT_CONV",SWIG_FromCharPtr("0.3048"));
13880 4 : SWIG_Python_SetConstant(d, "SRS_UL_US_FOOT",SWIG_FromCharPtr("Foot_US"));
13881 4 : SWIG_Python_SetConstant(d, "SRS_UL_US_FOOT_CONV",SWIG_FromCharPtr("0.3048006096012192"));
13882 4 : SWIG_Python_SetConstant(d, "SRS_UL_NAUTICAL_MILE",SWIG_FromCharPtr("Nautical Mile"));
13883 4 : SWIG_Python_SetConstant(d, "SRS_UL_NAUTICAL_MILE_CONV",SWIG_FromCharPtr("1852.0"));
13884 4 : SWIG_Python_SetConstant(d, "SRS_UL_LINK",SWIG_FromCharPtr("Link"));
13885 4 : SWIG_Python_SetConstant(d, "SRS_UL_LINK_CONV",SWIG_FromCharPtr("0.20116684023368047"));
13886 4 : SWIG_Python_SetConstant(d, "SRS_UL_CHAIN",SWIG_FromCharPtr("Chain"));
13887 4 : SWIG_Python_SetConstant(d, "SRS_UL_CHAIN_CONV",SWIG_FromCharPtr("20.116684023368047"));
13888 4 : SWIG_Python_SetConstant(d, "SRS_UL_ROD",SWIG_FromCharPtr("Rod"));
13889 4 : SWIG_Python_SetConstant(d, "SRS_UL_ROD_CONV",SWIG_FromCharPtr("5.02921005842012"));
13890 4 : SWIG_Python_SetConstant(d, "SRS_UL_LINK_Clarke",SWIG_FromCharPtr("Link_Clarke"));
13891 4 : SWIG_Python_SetConstant(d, "SRS_UL_LINK_Clarke_CONV",SWIG_FromCharPtr("0.2011661949"));
13892 4 : SWIG_Python_SetConstant(d, "SRS_UA_DEGREE",SWIG_FromCharPtr("degree"));
13893 4 : SWIG_Python_SetConstant(d, "SRS_UA_DEGREE_CONV",SWIG_FromCharPtr("0.0174532925199433"));
13894 4 : SWIG_Python_SetConstant(d, "SRS_UA_RADIAN",SWIG_FromCharPtr("radian"));
13895 4 : SWIG_Python_SetConstant(d, "SRS_PM_GREENWICH",SWIG_FromCharPtr("Greenwich"));
13896 4 : SWIG_Python_SetConstant(d, "SRS_DN_NAD27",SWIG_FromCharPtr("North_American_Datum_1927"));
13897 4 : SWIG_Python_SetConstant(d, "SRS_DN_NAD83",SWIG_FromCharPtr("North_American_Datum_1983"));
13898 4 : SWIG_Python_SetConstant(d, "SRS_DN_WGS72",SWIG_FromCharPtr("WGS_1972"));
13899 4 : SWIG_Python_SetConstant(d, "SRS_DN_WGS84",SWIG_FromCharPtr("WGS_1984"));
13900 4 : SWIG_Python_SetConstant(d, "SRS_WGS84_SEMIMAJOR",SWIG_From_double(static_cast< double >(6378137.0)));
13901 4 : SWIG_Python_SetConstant(d, "SRS_WGS84_INVFLATTENING",SWIG_From_double(static_cast< double >(298.257223563)));
13902 : #if PY_VERSION_HEX >= 0x03000000
13903 : return m;
13904 : #else
13905 : return;
13906 : #endif
13907 8 : }
13908 :
|
