Points&Forces (survey)
Software tools facilitating the task of surveying architecture
a_shape_libTCL8_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 4.0.2
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGTCL
13 #define SWIGTCL
14 #endif
15 
16 
17 #ifdef __cplusplus
18 /* SwigValueWrapper is described in swig.swg */
19 template<typename T> class SwigValueWrapper {
20  struct SwigMovePointer {
21  T *ptr;
22  SwigMovePointer(T *p) : ptr(p) { }
23  ~SwigMovePointer() { delete ptr; }
24  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
25  } pointer;
26  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
28 public:
29  SwigValueWrapper() : pointer(0) { }
30  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
31  operator T&() const { return *pointer.ptr; }
32  T *operator&() { return pointer.ptr; }
33 };
34 
35 template <typename T> T SwigValueInit() {
36  return T();
37 }
38 #endif
39 
40 /* -----------------------------------------------------------------------------
41  * This section contains generic SWIG labels for method/variable
42  * declarations/attributes, and other compiler dependent labels.
43  * ----------------------------------------------------------------------------- */
44 
45 /* template workaround for compilers that cannot correctly implement the C++ standard */
46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
48 # define SWIGTEMPLATEDISAMBIGUATOR template
49 # elif defined(__HP_aCC)
50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
52 # define SWIGTEMPLATEDISAMBIGUATOR template
53 # else
54 # define SWIGTEMPLATEDISAMBIGUATOR
55 # endif
56 #endif
57 
58 /* inline attribute */
59 #ifndef SWIGINLINE
60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
61 # define SWIGINLINE inline
62 # else
63 # define SWIGINLINE
64 # endif
65 #endif
66 
67 /* attribute recognised by some compilers to avoid 'unused' warnings */
68 #ifndef SWIGUNUSED
69 # if defined(__GNUC__)
70 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
71 # define SWIGUNUSED __attribute__ ((__unused__))
72 # else
73 # define SWIGUNUSED
74 # endif
75 # elif defined(__ICC)
76 # define SWIGUNUSED __attribute__ ((__unused__))
77 # else
78 # define SWIGUNUSED
79 # endif
80 #endif
81 
82 #ifndef SWIG_MSC_UNSUPPRESS_4505
83 # if defined(_MSC_VER)
84 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
85 # endif
86 #endif
87 
88 #ifndef SWIGUNUSEDPARM
89 # ifdef __cplusplus
90 # define SWIGUNUSEDPARM(p)
91 # else
92 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
93 # endif
94 #endif
95 
96 /* internal SWIG method */
97 #ifndef SWIGINTERN
98 # define SWIGINTERN static SWIGUNUSED
99 #endif
100 
101 /* internal inline SWIG method */
102 #ifndef SWIGINTERNINLINE
103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
104 #endif
105 
106 /* exporting methods */
107 #if defined(__GNUC__)
108 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
109 # ifndef GCC_HASCLASSVISIBILITY
110 # define GCC_HASCLASSVISIBILITY
111 # endif
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
153 #endif
154 
155 /* Intel's compiler complains if a variable which was never initialised is
156  * cast to void, which is a common idiom which we use to indicate that we
157  * are aware a variable isn't used. So we just silence that warning.
158  * See: https://github.com/swig/swig/issues/192 for more discussion.
159  */
160 #ifdef __INTEL_COMPILER
161 # pragma warning disable 592
162 #endif
163 
164 
165 #include <stdio.h>
166 #include <tcl.h>
167 #include <errno.h>
168 #include <stdlib.h>
169 #include <stdarg.h>
170 #include <ctype.h>
171 
172 /* -----------------------------------------------------------------------------
173  * swigrun.swg
174  *
175  * This file contains generic C API SWIG runtime support for pointer
176  * type checking.
177  * ----------------------------------------------------------------------------- */
178 
179 /* This should only be incremented when either the layout of swig_type_info changes,
180  or for whatever reason, the runtime changes incompatibly */
181 #define SWIG_RUNTIME_VERSION "4"
182 
183 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
184 #ifdef SWIG_TYPE_TABLE
185 # define SWIG_QUOTE_STRING(x) #x
186 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
187 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
188 #else
189 # define SWIG_TYPE_TABLE_NAME
190 #endif
191 
192 /*
193  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
194  creating a static or dynamic library from the SWIG runtime code.
195  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
196 
197  But only do this if strictly necessary, ie, if you have problems
198  with your compiler or suchlike.
199 */
200 
201 #ifndef SWIGRUNTIME
202 # define SWIGRUNTIME SWIGINTERN
203 #endif
204 
205 #ifndef SWIGRUNTIMEINLINE
206 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
207 #endif
208 
209 /* Generic buffer size */
210 #ifndef SWIG_BUFFER_SIZE
211 # define SWIG_BUFFER_SIZE 1024
212 #endif
213 
214 /* Flags for pointer conversions */
215 #define SWIG_POINTER_DISOWN 0x1
216 #define SWIG_CAST_NEW_MEMORY 0x2
217 #define SWIG_POINTER_NO_NULL 0x4
218 
219 /* Flags for new pointer objects */
220 #define SWIG_POINTER_OWN 0x1
221 
222 
223 /*
224  Flags/methods for returning states.
225 
226  The SWIG conversion methods, as ConvertPtr, return an integer
227  that tells if the conversion was successful or not. And if not,
228  an error code can be returned (see swigerrors.swg for the codes).
229 
230  Use the following macros/flags to set or process the returning
231  states.
232 
233  In old versions of SWIG, code such as the following was usually written:
234 
235  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
236  // success code
237  } else {
238  //fail code
239  }
240 
241  Now you can be more explicit:
242 
243  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
244  if (SWIG_IsOK(res)) {
245  // success code
246  } else {
247  // fail code
248  }
249 
250  which is the same really, but now you can also do
251 
252  Type *ptr;
253  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
254  if (SWIG_IsOK(res)) {
255  // success code
256  if (SWIG_IsNewObj(res) {
257  ...
258  delete *ptr;
259  } else {
260  ...
261  }
262  } else {
263  // fail code
264  }
265 
266  I.e., now SWIG_ConvertPtr can return new objects and you can
267  identify the case and take care of the deallocation. Of course that
268  also requires SWIG_ConvertPtr to return new result values, such as
269 
270  int SWIG_ConvertPtr(obj, ptr,...) {
271  if (<obj is ok>) {
272  if (<need new object>) {
273  *ptr = <ptr to new allocated object>;
274  return SWIG_NEWOBJ;
275  } else {
276  *ptr = <ptr to old object>;
277  return SWIG_OLDOBJ;
278  }
279  } else {
280  return SWIG_BADOBJ;
281  }
282  }
283 
284  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
285  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
286  SWIG errors code.
287 
288  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
289  allows to return the 'cast rank', for example, if you have this
290 
291  int food(double)
292  int fooi(int);
293 
294  and you call
295 
296  food(1) // cast rank '1' (1 -> 1.0)
297  fooi(1) // cast rank '0'
298 
299  just use the SWIG_AddCast()/SWIG_CheckState()
300 */
301 
302 #define SWIG_OK (0)
303 #define SWIG_ERROR (-1)
304 #define SWIG_IsOK(r) (r >= 0)
305 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
306 
307 /* The CastRankLimit says how many bits are used for the cast rank */
308 #define SWIG_CASTRANKLIMIT (1 << 8)
309 /* The NewMask denotes the object was created (using new/malloc) */
310 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
311 /* The TmpMask is for in/out typemaps that use temporal objects */
312 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
313 /* Simple returning values */
314 #define SWIG_BADOBJ (SWIG_ERROR)
315 #define SWIG_OLDOBJ (SWIG_OK)
316 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
317 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
318 /* Check, add and del mask methods */
319 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
320 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
321 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
322 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
323 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
324 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
325 
326 /* Cast-Rank Mode */
327 #if defined(SWIG_CASTRANK_MODE)
328 # ifndef SWIG_TypeRank
329 # define SWIG_TypeRank unsigned long
330 # endif
331 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
332 # define SWIG_MAXCASTRANK (2)
333 # endif
334 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
335 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
336 SWIGINTERNINLINE int SWIG_AddCast(int r) {
337  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
338 }
340  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
341 }
342 #else /* no cast-rank mode */
343 # define SWIG_AddCast(r) (r)
344 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
345 #endif
346 
347 
348 #include <string.h>
349 
350 #ifdef __cplusplus
351 extern "C" {
352 #endif
353 
354 typedef void *(*swig_converter_func)(void *, int *);
355 typedef struct swig_type_info *(*swig_dycast_func)(void **);
356 
357 /* Structure to store information on one type */
358 typedef struct swig_type_info {
359  const char *name; /* mangled name of this type */
360  const char *str; /* human readable name of this type */
361  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
362  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
363  void *clientdata; /* language specific type data */
364  int owndata; /* flag if the structure owns the clientdata */
366 
367 /* Structure to store a type and conversion function used for casting */
368 typedef struct swig_cast_info {
369  swig_type_info *type; /* pointer to type that is equivalent to this type */
370  swig_converter_func converter; /* function to cast the void pointers */
371  struct swig_cast_info *next; /* pointer to next cast in linked list */
372  struct swig_cast_info *prev; /* pointer to the previous cast */
374 
375 /* Structure used to store module information
376  * Each module generates one structure like this, and the runtime collects
377  * all of these structures and stores them in a circularly linked list.*/
378 typedef struct swig_module_info {
379  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
380  size_t size; /* Number of types in this module */
381  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
382  swig_type_info **type_initial; /* Array of initially generated type structures */
383  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
384  void *clientdata; /* Language specific module data */
386 
387 /*
388  Compare two type names skipping the space characters, therefore
389  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
390 
391  Return 0 when the two name types are equivalent, as in
392  strncmp, but skipping ' '.
393 */
394 SWIGRUNTIME int
395 SWIG_TypeNameComp(const char *f1, const char *l1,
396  const char *f2, const char *l2) {
397  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
398  while ((*f1 == ' ') && (f1 != l1)) ++f1;
399  while ((*f2 == ' ') && (f2 != l2)) ++f2;
400  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
401  }
402  return (int)((l1 - f1) - (l2 - f2));
403 }
404 
405 /*
406  Check type equivalence in a name list like <name1>|<name2>|...
407  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
408 */
409 SWIGRUNTIME int
410 SWIG_TypeCmp(const char *nb, const char *tb) {
411  int equiv = 1;
412  const char* te = tb + strlen(tb);
413  const char* ne = nb;
414  while (equiv != 0 && *ne) {
415  for (nb = ne; *ne; ++ne) {
416  if (*ne == '|') break;
417  }
418  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
419  if (*ne) ++ne;
420  }
421  return equiv;
422 }
423 
424 /*
425  Check type equivalence in a name list like <name1>|<name2>|...
426  Return 0 if not equal, 1 if equal
427 */
428 SWIGRUNTIME int
429 SWIG_TypeEquiv(const char *nb, const char *tb) {
430  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
431 }
432 
433 /*
434  Check the typename
435 */
437 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
438  if (ty) {
439  swig_cast_info *iter = ty->cast;
440  while (iter) {
441  if (strcmp(iter->type->name, c) == 0) {
442  if (iter == ty->cast)
443  return iter;
444  /* Move iter to the top of the linked list */
445  iter->prev->next = iter->next;
446  if (iter->next)
447  iter->next->prev = iter->prev;
448  iter->next = ty->cast;
449  iter->prev = 0;
450  if (ty->cast) ty->cast->prev = iter;
451  ty->cast = iter;
452  return iter;
453  }
454  iter = iter->next;
455  }
456  }
457  return 0;
458 }
459 
460 /*
461  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
462 */
465  if (ty) {
466  swig_cast_info *iter = ty->cast;
467  while (iter) {
468  if (iter->type == from) {
469  if (iter == ty->cast)
470  return iter;
471  /* Move iter to the top of the linked list */
472  iter->prev->next = iter->next;
473  if (iter->next)
474  iter->next->prev = iter->prev;
475  iter->next = ty->cast;
476  iter->prev = 0;
477  if (ty->cast) ty->cast->prev = iter;
478  ty->cast = iter;
479  return iter;
480  }
481  iter = iter->next;
482  }
483  }
484  return 0;
485 }
486 
487 /*
488  Cast a pointer up an inheritance hierarchy
489 */
490 SWIGRUNTIMEINLINE void *
491 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
492  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
493 }
494 
495 /*
496  Dynamic pointer casting. Down an inheritance hierarchy
497 */
500  swig_type_info *lastty = ty;
501  if (!ty || !ty->dcast) return ty;
502  while (ty && (ty->dcast)) {
503  ty = (*ty->dcast)(ptr);
504  if (ty) lastty = ty;
505  }
506  return lastty;
507 }
508 
509 /*
510  Return the name associated with this type
511 */
512 SWIGRUNTIMEINLINE const char *
514  return ty->name;
515 }
516 
517 /*
518  Return the pretty name associated with this type,
519  that is an unmangled type name in a form presentable to the user.
520 */
521 SWIGRUNTIME const char *
523  /* The "str" field contains the equivalent pretty names of the
524  type, separated by vertical-bar characters. We choose
525  to print the last name, as it is often (?) the most
526  specific. */
527  if (!type) return NULL;
528  if (type->str != NULL) {
529  const char *last_name = type->str;
530  const char *s;
531  for (s = type->str; *s; s++)
532  if (*s == '|') last_name = s+1;
533  return last_name;
534  }
535  else
536  return type->name;
537 }
538 
539 /*
540  Set the clientdata field for a type
541 */
542 SWIGRUNTIME void
544  swig_cast_info *cast = ti->cast;
545  /* if (ti->clientdata == clientdata) return; */
546  ti->clientdata = clientdata;
547 
548  while (cast) {
549  if (!cast->converter) {
550  swig_type_info *tc = cast->type;
551  if (!tc->clientdata) {
553  }
554  }
555  cast = cast->next;
556  }
557 }
558 SWIGRUNTIME void
561  ti->owndata = 1;
562 }
563 
564 /*
565  Search for a swig_type_info structure only by mangled name
566  Search is a O(log #types)
567 
568  We start searching at module start, and finish searching when start == end.
569  Note: if start == end at the beginning of the function, we go all the way around
570  the circular list.
571 */
574  swig_module_info *end,
575  const char *name) {
576  swig_module_info *iter = start;
577  do {
578  if (iter->size) {
579  size_t l = 0;
580  size_t r = iter->size - 1;
581  do {
582  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
583  size_t i = (l + r) >> 1;
584  const char *iname = iter->types[i]->name;
585  if (iname) {
586  int compare = strcmp(name, iname);
587  if (compare == 0) {
588  return iter->types[i];
589  } else if (compare < 0) {
590  if (i) {
591  r = i - 1;
592  } else {
593  break;
594  }
595  } else if (compare > 0) {
596  l = i + 1;
597  }
598  } else {
599  break; /* should never happen */
600  }
601  } while (l <= r);
602  }
603  iter = iter->next;
604  } while (iter != end);
605  return 0;
606 }
607 
608 /*
609  Search for a swig_type_info structure for either a mangled name or a human readable name.
610  It first searches the mangled names of the types, which is a O(log #types)
611  If a type is not found it then searches the human readable names, which is O(#types).
612 
613  We start searching at module start, and finish searching when start == end.
614  Note: if start == end at the beginning of the function, we go all the way around
615  the circular list.
616 */
619  swig_module_info *end,
620  const char *name) {
621  /* STEP 1: Search the name field using binary search */
622  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
623  if (ret) {
624  return ret;
625  } else {
626  /* STEP 2: If the type hasn't been found, do a complete search
627  of the str field (the human readable name) */
628  swig_module_info *iter = start;
629  do {
630  size_t i = 0;
631  for (; i < iter->size; ++i) {
632  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
633  return iter->types[i];
634  }
635  iter = iter->next;
636  } while (iter != end);
637  }
638 
639  /* neither found a match */
640  return 0;
641 }
642 
643 /*
644  Pack binary data into a string
645 */
646 SWIGRUNTIME char *
647 SWIG_PackData(char *c, void *ptr, size_t sz) {
648  static const char hex[17] = "0123456789abcdef";
649  const unsigned char *u = (unsigned char *) ptr;
650  const unsigned char *eu = u + sz;
651  for (; u != eu; ++u) {
652  unsigned char uu = *u;
653  *(c++) = hex[(uu & 0xf0) >> 4];
654  *(c++) = hex[uu & 0xf];
655  }
656  return c;
657 }
658 
659 /*
660  Unpack binary data from a string
661 */
662 SWIGRUNTIME const char *
663 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
664  unsigned char *u = (unsigned char *) ptr;
665  const unsigned char *eu = u + sz;
666  for (; u != eu; ++u) {
667  char d = *(c++);
668  unsigned char uu;
669  if ((d >= '0') && (d <= '9'))
670  uu = (unsigned char)((d - '0') << 4);
671  else if ((d >= 'a') && (d <= 'f'))
672  uu = (unsigned char)((d - ('a'-10)) << 4);
673  else
674  return (char *) 0;
675  d = *(c++);
676  if ((d >= '0') && (d <= '9'))
677  uu |= (unsigned char)(d - '0');
678  else if ((d >= 'a') && (d <= 'f'))
679  uu |= (unsigned char)(d - ('a'-10));
680  else
681  return (char *) 0;
682  *u = uu;
683  }
684  return c;
685 }
686 
687 /*
688  Pack 'void *' into a string buffer.
689 */
690 SWIGRUNTIME char *
691 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
692  char *r = buff;
693  if ((2*sizeof(void *) + 2) > bsz) return 0;
694  *(r++) = '_';
695  r = SWIG_PackData(r,&ptr,sizeof(void *));
696  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
697  strcpy(r,name);
698  return buff;
699 }
700 
701 SWIGRUNTIME const char *
702 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
703  if (*c != '_') {
704  if (strcmp(c,"NULL") == 0) {
705  *ptr = (void *) 0;
706  return name;
707  } else {
708  return 0;
709  }
710  }
711  return SWIG_UnpackData(++c,ptr,sizeof(void *));
712 }
713 
714 SWIGRUNTIME char *
715 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
716  char *r = buff;
717  size_t lname = (name ? strlen(name) : 0);
718  if ((2*sz + 2 + lname) > bsz) return 0;
719  *(r++) = '_';
720  r = SWIG_PackData(r,ptr,sz);
721  if (lname) {
722  strncpy(r,name,lname+1);
723  } else {
724  *r = 0;
725  }
726  return buff;
727 }
728 
729 SWIGRUNTIME const char *
730 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
731  if (*c != '_') {
732  if (strcmp(c,"NULL") == 0) {
733  memset(ptr,0,sz);
734  return name;
735  } else {
736  return 0;
737  }
738  }
739  return SWIG_UnpackData(++c,ptr,sz);
740 }
741 
742 #ifdef __cplusplus
743 }
744 #endif
745 
746 /* Errors in SWIG */
747 #define SWIG_UnknownError -1
748 #define SWIG_IOError -2
749 #define SWIG_RuntimeError -3
750 #define SWIG_IndexError -4
751 #define SWIG_TypeError -5
752 #define SWIG_DivisionByZero -6
753 #define SWIG_OverflowError -7
754 #define SWIG_SyntaxError -8
755 #define SWIG_ValueError -9
756 #define SWIG_SystemError -10
757 #define SWIG_AttributeError -11
758 #define SWIG_MemoryError -12
759 #define SWIG_NullReferenceError -13
760 
761 
762 
763 /* -----------------------------------------------------------------------------
764  * error manipulation
765  * ----------------------------------------------------------------------------- */
766 
767 SWIGINTERN const char*
769  const char* type = 0;
770  switch(code) {
771  case SWIG_MemoryError:
772  type = "MemoryError";
773  break;
774  case SWIG_IOError:
775  type = "IOError";
776  break;
777  case SWIG_RuntimeError:
778  type = "RuntimeError";
779  break;
780  case SWIG_IndexError:
781  type = "IndexError";
782  break;
783  case SWIG_TypeError:
784  type = "TypeError";
785  break;
786  case SWIG_DivisionByZero:
787  type = "ZeroDivisionError";
788  break;
789  case SWIG_OverflowError:
790  type = "OverflowError";
791  break;
792  case SWIG_SyntaxError:
793  type = "SyntaxError";
794  break;
795  case SWIG_ValueError:
796  type = "ValueError";
797  break;
798  case SWIG_SystemError:
799  type = "SystemError";
800  break;
801  case SWIG_AttributeError:
802  type = "AttributeError";
803  break;
804  default:
805  type = "RuntimeError";
806  }
807  return type;
808 }
809 
810 
811 SWIGINTERN void
812 SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
813 {
814  Tcl_ResetResult(interp);
815  Tcl_SetObjResult(interp, obj);
816  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
817 }
818 
819 SWIGINTERN void
820 SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
821 {
822  Tcl_ResetResult(interp);
823  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
824  Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
825  /*
826  Tcl_AddErrorInfo(interp, ctype);
827  Tcl_AddErrorInfo(interp, " ");
828  Tcl_AddErrorInfo(interp, mesg);
829  */
830 }
831 
832 SWIGINTERNINLINE void
833 SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
834 {
835  Tcl_AddErrorInfo(interp, mesg);
836 }
837 
838 
839 
840 /* -----------------------------------------------------------------------------
841  * SWIG API. Portion that goes into the runtime
842  * ----------------------------------------------------------------------------- */
843 #ifdef __cplusplus
844 extern "C" {
845 #endif
846 
847 /* -----------------------------------------------------------------------------
848  * Constant declarations
849  * ----------------------------------------------------------------------------- */
850 
851 /* Constant Types */
852 #define SWIG_TCL_POINTER 4
853 #define SWIG_TCL_BINARY 5
854 
855 /* Constant information structure */
856 typedef struct swig_const_info {
857  int type;
858  const char *name;
859  long lvalue;
860  double dvalue;
861  void *pvalue;
864 
865 typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
866 typedef int (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
867 typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
868 typedef void (*swig_delete_func)(ClientData);
869 
870 typedef struct swig_method {
871  const char *name;
874 
875 typedef struct swig_attribute {
876  const char *name;
880 
881 typedef struct swig_class {
882  const char *name;
885  void (*destructor)(void *);
888  struct swig_class **bases;
889  const char **base_names;
891  Tcl_HashTable hashtable;
893 
894 typedef struct swig_instance {
895  Tcl_Obj *thisptr;
896  void *thisvalue;
898  int destroy;
899  Tcl_Command cmdtok;
901 
902 /* Structure for command table */
903 typedef struct {
904  const char *name;
905  int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
906  ClientData clientdata;
908 
909 /* Structure for variable linking table */
910 typedef struct {
911  const char *name;
912  void *addr;
913  char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
914  char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
915 } swig_var_info;
916 
917 
918 /* -----------------------------------------------------------------------------*
919  * Install a constant object
920  * -----------------------------------------------------------------------------*/
921 
922 static Tcl_HashTable swigconstTable;
923 static int swigconstTableinit = 0;
924 
925 SWIGINTERN void
926 SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
927  int newobj;
928  Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
929  Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
930 }
931 
932 SWIGINTERN Tcl_Obj *
933 SWIG_Tcl_GetConstantObj(const char *key) {
934  Tcl_HashEntry *entryPtr;
935  if (!swigconstTableinit) return 0;
936  entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
937  if (entryPtr) {
938  return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
939  }
940  return 0;
941 }
942 
943 #ifdef __cplusplus
944 }
945 #endif
946 
947 
948 
949 /* -----------------------------------------------------------------------------
950  * tclrun.swg
951  *
952  * This file contains the runtime support for Tcl modules and includes
953  * code for managing global variables and pointer type checking.
954  * ----------------------------------------------------------------------------- */
955 
956 /* Common SWIG API */
957 
958 /* for raw pointers */
959 #define SWIG_ConvertPtr(oc, ptr, ty, flags) SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
960 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags)
961 
962 /* for raw packed data */
963 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
964 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
965 
966 /* for class or struct pointers */
967 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
968 #define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
969 
970 /* for C or C++ function pointers */
971 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
972 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0)
973 
974 /* for C++ member pointers, ie, member methods */
975 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
976 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
977 
978 
979 /* Runtime API */
980 
981 #define SWIG_GetModule(clientdata) SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))
982 #define SWIG_SetModule(clientdata, pointer) SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
983 
984 
985 /* Error manipulation */
986 
987 #define SWIG_ErrorType(code) SWIG_Tcl_ErrorType(code)
988 #define SWIG_Error(code, msg) SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
989 #define SWIG_fail goto fail
990 
991 
992 /* Tcl-specific SWIG API */
993 
994 #define SWIG_Acquire(ptr) SWIG_Tcl_Acquire(ptr)
995 #define SWIG_MethodCommand SWIG_Tcl_MethodCommand
996 #define SWIG_Disown(ptr) SWIG_Tcl_Disown(ptr)
997 #define SWIG_ConvertPtrFromString(c, ptr, ty, flags) SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)
998 #define SWIG_MakePtr(c, ptr, ty, flags) SWIG_Tcl_MakePtr(c, ptr, ty, flags)
999 #define SWIG_PointerTypeFromString(c) SWIG_Tcl_PointerTypeFromString(c)
1000 #define SWIG_GetArgs SWIG_Tcl_GetArgs
1001 #define SWIG_GetConstantObj(key) SWIG_Tcl_GetConstantObj(key)
1002 #define SWIG_ObjectConstructor SWIG_Tcl_ObjectConstructor
1003 #define SWIG_Thisown(ptr) SWIG_Tcl_Thisown(ptr)
1004 #define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete
1005 
1006 
1007 #define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
1008 #define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2)
1009 /* -----------------------------------------------------------------------------
1010  * pointers/data manipulation
1011  * ----------------------------------------------------------------------------- */
1012 
1013 /* For backward compatibility only */
1014 #define SWIG_POINTER_EXCEPTION 0
1015 #define SWIG_GetConstant SWIG_GetConstantObj
1016 #define SWIG_Tcl_GetConstant SWIG_Tcl_GetConstantObj
1017 
1018 #if TCL_MAJOR_VERSION >= 8 && TCL_MINOR_VERSION >= 5
1019 #define SWIG_TCL_HASHTABLE_INIT {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1020 #else
1021 #define SWIG_TCL_HASHTABLE_INIT {0}
1022 #endif
1023 
1024 #include "assert.h"
1025 
1026 #ifdef __cplusplus
1027 extern "C" {
1028 #endif
1029 
1030 /* Object support */
1031 
1032 SWIGRUNTIME Tcl_HashTable*
1034  static Tcl_HashTable swigobjectTable;
1035  static int swigobjectTableinit = 0;
1036  if (!swigobjectTableinit) {
1037  Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
1038  swigobjectTableinit = 1;
1039  }
1040  return &swigobjectTable;
1041 }
1042 
1043 /* Acquire ownership of a pointer */
1044 SWIGRUNTIME void
1045 SWIG_Tcl_Acquire(void *ptr) {
1046  int newobj;
1047  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
1048 }
1049 
1050 SWIGRUNTIME int
1051 SWIG_Tcl_Thisown(void *ptr) {
1052  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
1053  return 1;
1054  }
1055  return 0;
1056 }
1057 
1058 /* Disown a pointer. Returns 1 if we owned it to begin with */
1059 SWIGRUNTIME int
1060 SWIG_Tcl_Disown(void *ptr) {
1061  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
1062  if (entryPtr) {
1063  Tcl_DeleteHashEntry(entryPtr);
1064  return 1;
1065  }
1066  return 0;
1067 }
1068 
1069 /* Convert a pointer value */
1070 SWIGRUNTIME int
1071 SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
1072  swig_cast_info *tc;
1073  /* Pointer values must start with leading underscore */
1074  while (*c != '_') {
1075  *ptr = (void *) 0;
1076  if (strcmp(c,"NULL") == 0)
1078 
1079  /* Empty string: not a pointer */
1080  if (*c == 0) return SWIG_ERROR;
1081 
1082  /* Hmmm. It could be an object name. */
1083 
1084  /* Check if this is a command at all. Prevents <c> cget -this */
1085  /* from being called when c is not a command, firing the unknown proc */
1086  if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
1087  Tcl_Obj *result = Tcl_GetObjResult(interp);
1088  if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
1089  /* It's not a command, so it can't be a pointer */
1090  Tcl_ResetResult(interp);
1091  return SWIG_ERROR;
1092  }
1093  } else {
1094  /* This will only fail if the argument is multiple words. */
1095  /* Multiple words are also not commands. */
1096  Tcl_ResetResult(interp);
1097  return SWIG_ERROR;
1098  }
1099 
1100  /* Check if this is really a SWIG pointer */
1101  if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
1102  Tcl_ResetResult(interp);
1103  return SWIG_ERROR;
1104  }
1105 
1106  c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
1107  }
1108 
1109  c++;
1110  c = SWIG_UnpackData(c,ptr,sizeof(void *));
1111  if (ty) {
1112  tc = c ? SWIG_TypeCheck(c,ty) : 0;
1113  if (!tc) {
1114  return SWIG_ERROR;
1115  }
1116  if (flags & SWIG_POINTER_DISOWN) {
1117  SWIG_Disown((void *) *ptr);
1118  }
1119  {
1120  int newmemory = 0;
1121  *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
1122  assert(!newmemory); /* newmemory handling not yet implemented */
1123  }
1124  }
1125  return SWIG_OK;
1126 }
1127 
1128 /* Convert a pointer value */
1130 SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
1131  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
1132 }
1133 
1134 /* Convert a pointer value */
1135 SWIGRUNTIME char *
1137  char d;
1138  /* Pointer values must start with leading underscore. NULL has no type */
1139  if (*c != '_') {
1140  return 0;
1141  }
1142  c++;
1143  /* Extract hex value from pointer */
1144  while ((d = *c)) {
1145  if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
1146  c++;
1147  }
1148  return c;
1149 }
1150 
1151 /* Convert a packed pointer value */
1152 SWIGRUNTIME int
1153 SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
1154  swig_cast_info *tc;
1155  const char *c;
1156 
1157  if (!obj) goto type_error;
1158  c = Tcl_GetStringFromObj(obj,NULL);
1159  /* Pointer values must start with leading underscore */
1160  if (*c != '_') goto type_error;
1161  c++;
1162  c = SWIG_UnpackData(c,ptr,sz);
1163  if (ty) {
1164  tc = SWIG_TypeCheck(c,ty);
1165  if (!tc) goto type_error;
1166  }
1167  return SWIG_OK;
1168 
1169  type_error:
1170 
1171  return SWIG_ERROR;
1172 }
1173 
1174 
1175 /* Take a pointer and convert it to a string */
1176 SWIGRUNTIME void
1177 SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int SWIGUNUSEDPARM(flags)) {
1178  if (ptr) {
1179  *(c++) = '_';
1180  c = SWIG_PackData(c,&ptr,sizeof(void *));
1181  strcpy(c,ty->name);
1182  } else {
1183  strcpy(c,"NULL");
1184  }
1185 }
1186 
1187 /* Create a new pointer object */
1188 SWIGRUNTIMEINLINE Tcl_Obj *
1189 SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1190  Tcl_Obj *robj;
1191  char result[SWIG_BUFFER_SIZE];
1192  SWIG_MakePtr(result,ptr,type,flags);
1193  robj = Tcl_NewStringObj(result,-1);
1194  return robj;
1195 }
1196 
1197 SWIGRUNTIME Tcl_Obj *
1198 SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1199  char result[1024];
1200  char *r = result;
1201  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1202  *(r++) = '_';
1203  r = SWIG_PackData(r,ptr,sz);
1204  strcpy(r,type->name);
1205  return Tcl_NewStringObj(result,-1);
1206 }
1207 
1208 /* -----------------------------------------------------------------------------*
1209  * Get type list
1210  * -----------------------------------------------------------------------------*/
1211 
1213 SWIG_Tcl_GetModule(Tcl_Interp *interp) {
1214  const char *data;
1215  swig_module_info *ret = 0;
1216 
1217  /* first check if pointer already created */
1218  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
1219  if (data) {
1220  SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
1221  }
1222 
1223  return ret;
1224 }
1225 
1226 SWIGRUNTIME void
1227 SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
1228  char buf[SWIG_BUFFER_SIZE];
1229  char *data;
1230 
1231  /* create a new pointer */
1232  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
1233  *data = 0;
1234  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
1235 }
1236 
1237 /* -----------------------------------------------------------------------------*
1238  * Object auxiliaries
1239  * -----------------------------------------------------------------------------*/
1240 
1241 
1242 SWIGRUNTIME void
1243 SWIG_Tcl_ObjectDelete(ClientData clientData) {
1244  swig_instance *si = (swig_instance *) clientData;
1245  if (!si) return;
1246  if (si->destroy && SWIG_Disown(si->thisvalue)) {
1247  if (si->classptr->destructor) {
1248  (si->classptr->destructor)(si->thisvalue);
1249  }
1250  }
1251  Tcl_DecrRefCount(si->thisptr);
1252  free(si);
1253 }
1254 
1255 /* Function to invoke object methods given an instance */
1256 SWIGRUNTIME int
1257 SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
1258  char *method, *attrname;
1259  swig_instance *inst = (swig_instance *) clientData;
1260  swig_method *meth;
1261  swig_attribute *attr;
1262  Tcl_Obj *oldarg;
1263  Tcl_Obj **objv;
1264  int rcode;
1265  swig_class *cls;
1266  swig_class *cls_stack[64];
1267  int cls_stack_bi[64];
1268  int cls_stack_top = 0;
1269  int numconf = 2;
1270  int bi;
1271 
1272  objv = (Tcl_Obj **) _objv;
1273  if (objc < 2) {
1274  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1275  return TCL_ERROR;
1276  }
1277  method = Tcl_GetStringFromObj(objv[1],NULL);
1278  if (strcmp(method,"-acquire") == 0) {
1279  inst->destroy = 1;
1280  SWIG_Acquire(inst->thisvalue);
1281  return TCL_OK;
1282  }
1283  if (strcmp(method,"-disown") == 0) {
1284  if (inst->destroy) {
1285  SWIG_Disown(inst->thisvalue);
1286  }
1287  inst->destroy = 0;
1288  return TCL_OK;
1289  }
1290  if (strcmp(method,"-delete") == 0) {
1291  Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
1292  return TCL_OK;
1293  }
1294  cls_stack[cls_stack_top] = inst->classptr;
1295  cls_stack_bi[cls_stack_top] = -1;
1296  while (1) {
1297  Tcl_HashEntry* hashentry;
1298  bi = cls_stack_bi[cls_stack_top];
1299  cls = cls_stack[cls_stack_top];
1300  if (bi != -1) {
1301  if (!cls->bases[bi] && cls->base_names[bi]) {
1302  /* lookup and cache the base class */
1303  swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
1304  if (info) cls->bases[bi] = (swig_class *) info->clientdata;
1305  }
1306  cls = cls->bases[bi];
1307  if (cls) {
1308  cls_stack_bi[cls_stack_top]++;
1309  cls_stack_top++;
1310  cls_stack[cls_stack_top] = cls;
1311  cls_stack_bi[cls_stack_top] = -1;
1312  continue;
1313  }
1314  }
1315  if (!cls) {
1316  cls_stack_top--;
1317  if (cls_stack_top < 0) break;
1318  else continue;
1319  }
1320  cls_stack_bi[cls_stack_top]++;
1321 
1322  hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
1323  if (hashentry) {
1324  ClientData cd = Tcl_GetHashValue(hashentry);
1325  swig_wrapper method_wrapper = (swig_wrapper)cd;
1326  oldarg = objv[1];
1327  objv[1] = inst->thisptr;
1328  Tcl_IncrRefCount(inst->thisptr);
1329  rcode = (method_wrapper)(clientData,interp,objc,objv);
1330  objv[1] = oldarg;
1331  Tcl_DecrRefCount(inst->thisptr);
1332  return rcode;
1333  }
1334  /* Check class methods for a match */
1335  if (strcmp(method,"cget") == 0) {
1336  if (objc < 3) {
1337  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1338  return TCL_ERROR;
1339  }
1340  attrname = Tcl_GetStringFromObj(objv[2],NULL);
1341  attr = cls->attributes;
1342  while (attr && attr->name) {
1343  if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
1344  oldarg = objv[1];
1345  objv[1] = inst->thisptr;
1346  Tcl_IncrRefCount(inst->thisptr);
1347  rcode = (*attr->getmethod)(clientData,interp,2, objv);
1348  objv[1] = oldarg;
1349  Tcl_DecrRefCount(inst->thisptr);
1350  return rcode;
1351  }
1352  attr++;
1353  }
1354  if (strcmp(attrname, "-this") == 0) {
1355  Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
1356  return TCL_OK;
1357  }
1358  if (strcmp(attrname, "-thisown") == 0) {
1359  if (SWIG_Thisown(inst->thisvalue)) {
1360  Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
1361  } else {
1362  Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
1363  }
1364  return TCL_OK;
1365  }
1366  } else if (strcmp(method, "configure") == 0) {
1367  int i;
1368  if (objc < 4) {
1369  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1370  return TCL_ERROR;
1371  }
1372  i = 2;
1373  while (i < objc) {
1374  attrname = Tcl_GetStringFromObj(objv[i],NULL);
1375  attr = cls->attributes;
1376  while (attr && attr->name) {
1377  if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
1378  oldarg = objv[i];
1379  objv[i] = inst->thisptr;
1380  Tcl_IncrRefCount(inst->thisptr);
1381  rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
1382  objv[i] = oldarg;
1383  Tcl_DecrRefCount(inst->thisptr);
1384  if (rcode != TCL_OK) return rcode;
1385  numconf += 2;
1386  }
1387  attr++;
1388  }
1389  i+=2;
1390  }
1391  }
1392  }
1393  if (strcmp(method,"configure") == 0) {
1394  if (numconf >= objc) {
1395  return TCL_OK;
1396  } else {
1397  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1398  return TCL_ERROR;
1399  }
1400  }
1401  if (strcmp(method,"cget") == 0) {
1402  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1403  return TCL_ERROR;
1404  }
1405  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
1406  cls = inst->classptr;
1407  bi = 0;
1408  while (cls) {
1409  meth = cls->methods;
1410  while (meth && meth->name) {
1411  char *cr = (char *) Tcl_GetStringResult(interp);
1412  size_t meth_len = strlen(meth->name);
1413  char* where = strchr(cr,':');
1414  while(where) {
1415  where = strstr(where, meth->name);
1416  if(where) {
1417  if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
1418  break;
1419  } else {
1420  where++;
1421  }
1422  }
1423  }
1424 
1425  if (!where)
1426  Tcl_AppendElement(interp, (char *) meth->name);
1427  meth++;
1428  }
1429  cls = inst->classptr->bases[bi++];
1430  }
1431  return TCL_ERROR;
1432 }
1433 
1434 /* This function takes the current result and turns it into an object command */
1435 SWIGRUNTIME Tcl_Obj *
1436 SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
1437  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
1438  /* Check to see if this pointer belongs to a class or not */
1439  if (thisvalue && (type->clientdata) && (interp)) {
1440  Tcl_CmdInfo ci;
1441  char *name;
1442  name = Tcl_GetStringFromObj(robj,NULL);
1443  if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
1444  swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
1445  newinst->thisptr = Tcl_DuplicateObj(robj);
1446  Tcl_IncrRefCount(newinst->thisptr);
1447  newinst->thisvalue = thisvalue;
1448  newinst->classptr = (swig_class *) type->clientdata;
1449  newinst->destroy = flags;
1450  newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1451  if (flags) {
1452  SWIG_Acquire(thisvalue);
1453  }
1454  }
1455  }
1456  return robj;
1457 }
1458 
1459 /* Function to create objects */
1460 SWIGRUNTIME int
1461 SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1462  Tcl_Obj *newObj = 0;
1463  void *thisvalue = 0;
1464  swig_instance *newinst = 0;
1465  swig_class *classptr = (swig_class *) clientData;
1466  swig_wrapper cons = 0;
1467  char *name = 0;
1468  int firstarg = 0;
1469  int thisarg = 0;
1470  int destroy = 1;
1471 
1472  if (!classptr) {
1473  Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
1474  return TCL_ERROR;
1475  }
1476  cons = classptr->constructor;
1477  if (objc > 1) {
1478  char *s = Tcl_GetStringFromObj(objv[1],NULL);
1479  if (strcmp(s,"-this") == 0) {
1480  thisarg = 2;
1481  cons = 0;
1482  } else if (strcmp(s,"-args") == 0) {
1483  firstarg = 1;
1484  } else if (objc == 2) {
1485  firstarg = 1;
1486  name = s;
1487  } else if (objc >= 3) {
1488  char *s1;
1489  name = s;
1490  s1 = Tcl_GetStringFromObj(objv[2],NULL);
1491  if (strcmp(s1,"-this") == 0) {
1492  thisarg = 3;
1493  cons = 0;
1494  } else {
1495  firstarg = 1;
1496  }
1497  }
1498  }
1499  if (cons) {
1500  int result;
1501  result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
1502  if (result != TCL_OK) {
1503  return result;
1504  }
1505  newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
1506  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1507  } else if (thisarg > 0) {
1508  if (thisarg < objc) {
1509  destroy = 0;
1510  newObj = Tcl_DuplicateObj(objv[thisarg]);
1511  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1512  } else {
1513  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1514  return TCL_ERROR;
1515  }
1516  } else {
1517  Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
1518  return TCL_ERROR;
1519  }
1520  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
1521  Tcl_DecrRefCount(newObj);
1522  return TCL_ERROR;
1523  }
1524  newinst = (swig_instance *) malloc(sizeof(swig_instance));
1525  newinst->thisptr = newObj;
1526  Tcl_IncrRefCount(newObj);
1527  newinst->thisvalue = thisvalue;
1528  newinst->classptr = classptr;
1529  newinst->destroy = destroy;
1530  if (destroy) {
1531  SWIG_Acquire(thisvalue);
1532  }
1533  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1534  return TCL_OK;
1535 }
1536 
1537 /* -----------------------------------------------------------------------------*
1538  * Get arguments
1539  * -----------------------------------------------------------------------------*/
1540 SWIGRUNTIME int
1541 SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
1542  int argno = 0, opt = 0;
1543  long tempi;
1544  double tempd;
1545  const char *c;
1546  va_list ap;
1547  void *vptr;
1548  Tcl_Obj *obj = 0;
1549  swig_type_info *ty;
1550 
1551  va_start(ap,fmt);
1552  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
1553  if (*c == '|') {
1554  opt = 1;
1555  c++;
1556  }
1557  if (argno >= (objc-1)) {
1558  if (!opt) {
1559  Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
1560  goto argerror;
1561  } else {
1562  va_end(ap);
1563  return TCL_OK;
1564  }
1565  }
1566 
1567  vptr = va_arg(ap,void *);
1568  if (vptr) {
1569  if (isupper(*c)) {
1570  obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
1571  if (!obj) obj = objv[argno+1];
1572  } else {
1573  obj = objv[argno+1];
1574  }
1575  switch(*c) {
1576  case 'i': case 'I':
1577  case 'l': case 'L':
1578  case 'h': case 'H':
1579  case 'b': case 'B':
1580  if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
1581  if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
1582  else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
1583  else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
1584  else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
1585  break;
1586  case 'f': case 'F':
1587  case 'd': case 'D':
1588  if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
1589  if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
1590  else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
1591  break;
1592  case 's': case 'S':
1593  if (*(c+1) == '#') {
1594  int *vlptr = (int *) va_arg(ap, void *);
1595  *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
1596  c++;
1597  } else {
1598  *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
1599  }
1600  break;
1601  case 'c': case 'C':
1602  *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
1603  break;
1604  case 'p': case 'P':
1605  ty = (swig_type_info *) va_arg(ap, void *);
1606  if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
1607  break;
1608  case 'o': case 'O':
1609  *((Tcl_Obj **)vptr) = objv[argno+1];
1610  break;
1611  default:
1612  break;
1613  }
1614  }
1615  }
1616 
1617  if ((*c != ';') && ((objc-1) > argno)) {
1618  Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
1619  goto argerror;
1620  }
1621  va_end(ap);
1622  return TCL_OK;
1623 
1624  argerror:
1625  {
1626  char temp[32];
1627  sprintf(temp,"%d", argno+1);
1628  c = strchr(fmt,':');
1629  if (!c) c = strchr(fmt,';');
1630  if (!c) c = (char *)"";
1631  Tcl_AppendResult(interp,c," argument ", temp, NULL);
1632  va_end(ap);
1633  return TCL_ERROR;
1634  }
1635 }
1636 
1637 #ifdef __cplusplus
1638 }
1639 #endif
1640 
1641 
1642 
1643 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1644 
1645 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1646 
1647 
1648 
1649 /* -------- TYPES TABLE (BEGIN) -------- */
1650 
1651 #define SWIGTYPE_p_a_base swig_types[0]
1652 #define SWIGTYPE_p_a_point swig_types[1]
1653 #define SWIGTYPE_p_a_shape swig_types[2]
1654 #define SWIGTYPE_p_a_shape_circle swig_types[3]
1655 #define SWIGTYPE_p_a_shape_cylinder swig_types[4]
1656 #define SWIGTYPE_p_a_shape_line swig_types[5]
1657 #define SWIGTYPE_p_a_shape_plane swig_types[6]
1658 #define SWIGTYPE_p_a_shape_quadric swig_types[7]
1659 #define SWIGTYPE_p_a_shape_sphere swig_types[8]
1660 #define SWIGTYPE_p_char swig_types[9]
1661 #define SWIGTYPE_p_std__vectorT_a_point_t swig_types[10]
1662 #define SWIGTYPE_p_vnl_vectorT_double_t swig_types[11]
1664 static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
1665 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1666 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1667 
1668 /* -------- TYPES TABLE (END) -------- */
1669 
1670 #define SWIG_init A_shape_Init
1671 #define SWIG_name "a_shape"
1672 #define SWIG_prefix ""
1673 #define SWIG_version "0.0"
1674 
1675 #define SWIGVERSION 0x040002
1676 #define SWIG_VERSION SWIGVERSION
1677 
1678 
1679 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1680 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1681 
1682 
1683 #include <stdexcept>
1684 
1685 
1686 
1687 #ifdef __cplusplus
1688 extern "C" {
1689 #endif
1690 #ifdef MAC_TCL
1691 #pragma export on
1692 #endif
1693 SWIGEXPORT int SWIG_init(Tcl_Interp *);
1694 #ifdef MAC_TCL
1695 #pragma export off
1696 #endif
1697 #ifdef __cplusplus
1698 }
1699 #endif
1700 
1701 /* Compatibility version for TCL stubs */
1702 #ifndef SWIG_TCL_STUBS_VERSION
1703 #define SWIG_TCL_STUBS_VERSION "8.1"
1704 #endif
1705 
1706 
1707 
1708 #include <string>
1709 
1710 
1711 #include "a_base.h"
1712 #include <iostream>
1713 #include <sstream>
1714 
1715 
1716 #include <limits.h>
1717 #if !defined(SWIG_NO_LLONG_MAX)
1718 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1719 # define LLONG_MAX __LONG_LONG_MAX__
1720 # define LLONG_MIN (-LLONG_MAX - 1LL)
1721 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1722 # endif
1723 #endif
1724 
1725 
1726 SWIGINTERNINLINE Tcl_Obj *
1727 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1728 {
1729  return (size < INT_MAX) ? Tcl_NewStringObj(carray, static_cast< int >(size)) : NULL;
1730 }
1731 
1732 
1733 SWIGINTERNINLINE Tcl_Obj *
1734 SWIG_From_std_string (const std::string& s)
1735 {
1736  return SWIG_FromCharPtrAndSize(s.data(), s.size());
1737 }
1738 
1739 
1740 SWIGINTERN int
1741 SWIG_AsVal_double SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, double *val)
1742 {
1743  double v;
1744  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
1745  if (val) *val = v;
1746  return SWIG_OK;
1747  }
1748  return SWIG_TypeError;
1749 }
1750 
1751 
1752  #define SWIG_From_double Tcl_NewDoubleObj
1753 
1754 SWIGINTERN std::string a_base_print(a_base *self){
1755  std::ostringstream out;
1756  out << *self;
1757  return out.str();
1758  }
1759 
1760 #include "a_shape.h"
1761 
1762 
1763 SWIGINTERNINLINE Tcl_Obj*
1764 SWIG_From_long (long value)
1765 {
1766  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1767  return Tcl_NewIntObj(static_cast< int >(value));
1768  } else {
1769  return Tcl_NewLongObj(value);
1770  }
1771 }
1772 
1773 
1774 #include <stdio.h>
1775 #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__BORLANDC__) || defined(_WATCOM)
1776 # ifndef snprintf
1777 # define snprintf _snprintf
1778 # endif
1779 #endif
1780 
1781 
1782 SWIGINTERNINLINE Tcl_Obj*
1783 SWIG_From_unsigned_SS_long (unsigned long value)
1784 {
1785  if (value < (unsigned long) LONG_MAX) {
1786  return SWIG_From_long (static_cast< long >(value));
1787  } else {
1788  char temp[256];
1789  sprintf(temp, "%lu", value);
1790  return Tcl_NewStringObj(temp,-1);
1791  }
1792 }
1793 
1794 
1795 SWIGINTERNINLINE Tcl_Obj *
1796 SWIG_From_unsigned_SS_int (unsigned int value)
1797 {
1798  return SWIG_From_unsigned_SS_long (value);
1799 }
1800 
1801 
1802 SWIGINTERNINLINE Tcl_Obj *
1803 SWIG_From_int (int value)
1804 {
1805  return SWIG_From_long (value);
1806 }
1807 
1808 
1809 SWIGINTERN int
1810 SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1811 {
1812  long v;
1813  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1814  if (val) *val = (long) v;
1815  return SWIG_OK;
1816  }
1817  return SWIG_TypeError;
1818 }
1819 
1820 
1821 SWIGINTERN int
1822 SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1823 {
1824  long v;
1825  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1826  if (SWIG_IsOK(res)) {
1827  if ((v < INT_MIN || v > INT_MAX)) {
1828  return SWIG_OverflowError;
1829  } else {
1830  if (val) *val = static_cast< int >(v);
1831  }
1832  }
1833  return res;
1834 }
1835 
1836 
1837 #include "a_shape_circle.h"
1838 
1839 
1840 SWIGINTERN int
1841 SWIG_AsVal_short SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, short *val)
1842 {
1843  long v;
1844  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1845  if (SWIG_IsOK(res)) {
1846  if ((v < SHRT_MIN || v > SHRT_MAX)) {
1847  return SWIG_OverflowError;
1848  } else {
1849  if (val) *val = static_cast< short >(v);
1850  }
1851  }
1852  return res;
1853 }
1854 
1855 
1856 SWIGINTERN int
1857 SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
1858  long v;
1859  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1860  if (v >= 0) {
1861  if (val) *val = (unsigned long) v;
1862  return SWIG_OK;
1863  }
1864  /* If v is negative, then this could be a negative number, or an
1865  unsigned value which doesn't fit in a signed long, so try to
1866  get it as a string so we can distinguish these cases. */
1867  }
1868  {
1869  int len = 0;
1870  const char *nptr = Tcl_GetStringFromObj(obj, &len);
1871  if (nptr && len > 0) {
1872  char *endptr;
1873  unsigned long v;
1874  if (*nptr == '-') return SWIG_OverflowError;
1875  errno = 0;
1876  v = strtoul(nptr, &endptr,0);
1877  if (nptr[0] == '\0' || *endptr != '\0')
1878  return SWIG_TypeError;
1879  if (v == ULONG_MAX && errno == ERANGE) {
1880  errno = 0;
1881  return SWIG_OverflowError;
1882  } else {
1883  if (*endptr == '\0') {
1884  if (val) *val = v;
1885  return SWIG_OK;
1886  }
1887  }
1888  }
1889  }
1890 
1891  return SWIG_TypeError;
1892 }
1893 
1894 
1895 SWIGINTERN int
1896 SWIG_AsVal_unsigned_SS_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned int *val)
1897 {
1898  unsigned long v;
1899  int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1900  if (SWIG_IsOK(res)) {
1901  if ((v > UINT_MAX)) {
1902  return SWIG_OverflowError;
1903  } else {
1904  if (val) *val = static_cast< unsigned int >(v);
1905  }
1906  }
1907  return res;
1908 }
1909 
1910 
1911 #include "a_shape_quadric.h"
1912 #include "a_shape_cylinder.h"
1913 
1914 
1915 #include "a_shape_line.h"
1916 
1917 
1918 #include "a_shape_plane.h"
1919 
1920 
1921 #include "a_shape_quadric.h"
1922 
1924 SWIGINTERN void a_shape_quadric_Ap(a_shape_quadric *self){self->getAp();}
1925 SWIGINTERN void a_shape_quadric_b(a_shape_quadric *self){self->getb();std::cout << std::endl;}
1926 
1927 #include "a_shape_sphere.h"
1928 
1929 #ifdef __cplusplus
1930 extern "C" {
1931 #endif
1932 SWIGINTERN int
1933 _wrap_a_base_classname(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1934  a_base *arg1 = (a_base *) 0 ;
1935  void *argp1 = 0 ;
1936  int res1 = 0 ;
1937  std::string result;
1938 
1939  if (SWIG_GetArgs(interp, objc, objv,"o:a_base_classname self ",(void *)0) == TCL_ERROR) SWIG_fail;
1940  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_base, 0 | 0 );
1941  if (!SWIG_IsOK(res1)) {
1942  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_base_classname" "', argument " "1"" of type '" "a_base *""'");
1943  }
1944  arg1 = reinterpret_cast< a_base * >(argp1);
1945  result = (arg1)->classname();
1946  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
1947  return TCL_OK;
1948 fail:
1949  return TCL_ERROR;
1950 }
1951 
1952 
1953 SWIGINTERN int
1954 _wrap_a_base_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1955  std::string result;
1956 
1957  if (SWIG_GetArgs(interp, objc, objv,":a_base_help ") == TCL_ERROR) SWIG_fail;
1958  result = a_base::help();
1959  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
1960  return TCL_OK;
1961 fail:
1962  return TCL_ERROR;
1963 }
1964 
1965 
1966 SWIGINTERN int
1967 _wrap_a_base_small__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1968  a_base *arg1 = (a_base *) 0 ;
1969  double arg2 ;
1970  void *argp1 = 0 ;
1971  int res1 = 0 ;
1972  double val2 ;
1973  int ecode2 = 0 ;
1974 
1975  if (SWIG_GetArgs(interp, objc, objv,"oo:a_base_small self tol ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
1976  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_base, 0 | 0 );
1977  if (!SWIG_IsOK(res1)) {
1978  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_base_small" "', argument " "1"" of type '" "a_base *""'");
1979  }
1980  arg1 = reinterpret_cast< a_base * >(argp1);
1981  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
1982  if (!SWIG_IsOK(ecode2)) {
1983  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_base_small" "', argument " "2"" of type '" "double""'");
1984  }
1985  arg2 = static_cast< double >(val2);
1986  (arg1)->small(arg2);
1987 
1988  return TCL_OK;
1989 fail:
1990  return TCL_ERROR;
1991 }
1992 
1993 
1994 SWIGINTERN int
1995 _wrap_a_base_small__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1996  a_base *arg1 = (a_base *) 0 ;
1997  void *argp1 = 0 ;
1998  int res1 = 0 ;
1999  double result;
2000 
2001  if (SWIG_GetArgs(interp, objc, objv,"o:a_base_small self ",(void *)0) == TCL_ERROR) SWIG_fail;
2002  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_base, 0 | 0 );
2003  if (!SWIG_IsOK(res1)) {
2004  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_base_small" "', argument " "1"" of type '" "a_base const *""'");
2005  }
2006  arg1 = reinterpret_cast< a_base * >(argp1);
2007  result = (double)((a_base const *)arg1)->small();
2008  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2009  return TCL_OK;
2010 fail:
2011  return TCL_ERROR;
2012 }
2013 
2014 
2015 SWIGINTERN int
2016 _wrap_a_base_small(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2017  Tcl_Obj *CONST *argv = objv+1;
2018  int argc = objc-1;
2019  if (argc == 1) {
2020  int _v;
2021  void *vptr = 0;
2022  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_base, 0);
2023  _v = SWIG_CheckState(res);
2024  if (_v) {
2025  return _wrap_a_base_small__SWIG_1(clientData, interp, objc, argv - 1);
2026  }
2027  }
2028  if (argc == 2) {
2029  int _v;
2030  void *vptr = 0;
2031  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_base, 0);
2032  _v = SWIG_CheckState(res);
2033  if (_v) {
2034  {
2035  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2036  _v = SWIG_CheckState(res);
2037  }
2038  if (_v) {
2039  return _wrap_a_base_small__SWIG_0(clientData, interp, objc, argv - 1);
2040  }
2041  }
2042  }
2043 
2044  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_base_small'.\n"
2045  " Possible C/C++ prototypes are:\n"
2046  " a_base::small(double)\n"
2047  " a_base::small() const\n", TCL_STATIC);
2048  return TCL_ERROR;
2049 }
2050 
2051 
2052 SWIGINTERN int
2053 _wrap_a_base_print(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2054  a_base *arg1 = (a_base *) 0 ;
2055  void *argp1 = 0 ;
2056  int res1 = 0 ;
2057  std::string result;
2058 
2059  if (SWIG_GetArgs(interp, objc, objv,"o:a_base_print self ",(void *)0) == TCL_ERROR) SWIG_fail;
2060  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_base, 0 | 0 );
2061  if (!SWIG_IsOK(res1)) {
2062  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_base_print" "', argument " "1"" of type '" "a_base *""'");
2063  }
2064  arg1 = reinterpret_cast< a_base * >(argp1);
2065  result = a_base_print(arg1);
2066  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2067  return TCL_OK;
2068 fail:
2069  return TCL_ERROR;
2070 }
2071 
2072 
2073 SWIGINTERN int
2074 _wrap_new_a_base(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2075  a_base *result = 0 ;
2076 
2077  if (SWIG_GetArgs(interp, objc, objv,":new_a_base ") == TCL_ERROR) SWIG_fail;
2078  result = (a_base *)new a_base();
2079  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_base,0));
2080  return TCL_OK;
2081 fail:
2082  return TCL_ERROR;
2083 }
2084 
2085 
2086 SWIGINTERN int
2087 _wrap_delete_a_base(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2088  a_base *arg1 = (a_base *) 0 ;
2089  void *argp1 = 0 ;
2090  int res1 = 0 ;
2091 
2092  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_base self ",(void *)0) == TCL_ERROR) SWIG_fail;
2093  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_base, SWIG_POINTER_DISOWN | 0 );
2094  if (!SWIG_IsOK(res1)) {
2095  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_base" "', argument " "1"" of type '" "a_base *""'");
2096  }
2097  arg1 = reinterpret_cast< a_base * >(argp1);
2098  delete arg1;
2099 
2100  return TCL_OK;
2101 fail:
2102  return TCL_ERROR;
2103 }
2104 
2105 
2107 a_base *arg1 = (a_base *) obj;
2108 delete arg1;
2109 }
2111  {"classname", _wrap_a_base_classname},
2112  {"small", _wrap_a_base_small},
2113  {"print", _wrap_a_base_print},
2114  {0,0}
2115 };
2117  {0,0,0}
2118 };
2120 static const char * swig_a_base_base_names[] = {0};
2122 SWIGINTERN int
2123 _wrap_a_shape_classname(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2124  a_shape *arg1 = (a_shape *) 0 ;
2125  void *argp1 = 0 ;
2126  int res1 = 0 ;
2127  std::string result;
2128 
2129  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_classname self ",(void *)0) == TCL_ERROR) SWIG_fail;
2130  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2131  if (!SWIG_IsOK(res1)) {
2132  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_classname" "', argument " "1"" of type '" "a_shape const *""'");
2133  }
2134  arg1 = reinterpret_cast< a_shape * >(argp1);
2135  result = ((a_shape const *)arg1)->classname();
2136  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2137  return TCL_OK;
2138 fail:
2139  return TCL_ERROR;
2140 }
2141 
2142 
2143 SWIGINTERN int
2144 _wrap_a_shape_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2145  std::string result;
2146 
2147  if (SWIG_GetArgs(interp, objc, objv,":a_shape_help ") == TCL_ERROR) SWIG_fail;
2148  result = a_shape::help();
2149  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2150  return TCL_OK;
2151 fail:
2152  return TCL_ERROR;
2153 }
2154 
2155 
2156 SWIGINTERN int
2157 _wrap_a_shape_P__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2158  a_shape *arg1 = (a_shape *) 0 ;
2159  double arg2 ;
2160  void *argp1 = 0 ;
2161  int res1 = 0 ;
2162  double val2 ;
2163  int ecode2 = 0 ;
2164 
2165  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_P self P ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2166  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2167  if (!SWIG_IsOK(res1)) {
2168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_P" "', argument " "1"" of type '" "a_shape *""'");
2169  }
2170  arg1 = reinterpret_cast< a_shape * >(argp1);
2171  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2172  if (!SWIG_IsOK(ecode2)) {
2173  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_P" "', argument " "2"" of type '" "double""'");
2174  }
2175  arg2 = static_cast< double >(val2);
2176  (arg1)->P(arg2);
2177 
2178  return TCL_OK;
2179 fail:
2180  return TCL_ERROR;
2181 }
2182 
2183 
2184 SWIGINTERN int
2185 _wrap_a_shape_P__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2186  a_shape *arg1 = (a_shape *) 0 ;
2187  void *argp1 = 0 ;
2188  int res1 = 0 ;
2189  double result;
2190 
2191  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_P self ",(void *)0) == TCL_ERROR) SWIG_fail;
2192  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2193  if (!SWIG_IsOK(res1)) {
2194  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_P" "', argument " "1"" of type '" "a_shape const *""'");
2195  }
2196  arg1 = reinterpret_cast< a_shape * >(argp1);
2197  result = (double)((a_shape const *)arg1)->P();
2198  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2199  return TCL_OK;
2200 fail:
2201  return TCL_ERROR;
2202 }
2203 
2204 
2205 SWIGINTERN int
2206 _wrap_a_shape_P(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2207  Tcl_Obj *CONST *argv = objv+1;
2208  int argc = objc-1;
2209  if (argc == 1) {
2210  int _v;
2211  void *vptr = 0;
2212  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape, 0);
2213  _v = SWIG_CheckState(res);
2214  if (_v) {
2215  return _wrap_a_shape_P__SWIG_1(clientData, interp, objc, argv - 1);
2216  }
2217  }
2218  if (argc == 2) {
2219  int _v;
2220  void *vptr = 0;
2221  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape, 0);
2222  _v = SWIG_CheckState(res);
2223  if (_v) {
2224  {
2225  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2226  _v = SWIG_CheckState(res);
2227  }
2228  if (_v) {
2229  return _wrap_a_shape_P__SWIG_0(clientData, interp, objc, argv - 1);
2230  }
2231  }
2232  }
2233 
2234  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_P'.\n"
2235  " Possible C/C++ prototypes are:\n"
2236  " a_shape::P(double const)\n"
2237  " a_shape::P() const\n", TCL_STATIC);
2238  return TCL_ERROR;
2239 }
2240 
2241 
2242 SWIGINTERN int
2243 _wrap_a_shape_npara(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2244  a_shape *arg1 = (a_shape *) 0 ;
2245  void *argp1 = 0 ;
2246  int res1 = 0 ;
2247  unsigned int result;
2248 
2249  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_npara self ",(void *)0) == TCL_ERROR) SWIG_fail;
2250  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2251  if (!SWIG_IsOK(res1)) {
2252  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_npara" "', argument " "1"" of type '" "a_shape const *""'");
2253  }
2254  arg1 = reinterpret_cast< a_shape * >(argp1);
2255  result = (unsigned int)((a_shape const *)arg1)->npara();
2256  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)));
2257  return TCL_OK;
2258 fail:
2259  return TCL_ERROR;
2260 }
2261 
2262 
2263 SWIGINTERN int
2264 _wrap_a_shape_closest_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2265  a_shape *arg1 = (a_shape *) 0 ;
2266  a_point arg2 ;
2267  void *argp1 = 0 ;
2268  int res1 = 0 ;
2269  void *argp2 ;
2270  int res2 = 0 ;
2271  a_point result;
2272 
2273  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_closest_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2274  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2275  if (!SWIG_IsOK(res1)) {
2276  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_closest_point" "', argument " "1"" of type '" "a_shape const *""'");
2277  }
2278  arg1 = reinterpret_cast< a_shape * >(argp1);
2279  {
2280  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2281  if (!SWIG_IsOK(res2)) {
2282  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_closest_point" "', argument " "2"" of type '" "a_point const""'");
2283  }
2284  if (!argp2) {
2285  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_closest_point" "', argument " "2"" of type '" "a_point const""'");
2286  } else {
2287  arg2 = *(reinterpret_cast< a_point * >(argp2));
2288  }
2289  }
2290  result = ((a_shape const *)arg1)->closest_point(arg2);
2291  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
2292  return TCL_OK;
2293 fail:
2294  return TCL_ERROR;
2295 }
2296 
2297 
2298 SWIGINTERN int
2299 _wrap_a_shape_dist_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2300  a_shape *arg1 = (a_shape *) 0 ;
2301  a_point arg2 ;
2302  void *argp1 = 0 ;
2303  int res1 = 0 ;
2304  void *argp2 ;
2305  int res2 = 0 ;
2306  double result;
2307 
2308  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_dist_point self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2309  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2310  if (!SWIG_IsOK(res1)) {
2311  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_dist_point" "', argument " "1"" of type '" "a_shape *""'");
2312  }
2313  arg1 = reinterpret_cast< a_shape * >(argp1);
2314  {
2315  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2316  if (!SWIG_IsOK(res2)) {
2317  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_dist_point" "', argument " "2"" of type '" "a_point const""'");
2318  }
2319  if (!argp2) {
2320  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_dist_point" "', argument " "2"" of type '" "a_point const""'");
2321  } else {
2322  arg2 = *(reinterpret_cast< a_point * >(argp2));
2323  }
2324  }
2325  result = (double)(arg1)->dist_point(arg2);
2326  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2327  return TCL_OK;
2328 fail:
2329  return TCL_ERROR;
2330 }
2331 
2332 
2333 SWIGINTERN int
2334 _wrap_a_shape_dist_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2335  a_shape *arg1 = (a_shape *) 0 ;
2336  std::vector< a_point > *arg2 = 0 ;
2337  void *argp1 = 0 ;
2338  int res1 = 0 ;
2339  void *argp2 ;
2340  int res2 = 0 ;
2341  double result;
2342 
2343  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_dist_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2344  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2345  if (!SWIG_IsOK(res1)) {
2346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_dist_cloud" "', argument " "1"" of type '" "a_shape *""'");
2347  }
2348  arg1 = reinterpret_cast< a_shape * >(argp1);
2349  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2350  if (!SWIG_IsOK(res2)) {
2351  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2352  }
2353  if (!argp2) {
2354  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2355  }
2356  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2357  result = (double)(arg1)->dist_cloud((std::vector< a_point > const &)*arg2);
2358  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2359  return TCL_OK;
2360 fail:
2361  return TCL_ERROR;
2362 }
2363 
2364 
2365 SWIGINTERN int
2366 _wrap_a_shape_average_dist_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2367  a_shape *arg1 = (a_shape *) 0 ;
2368  std::vector< a_point > *arg2 = 0 ;
2369  void *argp1 = 0 ;
2370  int res1 = 0 ;
2371  void *argp2 ;
2372  int res2 = 0 ;
2373  double result;
2374 
2375  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_average_dist_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2376  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2377  if (!SWIG_IsOK(res1)) {
2378  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_average_dist_cloud" "', argument " "1"" of type '" "a_shape *""'");
2379  }
2380  arg1 = reinterpret_cast< a_shape * >(argp1);
2381  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2382  if (!SWIG_IsOK(res2)) {
2383  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_average_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2384  }
2385  if (!argp2) {
2386  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_average_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2387  }
2388  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2389  result = (double)(arg1)->average_dist_cloud((std::vector< a_point > const &)*arg2);
2390  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2391  return TCL_OK;
2392 fail:
2393  return TCL_ERROR;
2394 }
2395 
2396 
2397 SWIGINTERN int
2398 _wrap_a_shape_rms_dist_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2399  a_shape *arg1 = (a_shape *) 0 ;
2400  std::vector< a_point > *arg2 = 0 ;
2401  void *argp1 = 0 ;
2402  int res1 = 0 ;
2403  void *argp2 ;
2404  int res2 = 0 ;
2405  double result;
2406 
2407  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_rms_dist_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2408  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2409  if (!SWIG_IsOK(res1)) {
2410  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_rms_dist_cloud" "', argument " "1"" of type '" "a_shape *""'");
2411  }
2412  arg1 = reinterpret_cast< a_shape * >(argp1);
2413  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2414  if (!SWIG_IsOK(res2)) {
2415  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_rms_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2416  }
2417  if (!argp2) {
2418  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_rms_dist_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2419  }
2420  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2421  result = (double)(arg1)->rms_dist_cloud((std::vector< a_point > const &)*arg2);
2422  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2423  return TCL_OK;
2424 fail:
2425  return TCL_ERROR;
2426 }
2427 
2428 
2429 SWIGINTERN int
2430 _wrap_a_shape_threshold_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2431  a_shape *arg1 = (a_shape *) 0 ;
2432  std::vector< a_point > *arg2 = 0 ;
2433  std::vector< a_point > *arg3 = 0 ;
2434  void *argp1 = 0 ;
2435  int res1 = 0 ;
2436  void *argp2 ;
2437  int res2 = 0 ;
2438  void *argp3 = 0 ;
2439  int res3 = 0 ;
2440  int result;
2441 
2442  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_threshold_cloud self pts pts2 ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2443  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2444  if (!SWIG_IsOK(res1)) {
2445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_threshold_cloud" "', argument " "1"" of type '" "a_shape *""'");
2446  }
2447  arg1 = reinterpret_cast< a_shape * >(argp1);
2448  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2449  if (!SWIG_IsOK(res2)) {
2450  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_threshold_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2451  }
2452  if (!argp2) {
2453  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_threshold_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2454  }
2455  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2456  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2457  if (!SWIG_IsOK(res3)) {
2458  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_threshold_cloud" "', argument " "3"" of type '" "std::vector< a_point > &""'");
2459  }
2460  if (!argp3) {
2461  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_threshold_cloud" "', argument " "3"" of type '" "std::vector< a_point > &""'");
2462  }
2463  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
2464  result = (int)(arg1)->threshold_cloud((std::vector< a_point > const &)*arg2,*arg3);
2465  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2466  return TCL_OK;
2467 fail:
2468  return TCL_ERROR;
2469 }
2470 
2471 
2472 SWIGINTERN int
2473 _wrap_a_shape_best_fitting_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2474  a_shape *arg1 = (a_shape *) 0 ;
2475  std::vector< a_point > *arg2 = 0 ;
2476  std::vector< a_point > *arg3 = 0 ;
2477  void *argp1 = 0 ;
2478  int res1 = 0 ;
2479  void *argp2 ;
2480  int res2 = 0 ;
2481  void *argp3 = 0 ;
2482  int res3 = 0 ;
2483  int result;
2484 
2485  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_best_fitting_cloud self pts pts2 ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2486  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2487  if (!SWIG_IsOK(res1)) {
2488  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_best_fitting_cloud" "', argument " "1"" of type '" "a_shape *""'");
2489  }
2490  arg1 = reinterpret_cast< a_shape * >(argp1);
2491  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2492  if (!SWIG_IsOK(res2)) {
2493  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_best_fitting_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2494  }
2495  if (!argp2) {
2496  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_best_fitting_cloud" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
2497  }
2498  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2499  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2500  if (!SWIG_IsOK(res3)) {
2501  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_best_fitting_cloud" "', argument " "3"" of type '" "std::vector< a_point > &""'");
2502  }
2503  if (!argp3) {
2504  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_best_fitting_cloud" "', argument " "3"" of type '" "std::vector< a_point > &""'");
2505  }
2506  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
2507  result = (int)(arg1)->best_fitting_cloud((std::vector< a_point > const &)*arg2,*arg3);
2508  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2509  return TCL_OK;
2510 fail:
2511  return TCL_ERROR;
2512 }
2513 
2514 
2515 SWIGINTERN int
2516 _wrap_a_shape_fit_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2517  a_shape *arg1 = (a_shape *) 0 ;
2518  std::vector< a_point > *arg2 = 0 ;
2519  void *argp1 = 0 ;
2520  int res1 = 0 ;
2521  void *argp2 = 0 ;
2522  int res2 = 0 ;
2523 
2524  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_fit_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2525  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2526  if (!SWIG_IsOK(res1)) {
2527  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_fit_cloud" "', argument " "1"" of type '" "a_shape *""'");
2528  }
2529  arg1 = reinterpret_cast< a_shape * >(argp1);
2530  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
2531  if (!SWIG_IsOK(res2)) {
2532  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
2533  }
2534  if (!argp2) {
2535  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
2536  }
2537  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
2538  (arg1)->fit_cloud(*arg2);
2539 
2540  return TCL_OK;
2541 fail:
2542  return TCL_ERROR;
2543 }
2544 
2545 
2546 SWIGINTERN int
2547 _wrap_a_shape_getparameters(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2548  a_shape *arg1 = (a_shape *) 0 ;
2549  void *argp1 = 0 ;
2550  int res1 = 0 ;
2551  vnl_vector< double > result;
2552 
2553  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_getparameters self ",(void *)0) == TCL_ERROR) SWIG_fail;
2554  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2555  if (!SWIG_IsOK(res1)) {
2556  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_getparameters" "', argument " "1"" of type '" "a_shape const *""'");
2557  }
2558  arg1 = reinterpret_cast< a_shape * >(argp1);
2559  result = ((a_shape const *)arg1)->getparameters();
2560  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new vnl_vector< double >(static_cast< const vnl_vector< double >& >(result))), SWIGTYPE_p_vnl_vectorT_double_t, SWIG_POINTER_OWN | 0 ));
2561  return TCL_OK;
2562 fail:
2563  return TCL_ERROR;
2564 }
2565 
2566 
2567 SWIGINTERN int
2568 _wrap_a_shape_para(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2569  a_shape *arg1 = (a_shape *) 0 ;
2570  int arg2 ;
2571  double arg3 ;
2572  void *argp1 = 0 ;
2573  int res1 = 0 ;
2574  int val2 ;
2575  int ecode2 = 0 ;
2576  double val3 ;
2577  int ecode3 = 0 ;
2578 
2579  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_para self i val ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2580  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, 0 | 0 );
2581  if (!SWIG_IsOK(res1)) {
2582  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_para" "', argument " "1"" of type '" "a_shape *""'");
2583  }
2584  arg1 = reinterpret_cast< a_shape * >(argp1);
2585  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2586  if (!SWIG_IsOK(ecode2)) {
2587  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_para" "', argument " "2"" of type '" "int""'");
2588  }
2589  arg2 = static_cast< int >(val2);
2590  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2591  if (!SWIG_IsOK(ecode3)) {
2592  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_shape_para" "', argument " "3"" of type '" "double""'");
2593  }
2594  arg3 = static_cast< double >(val3);
2595  (arg1)->para(arg2,arg3);
2596 
2597  return TCL_OK;
2598 fail:
2599  return TCL_ERROR;
2600 }
2601 
2602 
2603 SWIGINTERN int
2604 _wrap_delete_a_shape(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2605  a_shape *arg1 = (a_shape *) 0 ;
2606  void *argp1 = 0 ;
2607  int res1 = 0 ;
2608 
2609  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_shape self ",(void *)0) == TCL_ERROR) SWIG_fail;
2610  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape, SWIG_POINTER_DISOWN | 0 );
2611  if (!SWIG_IsOK(res1)) {
2612  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_shape" "', argument " "1"" of type '" "a_shape *""'");
2613  }
2614  arg1 = reinterpret_cast< a_shape * >(argp1);
2615  delete arg1;
2616 
2617  return TCL_OK;
2618 fail:
2619  return TCL_ERROR;
2620 }
2621 
2622 
2624 a_shape *arg1 = (a_shape *) obj;
2625 delete arg1;
2626 }
2628  {"classname", _wrap_a_shape_classname},
2629  {"P", _wrap_a_shape_P},
2630  {"npara", _wrap_a_shape_npara},
2631  {"closest_point", _wrap_a_shape_closest_point},
2632  {"dist_point", _wrap_a_shape_dist_point},
2633  {"dist_cloud", _wrap_a_shape_dist_cloud},
2634  {"average_dist_cloud", _wrap_a_shape_average_dist_cloud},
2635  {"rms_dist_cloud", _wrap_a_shape_rms_dist_cloud},
2636  {"threshold_cloud", _wrap_a_shape_threshold_cloud},
2637  {"best_fitting_cloud", _wrap_a_shape_best_fitting_cloud},
2638  {"fit_cloud", _wrap_a_shape_fit_cloud},
2639  {"getparameters", _wrap_a_shape_getparameters},
2640  {"para", _wrap_a_shape_para},
2641  {0,0}
2642 };
2644  {0,0,0}
2645 };
2646 static swig_class *swig_a_shape_bases[] = {0,0};
2647 static const char * swig_a_shape_base_names[] = {"a_base *",0};
2649 SWIGINTERN int
2650 _wrap_a_shape_circle_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2651  std::string result;
2652 
2653  if (SWIG_GetArgs(interp, objc, objv,":a_shape_circle_help ") == TCL_ERROR) SWIG_fail;
2654  result = a_shape_circle::help();
2655  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2656  return TCL_OK;
2657 fail:
2658  return TCL_ERROR;
2659 }
2660 
2661 
2662 SWIGINTERN int
2663 _wrap_new_a_shape_circle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2664  a_shape_circle *result = 0 ;
2665 
2666  if (SWIG_GetArgs(interp, objc, objv,":new_a_shape_circle ") == TCL_ERROR) SWIG_fail;
2667  result = (a_shape_circle *)new a_shape_circle();
2668  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_shape_circle,0));
2669  return TCL_OK;
2670 fail:
2671  return TCL_ERROR;
2672 }
2673 
2674 
2675 SWIGINTERN int
2676 _wrap_a_shape_circle_closest_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2677  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2678  a_point arg2 ;
2679  void *argp1 = 0 ;
2680  int res1 = 0 ;
2681  void *argp2 ;
2682  int res2 = 0 ;
2683  a_point result;
2684 
2685  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_closest_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2686  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2687  if (!SWIG_IsOK(res1)) {
2688  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_closest_point" "', argument " "1"" of type '" "a_shape_circle const *""'");
2689  }
2690  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2691  {
2692  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2693  if (!SWIG_IsOK(res2)) {
2694  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_closest_point" "', argument " "2"" of type '" "a_point const""'");
2695  }
2696  if (!argp2) {
2697  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_closest_point" "', argument " "2"" of type '" "a_point const""'");
2698  } else {
2699  arg2 = *(reinterpret_cast< a_point * >(argp2));
2700  }
2701  }
2702  result = ((a_shape_circle const *)arg1)->closest_point(arg2);
2703  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
2704  return TCL_OK;
2705 fail:
2706  return TCL_ERROR;
2707 }
2708 
2709 
2710 SWIGINTERN int
2711 _wrap_a_shape_circle_dist_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2712  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2713  a_point arg2 ;
2714  void *argp1 = 0 ;
2715  int res1 = 0 ;
2716  void *argp2 ;
2717  int res2 = 0 ;
2718  double result;
2719 
2720  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_dist_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2721  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2722  if (!SWIG_IsOK(res1)) {
2723  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_dist_point" "', argument " "1"" of type '" "a_shape_circle const *""'");
2724  }
2725  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2726  {
2727  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2728  if (!SWIG_IsOK(res2)) {
2729  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_dist_point" "', argument " "2"" of type '" "a_point const""'");
2730  }
2731  if (!argp2) {
2732  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_dist_point" "', argument " "2"" of type '" "a_point const""'");
2733  } else {
2734  arg2 = *(reinterpret_cast< a_point * >(argp2));
2735  }
2736  }
2737  result = (double)((a_shape_circle const *)arg1)->dist_point(arg2);
2738  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2739  return TCL_OK;
2740 fail:
2741  return TCL_ERROR;
2742 }
2743 
2744 
2745 SWIGINTERN int
2746 _wrap_a_shape_circle_p3pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2747  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2748  a_point arg2 ;
2749  a_point arg3 ;
2750  a_point arg4 ;
2751  void *argp1 = 0 ;
2752  int res1 = 0 ;
2753  void *argp2 ;
2754  int res2 = 0 ;
2755  void *argp3 ;
2756  int res3 = 0 ;
2757  void *argp4 ;
2758  int res4 = 0 ;
2759 
2760  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_shape_circle_p3pts self p1 p2 p3 ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2761  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2762  if (!SWIG_IsOK(res1)) {
2763  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_p3pts" "', argument " "1"" of type '" "a_shape_circle *""'");
2764  }
2765  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2766  {
2767  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2768  if (!SWIG_IsOK(res2)) {
2769  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_p3pts" "', argument " "2"" of type '" "a_point const""'");
2770  }
2771  if (!argp2) {
2772  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_p3pts" "', argument " "2"" of type '" "a_point const""'");
2773  } else {
2774  arg2 = *(reinterpret_cast< a_point * >(argp2));
2775  }
2776  }
2777  {
2778  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
2779  if (!SWIG_IsOK(res3)) {
2780  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_circle_p3pts" "', argument " "3"" of type '" "a_point const""'");
2781  }
2782  if (!argp3) {
2783  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_p3pts" "', argument " "3"" of type '" "a_point const""'");
2784  } else {
2785  arg3 = *(reinterpret_cast< a_point * >(argp3));
2786  }
2787  }
2788  {
2789  res4 = SWIG_ConvertPtr(objv[4], &argp4, SWIGTYPE_p_a_point, 0 );
2790  if (!SWIG_IsOK(res4)) {
2791  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "a_shape_circle_p3pts" "', argument " "4"" of type '" "a_point const""'");
2792  }
2793  if (!argp4) {
2794  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_p3pts" "', argument " "4"" of type '" "a_point const""'");
2795  } else {
2796  arg4 = *(reinterpret_cast< a_point * >(argp4));
2797  }
2798  }
2799  (arg1)->p3pts(arg2,arg3,arg4);
2800 
2801  return TCL_OK;
2802 fail:
2803  return TCL_ERROR;
2804 }
2805 
2806 
2807 SWIGINTERN int
2808 _wrap_a_shape_circle_dir__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2809  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2810  void *argp1 = 0 ;
2811  int res1 = 0 ;
2812  a_point result;
2813 
2814  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_circle_dir self ",(void *)0) == TCL_ERROR) SWIG_fail;
2815  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2816  if (!SWIG_IsOK(res1)) {
2817  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_dir" "', argument " "1"" of type '" "a_shape_circle const *""'");
2818  }
2819  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2820  result = ((a_shape_circle const *)arg1)->dir();
2821  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
2822  return TCL_OK;
2823 fail:
2824  return TCL_ERROR;
2825 }
2826 
2827 
2828 SWIGINTERN int
2829 _wrap_a_shape_circle_orig__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2830  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2831  void *argp1 = 0 ;
2832  int res1 = 0 ;
2833  a_point result;
2834 
2835  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_circle_orig self ",(void *)0) == TCL_ERROR) SWIG_fail;
2836  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2837  if (!SWIG_IsOK(res1)) {
2838  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_orig" "', argument " "1"" of type '" "a_shape_circle const *""'");
2839  }
2840  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2841  result = ((a_shape_circle const *)arg1)->orig();
2842  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
2843  return TCL_OK;
2844 fail:
2845  return TCL_ERROR;
2846 }
2847 
2848 
2849 SWIGINTERN int
2850 _wrap_a_shape_circle_radius__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2851  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2852  void *argp1 = 0 ;
2853  int res1 = 0 ;
2854  double result;
2855 
2856  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_circle_radius self ",(void *)0) == TCL_ERROR) SWIG_fail;
2857  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2858  if (!SWIG_IsOK(res1)) {
2859  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_radius" "', argument " "1"" of type '" "a_shape_circle const *""'");
2860  }
2861  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2862  result = (double)((a_shape_circle const *)arg1)->radius();
2863  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2864  return TCL_OK;
2865 fail:
2866  return TCL_ERROR;
2867 }
2868 
2869 
2870 SWIGINTERN int
2871 _wrap_a_shape_circle_dir__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2872  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2873  a_point arg2 ;
2874  void *argp1 = 0 ;
2875  int res1 = 0 ;
2876  void *argp2 ;
2877  int res2 = 0 ;
2878 
2879  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_dir self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2880  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2881  if (!SWIG_IsOK(res1)) {
2882  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_dir" "', argument " "1"" of type '" "a_shape_circle *""'");
2883  }
2884  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2885  {
2886  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2887  if (!SWIG_IsOK(res2)) {
2888  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_dir" "', argument " "2"" of type '" "a_point const""'");
2889  }
2890  if (!argp2) {
2891  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_dir" "', argument " "2"" of type '" "a_point const""'");
2892  } else {
2893  arg2 = *(reinterpret_cast< a_point * >(argp2));
2894  }
2895  }
2896  (arg1)->dir(arg2);
2897 
2898  return TCL_OK;
2899 fail:
2900  return TCL_ERROR;
2901 }
2902 
2903 
2904 SWIGINTERN int
2905 _wrap_a_shape_circle_dir(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2906  Tcl_Obj *CONST *argv = objv+1;
2907  int argc = objc-1;
2908  if (argc == 1) {
2909  int _v;
2910  void *vptr = 0;
2911  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
2912  _v = SWIG_CheckState(res);
2913  if (_v) {
2914  return _wrap_a_shape_circle_dir__SWIG_0(clientData, interp, objc, argv - 1);
2915  }
2916  }
2917  if (argc == 2) {
2918  int _v;
2919  void *vptr = 0;
2920  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
2921  _v = SWIG_CheckState(res);
2922  if (_v) {
2923  void *vptr = 0;
2924  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
2925  _v = SWIG_CheckState(res);
2926  if (_v) {
2927  return _wrap_a_shape_circle_dir__SWIG_1(clientData, interp, objc, argv - 1);
2928  }
2929  }
2930  }
2931 
2932  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_circle_dir'.\n"
2933  " Possible C/C++ prototypes are:\n"
2934  " a_shape_circle::dir() const\n"
2935  " a_shape_circle::dir(a_point const)\n", TCL_STATIC);
2936  return TCL_ERROR;
2937 }
2938 
2939 
2940 SWIGINTERN int
2941 _wrap_a_shape_circle_orig__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2942  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
2943  a_point arg2 ;
2944  void *argp1 = 0 ;
2945  int res1 = 0 ;
2946  void *argp2 ;
2947  int res2 = 0 ;
2948 
2949  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_orig self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2950  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
2951  if (!SWIG_IsOK(res1)) {
2952  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_orig" "', argument " "1"" of type '" "a_shape_circle *""'");
2953  }
2954  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
2955  {
2956  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2957  if (!SWIG_IsOK(res2)) {
2958  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_orig" "', argument " "2"" of type '" "a_point const""'");
2959  }
2960  if (!argp2) {
2961  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_orig" "', argument " "2"" of type '" "a_point const""'");
2962  } else {
2963  arg2 = *(reinterpret_cast< a_point * >(argp2));
2964  }
2965  }
2966  (arg1)->orig(arg2);
2967 
2968  return TCL_OK;
2969 fail:
2970  return TCL_ERROR;
2971 }
2972 
2973 
2974 SWIGINTERN int
2975 _wrap_a_shape_circle_orig(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2976  Tcl_Obj *CONST *argv = objv+1;
2977  int argc = objc-1;
2978  if (argc == 1) {
2979  int _v;
2980  void *vptr = 0;
2981  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
2982  _v = SWIG_CheckState(res);
2983  if (_v) {
2984  return _wrap_a_shape_circle_orig__SWIG_0(clientData, interp, objc, argv - 1);
2985  }
2986  }
2987  if (argc == 2) {
2988  int _v;
2989  void *vptr = 0;
2990  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
2991  _v = SWIG_CheckState(res);
2992  if (_v) {
2993  void *vptr = 0;
2994  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
2995  _v = SWIG_CheckState(res);
2996  if (_v) {
2997  return _wrap_a_shape_circle_orig__SWIG_1(clientData, interp, objc, argv - 1);
2998  }
2999  }
3000  }
3001 
3002  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_circle_orig'.\n"
3003  " Possible C/C++ prototypes are:\n"
3004  " a_shape_circle::orig() const\n"
3005  " a_shape_circle::orig(a_point const)\n", TCL_STATIC);
3006  return TCL_ERROR;
3007 }
3008 
3009 
3010 SWIGINTERN int
3011 _wrap_a_shape_circle_radius__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3012  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3013  double arg2 ;
3014  void *argp1 = 0 ;
3015  int res1 = 0 ;
3016  double val2 ;
3017  int ecode2 = 0 ;
3018 
3019  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_radius self r ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3020  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3021  if (!SWIG_IsOK(res1)) {
3022  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_radius" "', argument " "1"" of type '" "a_shape_circle *""'");
3023  }
3024  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3025  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3026  if (!SWIG_IsOK(ecode2)) {
3027  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_circle_radius" "', argument " "2"" of type '" "double""'");
3028  }
3029  arg2 = static_cast< double >(val2);
3030  (arg1)->radius(arg2);
3031 
3032  return TCL_OK;
3033 fail:
3034  return TCL_ERROR;
3035 }
3036 
3037 
3038 SWIGINTERN int
3039 _wrap_a_shape_circle_radius(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3040  Tcl_Obj *CONST *argv = objv+1;
3041  int argc = objc-1;
3042  if (argc == 1) {
3043  int _v;
3044  void *vptr = 0;
3045  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
3046  _v = SWIG_CheckState(res);
3047  if (_v) {
3048  return _wrap_a_shape_circle_radius__SWIG_0(clientData, interp, objc, argv - 1);
3049  }
3050  }
3051  if (argc == 2) {
3052  int _v;
3053  void *vptr = 0;
3054  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
3055  _v = SWIG_CheckState(res);
3056  if (_v) {
3057  {
3058  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3059  _v = SWIG_CheckState(res);
3060  }
3061  if (_v) {
3062  return _wrap_a_shape_circle_radius__SWIG_1(clientData, interp, objc, argv - 1);
3063  }
3064  }
3065  }
3066 
3067  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_circle_radius'.\n"
3068  " Possible C/C++ prototypes are:\n"
3069  " a_shape_circle::radius() const\n"
3070  " a_shape_circle::radius(double)\n", TCL_STATIC);
3071  return TCL_ERROR;
3072 }
3073 
3074 
3075 SWIGINTERN int
3076 _wrap_a_shape_circle_random_hint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3077  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3078  std::vector< a_point > *arg2 = 0 ;
3079  void *argp1 = 0 ;
3080  int res1 = 0 ;
3081  void *argp2 ;
3082  int res2 = 0 ;
3083 
3084  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_random_hint self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3085  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3086  if (!SWIG_IsOK(res1)) {
3087  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_random_hint" "', argument " "1"" of type '" "a_shape_circle *""'");
3088  }
3089  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3090  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3091  if (!SWIG_IsOK(res2)) {
3092  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
3093  }
3094  if (!argp2) {
3095  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
3096  }
3097  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
3098  (arg1)->random_hint((std::vector< a_point > const &)*arg2);
3099 
3100  return TCL_OK;
3101 fail:
3102  return TCL_ERROR;
3103 }
3104 
3105 
3106 SWIGINTERN int
3107 _wrap_a_shape_circle_fit_cloud__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3108  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3109  std::vector< a_point > *arg2 = 0 ;
3110  short arg3 ;
3111  void *argp1 = 0 ;
3112  int res1 = 0 ;
3113  void *argp2 = 0 ;
3114  int res2 = 0 ;
3115  short val3 ;
3116  int ecode3 = 0 ;
3117 
3118  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_circle_fit_cloud self pts nl ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3119  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3120  if (!SWIG_IsOK(res1)) {
3121  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_fit_cloud" "', argument " "1"" of type '" "a_shape_circle *""'");
3122  }
3123  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3124  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3125  if (!SWIG_IsOK(res2)) {
3126  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
3127  }
3128  if (!argp2) {
3129  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
3130  }
3131  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
3132  ecode3 = SWIG_AsVal_short SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3133  if (!SWIG_IsOK(ecode3)) {
3134  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_shape_circle_fit_cloud" "', argument " "3"" of type '" "short""'");
3135  }
3136  arg3 = static_cast< short >(val3);
3137  (arg1)->fit_cloud(*arg2,arg3);
3138 
3139  return TCL_OK;
3140 fail:
3141  return TCL_ERROR;
3142 }
3143 
3144 
3145 SWIGINTERN int
3146 _wrap_a_shape_circle_fit_cloud__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3147  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3148  std::vector< a_point > *arg2 = 0 ;
3149  void *argp1 = 0 ;
3150  int res1 = 0 ;
3151  void *argp2 = 0 ;
3152  int res2 = 0 ;
3153 
3154  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_circle_fit_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3155  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3156  if (!SWIG_IsOK(res1)) {
3157  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_fit_cloud" "', argument " "1"" of type '" "a_shape_circle *""'");
3158  }
3159  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3160  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3161  if (!SWIG_IsOK(res2)) {
3162  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_circle_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
3163  }
3164  if (!argp2) {
3165  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
3166  }
3167  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
3168  (arg1)->fit_cloud(*arg2);
3169 
3170  return TCL_OK;
3171 fail:
3172  return TCL_ERROR;
3173 }
3174 
3175 
3176 SWIGINTERN int
3177 _wrap_a_shape_circle_fit_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3178  Tcl_Obj *CONST *argv = objv+1;
3179  int argc = objc-1;
3180  if (argc == 2) {
3181  int _v;
3182  void *vptr = 0;
3183  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
3184  _v = SWIG_CheckState(res);
3185  if (_v) {
3186  void *vptr = 0;
3188  _v = SWIG_CheckState(res);
3189  if (_v) {
3190  return _wrap_a_shape_circle_fit_cloud__SWIG_1(clientData, interp, objc, argv - 1);
3191  }
3192  }
3193  }
3194  if (argc == 3) {
3195  int _v;
3196  void *vptr = 0;
3197  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_circle, 0);
3198  _v = SWIG_CheckState(res);
3199  if (_v) {
3200  void *vptr = 0;
3202  _v = SWIG_CheckState(res);
3203  if (_v) {
3204  {
3205  int res = SWIG_AsVal_short SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3206  _v = SWIG_CheckState(res);
3207  }
3208  if (_v) {
3209  return _wrap_a_shape_circle_fit_cloud__SWIG_0(clientData, interp, objc, argv - 1);
3210  }
3211  }
3212  }
3213  }
3214 
3215  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_circle_fit_cloud'.\n"
3216  " Possible C/C++ prototypes are:\n"
3217  " a_shape_circle::fit_cloud(std::vector< a_point > &,short)\n"
3218  " a_shape_circle::fit_cloud(std::vector< a_point > &)\n", TCL_STATIC);
3219  return TCL_ERROR;
3220 }
3221 
3222 
3223 SWIGINTERN int
3224 _wrap_a_shape_circle_export_points(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3225  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3226  unsigned int arg2 ;
3227  std::vector< a_point > *arg3 = 0 ;
3228  void *argp1 = 0 ;
3229  int res1 = 0 ;
3230  unsigned int val2 ;
3231  int ecode2 = 0 ;
3232  void *argp3 ;
3233  int res3 = 0 ;
3234 
3235  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_circle_export_points self nseg pts ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3236  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3237  if (!SWIG_IsOK(res1)) {
3238  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_export_points" "', argument " "1"" of type '" "a_shape_circle const *""'");
3239  }
3240  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3241  ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3242  if (!SWIG_IsOK(ecode2)) {
3243  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_circle_export_points" "', argument " "2"" of type '" "unsigned int""'");
3244  }
3245  arg2 = static_cast< unsigned int >(val2);
3246  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3247  if (!SWIG_IsOK(res3)) {
3248  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_circle_export_points" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3249  }
3250  if (!argp3) {
3251  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_export_points" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3252  }
3253  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
3254  ((a_shape_circle const *)arg1)->export_points(arg2,(std::vector< a_point > const &)*arg3);
3255 
3256  return TCL_OK;
3257 fail:
3258  return TCL_ERROR;
3259 }
3260 
3261 
3262 SWIGINTERN int
3263 _wrap_a_shape_circle_export_lines(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3264  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3265  unsigned int arg2 ;
3266  std::vector< a_point > *arg3 = 0 ;
3267  void *argp1 = 0 ;
3268  int res1 = 0 ;
3269  unsigned int val2 ;
3270  int ecode2 = 0 ;
3271  void *argp3 ;
3272  int res3 = 0 ;
3273 
3274  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_circle_export_lines self nseg pts ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3275  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, 0 | 0 );
3276  if (!SWIG_IsOK(res1)) {
3277  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_circle_export_lines" "', argument " "1"" of type '" "a_shape_circle const *""'");
3278  }
3279  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3280  ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3281  if (!SWIG_IsOK(ecode2)) {
3282  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_circle_export_lines" "', argument " "2"" of type '" "unsigned int""'");
3283  }
3284  arg2 = static_cast< unsigned int >(val2);
3285  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3286  if (!SWIG_IsOK(res3)) {
3287  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_circle_export_lines" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3288  }
3289  if (!argp3) {
3290  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_circle_export_lines" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3291  }
3292  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
3293  ((a_shape_circle const *)arg1)->export_lines(arg2,(std::vector< a_point > const &)*arg3);
3294 
3295  return TCL_OK;
3296 fail:
3297  return TCL_ERROR;
3298 }
3299 
3300 
3301 SWIGINTERN int
3302 _wrap_delete_a_shape_circle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3303  a_shape_circle *arg1 = (a_shape_circle *) 0 ;
3304  void *argp1 = 0 ;
3305  int res1 = 0 ;
3306 
3307  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_shape_circle self ",(void *)0) == TCL_ERROR) SWIG_fail;
3308  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_circle, SWIG_POINTER_DISOWN | 0 );
3309  if (!SWIG_IsOK(res1)) {
3310  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_shape_circle" "', argument " "1"" of type '" "a_shape_circle *""'");
3311  }
3312  arg1 = reinterpret_cast< a_shape_circle * >(argp1);
3313  delete arg1;
3314 
3315  return TCL_OK;
3316 fail:
3317  return TCL_ERROR;
3318 }
3319 
3320 
3322 a_shape_circle *arg1 = (a_shape_circle *) obj;
3323 delete arg1;
3324 }
3326  {"closest_point", _wrap_a_shape_circle_closest_point},
3327  {"dist_point", _wrap_a_shape_circle_dist_point},
3328  {"p3pts", _wrap_a_shape_circle_p3pts},
3329  {"dir", _wrap_a_shape_circle_dir},
3330  {"orig", _wrap_a_shape_circle_orig},
3331  {"radius", _wrap_a_shape_circle_radius},
3332  {"random_hint", _wrap_a_shape_circle_random_hint},
3333  {"fit_cloud", _wrap_a_shape_circle_fit_cloud},
3334  {"export_points", _wrap_a_shape_circle_export_points},
3335  {"export_lines", _wrap_a_shape_circle_export_lines},
3336  {0,0}
3337 };
3339  {0,0,0}
3340 };
3342 static const char * swig_a_shape_circle_base_names[] = {"a_shape *",0};
3344 SWIGINTERN int
3345 _wrap_a_shape_cylinder_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3346  std::string result;
3347 
3348  if (SWIG_GetArgs(interp, objc, objv,":a_shape_cylinder_help ") == TCL_ERROR) SWIG_fail;
3349  result = a_shape_cylinder::help();
3350  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3351  return TCL_OK;
3352 fail:
3353  return TCL_ERROR;
3354 }
3355 
3356 
3357 SWIGINTERN int
3358 _wrap_new_a_shape_cylinder(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3359  a_shape_cylinder *result = 0 ;
3360 
3361  if (SWIG_GetArgs(interp, objc, objv,":new_a_shape_cylinder ") == TCL_ERROR) SWIG_fail;
3362  result = (a_shape_cylinder *)new a_shape_cylinder();
3363  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_shape_cylinder,0));
3364  return TCL_OK;
3365 fail:
3366  return TCL_ERROR;
3367 }
3368 
3369 
3370 SWIGINTERN int
3371 _wrap_a_shape_cylinder_p9pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3372  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3373  a_point *arg2 = (a_point *) 0 ;
3374  void *argp1 = 0 ;
3375  int res1 = 0 ;
3376  void *argp2 = 0 ;
3377  int res2 = 0 ;
3378 
3379  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_cylinder_p9pts self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3380  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3381  if (!SWIG_IsOK(res1)) {
3382  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_p9pts" "', argument " "1"" of type '" "a_shape_cylinder *""'");
3383  }
3384  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3385  res2 = SWIG_ConvertPtr(objv[2], &argp2,SWIGTYPE_p_a_point, 0 | 0 );
3386  if (!SWIG_IsOK(res2)) {
3387  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_cylinder_p9pts" "', argument " "2"" of type '" "a_point const *""'");
3388  }
3389  arg2 = reinterpret_cast< a_point * >(argp2);
3390  (arg1)->p9pts((a_point const *)arg2);
3391 
3392  return TCL_OK;
3393 fail:
3394  return TCL_ERROR;
3395 }
3396 
3397 
3398 SWIGINTERN int
3399 _wrap_a_shape_cylinder_radius__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3400  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3401  void *argp1 = 0 ;
3402  int res1 = 0 ;
3403  double result;
3404 
3405  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_cylinder_radius self ",(void *)0) == TCL_ERROR) SWIG_fail;
3406  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3407  if (!SWIG_IsOK(res1)) {
3408  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_radius" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3409  }
3410  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3411  result = (double)((a_shape_cylinder const *)arg1)->radius();
3412  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3413  return TCL_OK;
3414 fail:
3415  return TCL_ERROR;
3416 }
3417 
3418 
3419 SWIGINTERN int
3420 _wrap_a_shape_cylinder_radius__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3421  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3422  double arg2 ;
3423  void *argp1 = 0 ;
3424  int res1 = 0 ;
3425  double val2 ;
3426  int ecode2 = 0 ;
3427 
3428  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_cylinder_radius self r ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3429  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3430  if (!SWIG_IsOK(res1)) {
3431  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_radius" "', argument " "1"" of type '" "a_shape_cylinder *""'");
3432  }
3433  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3434  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3435  if (!SWIG_IsOK(ecode2)) {
3436  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_cylinder_radius" "', argument " "2"" of type '" "double""'");
3437  }
3438  arg2 = static_cast< double >(val2);
3439  (arg1)->radius(arg2);
3440 
3441  return TCL_OK;
3442 fail:
3443  return TCL_ERROR;
3444 }
3445 
3446 
3447 SWIGINTERN int
3448 _wrap_a_shape_cylinder_radius(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3449  Tcl_Obj *CONST *argv = objv+1;
3450  int argc = objc-1;
3451  if (argc == 1) {
3452  int _v;
3453  void *vptr = 0;
3454  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3455  _v = SWIG_CheckState(res);
3456  if (_v) {
3457  return _wrap_a_shape_cylinder_radius__SWIG_0(clientData, interp, objc, argv - 1);
3458  }
3459  }
3460  if (argc == 2) {
3461  int _v;
3462  void *vptr = 0;
3463  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3464  _v = SWIG_CheckState(res);
3465  if (_v) {
3466  {
3467  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3468  _v = SWIG_CheckState(res);
3469  }
3470  if (_v) {
3471  return _wrap_a_shape_cylinder_radius__SWIG_1(clientData, interp, objc, argv - 1);
3472  }
3473  }
3474  }
3475 
3476  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_cylinder_radius'.\n"
3477  " Possible C/C++ prototypes are:\n"
3478  " a_shape_cylinder::radius() const\n"
3479  " a_shape_cylinder::radius(double const)\n", TCL_STATIC);
3480  return TCL_ERROR;
3481 }
3482 
3483 
3484 SWIGINTERN int
3485 _wrap_a_shape_cylinder_center__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3486  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3487  void *argp1 = 0 ;
3488  int res1 = 0 ;
3489  a_point result;
3490 
3491  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_cylinder_center self ",(void *)0) == TCL_ERROR) SWIG_fail;
3492  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3493  if (!SWIG_IsOK(res1)) {
3494  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_center" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3495  }
3496  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3497  result = ((a_shape_cylinder const *)arg1)->center();
3498  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3499  return TCL_OK;
3500 fail:
3501  return TCL_ERROR;
3502 }
3503 
3504 
3505 SWIGINTERN int
3506 _wrap_a_shape_cylinder_center__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3507  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3508  a_point arg2 ;
3509  void *argp1 = 0 ;
3510  int res1 = 0 ;
3511  void *argp2 ;
3512  int res2 = 0 ;
3513 
3514  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_cylinder_center self c ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3515  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3516  if (!SWIG_IsOK(res1)) {
3517  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_center" "', argument " "1"" of type '" "a_shape_cylinder *""'");
3518  }
3519  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3520  {
3521  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3522  if (!SWIG_IsOK(res2)) {
3523  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_cylinder_center" "', argument " "2"" of type '" "a_point const""'");
3524  }
3525  if (!argp2) {
3526  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_cylinder_center" "', argument " "2"" of type '" "a_point const""'");
3527  } else {
3528  arg2 = *(reinterpret_cast< a_point * >(argp2));
3529  }
3530  }
3531  (arg1)->center(arg2);
3532 
3533  return TCL_OK;
3534 fail:
3535  return TCL_ERROR;
3536 }
3537 
3538 
3539 SWIGINTERN int
3540 _wrap_a_shape_cylinder_center(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3541  Tcl_Obj *CONST *argv = objv+1;
3542  int argc = objc-1;
3543  if (argc == 1) {
3544  int _v;
3545  void *vptr = 0;
3546  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3547  _v = SWIG_CheckState(res);
3548  if (_v) {
3549  return _wrap_a_shape_cylinder_center__SWIG_0(clientData, interp, objc, argv - 1);
3550  }
3551  }
3552  if (argc == 2) {
3553  int _v;
3554  void *vptr = 0;
3555  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3556  _v = SWIG_CheckState(res);
3557  if (_v) {
3558  void *vptr = 0;
3559  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3560  _v = SWIG_CheckState(res);
3561  if (_v) {
3562  return _wrap_a_shape_cylinder_center__SWIG_1(clientData, interp, objc, argv - 1);
3563  }
3564  }
3565  }
3566 
3567  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_cylinder_center'.\n"
3568  " Possible C/C++ prototypes are:\n"
3569  " a_shape_cylinder::center() const\n"
3570  " a_shape_cylinder::center(a_point const)\n", TCL_STATIC);
3571  return TCL_ERROR;
3572 }
3573 
3574 
3575 SWIGINTERN int
3576 _wrap_a_shape_cylinder_dir__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3577  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3578  void *argp1 = 0 ;
3579  int res1 = 0 ;
3580  a_point result;
3581 
3582  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_cylinder_dir self ",(void *)0) == TCL_ERROR) SWIG_fail;
3583  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3584  if (!SWIG_IsOK(res1)) {
3585  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_dir" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3586  }
3587  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3588  result = ((a_shape_cylinder const *)arg1)->dir();
3589  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3590  return TCL_OK;
3591 fail:
3592  return TCL_ERROR;
3593 }
3594 
3595 
3596 SWIGINTERN int
3597 _wrap_a_shape_cylinder_dir__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3598  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3599  a_point arg2 ;
3600  void *argp1 = 0 ;
3601  int res1 = 0 ;
3602  void *argp2 ;
3603  int res2 = 0 ;
3604 
3605  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_cylinder_dir self d ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3606  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3607  if (!SWIG_IsOK(res1)) {
3608  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_dir" "', argument " "1"" of type '" "a_shape_cylinder *""'");
3609  }
3610  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3611  {
3612  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3613  if (!SWIG_IsOK(res2)) {
3614  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_cylinder_dir" "', argument " "2"" of type '" "a_point const""'");
3615  }
3616  if (!argp2) {
3617  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_cylinder_dir" "', argument " "2"" of type '" "a_point const""'");
3618  } else {
3619  arg2 = *(reinterpret_cast< a_point * >(argp2));
3620  }
3621  }
3622  (arg1)->dir(arg2);
3623 
3624  return TCL_OK;
3625 fail:
3626  return TCL_ERROR;
3627 }
3628 
3629 
3630 SWIGINTERN int
3631 _wrap_a_shape_cylinder_dir(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3632  Tcl_Obj *CONST *argv = objv+1;
3633  int argc = objc-1;
3634  if (argc == 1) {
3635  int _v;
3636  void *vptr = 0;
3637  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3638  _v = SWIG_CheckState(res);
3639  if (_v) {
3640  return _wrap_a_shape_cylinder_dir__SWIG_0(clientData, interp, objc, argv - 1);
3641  }
3642  }
3643  if (argc == 2) {
3644  int _v;
3645  void *vptr = 0;
3646  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_cylinder, 0);
3647  _v = SWIG_CheckState(res);
3648  if (_v) {
3649  void *vptr = 0;
3650  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3651  _v = SWIG_CheckState(res);
3652  if (_v) {
3653  return _wrap_a_shape_cylinder_dir__SWIG_1(clientData, interp, objc, argv - 1);
3654  }
3655  }
3656  }
3657 
3658  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_cylinder_dir'.\n"
3659  " Possible C/C++ prototypes are:\n"
3660  " a_shape_cylinder::dir() const\n"
3661  " a_shape_cylinder::dir(a_point const)\n", TCL_STATIC);
3662  return TCL_ERROR;
3663 }
3664 
3665 
3666 SWIGINTERN int
3667 _wrap_a_shape_cylinder_closest_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3668  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3669  a_point arg2 ;
3670  void *argp1 = 0 ;
3671  int res1 = 0 ;
3672  void *argp2 ;
3673  int res2 = 0 ;
3674  a_point result;
3675 
3676  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_cylinder_closest_point self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3677  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3678  if (!SWIG_IsOK(res1)) {
3679  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_closest_point" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3680  }
3681  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3682  {
3683  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3684  if (!SWIG_IsOK(res2)) {
3685  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_cylinder_closest_point" "', argument " "2"" of type '" "a_point const""'");
3686  }
3687  if (!argp2) {
3688  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_cylinder_closest_point" "', argument " "2"" of type '" "a_point const""'");
3689  } else {
3690  arg2 = *(reinterpret_cast< a_point * >(argp2));
3691  }
3692  }
3693  result = ((a_shape_cylinder const *)arg1)->closest_point(arg2);
3694  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3695  return TCL_OK;
3696 fail:
3697  return TCL_ERROR;
3698 }
3699 
3700 
3701 SWIGINTERN int
3702 _wrap_a_shape_cylinder_export_points(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3703  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3704  unsigned int arg2 ;
3705  std::vector< a_point > *arg3 = 0 ;
3706  void *argp1 = 0 ;
3707  int res1 = 0 ;
3708  unsigned int val2 ;
3709  int ecode2 = 0 ;
3710  void *argp3 ;
3711  int res3 = 0 ;
3712 
3713  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_cylinder_export_points self nseg pts ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3714  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3715  if (!SWIG_IsOK(res1)) {
3716  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_export_points" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3717  }
3718  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3719  ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3720  if (!SWIG_IsOK(ecode2)) {
3721  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_cylinder_export_points" "', argument " "2"" of type '" "unsigned int""'");
3722  }
3723  arg2 = static_cast< unsigned int >(val2);
3724  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3725  if (!SWIG_IsOK(res3)) {
3726  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_cylinder_export_points" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3727  }
3728  if (!argp3) {
3729  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_cylinder_export_points" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3730  }
3731  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
3732  ((a_shape_cylinder const *)arg1)->export_points(arg2,(std::vector< a_point > const &)*arg3);
3733 
3734  return TCL_OK;
3735 fail:
3736  return TCL_ERROR;
3737 }
3738 
3739 
3740 SWIGINTERN int
3741 _wrap_a_shape_cylinder_export_triangles(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3742  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3743  unsigned int arg2 ;
3744  std::vector< a_point > *arg3 = 0 ;
3745  void *argp1 = 0 ;
3746  int res1 = 0 ;
3747  unsigned int val2 ;
3748  int ecode2 = 0 ;
3749  void *argp3 ;
3750  int res3 = 0 ;
3751 
3752  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_cylinder_export_triangles self nseg pts ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3753  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, 0 | 0 );
3754  if (!SWIG_IsOK(res1)) {
3755  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_cylinder_export_triangles" "', argument " "1"" of type '" "a_shape_cylinder const *""'");
3756  }
3757  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3758  ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3759  if (!SWIG_IsOK(ecode2)) {
3760  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_cylinder_export_triangles" "', argument " "2"" of type '" "unsigned int""'");
3761  }
3762  arg2 = static_cast< unsigned int >(val2);
3763  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
3764  if (!SWIG_IsOK(res3)) {
3765  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_cylinder_export_triangles" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3766  }
3767  if (!argp3) {
3768  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_cylinder_export_triangles" "', argument " "3"" of type '" "std::vector< a_point > const &""'");
3769  }
3770  arg3 = reinterpret_cast< std::vector< a_point > * >(argp3);
3771  ((a_shape_cylinder const *)arg1)->export_triangles(arg2,(std::vector< a_point > const &)*arg3);
3772 
3773  return TCL_OK;
3774 fail:
3775  return TCL_ERROR;
3776 }
3777 
3778 
3779 SWIGINTERN int
3780 _wrap_delete_a_shape_cylinder(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3781  a_shape_cylinder *arg1 = (a_shape_cylinder *) 0 ;
3782  void *argp1 = 0 ;
3783  int res1 = 0 ;
3784 
3785  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_shape_cylinder self ",(void *)0) == TCL_ERROR) SWIG_fail;
3786  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_cylinder, SWIG_POINTER_DISOWN | 0 );
3787  if (!SWIG_IsOK(res1)) {
3788  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_shape_cylinder" "', argument " "1"" of type '" "a_shape_cylinder *""'");
3789  }
3790  arg1 = reinterpret_cast< a_shape_cylinder * >(argp1);
3791  delete arg1;
3792 
3793  return TCL_OK;
3794 fail:
3795  return TCL_ERROR;
3796 }
3797 
3798 
3800 a_shape_cylinder *arg1 = (a_shape_cylinder *) obj;
3801 delete arg1;
3802 }
3804  {"p9pts", _wrap_a_shape_cylinder_p9pts},
3805  {"radius", _wrap_a_shape_cylinder_radius},
3806  {"center", _wrap_a_shape_cylinder_center},
3807  {"dir", _wrap_a_shape_cylinder_dir},
3808  {"closest_point", _wrap_a_shape_cylinder_closest_point},
3809  {"export_points", _wrap_a_shape_cylinder_export_points},
3810  {"export_triangles", _wrap_a_shape_cylinder_export_triangles},
3811  {0,0}
3812 };
3814  {0,0,0}
3815 };
3817 static const char * swig_a_shape_cylinder_base_names[] = {0};
3819 SWIGINTERN int
3820 _wrap_a_shape_line_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3821  std::string result;
3822 
3823  if (SWIG_GetArgs(interp, objc, objv,":a_shape_line_help ") == TCL_ERROR) SWIG_fail;
3824  result = a_shape_line::help();
3825  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3826  return TCL_OK;
3827 fail:
3828  return TCL_ERROR;
3829 }
3830 
3831 
3832 SWIGINTERN int
3833 _wrap_new_a_shape_line(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3834  a_shape_line *result = 0 ;
3835 
3836  if (SWIG_GetArgs(interp, objc, objv,":new_a_shape_line ") == TCL_ERROR) SWIG_fail;
3837  result = (a_shape_line *)new a_shape_line();
3838  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_shape_line,0));
3839  return TCL_OK;
3840 fail:
3841  return TCL_ERROR;
3842 }
3843 
3844 
3845 SWIGINTERN int
3846 _wrap_a_shape_line_closest_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3847  a_shape_line *arg1 = (a_shape_line *) 0 ;
3848  a_point arg2 ;
3849  void *argp1 = 0 ;
3850  int res1 = 0 ;
3851  void *argp2 ;
3852  int res2 = 0 ;
3853  a_point result;
3854 
3855  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_closest_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3856  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
3857  if (!SWIG_IsOK(res1)) {
3858  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_closest_point" "', argument " "1"" of type '" "a_shape_line const *""'");
3859  }
3860  arg1 = reinterpret_cast< a_shape_line * >(argp1);
3861  {
3862  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3863  if (!SWIG_IsOK(res2)) {
3864  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_closest_point" "', argument " "2"" of type '" "a_point const""'");
3865  }
3866  if (!argp2) {
3867  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_closest_point" "', argument " "2"" of type '" "a_point const""'");
3868  } else {
3869  arg2 = *(reinterpret_cast< a_point * >(argp2));
3870  }
3871  }
3872  result = ((a_shape_line const *)arg1)->closest_point(arg2);
3873  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3874  return TCL_OK;
3875 fail:
3876  return TCL_ERROR;
3877 }
3878 
3879 
3880 SWIGINTERN int
3881 _wrap_a_shape_line_dist_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3882  a_shape_line *arg1 = (a_shape_line *) 0 ;
3883  a_point arg2 ;
3884  void *argp1 = 0 ;
3885  int res1 = 0 ;
3886  void *argp2 ;
3887  int res2 = 0 ;
3888  double result;
3889 
3890  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_dist_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3891  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
3892  if (!SWIG_IsOK(res1)) {
3893  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_dist_point" "', argument " "1"" of type '" "a_shape_line const *""'");
3894  }
3895  arg1 = reinterpret_cast< a_shape_line * >(argp1);
3896  {
3897  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3898  if (!SWIG_IsOK(res2)) {
3899  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_dist_point" "', argument " "2"" of type '" "a_point const""'");
3900  }
3901  if (!argp2) {
3902  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_dist_point" "', argument " "2"" of type '" "a_point const""'");
3903  } else {
3904  arg2 = *(reinterpret_cast< a_point * >(argp2));
3905  }
3906  }
3907  result = (double)((a_shape_line const *)arg1)->dist_point(arg2);
3908  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3909  return TCL_OK;
3910 fail:
3911  return TCL_ERROR;
3912 }
3913 
3914 
3915 SWIGINTERN int
3916 _wrap_a_shape_line_p2pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3917  a_shape_line *arg1 = (a_shape_line *) 0 ;
3918  a_point arg2 ;
3919  a_point arg3 ;
3920  void *argp1 = 0 ;
3921  int res1 = 0 ;
3922  void *argp2 ;
3923  int res2 = 0 ;
3924  void *argp3 ;
3925  int res3 = 0 ;
3926 
3927  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_line_p2pts self p1 p2 ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3928  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
3929  if (!SWIG_IsOK(res1)) {
3930  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_p2pts" "', argument " "1"" of type '" "a_shape_line *""'");
3931  }
3932  arg1 = reinterpret_cast< a_shape_line * >(argp1);
3933  {
3934  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3935  if (!SWIG_IsOK(res2)) {
3936  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_p2pts" "', argument " "2"" of type '" "a_point const""'");
3937  }
3938  if (!argp2) {
3939  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_p2pts" "', argument " "2"" of type '" "a_point const""'");
3940  } else {
3941  arg2 = *(reinterpret_cast< a_point * >(argp2));
3942  }
3943  }
3944  {
3945  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
3946  if (!SWIG_IsOK(res3)) {
3947  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_line_p2pts" "', argument " "3"" of type '" "a_point const""'");
3948  }
3949  if (!argp3) {
3950  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_p2pts" "', argument " "3"" of type '" "a_point const""'");
3951  } else {
3952  arg3 = *(reinterpret_cast< a_point * >(argp3));
3953  }
3954  }
3955  (arg1)->p2pts(arg2,arg3);
3956 
3957  return TCL_OK;
3958 fail:
3959  return TCL_ERROR;
3960 }
3961 
3962 
3963 SWIGINTERN int
3964 _wrap_a_shape_line_dir__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3965  a_shape_line *arg1 = (a_shape_line *) 0 ;
3966  void *argp1 = 0 ;
3967  int res1 = 0 ;
3968  a_point result;
3969 
3970  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_line_dir self ",(void *)0) == TCL_ERROR) SWIG_fail;
3971  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
3972  if (!SWIG_IsOK(res1)) {
3973  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_dir" "', argument " "1"" of type '" "a_shape_line const *""'");
3974  }
3975  arg1 = reinterpret_cast< a_shape_line * >(argp1);
3976  result = ((a_shape_line const *)arg1)->dir();
3977  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3978  return TCL_OK;
3979 fail:
3980  return TCL_ERROR;
3981 }
3982 
3983 
3984 SWIGINTERN int
3985 _wrap_a_shape_line_orig__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3986  a_shape_line *arg1 = (a_shape_line *) 0 ;
3987  void *argp1 = 0 ;
3988  int res1 = 0 ;
3989  a_point result;
3990 
3991  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_line_orig self ",(void *)0) == TCL_ERROR) SWIG_fail;
3992  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
3993  if (!SWIG_IsOK(res1)) {
3994  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_orig" "', argument " "1"" of type '" "a_shape_line const *""'");
3995  }
3996  arg1 = reinterpret_cast< a_shape_line * >(argp1);
3997  result = ((a_shape_line const *)arg1)->orig();
3998  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3999  return TCL_OK;
4000 fail:
4001  return TCL_ERROR;
4002 }
4003 
4004 
4005 SWIGINTERN int
4006 _wrap_a_shape_line_dir__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4007  a_shape_line *arg1 = (a_shape_line *) 0 ;
4008  a_point arg2 ;
4009  void *argp1 = 0 ;
4010  int res1 = 0 ;
4011  void *argp2 ;
4012  int res2 = 0 ;
4013 
4014  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_dir self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4015  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4016  if (!SWIG_IsOK(res1)) {
4017  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_dir" "', argument " "1"" of type '" "a_shape_line *""'");
4018  }
4019  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4020  {
4021  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4022  if (!SWIG_IsOK(res2)) {
4023  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_dir" "', argument " "2"" of type '" "a_point const""'");
4024  }
4025  if (!argp2) {
4026  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_dir" "', argument " "2"" of type '" "a_point const""'");
4027  } else {
4028  arg2 = *(reinterpret_cast< a_point * >(argp2));
4029  }
4030  }
4031  (arg1)->dir(arg2);
4032 
4033  return TCL_OK;
4034 fail:
4035  return TCL_ERROR;
4036 }
4037 
4038 
4039 SWIGINTERN int
4040 _wrap_a_shape_line_dir(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4041  Tcl_Obj *CONST *argv = objv+1;
4042  int argc = objc-1;
4043  if (argc == 1) {
4044  int _v;
4045  void *vptr = 0;
4046  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4047  _v = SWIG_CheckState(res);
4048  if (_v) {
4049  return _wrap_a_shape_line_dir__SWIG_0(clientData, interp, objc, argv - 1);
4050  }
4051  }
4052  if (argc == 2) {
4053  int _v;
4054  void *vptr = 0;
4055  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4056  _v = SWIG_CheckState(res);
4057  if (_v) {
4058  void *vptr = 0;
4059  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4060  _v = SWIG_CheckState(res);
4061  if (_v) {
4062  return _wrap_a_shape_line_dir__SWIG_1(clientData, interp, objc, argv - 1);
4063  }
4064  }
4065  }
4066 
4067  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_line_dir'.\n"
4068  " Possible C/C++ prototypes are:\n"
4069  " a_shape_line::dir() const\n"
4070  " a_shape_line::dir(a_point const)\n", TCL_STATIC);
4071  return TCL_ERROR;
4072 }
4073 
4074 
4075 SWIGINTERN int
4076 _wrap_a_shape_line_orig__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4077  a_shape_line *arg1 = (a_shape_line *) 0 ;
4078  a_point arg2 ;
4079  void *argp1 = 0 ;
4080  int res1 = 0 ;
4081  void *argp2 ;
4082  int res2 = 0 ;
4083 
4084  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_orig self pt ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4085  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4086  if (!SWIG_IsOK(res1)) {
4087  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_orig" "', argument " "1"" of type '" "a_shape_line *""'");
4088  }
4089  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4090  {
4091  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4092  if (!SWIG_IsOK(res2)) {
4093  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_orig" "', argument " "2"" of type '" "a_point const""'");
4094  }
4095  if (!argp2) {
4096  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_orig" "', argument " "2"" of type '" "a_point const""'");
4097  } else {
4098  arg2 = *(reinterpret_cast< a_point * >(argp2));
4099  }
4100  }
4101  (arg1)->orig(arg2);
4102 
4103  return TCL_OK;
4104 fail:
4105  return TCL_ERROR;
4106 }
4107 
4108 
4109 SWIGINTERN int
4110 _wrap_a_shape_line_orig(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4111  Tcl_Obj *CONST *argv = objv+1;
4112  int argc = objc-1;
4113  if (argc == 1) {
4114  int _v;
4115  void *vptr = 0;
4116  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4117  _v = SWIG_CheckState(res);
4118  if (_v) {
4119  return _wrap_a_shape_line_orig__SWIG_0(clientData, interp, objc, argv - 1);
4120  }
4121  }
4122  if (argc == 2) {
4123  int _v;
4124  void *vptr = 0;
4125  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4126  _v = SWIG_CheckState(res);
4127  if (_v) {
4128  void *vptr = 0;
4129  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4130  _v = SWIG_CheckState(res);
4131  if (_v) {
4132  return _wrap_a_shape_line_orig__SWIG_1(clientData, interp, objc, argv - 1);
4133  }
4134  }
4135  }
4136 
4137  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_line_orig'.\n"
4138  " Possible C/C++ prototypes are:\n"
4139  " a_shape_line::orig() const\n"
4140  " a_shape_line::orig(a_point const)\n", TCL_STATIC);
4141  return TCL_ERROR;
4142 }
4143 
4144 
4145 SWIGINTERN int
4146 _wrap_a_shape_line_random_hint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4147  a_shape_line *arg1 = (a_shape_line *) 0 ;
4148  std::vector< a_point > *arg2 = 0 ;
4149  void *argp1 = 0 ;
4150  int res1 = 0 ;
4151  void *argp2 ;
4152  int res2 = 0 ;
4153 
4154  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_random_hint self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4155  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4156  if (!SWIG_IsOK(res1)) {
4157  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_random_hint" "', argument " "1"" of type '" "a_shape_line *""'");
4158  }
4159  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4160  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4161  if (!SWIG_IsOK(res2)) {
4162  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4163  }
4164  if (!argp2) {
4165  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4166  }
4167  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4168  (arg1)->random_hint((std::vector< a_point > const &)*arg2);
4169 
4170  return TCL_OK;
4171 fail:
4172  return TCL_ERROR;
4173 }
4174 
4175 
4176 SWIGINTERN int
4177 _wrap_a_shape_line_fit_cloud__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4178  a_shape_line *arg1 = (a_shape_line *) 0 ;
4179  std::vector< a_point > *arg2 = 0 ;
4180  short arg3 ;
4181  void *argp1 = 0 ;
4182  int res1 = 0 ;
4183  void *argp2 = 0 ;
4184  int res2 = 0 ;
4185  short val3 ;
4186  int ecode3 = 0 ;
4187 
4188  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_shape_line_fit_cloud self pts nl ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4189  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4190  if (!SWIG_IsOK(res1)) {
4191  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_fit_cloud" "', argument " "1"" of type '" "a_shape_line *""'");
4192  }
4193  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4194  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4195  if (!SWIG_IsOK(res2)) {
4196  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4197  }
4198  if (!argp2) {
4199  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4200  }
4201  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4202  ecode3 = SWIG_AsVal_short SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4203  if (!SWIG_IsOK(ecode3)) {
4204  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_shape_line_fit_cloud" "', argument " "3"" of type '" "short""'");
4205  }
4206  arg3 = static_cast< short >(val3);
4207  (arg1)->fit_cloud(*arg2,arg3);
4208 
4209  return TCL_OK;
4210 fail:
4211  return TCL_ERROR;
4212 }
4213 
4214 
4215 SWIGINTERN int
4216 _wrap_a_shape_line_fit_cloud__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4217  a_shape_line *arg1 = (a_shape_line *) 0 ;
4218  std::vector< a_point > *arg2 = 0 ;
4219  void *argp1 = 0 ;
4220  int res1 = 0 ;
4221  void *argp2 = 0 ;
4222  int res2 = 0 ;
4223 
4224  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_fit_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4225  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4226  if (!SWIG_IsOK(res1)) {
4227  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_fit_cloud" "', argument " "1"" of type '" "a_shape_line *""'");
4228  }
4229  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4230  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4231  if (!SWIG_IsOK(res2)) {
4232  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4233  }
4234  if (!argp2) {
4235  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4236  }
4237  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4238  (arg1)->fit_cloud(*arg2);
4239 
4240  return TCL_OK;
4241 fail:
4242  return TCL_ERROR;
4243 }
4244 
4245 
4246 SWIGINTERN int
4247 _wrap_a_shape_line_fit_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4248  Tcl_Obj *CONST *argv = objv+1;
4249  int argc = objc-1;
4250  if (argc == 2) {
4251  int _v;
4252  void *vptr = 0;
4253  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4254  _v = SWIG_CheckState(res);
4255  if (_v) {
4256  void *vptr = 0;
4258  _v = SWIG_CheckState(res);
4259  if (_v) {
4260  return _wrap_a_shape_line_fit_cloud__SWIG_1(clientData, interp, objc, argv - 1);
4261  }
4262  }
4263  }
4264  if (argc == 3) {
4265  int _v;
4266  void *vptr = 0;
4267  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_line, 0);
4268  _v = SWIG_CheckState(res);
4269  if (_v) {
4270  void *vptr = 0;
4272  _v = SWIG_CheckState(res);
4273  if (_v) {
4274  {
4275  int res = SWIG_AsVal_short SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4276  _v = SWIG_CheckState(res);
4277  }
4278  if (_v) {
4279  return _wrap_a_shape_line_fit_cloud__SWIG_0(clientData, interp, objc, argv - 1);
4280  }
4281  }
4282  }
4283  }
4284 
4285  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_line_fit_cloud'.\n"
4286  " Possible C/C++ prototypes are:\n"
4287  " a_shape_line::fit_cloud(std::vector< a_point > &,short)\n"
4288  " a_shape_line::fit_cloud(std::vector< a_point > &)\n", TCL_STATIC);
4289  return TCL_ERROR;
4290 }
4291 
4292 
4293 SWIGINTERN int
4294 _wrap_a_shape_line_export_line(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4295  a_shape_line *arg1 = (a_shape_line *) 0 ;
4296  std::vector< a_point > *arg2 = 0 ;
4297  void *argp1 = 0 ;
4298  int res1 = 0 ;
4299  void *argp2 ;
4300  int res2 = 0 ;
4301 
4302  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_line_export_line self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4303  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, 0 | 0 );
4304  if (!SWIG_IsOK(res1)) {
4305  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_line_export_line" "', argument " "1"" of type '" "a_shape_line const *""'");
4306  }
4307  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4308  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4309  if (!SWIG_IsOK(res2)) {
4310  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_line_export_line" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4311  }
4312  if (!argp2) {
4313  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_line_export_line" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4314  }
4315  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4316  ((a_shape_line const *)arg1)->export_line((std::vector< a_point > const &)*arg2);
4317 
4318  return TCL_OK;
4319 fail:
4320  return TCL_ERROR;
4321 }
4322 
4323 
4324 SWIGINTERN int
4325 _wrap_delete_a_shape_line(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4326  a_shape_line *arg1 = (a_shape_line *) 0 ;
4327  void *argp1 = 0 ;
4328  int res1 = 0 ;
4329 
4330  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_shape_line self ",(void *)0) == TCL_ERROR) SWIG_fail;
4331  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_line, SWIG_POINTER_DISOWN | 0 );
4332  if (!SWIG_IsOK(res1)) {
4333  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_shape_line" "', argument " "1"" of type '" "a_shape_line *""'");
4334  }
4335  arg1 = reinterpret_cast< a_shape_line * >(argp1);
4336  delete arg1;
4337 
4338  return TCL_OK;
4339 fail:
4340  return TCL_ERROR;
4341 }
4342 
4343 
4345 a_shape_line *arg1 = (a_shape_line *) obj;
4346 delete arg1;
4347 }
4349  {"closest_point", _wrap_a_shape_line_closest_point},
4350  {"dist_point", _wrap_a_shape_line_dist_point},
4351  {"p2pts", _wrap_a_shape_line_p2pts},
4352  {"dir", _wrap_a_shape_line_dir},
4353  {"orig", _wrap_a_shape_line_orig},
4354  {"random_hint", _wrap_a_shape_line_random_hint},
4355  {"fit_cloud", _wrap_a_shape_line_fit_cloud},
4356  {"export_line", _wrap_a_shape_line_export_line},
4357  {0,0}
4358 };
4360  {0,0,0}
4361 };
4363 static const char * swig_a_shape_line_base_names[] = {"a_shape *",0};
4365 SWIGINTERN int
4366 _wrap_a_shape_plane_classname(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4367  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4368  void *argp1 = 0 ;
4369  int res1 = 0 ;
4370  std::string result;
4371 
4372  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_classname self ",(void *)0) == TCL_ERROR) SWIG_fail;
4373  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4374  if (!SWIG_IsOK(res1)) {
4375  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_classname" "', argument " "1"" of type '" "a_shape_plane *""'");
4376  }
4377  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4378  result = (arg1)->classname();
4379  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4380  return TCL_OK;
4381 fail:
4382  return TCL_ERROR;
4383 }
4384 
4385 
4386 SWIGINTERN int
4387 _wrap_new_a_shape_plane(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4388  a_shape_plane *result = 0 ;
4389 
4390  if (SWIG_GetArgs(interp, objc, objv,":new_a_shape_plane ") == TCL_ERROR) SWIG_fail;
4391  result = (a_shape_plane *)new a_shape_plane();
4392  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_shape_plane,0));
4393  return TCL_OK;
4394 fail:
4395  return TCL_ERROR;
4396 }
4397 
4398 
4399 SWIGINTERN int
4400 _wrap_a_shape_plane_normal__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4401  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4402  a_point arg2 ;
4403  void *argp1 = 0 ;
4404  int res1 = 0 ;
4405  void *argp2 ;
4406  int res2 = 0 ;
4407 
4408  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_normal self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4409  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4410  if (!SWIG_IsOK(res1)) {
4411  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_normal" "', argument " "1"" of type '" "a_shape_plane *""'");
4412  }
4413  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4414  {
4415  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4416  if (!SWIG_IsOK(res2)) {
4417  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_normal" "', argument " "2"" of type '" "a_point const""'");
4418  }
4419  if (!argp2) {
4420  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_normal" "', argument " "2"" of type '" "a_point const""'");
4421  } else {
4422  arg2 = *(reinterpret_cast< a_point * >(argp2));
4423  }
4424  }
4425  (arg1)->normal(arg2);
4426 
4427  return TCL_OK;
4428 fail:
4429  return TCL_ERROR;
4430 }
4431 
4432 
4433 SWIGINTERN int
4434 _wrap_a_shape_plane_normal__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4435  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4436  void *argp1 = 0 ;
4437  int res1 = 0 ;
4438  a_point result;
4439 
4440  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_normal self ",(void *)0) == TCL_ERROR) SWIG_fail;
4441  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4442  if (!SWIG_IsOK(res1)) {
4443  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_normal" "', argument " "1"" of type '" "a_shape_plane const *""'");
4444  }
4445  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4446  result = ((a_shape_plane const *)arg1)->normal();
4447  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
4448  return TCL_OK;
4449 fail:
4450  return TCL_ERROR;
4451 }
4452 
4453 
4454 SWIGINTERN int
4455 _wrap_a_shape_plane_normal(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4456  Tcl_Obj *CONST *argv = objv+1;
4457  int argc = objc-1;
4458  if (argc == 1) {
4459  int _v;
4460  void *vptr = 0;
4461  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_plane, 0);
4462  _v = SWIG_CheckState(res);
4463  if (_v) {
4464  return _wrap_a_shape_plane_normal__SWIG_1(clientData, interp, objc, argv - 1);
4465  }
4466  }
4467  if (argc == 2) {
4468  int _v;
4469  void *vptr = 0;
4470  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_plane, 0);
4471  _v = SWIG_CheckState(res);
4472  if (_v) {
4473  void *vptr = 0;
4474  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4475  _v = SWIG_CheckState(res);
4476  if (_v) {
4477  return _wrap_a_shape_plane_normal__SWIG_0(clientData, interp, objc, argv - 1);
4478  }
4479  }
4480  }
4481 
4482  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_plane_normal'.\n"
4483  " Possible C/C++ prototypes are:\n"
4484  " a_shape_plane::normal(a_point const)\n"
4485  " a_shape_plane::normal() const\n", TCL_STATIC);
4486  return TCL_ERROR;
4487 }
4488 
4489 
4490 SWIGINTERN int
4491 _wrap_a_shape_plane_origin(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4492  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4493  void *argp1 = 0 ;
4494  int res1 = 0 ;
4495  a_point result;
4496 
4497  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_origin self ",(void *)0) == TCL_ERROR) SWIG_fail;
4498  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4499  if (!SWIG_IsOK(res1)) {
4500  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_origin" "', argument " "1"" of type '" "a_shape_plane const *""'");
4501  }
4502  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4503  result = ((a_shape_plane const *)arg1)->origin();
4504  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
4505  return TCL_OK;
4506 fail:
4507  return TCL_ERROR;
4508 }
4509 
4510 
4511 SWIGINTERN int
4512 _wrap_a_shape_plane_normalise(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4513  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4514  void *argp1 = 0 ;
4515  int res1 = 0 ;
4516 
4517  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_normalise self ",(void *)0) == TCL_ERROR) SWIG_fail;
4518  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4519  if (!SWIG_IsOK(res1)) {
4520  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_normalise" "', argument " "1"" of type '" "a_shape_plane *""'");
4521  }
4522  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4523  (arg1)->normalise();
4524 
4525  return TCL_OK;
4526 fail:
4527  return TCL_ERROR;
4528 }
4529 
4530 
4531 SWIGINTERN int
4532 _wrap_a_shape_plane_p3pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4533  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4534  a_point arg2 ;
4535  a_point arg3 ;
4536  a_point arg4 ;
4537  void *argp1 = 0 ;
4538  int res1 = 0 ;
4539  void *argp2 ;
4540  int res2 = 0 ;
4541  void *argp3 ;
4542  int res3 = 0 ;
4543  void *argp4 ;
4544  int res4 = 0 ;
4545 
4546  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_shape_plane_p3pts self p1 p2 p3 ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4547  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4548  if (!SWIG_IsOK(res1)) {
4549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_p3pts" "', argument " "1"" of type '" "a_shape_plane *""'");
4550  }
4551  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4552  {
4553  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4554  if (!SWIG_IsOK(res2)) {
4555  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_p3pts" "', argument " "2"" of type '" "a_point const""'");
4556  }
4557  if (!argp2) {
4558  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_p3pts" "', argument " "2"" of type '" "a_point const""'");
4559  } else {
4560  arg2 = *(reinterpret_cast< a_point * >(argp2));
4561  }
4562  }
4563  {
4564  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4565  if (!SWIG_IsOK(res3)) {
4566  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_plane_p3pts" "', argument " "3"" of type '" "a_point const""'");
4567  }
4568  if (!argp3) {
4569  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_p3pts" "', argument " "3"" of type '" "a_point const""'");
4570  } else {
4571  arg3 = *(reinterpret_cast< a_point * >(argp3));
4572  }
4573  }
4574  {
4575  res4 = SWIG_ConvertPtr(objv[4], &argp4, SWIGTYPE_p_a_point, 0 );
4576  if (!SWIG_IsOK(res4)) {
4577  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "a_shape_plane_p3pts" "', argument " "4"" of type '" "a_point const""'");
4578  }
4579  if (!argp4) {
4580  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_p3pts" "', argument " "4"" of type '" "a_point const""'");
4581  } else {
4582  arg4 = *(reinterpret_cast< a_point * >(argp4));
4583  }
4584  }
4585  (arg1)->p3pts(arg2,arg3,arg4);
4586 
4587  return TCL_OK;
4588 fail:
4589  return TCL_ERROR;
4590 }
4591 
4592 
4593 SWIGINTERN int
4594 _wrap_a_shape_plane_dist__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4595  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4596  void *argp1 = 0 ;
4597  int res1 = 0 ;
4598  double result;
4599 
4600  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_dist self ",(void *)0) == TCL_ERROR) SWIG_fail;
4601  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4602  if (!SWIG_IsOK(res1)) {
4603  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_dist" "', argument " "1"" of type '" "a_shape_plane const *""'");
4604  }
4605  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4606  result = (double)((a_shape_plane const *)arg1)->dist();
4607  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
4608  return TCL_OK;
4609 fail:
4610  return TCL_ERROR;
4611 }
4612 
4613 
4614 SWIGINTERN int
4615 _wrap_a_shape_plane_dist__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4616  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4617  double arg2 ;
4618  void *argp1 = 0 ;
4619  int res1 = 0 ;
4620  double val2 ;
4621  int ecode2 = 0 ;
4622 
4623  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_dist self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4624  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4625  if (!SWIG_IsOK(res1)) {
4626  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_dist" "', argument " "1"" of type '" "a_shape_plane *""'");
4627  }
4628  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4629  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4630  if (!SWIG_IsOK(ecode2)) {
4631  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_shape_plane_dist" "', argument " "2"" of type '" "double""'");
4632  }
4633  arg2 = static_cast< double >(val2);
4634  (arg1)->dist(arg2);
4635 
4636  return TCL_OK;
4637 fail:
4638  return TCL_ERROR;
4639 }
4640 
4641 
4642 SWIGINTERN int
4643 _wrap_a_shape_plane_dist(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4644  Tcl_Obj *CONST *argv = objv+1;
4645  int argc = objc-1;
4646  if (argc == 1) {
4647  int _v;
4648  void *vptr = 0;
4649  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_plane, 0);
4650  _v = SWIG_CheckState(res);
4651  if (_v) {
4652  return _wrap_a_shape_plane_dist__SWIG_0(clientData, interp, objc, argv - 1);
4653  }
4654  }
4655  if (argc == 2) {
4656  int _v;
4657  void *vptr = 0;
4658  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_shape_plane, 0);
4659  _v = SWIG_CheckState(res);
4660  if (_v) {
4661  {
4662  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4663  _v = SWIG_CheckState(res);
4664  }
4665  if (_v) {
4666  return _wrap_a_shape_plane_dist__SWIG_1(clientData, interp, objc, argv - 1);
4667  }
4668  }
4669  }
4670 
4671  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_shape_plane_dist'.\n"
4672  " Possible C/C++ prototypes are:\n"
4673  " a_shape_plane::dist() const\n"
4674  " a_shape_plane::dist(double const)\n", TCL_STATIC);
4675  return TCL_ERROR;
4676 }
4677 
4678 
4679 SWIGINTERN int
4680 _wrap_a_shape_plane_closest_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4681  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4682  a_point arg2 ;
4683  void *argp1 = 0 ;
4684  int res1 = 0 ;
4685  void *argp2 ;
4686  int res2 = 0 ;
4687  a_point result;
4688 
4689  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_closest_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4690  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4691  if (!SWIG_IsOK(res1)) {
4692  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_closest_point" "', argument " "1"" of type '" "a_shape_plane const *""'");
4693  }
4694  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4695  {
4696  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4697  if (!SWIG_IsOK(res2)) {
4698  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_closest_point" "', argument " "2"" of type '" "a_point const""'");
4699  }
4700  if (!argp2) {
4701  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_closest_point" "', argument " "2"" of type '" "a_point const""'");
4702  } else {
4703  arg2 = *(reinterpret_cast< a_point * >(argp2));
4704  }
4705  }
4706  result = ((a_shape_plane const *)arg1)->closest_point(arg2);
4707  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
4708  return TCL_OK;
4709 fail:
4710  return TCL_ERROR;
4711 }
4712 
4713 
4714 SWIGINTERN int
4715 _wrap_a_shape_plane_dist_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4716  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4717  a_point arg2 ;
4718  void *argp1 = 0 ;
4719  int res1 = 0 ;
4720  void *argp2 ;
4721  int res2 = 0 ;
4722  double result;
4723 
4724  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_dist_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4725  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4726  if (!SWIG_IsOK(res1)) {
4727  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_dist_point" "', argument " "1"" of type '" "a_shape_plane const *""'");
4728  }
4729  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4730  {
4731  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4732  if (!SWIG_IsOK(res2)) {
4733  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_dist_point" "', argument " "2"" of type '" "a_point""'");
4734  }
4735  if (!argp2) {
4736  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_dist_point" "', argument " "2"" of type '" "a_point""'");
4737  } else {
4738  arg2 = *(reinterpret_cast< a_point * >(argp2));
4739  }
4740  }
4741  result = (double)((a_shape_plane const *)arg1)->dist_point(arg2);
4742  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
4743  return TCL_OK;
4744 fail:
4745  return TCL_ERROR;
4746 }
4747 
4748 
4749 SWIGINTERN int
4750 _wrap_a_shape_plane_random_hint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4751  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4752  std::vector< a_point > *arg2 = 0 ;
4753  void *argp1 = 0 ;
4754  int res1 = 0 ;
4755  void *argp2 ;
4756  int res2 = 0 ;
4757 
4758  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_random_hint self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4759  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4760  if (!SWIG_IsOK(res1)) {
4761  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_random_hint" "', argument " "1"" of type '" "a_shape_plane *""'");
4762  }
4763  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4764  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4765  if (!SWIG_IsOK(res2)) {
4766  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4767  }
4768  if (!argp2) {
4769  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_random_hint" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4770  }
4771  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4772  (arg1)->random_hint((std::vector< a_point > const &)*arg2);
4773 
4774  return TCL_OK;
4775 fail:
4776  return TCL_ERROR;
4777 }
4778 
4779 
4780 SWIGINTERN int
4781 _wrap_a_shape_plane_fit_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4782  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4783  std::vector< a_point > *arg2 = 0 ;
4784  void *argp1 = 0 ;
4785  int res1 = 0 ;
4786  void *argp2 = 0 ;
4787  int res2 = 0 ;
4788 
4789  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_fit_cloud self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4790  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4791  if (!SWIG_IsOK(res1)) {
4792  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_fit_cloud" "', argument " "1"" of type '" "a_shape_plane *""'");
4793  }
4794  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4795  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4796  if (!SWIG_IsOK(res2)) {
4797  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4798  }
4799  if (!argp2) {
4800  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_fit_cloud" "', argument " "2"" of type '" "std::vector< a_point > &""'");
4801  }
4802  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4803  (arg1)->fit_cloud(*arg2);
4804 
4805  return TCL_OK;
4806 fail:
4807  return TCL_ERROR;
4808 }
4809 
4810 
4811 SWIGINTERN int
4812 _wrap_a_shape_plane_export_3pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4813  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4814  void *argp1 = 0 ;
4815  int res1 = 0 ;
4816 
4817  if (SWIG_GetArgs(interp, objc, objv,"o:a_shape_plane_export_3pts self ",(void *)0) == TCL_ERROR) SWIG_fail;
4818  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4819  if (!SWIG_IsOK(res1)) {
4820  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_export_3pts" "', argument " "1"" of type '" "a_shape_plane const *""'");
4821  }
4822  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4823  ((a_shape_plane const *)arg1)->export_3pts();
4824 
4825  return TCL_OK;
4826 fail:
4827  return TCL_ERROR;
4828 }
4829 
4830 
4831 SWIGINTERN int
4832 _wrap_a_shape_plane_export_triangles(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4833  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4834  std::vector< a_point > *arg2 = 0 ;
4835  void *argp1 = 0 ;
4836  int res1 = 0 ;
4837  void *argp2 ;
4838  int res2 = 0 ;
4839 
4840  if (SWIG_GetArgs(interp, objc, objv,"oo:a_shape_plane_export_triangles self pts ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4841  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, 0 | 0 );
4842  if (!SWIG_IsOK(res1)) {
4843  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_plane_export_triangles" "', argument " "1"" of type '" "a_shape_plane const *""'");
4844  }
4845  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4846  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__vectorT_a_point_t, 0 );
4847  if (!SWIG_IsOK(res2)) {
4848  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_plane_export_triangles" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4849  }
4850  if (!argp2) {
4851  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_plane_export_triangles" "', argument " "2"" of type '" "std::vector< a_point > const &""'");
4852  }
4853  arg2 = reinterpret_cast< std::vector< a_point > * >(argp2);
4854  ((a_shape_plane const *)arg1)->export_triangles((std::vector< a_point > const &)*arg2);
4855 
4856  return TCL_OK;
4857 fail:
4858  return TCL_ERROR;
4859 }
4860 
4861 
4862 SWIGINTERN int
4863 _wrap_delete_a_shape_plane(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4864  a_shape_plane *arg1 = (a_shape_plane *) 0 ;
4865  void *argp1 = 0 ;
4866  int res1 = 0 ;
4867 
4868  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_shape_plane self ",(void *)0) == TCL_ERROR) SWIG_fail;
4869  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_plane, SWIG_POINTER_DISOWN | 0 );
4870  if (!SWIG_IsOK(res1)) {
4871  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_shape_plane" "', argument " "1"" of type '" "a_shape_plane *""'");
4872  }
4873  arg1 = reinterpret_cast< a_shape_plane * >(argp1);
4874  delete arg1;
4875 
4876  return TCL_OK;
4877 fail:
4878  return TCL_ERROR;
4879 }
4880 
4881 
4883 a_shape_plane *arg1 = (a_shape_plane *) obj;
4884 delete arg1;
4885 }
4887  {"classname", _wrap_a_shape_plane_classname},
4888  {"normal", _wrap_a_shape_plane_normal},
4889  {"origin", _wrap_a_shape_plane_origin},
4890  {"normalise", _wrap_a_shape_plane_normalise},
4891  {"p3pts", _wrap_a_shape_plane_p3pts},
4892  {"dist", _wrap_a_shape_plane_dist},
4893  {"closest_point", _wrap_a_shape_plane_closest_point},
4894  {"dist_point", _wrap_a_shape_plane_dist_point},
4895  {"random_hint", _wrap_a_shape_plane_random_hint},
4896  {"fit_cloud", _wrap_a_shape_plane_fit_cloud},
4897  {"export_3pts", _wrap_a_shape_plane_export_3pts},
4898  {"export_triangles", _wrap_a_shape_plane_export_triangles},
4899  {0,0}
4900 };
4902  {0,0,0}
4903 };
4905 static const char * swig_a_shape_plane_base_names[] = {"a_shape *",0};
4907 SWIGINTERN int
4908 _wrap_new_a_shape_quadric(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4909  a_shape_quadric *result = 0 ;
4910 
4911  if (SWIG_GetArgs(interp, objc, objv,":new_a_shape_quadric ") == TCL_ERROR) SWIG_fail;
4912  result = (a_shape_quadric *)new a_shape_quadric();
4913  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_shape_quadric,0));
4914  return TCL_OK;
4915 fail:
4916  return TCL_ERROR;
4917 }
4918 
4919 
4920 SWIGINTERN int
4921 _wrap_a_shape_quadric_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4922  std::string result;
4923 
4924  if (SWIG_GetArgs(interp, objc, objv,":a_shape_quadric_help ") == TCL_ERROR) SWIG_fail;
4925  result = a_shape_quadric::help();
4926  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4927  return TCL_OK;
4928 fail:
4929  return TCL_ERROR;
4930 }
4931 
4932 
4933 SWIGINTERN int
4934 _wrap_a_shape_quadric_p9pts(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4935  a_shape_quadric *arg1 = (a_shape_quadric *) 0 ;
4936  a_point *arg2 = 0 ;
4937  a_point *arg3 = 0 ;
4938  a_point *arg4 = 0 ;
4939  a_point *arg5 = 0 ;
4940  a_point *arg6 = 0 ;
4941  a_point *arg7 = 0 ;
4942  a_point *arg8 = 0 ;
4943  a_point *arg9 = 0 ;
4944  a_point *arg10 = 0 ;
4945  void *argp1 = 0 ;
4946  int res1 = 0 ;
4947  void *argp2 ;
4948  int res2 = 0 ;
4949  void *argp3 ;
4950  int res3 = 0 ;
4951  void *argp4 ;
4952  int res4 = 0 ;
4953  void *argp5 ;
4954  int res5 = 0 ;
4955  void *argp6 ;
4956  int res6 = 0 ;
4957  void *argp7 ;
4958  int res7 = 0 ;
4959  void *argp8 ;
4960  int res8 = 0 ;
4961  void *argp9 ;
4962  int res9 = 0 ;
4963  void *argp10 ;
4964  int res10 = 0 ;
4965 
4966  if (SWIG_GetArgs(interp, objc, objv,"oooooooooo:a_shape_quadric_p9pts self p1 p2 p3 p4 p5 p6 p7 p8 p9 ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4967  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_shape_quadric, 0 | 0 );
4968  if (!SWIG_IsOK(res1)) {
4969  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_shape_quadric_p9pts" "', argument " "1"" of type '" "a_shape_quadric *""'");
4970  }
4971  arg1 = reinterpret_cast< a_shape_quadric * >(argp1);
4972  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4973  if (!SWIG_IsOK(res2)) {
4974  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_shape_quadric_p9pts" "', argument " "2"" of type '" "a_point const &""'");
4975  }
4976  if (!argp2) {
4977  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_quadric_p9pts" "', argument " "2"" of type '" "a_point const &""'");
4978  }
4979  arg2 = reinterpret_cast< a_point * >(argp2);
4980  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4981  if (!SWIG_IsOK(res3)) {
4982  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_shape_quadric_p9pts" "', argument " "3"" of type '" "a_point const &""'");
4983  }
4984  if (!argp3) {
4985  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_quadric_p9pts" "', argument " "3"" of type '" "a_point const &""'");
4986  }
4987  arg3 = reinterpret_cast< a_point * >(argp3);
4988  res4 = SWIG_ConvertPtr(objv[4], &argp4, SWIGTYPE_p_a_point, 0 );
4989  if (!SWIG_IsOK(res4)) {
4990  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "a_shape_quadric_p9pts" "', argument " "4"" of type '" "a_point const &""'");
4991  }
4992  if (!argp4) {
4993  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_shape_quadric_p9pts" "', argument " "4"" of type '" "a_point const &""'");
4994  }
4995  arg4 = reinterpret_cast< a_point * >(argp4);
4996  res5 = SWIG_ConvertPtr(objv[5], &argp5,