Text file
src/oneml/face/oneml_faceGO_wrap.cxx
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// source: /builds/sertiscorp/mle/edge/oneml/build/bindings/go/face/oneml_face.i
12
13#define SWIGMODULE faceAPI
14
15#ifdef __cplusplus
16/* SwigValueWrapper is described in swig.swg */
17template<typename T> class SwigValueWrapper {
18 struct SwigMovePointer {
19 T *ptr;
20 SwigMovePointer(T *p) : ptr(p) { }
21 ~SwigMovePointer() { delete ptr; }
22 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23 } pointer;
24 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26public:
27 SwigValueWrapper() : pointer(0) { }
28 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29 operator T&() const { return *pointer.ptr; }
30 T *operator&() { return pointer.ptr; }
31};
32
33template <typename T> T SwigValueInit() {
34 return T();
35}
36#endif
37
38/* -----------------------------------------------------------------------------
39 * This section contains generic SWIG labels for method/variable
40 * declarations/attributes, and other compiler dependent labels.
41 * ----------------------------------------------------------------------------- */
42
43/* template workaround for compilers that cannot correctly implement the C++ standard */
44#ifndef SWIGTEMPLATEDISAMBIGUATOR
45# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46# define SWIGTEMPLATEDISAMBIGUATOR template
47# elif defined(__HP_aCC)
48/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50# define SWIGTEMPLATEDISAMBIGUATOR template
51# else
52# define SWIGTEMPLATEDISAMBIGUATOR
53# endif
54#endif
55
56/* inline attribute */
57#ifndef SWIGINLINE
58# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59# define SWIGINLINE inline
60# else
61# define SWIGINLINE
62# endif
63#endif
64
65/* attribute recognised by some compilers to avoid 'unused' warnings */
66#ifndef SWIGUNUSED
67# if defined(__GNUC__)
68# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69# define SWIGUNUSED __attribute__ ((__unused__))
70# else
71# define SWIGUNUSED
72# endif
73# elif defined(__ICC)
74# define SWIGUNUSED __attribute__ ((__unused__))
75# else
76# define SWIGUNUSED
77# endif
78#endif
79
80#ifndef SWIG_MSC_UNSUPPRESS_4505
81# if defined(_MSC_VER)
82# pragma warning(disable : 4505) /* unreferenced local function has been removed */
83# endif
84#endif
85
86#ifndef SWIGUNUSEDPARM
87# ifdef __cplusplus
88# define SWIGUNUSEDPARM(p)
89# else
90# define SWIGUNUSEDPARM(p) p SWIGUNUSED
91# endif
92#endif
93
94/* internal SWIG method */
95#ifndef SWIGINTERN
96# define SWIGINTERN static SWIGUNUSED
97#endif
98
99/* internal inline SWIG method */
100#ifndef SWIGINTERNINLINE
101# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102#endif
103
104/* exporting methods */
105#if defined(__GNUC__)
106# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
107# ifndef GCC_HASCLASSVISIBILITY
108# define GCC_HASCLASSVISIBILITY
109# endif
110# endif
111#endif
112
113#ifndef SWIGEXPORT
114# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
115# if defined(STATIC_LINKED)
116# define SWIGEXPORT
117# else
118# define SWIGEXPORT __declspec(dllexport)
119# endif
120# else
121# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
122# define SWIGEXPORT __attribute__ ((visibility("default")))
123# else
124# define SWIGEXPORT
125# endif
126# endif
127#endif
128
129/* calling conventions for Windows */
130#ifndef SWIGSTDCALL
131# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
132# define SWIGSTDCALL __stdcall
133# else
134# define SWIGSTDCALL
135# endif
136#endif
137
138/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
139#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
140# define _CRT_SECURE_NO_DEPRECATE
141#endif
142
143/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
144#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
145# define _SCL_SECURE_NO_DEPRECATE
146#endif
147
148/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
149#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
150# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
151#endif
152
153/* Intel's compiler complains if a variable which was never initialised is
154 * cast to void, which is a common idiom which we use to indicate that we
155 * are aware a variable isn't used. So we just silence that warning.
156 * See: https://github.com/swig/swig/issues/192 for more discussion.
157 */
158#ifdef __INTEL_COMPILER
159# pragma warning disable 592
160#endif
161
162
163#include <stddef.h>
164#include <stdio.h>
165#include <stdlib.h>
166#include <string.h>
167#include <sys/types.h>
168
169
170
171typedef long long intgo;
172typedef unsigned long long uintgo;
173
174
175# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__))
176# define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__))
177# else
178# define SWIGSTRUCTPACKED __attribute__((__packed__))
179# endif
180
181
182
183typedef struct { char *p; intgo n; } _gostring_;
184typedef struct { void* array; intgo len; intgo cap; } _goslice_;
185
186
187
188
189#define swiggo_size_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
190#define swiggo_size_assert(t, n) swiggo_size_assert_eq(sizeof(t), n, swiggo_sizeof_##t##_is_not_##n)
191
192swiggo_size_assert(char, 1)
193swiggo_size_assert(short, 2)
194swiggo_size_assert(int, 4)
195typedef long long swiggo_long_long;
196swiggo_size_assert(swiggo_long_long, 8)
197swiggo_size_assert(float, 4)
198swiggo_size_assert(double, 8)
199
200#ifdef __cplusplus
201extern "C" {
202#endif
203extern void crosscall2(void (*fn)(void *, int), void *, int);
204extern char* _cgo_topofstack(void) __attribute__ ((weak));
205extern void _cgo_allocate(void *, int);
206extern void _cgo_panic(void *, int);
207#ifdef __cplusplus
208}
209#endif
210
211static char *_swig_topofstack() {
212 if (_cgo_topofstack) {
213 return _cgo_topofstack();
214 } else {
215 return 0;
216 }
217}
218
219static void _swig_gopanic(const char *p) {
220 struct {
221 const char *p;
222 } SWIGSTRUCTPACKED a;
223 a.p = p;
224 crosscall2(_cgo_panic, &a, (int) sizeof a);
225}
226
227
228
229
230#define SWIG_contract_assert(expr, msg) \
231 if (!(expr)) { _swig_gopanic(msg); } else
232
233
234#define SWIG_exception(code, msg) _swig_gopanic(msg)
235
236
237static _gostring_ Swig_AllocateString(const char *p, size_t l) {
238 _gostring_ ret;
239 ret.p = (char*)malloc(l);
240 memcpy(ret.p, p, l);
241 ret.n = l;
242 return ret;
243}
244
245
246static void Swig_free(void* p) {
247 free(p);
248}
249
250static void* Swig_malloc(int c) {
251 return malloc(c);
252}
253
254
255#define SWIG_FILE_WITH_INIT
256#include "oneml/public/oneml_structs.h"
257
258
259#include <vector>
260#include <stdexcept>
261
262
263#include <stdint.h> // Use the C99 official header
264
265
266#include <string>
267
268
269#include <typeinfo>
270#include <stdexcept>
271
272
273#include <utility>
274
275SWIGINTERN std::vector< oneML::Image >::const_reference std_vector_Sl_oneML_Image_Sg__get(std::vector< oneML::Image > *self,int i){
276 int size = int(self->size());
277 if (i>=0 && i<size)
278 return (*self)[i];
279 else
280 throw std::out_of_range("vector index out of range");
281 }
282SWIGINTERN void std_vector_Sl_oneML_Image_Sg__set(std::vector< oneML::Image > *self,int i,std::vector< oneML::Image >::value_type const &val){
283 int size = int(self->size());
284 if (i>=0 && i<size)
285 (*self)[i] = val;
286 else
287 throw std::out_of_range("vector index out of range");
288 }
289SWIGINTERN oneML::Image *new_oneML_Image__SWIG_1(int w,int h,int d,unsigned char *data){
290 oneML::Image* img = new oneML::Image();
291 int size = w*h*d/8;
292 auto ptr = new unsigned char[size];
293 memcpy(ptr, data, size);
294 img->set_width(w);
295 img->set_height(h);
296 img->set_depth(d);
297 img->set_data(reinterpret_cast<uint8_t*>(ptr));
298
299 return img;
300 }
301SWIGINTERN void oneML_Image_go_set_data(oneML::Image *self,unsigned char *data){
302 self->set_data(reinterpret_cast<uint8_t*>(data));
303 }
304SWIGINTERN uint8_t *oneML_Image_go_get_data(oneML::Image *self){
305 return self->get_data().get();
306 }
307
308#include "oneml/public/oneml_face_detector_API.h"
309
310SWIGINTERN std::vector< float >::const_reference std_vector_Sl_float_Sg__get(std::vector< float > *self,int i){
311 int size = int(self->size());
312 if (i>=0 && i<size)
313 return (*self)[i];
314 else
315 throw std::out_of_range("vector index out of range");
316 }
317SWIGINTERN void std_vector_Sl_float_Sg__set(std::vector< float > *self,int i,std::vector< float >::value_type const &val){
318 int size = int(self->size());
319 if (i>=0 && i<size)
320 (*self)[i] = val;
321 else
322 throw std::out_of_range("vector index out of range");
323 }
324SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
325 int size = int(self->size());
326 if (i>=0 && i<size)
327 return (*self)[i];
328 else
329 throw std::out_of_range("vector index out of range");
330 }
331SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
332 int size = int(self->size());
333 if (i>=0 && i<size)
334 (*self)[i] = val;
335 else
336 throw std::out_of_range("vector index out of range");
337 }
338SWIGINTERN std::vector< oneML::BBox >::const_reference std_vector_Sl_oneML_BBox_Sg__get(std::vector< oneML::BBox > *self,int i){
339 int size = int(self->size());
340 if (i>=0 && i<size)
341 return (*self)[i];
342 else
343 throw std::out_of_range("vector index out of range");
344 }
345SWIGINTERN void std_vector_Sl_oneML_BBox_Sg__set(std::vector< oneML::BBox > *self,int i,std::vector< oneML::BBox >::value_type const &val){
346 int size = int(self->size());
347 if (i>=0 && i<size)
348 (*self)[i] = val;
349 else
350 throw std::out_of_range("vector index out of range");
351 }
352SWIGINTERN std::array< float,5 >::const_reference std_array_Sl_float_Sc_5_Sg__get(std::array< float,5 > *self,int i){
353 int size = int(self->size());
354 if (i>=0 && i<size)
355 return (*self)[i];
356 else
357 throw std::out_of_range("array index out of range");
358 }
359SWIGINTERN void std_array_Sl_float_Sc_5_Sg__set(std::array< float,5 > *self,int i,std::array< float,5 >::value_type const &val){
360 int size = int(self->size());
361 if (i>=0 && i<size)
362 (*self)[i] = val;
363 else
364 throw std::out_of_range("array index out of range");
365 }
366SWIGINTERN std::vector< oneML::face::FaceLandmark< 5 > >::const_reference std_vector_Sl_oneML_face_FaceLandmark_Sl_5_Sg__Sg__get(std::vector< oneML::face::FaceLandmark< 5 > > *self,int i){
367 int size = int(self->size());
368 if (i>=0 && i<size)
369 return (*self)[i];
370 else
371 throw std::out_of_range("vector index out of range");
372 }
373SWIGINTERN void std_vector_Sl_oneML_face_FaceLandmark_Sl_5_Sg__Sg__set(std::vector< oneML::face::FaceLandmark< 5 > > *self,int i,std::vector< oneML::face::FaceLandmark< 5 > >::value_type const &val){
374 int size = int(self->size());
375 if (i>=0 && i<size)
376 (*self)[i] = val;
377 else
378 throw std::out_of_range("vector index out of range");
379 }
380SWIGINTERN std::vector< oneML::face::FaceDetectorResult >::const_reference std_vector_Sl_oneML_face_FaceDetectorResult_Sg__get(std::vector< oneML::face::FaceDetectorResult > *self,int i){
381 int size = int(self->size());
382 if (i>=0 && i<size)
383 return (*self)[i];
384 else
385 throw std::out_of_range("vector index out of range");
386 }
387SWIGINTERN void std_vector_Sl_oneML_face_FaceDetectorResult_Sg__set(std::vector< oneML::face::FaceDetectorResult > *self,int i,std::vector< oneML::face::FaceDetectorResult >::value_type const &val){
388 int size = int(self->size());
389 if (i>=0 && i<size)
390 (*self)[i] = val;
391 else
392 throw std::out_of_range("vector index out of range");
393 }
394SWIGINTERN std::vector< float > oneML_face_FaceDetectorResult_go_get_scores(oneML::face::FaceDetectorResult *self){
395 std::vector<float> scores;
396 self->get_scores(scores);
397 return scores;
398 }
399SWIGINTERN std::vector< oneML::face::BBox > oneML_face_FaceDetectorResult_go_get_bboxes(oneML::face::FaceDetectorResult *self){
400 std::vector<oneML::face::BBox> bboxes;
401 self->get_bboxes(bboxes);
402 return bboxes;
403 }
404SWIGINTERN std::vector< oneML::face::FaceLandmark5 > oneML_face_FaceDetectorResult_go_get_landmarks(oneML::face::FaceDetectorResult *self){
405 std::vector<oneML::face::FaceLandmark5> landmarks;
406 self->get_landmarks(landmarks);
407 return landmarks;
408 }
409SWIGINTERN std::vector< int > oneML_face_FaceDetectorResult_go_get_poses(oneML::face::FaceDetectorResult *self){
410 std::vector<oneML::face::Pose> v;
411 self->get_poses(v);
412
413 std::vector<int> poses;
414 poses.reserve(v.size());
415 for (auto & pose : v) {
416 poses.emplace_back(static_cast<int>(pose));
417 }
418 return poses;
419 }
420SWIGINTERN std::vector< int > oneML_face_FaceDetectorResult_go_get_return_status(oneML::face::FaceDetectorResult *self){
421 std::vector<oneML::face::FaceDetectorStatus> v = self->get_return_status();
422
423 std::vector<int> statuses;
424 statuses.reserve(v.size());
425 for (auto & status : v) {
426 statuses.emplace_back(static_cast<int>(status));
427 }
428 return statuses;
429 }
430SWIGINTERN std::vector< oneML::face::FaceDetectorResult > oneML_face_FaceDetector_go_detect_batch__SWIG_0(oneML::face::FaceDetector *self,std::vector< oneML::Image > &images){
431 std::vector<oneML::face::FaceDetectorResult> results;
432 self->detect(images, results);
433 return results;
434 }
435SWIGINTERN std::vector< oneML::face::FaceDetectorResult > oneML_face_FaceDetector_go_detect_batch__SWIG_1(oneML::face::FaceDetector *self,std::vector< oneML::Image > &images,float score_threshold){
436 std::vector<oneML::face::FaceDetectorResult> results;
437 self->detect(images, score_threshold, results);
438 return results;
439 }
440SWIGINTERN oneML::face::FaceDetectorResult oneML_face_FaceDetector_go_detect__SWIG_0(oneML::face::FaceDetector *self,oneML::Image &image){
441 oneML::face::FaceDetectorResult result;
442 self->detect(image, result);
443 return result;
444 }
445SWIGINTERN oneML::face::FaceDetectorResult oneML_face_FaceDetector_go_detect__SWIG_1(oneML::face::FaceDetector *self,oneML::Image &image,float score_threshold){
446 oneML::face::FaceDetectorResult result;
447 self->detect(image, score_threshold, result);
448 return result;
449 }
450
451#include "oneml/public/oneml_face_embedder_API.h"
452
453SWIGINTERN std::array< float,512 >::const_reference std_array_Sl_float_Sc_512_Sg__get(std::array< float,512 > *self,int i){
454 int size = int(self->size());
455 if (i>=0 && i<size)
456 return (*self)[i];
457 else
458 throw std::out_of_range("array index out of range");
459 }
460SWIGINTERN void std_array_Sl_float_Sc_512_Sg__set(std::array< float,512 > *self,int i,std::array< float,512 >::value_type const &val){
461 int size = int(self->size());
462 if (i>=0 && i<size)
463 (*self)[i] = val;
464 else
465 throw std::out_of_range("array index out of range");
466 }
467SWIGINTERN std::vector< oneML::face::FaceEmbedderResult >::const_reference std_vector_Sl_oneML_face_FaceEmbedderResult_Sg__get(std::vector< oneML::face::FaceEmbedderResult > *self,int i){
468 int size = int(self->size());
469 if (i>=0 && i<size)
470 return (*self)[i];
471 else
472 throw std::out_of_range("vector index out of range");
473 }
474SWIGINTERN void std_vector_Sl_oneML_face_FaceEmbedderResult_Sg__set(std::vector< oneML::face::FaceEmbedderResult > *self,int i,std::vector< oneML::face::FaceEmbedderResult >::value_type const &val){
475 int size = int(self->size());
476 if (i>=0 && i<size)
477 (*self)[i] = val;
478 else
479 throw std::out_of_range("vector index out of range");
480 }
481SWIGINTERN oneML::face::Embedding oneML_face_FaceEmbedderResult_go_get_embedding(oneML::face::FaceEmbedderResult *self){
482 oneML::face::Embedding embedding;
483 self->get_embedding(embedding);
484 return embedding;
485 }
486SWIGINTERN int oneML_face_FaceEmbedderResult_go_get_return_status(oneML::face::FaceEmbedderResult *self){
487 auto status = self->get_return_status();
488 return static_cast<int>(status);
489 }
490SWIGINTERN oneML::face::FaceEmbedderResult oneML_face_FaceEmbedder_go_embed__SWIG_0(oneML::face::FaceEmbedder *self,oneML::Image const &image,bool flip=false){
491 oneML::face::FaceEmbedderResult result;
492 self->embed(image, result, flip);
493 return result;
494 }
495SWIGINTERN std::vector< oneML::face::FaceEmbedderResult > oneML_face_FaceEmbedder_go_embed_batch__SWIG_0(oneML::face::FaceEmbedder *self,std::vector< oneML::Image > const &images,bool flip=false){
496 std::vector<oneML::face::FaceEmbedderResult> results;
497 self->embed(images, results, flip);
498 return results;
499 }
500
501#include "oneml/public/oneml_face_id_API.h"
502
503SWIGINTERN std::vector< oneML::face::FaceIdResult >::const_reference std_vector_Sl_oneML_face_FaceIdResult_Sg__get(std::vector< oneML::face::FaceIdResult > *self,int i){
504 int size = int(self->size());
505 if (i>=0 && i<size)
506 return (*self)[i];
507 else
508 throw std::out_of_range("vector index out of range");
509 }
510SWIGINTERN void std_vector_Sl_oneML_face_FaceIdResult_Sg__set(std::vector< oneML::face::FaceIdResult > *self,int i,std::vector< oneML::face::FaceIdResult >::value_type const &val){
511 int size = int(self->size());
512 if (i>=0 && i<size)
513 (*self)[i] = val;
514 else
515 throw std::out_of_range("vector index out of range");
516 }
517SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
518 int size = int(self->size());
519 if (i>=0 && i<size)
520 return (*self)[i];
521 else
522 throw std::out_of_range("vector index out of range");
523 }
524SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
525 int size = int(self->size());
526 if (i>=0 && i<size)
527 (*self)[i] = val;
528 else
529 throw std::out_of_range("vector index out of range");
530 }
531SWIGINTERN std::vector< std::array< float,512 > >::const_reference std_vector_Sl_std_array_Sl_float_Sc_512_Sg__Sg__get(std::vector< std::array< float,512 > > *self,int i){
532 int size = int(self->size());
533 if (i>=0 && i<size)
534 return (*self)[i];
535 else
536 throw std::out_of_range("vector index out of range");
537 }
538SWIGINTERN void std_vector_Sl_std_array_Sl_float_Sc_512_Sg__Sg__set(std::vector< std::array< float,512 > > *self,int i,std::vector< std::array< float,512 > >::value_type const &val){
539 int size = int(self->size());
540 if (i>=0 && i<size)
541 (*self)[i] = val;
542 else
543 throw std::out_of_range("vector index out of range");
544 }
545SWIGINTERN int oneML_face_FaceIdResult_go_get_return_status(oneML::face::FaceIdResult *self){
546 auto status = self->get_return_status();
547 return static_cast<int>(status);
548 }
549SWIGINTERN oneML::face::FaceIdResult oneML_face_FaceId_go_predict__SWIG_0(oneML::face::FaceId *self,oneML::Image const &image){
550 oneML::face::FaceIdResult result;
551 self->predict(image, result);
552 return result;
553 }
554SWIGINTERN oneML::face::FaceIdResult oneML_face_FaceId_go_predict__SWIG_1(oneML::face::FaceId *self,oneML::Image const &image,float same_person_dist_threshold){
555 oneML::face::FaceIdResult result;
556 self->predict(image, same_person_dist_threshold, result);
557 return result;
558 }
559SWIGINTERN std::vector< oneML::face::FaceIdResult > oneML_face_FaceId_go_predict_batch__SWIG_0(oneML::face::FaceId *self,std::vector< oneML::Image > const &images){
560 std::vector<oneML::face::FaceIdResult> results;
561 self->predict(images, results);
562 return results;
563 }
564SWIGINTERN std::vector< oneML::face::FaceIdResult > oneML_face_FaceId_go_predict_batch__SWIG_1(oneML::face::FaceId *self,std::vector< oneML::Image > const &images,float same_person_dist_threshold){
565 std::vector<oneML::face::FaceIdResult> results;
566 self->predict(images, same_person_dist_threshold, results);
567 return results;
568 }
569SWIGINTERN bool oneML_face_FaceId_go_is_the_same_person_img__SWIG_0(oneML::face::FaceId *self,oneML::Image const &img1,oneML::Image const &img2){
570 std::pair<oneML::ReturnStatus, bool> result = self->is_the_same_person(img1, img2);
571 return result.second;
572 }
573SWIGINTERN bool oneML_face_FaceId_go_is_the_same_person_img__SWIG_1(oneML::face::FaceId *self,oneML::Image const &img1,oneML::Image const &img2,float same_person_dist_threshol){
574 std::pair<oneML::ReturnStatus, bool> result = self->is_the_same_person(img1, img2, same_person_dist_threshol);
575 return result.second;
576 }
577SWIGINTERN std::pair< bool,oneML::face::Embedding > oneML_face_FaceId_go_is_the_same_person_emb__SWIG_0(oneML::face::FaceId *self,oneML::face::Embedding &face_emb,oneML::Image &face_img){
578 oneML::face::Embedding img_emb;
579 std::pair<oneML::ReturnStatus, bool> result = self->is_the_same_person(face_emb, face_img, img_emb);
580 return {result.second, img_emb};
581 }
582SWIGINTERN std::pair< bool,oneML::face::Embedding > oneML_face_FaceId_go_is_the_same_person_emb__SWIG_1(oneML::face::FaceId *self,oneML::face::Embedding &face_emb,oneML::Image &face_img,float same_person_dist_threshol){
583 oneML::face::Embedding img_emb;
584 std::pair<oneML::ReturnStatus, bool> result = self->is_the_same_person(face_emb, face_img, same_person_dist_threshol, img_emb);
585 return {result.second, img_emb};
586 }
587SWIGINTERN int oneML_face_FaceId_go_register_id_emb(oneML::face::FaceId *self,std::string const &id,oneML::face::Embedding const &emb){
588 std::pair<oneML::ReturnStatus, int> result = self->register_id_emb(id, emb);
589 return result.second;
590 }
591SWIGINTERN oneML::face::Embedding oneML_face_FaceId_go_register_id_images(oneML::face::FaceId *self,std::string const &id,std::vector< oneML::Image > const &images,bool const &avg_emb){
592 std::pair<oneML::ReturnStatus, oneML::face::Embedding> result = self->register_id_images(id, images, avg_emb);
593 return result.second;
594 }
595SWIGINTERN oneML::face::Embedding oneML_face_FaceId_go_register_id_image(oneML::face::FaceId *self,std::string const &id,oneML::Image const &image){
596 std::pair<oneML::ReturnStatus, oneML::face::Embedding> result = self->register_id_images(id, image);
597 return result.second;
598 }
599SWIGINTERN void oneML_face_FaceId_go_update_embedding_dynamically_img(oneML::face::FaceId *self,std::string const &id,oneML::Image const &img,oneML::face::Embedding const &ori_emb){
600 self->update_embedding_dynamically(id, img, ori_emb);
601 }
602SWIGINTERN void oneML_face_FaceId_go_update_embedding_dynamically_emb(oneML::face::FaceId *self,std::string const &id,oneML::face::Embedding const &probe_emb,oneML::face::Embedding const &ori_emb){
603 self->update_embedding_dynamically(id, probe_emb, ori_emb);
604 }
605SWIGINTERN void oneML_face_FaceId_go_update_embedding(oneML::face::FaceId *self,std::string const &id,oneML::face::Embedding const &emb){
606 self->update_embedding(id, emb);
607 }
608SWIGINTERN void oneML_face_FaceId_go_remove_id(oneML::face::FaceId *self,std::string const &id){
609 self->remove_id(id);
610 }
611SWIGINTERN std::vector< std::string > oneML_face_FaceId_go_get_ids(oneML::face::FaceId *self){
612 std::vector<std::string> ids;
613 self->get_ids(ids);
614 return ids;
615 }
616
617#include "oneml/public/oneml_face_pad_API.h"
618
619SWIGINTERN std::vector< oneML::face::FacePadResult >::const_reference std_vector_Sl_oneML_face_FacePadResult_Sg__get(std::vector< oneML::face::FacePadResult > *self,int i){
620 int size = int(self->size());
621 if (i>=0 && i<size)
622 return (*self)[i];
623 else
624 throw std::out_of_range("vector index out of range");
625 }
626SWIGINTERN void std_vector_Sl_oneML_face_FacePadResult_Sg__set(std::vector< oneML::face::FacePadResult > *self,int i,std::vector< oneML::face::FacePadResult >::value_type const &val){
627 int size = int(self->size());
628 if (i>=0 && i<size)
629 (*self)[i] = val;
630 else
631 throw std::out_of_range("vector index out of range");
632 }
633SWIGINTERN int oneML_face_FacePadResult_go_get_return_status(oneML::face::FacePadResult *self){
634 return static_cast<int>(self->get_return_status());
635 }
636SWIGINTERN std::vector< oneML::face::FacePadResult > oneML_face_FacePad_go_classify_batch__SWIG_0(oneML::face::FacePad *self,std::vector< oneML::Image > &images){
637 std::vector<oneML::face::FacePadResult> results;
638 self->classify(images, results);
639 return results;
640 }
641SWIGINTERN std::vector< oneML::face::FacePadResult > oneML_face_FacePad_go_classify_batch__SWIG_1(oneML::face::FacePad *self,std::vector< oneML::Image > &images,float spoof_threshold){
642 std::vector<oneML::face::FacePadResult> results;
643 self->classify(images, spoof_threshold, results);
644 return results;
645 }
646SWIGINTERN oneML::face::FacePadResult oneML_face_FacePad_go_classify__SWIG_0(oneML::face::FacePad *self,oneML::Image &image){
647 oneML::face::FacePadResult result;
648 self->classify(image, result);
649 return result;
650 }
651SWIGINTERN oneML::face::FacePadResult oneML_face_FacePad_go_classify__SWIG_1(oneML::face::FacePad *self,oneML::Image &image,float spoof_threshold){
652 oneML::face::FacePadResult result;
653 self->classify(image, spoof_threshold, result);
654 return result;
655 }
656
657#include "oneml/public/oneml_utils_API.h"
658
659SWIGINTERN oneML::Image oneML_Utils__crop_align_face_landmark(oneML::Utils *self,oneML::Image &image,oneML::face::FaceLandmark5 &landmark_in){
660 oneML::Image image_out;
661 self->crop_align_face_landmark(image, landmark_in, image_out);
662
663 return image_out;
664 }
665SWIGINTERN oneML::Image oneML_Utils__read_image_cv(oneML::Utils *self,std::string const &img_path){
666 oneML::Image image;
667 self->read_image_cv(img_path, image);
668
669 return image;
670 }
671
672#include "oneml/license/oneml_license_manager.h"
673
674
675#include "oneml/public/oneml_ekyc_API.h"
676
677SWIGINTERN std::vector< oneML::face::BBox > oneML_face_EKYCResult_go_get_bboxes(oneML::face::EKYCResult *self){
678 oneML::face::BBox bbox1, bbox2;
679 self->get_bboxes(bbox1, bbox2);
680 return {bbox1, bbox2};
681 }
682SWIGINTERN std::vector< float > oneML_face_EKYCResult_go_get_bbox_scores(oneML::face::EKYCResult *self){
683 float score1, score2;
684 self->get_bbox_scores(score1, score2);
685 return {score1, score2};
686 }
687SWIGINTERN std::vector< oneML::face::FaceLandmark5 > oneML_face_EKYCResult_go_get_landmarks(oneML::face::EKYCResult *self){
688 oneML::face::FaceLandmark5 landmark1, landmark2;
689 self->get_landmarks(landmark1, landmark2);
690 return {landmark1, landmark2};
691 }
692SWIGINTERN std::vector< int > oneML_face_EKYCResult_go_get_face_poses(oneML::face::EKYCResult *self){
693 oneML::face::Pose pose1, pose2;
694 self->get_face_poses(pose1, pose2);
695 return {static_cast<int>(pose1), static_cast<int>(pose2)};
696 }
697SWIGINTERN int oneML_face_EKYCResult_go_get_return_status(oneML::face::EKYCResult *self){
698 return static_cast<int>(self->get_return_status());
699 }
700SWIGINTERN oneML::face::EKYCResult oneML_face_EKYC_go_run__SWIG_0(oneML::face::EKYC *self,oneML::Image &image1,oneML::Image &image2,oneML::face::EKYCOps const &image1_ops,oneML::face::EKYCOps const &image2_ops){
701 oneML::face::EKYCResult result;
702 self->run(image1, image2, image1_ops, image2_ops, result);
703 return result;
704 }
705SWIGINTERN oneML::face::EKYCResult oneML_face_EKYC_go_run__SWIG_1(oneML::face::EKYC *self,oneML::Image &image1,oneML::Image &image2,oneML::face::EKYCOps const &image1_ops,oneML::face::EKYCOps const &image2_ops,float same_person_dist_threshold){
706 oneML::face::EKYCResult result;
707 self->run(image1, image2, image1_ops, image2_ops, same_person_dist_threshold, result);
708 return result;
709 }
710#ifdef __cplusplus
711extern "C" {
712#endif
713
714void _wrap_Swig_free_face_86f062e835b3dd07(void *_swig_go_0) {
715 void *arg1 = (void *) 0 ;
716
717 arg1 = *(void **)&_swig_go_0;
718
719 Swig_free(arg1);
720
721}
722
723
724void *_wrap_Swig_malloc_face_86f062e835b3dd07(intgo _swig_go_0) {
725 int arg1 ;
726 void *result = 0 ;
727 void *_swig_go_result;
728
729 arg1 = (int)_swig_go_0;
730
731 result = (void *)Swig_malloc(arg1);
732 *(void **)&_swig_go_result = (void *)result;
733 return _swig_go_result;
734}
735
736
737std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_0_face_86f062e835b3dd07() {
738 std::vector< oneML::Image > *result = 0 ;
739 std::vector< oneML::Image > *_swig_go_result;
740
741
742 {
743 try
744 {
745 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >();
746 }
747 catch (const std::invalid_argument& e)
748 {
749 SWIG_exception(SWIG_ValueError, e.what());
750 }
751 catch (const std::out_of_range& e)
752 {
753 SWIG_exception(SWIG_IndexError, e.what());
754 }
755 catch(const std::exception& e)
756 {
757 SWIG_exception(SWIG_RuntimeError, e.what());
758 }
759 }
760 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
761 return _swig_go_result;
762}
763
764
765std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
766 std::vector< oneML::Image >::size_type arg1 ;
767 std::vector< oneML::Image > *result = 0 ;
768 std::vector< oneML::Image > *_swig_go_result;
769
770 arg1 = (size_t)_swig_go_0;
771
772 {
773 try
774 {
775 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >(arg1);
776 }
777 catch (const std::invalid_argument& e)
778 {
779 SWIG_exception(SWIG_ValueError, e.what());
780 }
781 catch (const std::out_of_range& e)
782 {
783 SWIG_exception(SWIG_IndexError, e.what());
784 }
785 catch(const std::exception& e)
786 {
787 SWIG_exception(SWIG_RuntimeError, e.what());
788 }
789 }
790 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
791 return _swig_go_result;
792}
793
794
795std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
796 std::vector< oneML::Image > *arg1 = 0 ;
797 std::vector< oneML::Image > *result = 0 ;
798 std::vector< oneML::Image > *_swig_go_result;
799
800 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
801
802 {
803 try
804 {
805 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >((std::vector< oneML::Image > const &)*arg1);
806 }
807 catch (const std::invalid_argument& e)
808 {
809 SWIG_exception(SWIG_ValueError, e.what());
810 }
811 catch (const std::out_of_range& e)
812 {
813 SWIG_exception(SWIG_IndexError, e.what());
814 }
815 catch(const std::exception& e)
816 {
817 SWIG_exception(SWIG_RuntimeError, e.what());
818 }
819 }
820 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
821 return _swig_go_result;
822}
823
824
825long long _wrap_MultiImage_size_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
826 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
827 std::vector< oneML::Image >::size_type result;
828 long long _swig_go_result;
829
830 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
831
832 {
833 try
834 {
835 result = ((std::vector< oneML::Image > const *)arg1)->size();
836 }
837 catch (const std::invalid_argument& e)
838 {
839 SWIG_exception(SWIG_ValueError, e.what());
840 }
841 catch (const std::out_of_range& e)
842 {
843 SWIG_exception(SWIG_IndexError, e.what());
844 }
845 catch(const std::exception& e)
846 {
847 SWIG_exception(SWIG_RuntimeError, e.what());
848 }
849 }
850 _swig_go_result = result;
851 return _swig_go_result;
852}
853
854
855long long _wrap_MultiImage_capacity_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
856 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
857 std::vector< oneML::Image >::size_type result;
858 long long _swig_go_result;
859
860 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
861
862 {
863 try
864 {
865 result = ((std::vector< oneML::Image > const *)arg1)->capacity();
866 }
867 catch (const std::invalid_argument& e)
868 {
869 SWIG_exception(SWIG_ValueError, e.what());
870 }
871 catch (const std::out_of_range& e)
872 {
873 SWIG_exception(SWIG_IndexError, e.what());
874 }
875 catch(const std::exception& e)
876 {
877 SWIG_exception(SWIG_RuntimeError, e.what());
878 }
879 }
880 _swig_go_result = result;
881 return _swig_go_result;
882}
883
884
885void _wrap_MultiImage_reserve_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0, long long _swig_go_1) {
886 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
887 std::vector< oneML::Image >::size_type arg2 ;
888
889 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
890 arg2 = (size_t)_swig_go_1;
891
892 {
893 try
894 {
895 (arg1)->reserve(arg2);
896 }
897 catch (const std::invalid_argument& e)
898 {
899 SWIG_exception(SWIG_ValueError, e.what());
900 }
901 catch (const std::out_of_range& e)
902 {
903 SWIG_exception(SWIG_IndexError, e.what());
904 }
905 catch(const std::exception& e)
906 {
907 SWIG_exception(SWIG_RuntimeError, e.what());
908 }
909 }
910
911}
912
913
914bool _wrap_MultiImage_isEmpty_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
915 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
916 bool result;
917 bool _swig_go_result;
918
919 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
920
921 {
922 try
923 {
924 result = (bool)((std::vector< oneML::Image > const *)arg1)->empty();
925 }
926 catch (const std::invalid_argument& e)
927 {
928 SWIG_exception(SWIG_ValueError, e.what());
929 }
930 catch (const std::out_of_range& e)
931 {
932 SWIG_exception(SWIG_IndexError, e.what());
933 }
934 catch(const std::exception& e)
935 {
936 SWIG_exception(SWIG_RuntimeError, e.what());
937 }
938 }
939 _swig_go_result = result;
940 return _swig_go_result;
941}
942
943
944void _wrap_MultiImage_clear_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
945 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
946
947 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
948
949 {
950 try
951 {
952 (arg1)->clear();
953 }
954 catch (const std::invalid_argument& e)
955 {
956 SWIG_exception(SWIG_ValueError, e.what());
957 }
958 catch (const std::out_of_range& e)
959 {
960 SWIG_exception(SWIG_IndexError, e.what());
961 }
962 catch(const std::exception& e)
963 {
964 SWIG_exception(SWIG_RuntimeError, e.what());
965 }
966 }
967
968}
969
970
971void _wrap_MultiImage_add_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0, oneML::Image *_swig_go_1) {
972 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
973 std::vector< oneML::Image >::value_type *arg2 = 0 ;
974
975 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
976 arg2 = *(std::vector< oneML::Image >::value_type **)&_swig_go_1;
977
978 {
979 try
980 {
981 (arg1)->push_back((std::vector< oneML::Image >::value_type const &)*arg2);
982 }
983 catch (const std::invalid_argument& e)
984 {
985 SWIG_exception(SWIG_ValueError, e.what());
986 }
987 catch (const std::out_of_range& e)
988 {
989 SWIG_exception(SWIG_IndexError, e.what());
990 }
991 catch(const std::exception& e)
992 {
993 SWIG_exception(SWIG_RuntimeError, e.what());
994 }
995 }
996
997}
998
999
1000oneML::Image *_wrap_MultiImage_get_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0, intgo _swig_go_1) {
1001 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
1002 int arg2 ;
1003 std::vector< oneML::Image >::value_type *result = 0 ;
1004 oneML::Image *_swig_go_result;
1005
1006 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
1007 arg2 = (int)_swig_go_1;
1008
1009 {
1010 try
1011 {
1012 try {
1013 result = (std::vector< oneML::Image >::value_type *) &std_vector_Sl_oneML_Image_Sg__get(arg1,arg2);
1014 } catch(std::out_of_range &_e) {
1015 _swig_gopanic((&_e)->what());
1016 }
1017 }
1018 catch (const std::invalid_argument& e)
1019 {
1020 SWIG_exception(SWIG_ValueError, e.what());
1021 }
1022 catch (const std::out_of_range& e)
1023 {
1024 SWIG_exception(SWIG_IndexError, e.what());
1025 }
1026 catch(const std::exception& e)
1027 {
1028 SWIG_exception(SWIG_RuntimeError, e.what());
1029 }
1030 }
1031 *(std::vector< oneML::Image >::value_type **)&_swig_go_result = result;
1032 return _swig_go_result;
1033}
1034
1035
1036void _wrap_MultiImage_set_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0, intgo _swig_go_1, oneML::Image *_swig_go_2) {
1037 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
1038 int arg2 ;
1039 std::vector< oneML::Image >::value_type *arg3 = 0 ;
1040
1041 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
1042 arg2 = (int)_swig_go_1;
1043 arg3 = *(std::vector< oneML::Image >::value_type **)&_swig_go_2;
1044
1045 {
1046 try
1047 {
1048 try {
1049 std_vector_Sl_oneML_Image_Sg__set(arg1,arg2,(oneML::Image const &)*arg3);
1050 } catch(std::out_of_range &_e) {
1051 _swig_gopanic((&_e)->what());
1052 }
1053 }
1054 catch (const std::invalid_argument& e)
1055 {
1056 SWIG_exception(SWIG_ValueError, e.what());
1057 }
1058 catch (const std::out_of_range& e)
1059 {
1060 SWIG_exception(SWIG_IndexError, e.what());
1061 }
1062 catch(const std::exception& e)
1063 {
1064 SWIG_exception(SWIG_RuntimeError, e.what());
1065 }
1066 }
1067
1068}
1069
1070
1071void _wrap_delete_MultiImage_face_86f062e835b3dd07(std::vector< oneML::Image > *_swig_go_0) {
1072 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
1073
1074 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
1075
1076 {
1077 try
1078 {
1079 delete arg1;
1080 }
1081 catch (const std::invalid_argument& e)
1082 {
1083 SWIG_exception(SWIG_ValueError, e.what());
1084 }
1085 catch (const std::out_of_range& e)
1086 {
1087 SWIG_exception(SWIG_IndexError, e.what());
1088 }
1089 catch(const std::exception& e)
1090 {
1091 SWIG_exception(SWIG_RuntimeError, e.what());
1092 }
1093 }
1094
1095}
1096
1097
1098oneML::Image *_wrap_new_Image__SWIG_0_face_86f062e835b3dd07() {
1099 oneML::Image *result = 0 ;
1100 oneML::Image *_swig_go_result;
1101
1102
1103 {
1104 try
1105 {
1106 result = (oneML::Image *)new oneML::Image();
1107 }
1108 catch (const std::invalid_argument& e)
1109 {
1110 SWIG_exception(SWIG_ValueError, e.what());
1111 }
1112 catch (const std::out_of_range& e)
1113 {
1114 SWIG_exception(SWIG_IndexError, e.what());
1115 }
1116 catch(const std::exception& e)
1117 {
1118 SWIG_exception(SWIG_RuntimeError, e.what());
1119 }
1120 }
1121 *(oneML::Image **)&_swig_go_result = (oneML::Image *)result;
1122 return _swig_go_result;
1123}
1124
1125
1126long long _wrap_Image_size_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1127 oneML::Image *arg1 = (oneML::Image *) 0 ;
1128 size_t result;
1129 long long _swig_go_result;
1130
1131 arg1 = *(oneML::Image **)&_swig_go_0;
1132
1133 {
1134 try
1135 {
1136 result = ((oneML::Image const *)arg1)->size();
1137 }
1138 catch (const std::invalid_argument& e)
1139 {
1140 SWIG_exception(SWIG_ValueError, e.what());
1141 }
1142 catch (const std::out_of_range& e)
1143 {
1144 SWIG_exception(SWIG_IndexError, e.what());
1145 }
1146 catch(const std::exception& e)
1147 {
1148 SWIG_exception(SWIG_RuntimeError, e.what());
1149 }
1150 }
1151 _swig_go_result = result;
1152 return _swig_go_result;
1153}
1154
1155
1156void _wrap_Image_SetWidth_face_86f062e835b3dd07(oneML::Image *_swig_go_0, short _swig_go_1) {
1157 oneML::Image *arg1 = (oneML::Image *) 0 ;
1158 uint16_t arg2 ;
1159
1160 arg1 = *(oneML::Image **)&_swig_go_0;
1161 arg2 = (uint16_t)_swig_go_1;
1162
1163 {
1164 try
1165 {
1166 (arg1)->set_width(arg2);
1167 }
1168 catch (const std::invalid_argument& e)
1169 {
1170 SWIG_exception(SWIG_ValueError, e.what());
1171 }
1172 catch (const std::out_of_range& e)
1173 {
1174 SWIG_exception(SWIG_IndexError, e.what());
1175 }
1176 catch(const std::exception& e)
1177 {
1178 SWIG_exception(SWIG_RuntimeError, e.what());
1179 }
1180 }
1181
1182}
1183
1184
1185void _wrap_Image_SetHeight_face_86f062e835b3dd07(oneML::Image *_swig_go_0, short _swig_go_1) {
1186 oneML::Image *arg1 = (oneML::Image *) 0 ;
1187 uint16_t arg2 ;
1188
1189 arg1 = *(oneML::Image **)&_swig_go_0;
1190 arg2 = (uint16_t)_swig_go_1;
1191
1192 {
1193 try
1194 {
1195 (arg1)->set_height(arg2);
1196 }
1197 catch (const std::invalid_argument& e)
1198 {
1199 SWIG_exception(SWIG_ValueError, e.what());
1200 }
1201 catch (const std::out_of_range& e)
1202 {
1203 SWIG_exception(SWIG_IndexError, e.what());
1204 }
1205 catch(const std::exception& e)
1206 {
1207 SWIG_exception(SWIG_RuntimeError, e.what());
1208 }
1209 }
1210
1211}
1212
1213
1214void _wrap_Image_SetDepth_face_86f062e835b3dd07(oneML::Image *_swig_go_0, short _swig_go_1) {
1215 oneML::Image *arg1 = (oneML::Image *) 0 ;
1216 uint16_t arg2 ;
1217
1218 arg1 = *(oneML::Image **)&_swig_go_0;
1219 arg2 = (uint16_t)_swig_go_1;
1220
1221 {
1222 try
1223 {
1224 (arg1)->set_depth(arg2);
1225 }
1226 catch (const std::invalid_argument& e)
1227 {
1228 SWIG_exception(SWIG_ValueError, e.what());
1229 }
1230 catch (const std::out_of_range& e)
1231 {
1232 SWIG_exception(SWIG_IndexError, e.what());
1233 }
1234 catch(const std::exception& e)
1235 {
1236 SWIG_exception(SWIG_RuntimeError, e.what());
1237 }
1238 }
1239
1240}
1241
1242
1243short _wrap_Image_GetWidth_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1244 oneML::Image *arg1 = (oneML::Image *) 0 ;
1245 uint16_t result;
1246 short _swig_go_result;
1247
1248 arg1 = *(oneML::Image **)&_swig_go_0;
1249
1250 {
1251 try
1252 {
1253 result = (uint16_t)((oneML::Image const *)arg1)->get_width();
1254 }
1255 catch (const std::invalid_argument& e)
1256 {
1257 SWIG_exception(SWIG_ValueError, e.what());
1258 }
1259 catch (const std::out_of_range& e)
1260 {
1261 SWIG_exception(SWIG_IndexError, e.what());
1262 }
1263 catch(const std::exception& e)
1264 {
1265 SWIG_exception(SWIG_RuntimeError, e.what());
1266 }
1267 }
1268 _swig_go_result = result;
1269 return _swig_go_result;
1270}
1271
1272
1273short _wrap_Image_GetHeight_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1274 oneML::Image *arg1 = (oneML::Image *) 0 ;
1275 uint16_t result;
1276 short _swig_go_result;
1277
1278 arg1 = *(oneML::Image **)&_swig_go_0;
1279
1280 {
1281 try
1282 {
1283 result = (uint16_t)((oneML::Image const *)arg1)->get_height();
1284 }
1285 catch (const std::invalid_argument& e)
1286 {
1287 SWIG_exception(SWIG_ValueError, e.what());
1288 }
1289 catch (const std::out_of_range& e)
1290 {
1291 SWIG_exception(SWIG_IndexError, e.what());
1292 }
1293 catch(const std::exception& e)
1294 {
1295 SWIG_exception(SWIG_RuntimeError, e.what());
1296 }
1297 }
1298 _swig_go_result = result;
1299 return _swig_go_result;
1300}
1301
1302
1303short _wrap_Image_GetDepth_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1304 oneML::Image *arg1 = (oneML::Image *) 0 ;
1305 uint16_t result;
1306 short _swig_go_result;
1307
1308 arg1 = *(oneML::Image **)&_swig_go_0;
1309
1310 {
1311 try
1312 {
1313 result = (uint16_t)((oneML::Image const *)arg1)->get_depth();
1314 }
1315 catch (const std::invalid_argument& e)
1316 {
1317 SWIG_exception(SWIG_ValueError, e.what());
1318 }
1319 catch (const std::out_of_range& e)
1320 {
1321 SWIG_exception(SWIG_IndexError, e.what());
1322 }
1323 catch(const std::exception& e)
1324 {
1325 SWIG_exception(SWIG_RuntimeError, e.what());
1326 }
1327 }
1328 _swig_go_result = result;
1329 return _swig_go_result;
1330}
1331
1332
1333oneML::Image *_wrap_new_Image__SWIG_1_face_86f062e835b3dd07(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2, _goslice_ _swig_go_3) {
1334 int arg1 ;
1335 int arg2 ;
1336 int arg3 ;
1337 unsigned char *arg4 = (unsigned char *) 0 ;
1338 oneML::Image *result = 0 ;
1339 oneML::Image *_swig_go_result;
1340
1341 arg1 = (int)_swig_go_0;
1342 arg2 = (int)_swig_go_1;
1343 arg3 = (int)_swig_go_2;
1344 {
1345 if (_swig_go_3.len == 0) {
1346 _swig_gopanic("array must contain at least 1 element");
1347 }
1348 arg4 = (unsigned char *) _swig_go_3.array;
1349 }
1350
1351 {
1352 try
1353 {
1354 result = (oneML::Image *)new_oneML_Image__SWIG_1(arg1,arg2,arg3,arg4);
1355 }
1356 catch (const std::invalid_argument& e)
1357 {
1358 SWIG_exception(SWIG_ValueError, e.what());
1359 }
1360 catch (const std::out_of_range& e)
1361 {
1362 SWIG_exception(SWIG_IndexError, e.what());
1363 }
1364 catch(const std::exception& e)
1365 {
1366 SWIG_exception(SWIG_RuntimeError, e.what());
1367 }
1368 }
1369 *(oneML::Image **)&_swig_go_result = (oneML::Image *)result;
1370
1371
1372 return _swig_go_result;
1373}
1374
1375
1376void _wrap_Image_SetData_face_86f062e835b3dd07(oneML::Image *_swig_go_0, _goslice_ _swig_go_1) {
1377 oneML::Image *arg1 = (oneML::Image *) 0 ;
1378 unsigned char *arg2 = (unsigned char *) 0 ;
1379
1380 arg1 = *(oneML::Image **)&_swig_go_0;
1381 {
1382 if (_swig_go_1.len == 0) {
1383 _swig_gopanic("array must contain at least 1 element");
1384 }
1385 arg2 = (unsigned char *) _swig_go_1.array;
1386 }
1387
1388 {
1389 try
1390 {
1391 oneML_Image_go_set_data(arg1,arg2);
1392 }
1393 catch (const std::invalid_argument& e)
1394 {
1395 SWIG_exception(SWIG_ValueError, e.what());
1396 }
1397 catch (const std::out_of_range& e)
1398 {
1399 SWIG_exception(SWIG_IndexError, e.what());
1400 }
1401 catch(const std::exception& e)
1402 {
1403 SWIG_exception(SWIG_RuntimeError, e.what());
1404 }
1405 }
1406
1407
1408
1409}
1410
1411
1412char *_wrap_Image_GetData_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1413 oneML::Image *arg1 = (oneML::Image *) 0 ;
1414 uint8_t *result = 0 ;
1415 char *_swig_go_result;
1416
1417 arg1 = *(oneML::Image **)&_swig_go_0;
1418
1419 {
1420 try
1421 {
1422 result = (uint8_t *)oneML_Image_go_get_data(arg1);
1423 }
1424 catch (const std::invalid_argument& e)
1425 {
1426 SWIG_exception(SWIG_ValueError, e.what());
1427 }
1428 catch (const std::out_of_range& e)
1429 {
1430 SWIG_exception(SWIG_IndexError, e.what());
1431 }
1432 catch(const std::exception& e)
1433 {
1434 SWIG_exception(SWIG_RuntimeError, e.what());
1435 }
1436 }
1437 *(uint8_t **)&_swig_go_result = (uint8_t *)result;
1438 return _swig_go_result;
1439}
1440
1441
1442void _wrap_delete_Image_face_86f062e835b3dd07(oneML::Image *_swig_go_0) {
1443 oneML::Image *arg1 = (oneML::Image *) 0 ;
1444
1445 arg1 = *(oneML::Image **)&_swig_go_0;
1446
1447 {
1448 try
1449 {
1450 delete arg1;
1451 }
1452 catch (const std::invalid_argument& e)
1453 {
1454 SWIG_exception(SWIG_ValueError, e.what());
1455 }
1456 catch (const std::out_of_range& e)
1457 {
1458 SWIG_exception(SWIG_IndexError, e.what());
1459 }
1460 catch(const std::exception& e)
1461 {
1462 SWIG_exception(SWIG_RuntimeError, e.what());
1463 }
1464 }
1465
1466}
1467
1468
1469void _wrap_BBox_top_set_face_86f062e835b3dd07(oneML::BBox *_swig_go_0, float _swig_go_1) {
1470 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1471 float arg2 ;
1472
1473 arg1 = *(oneML::BBox **)&_swig_go_0;
1474 arg2 = (float)_swig_go_1;
1475
1476 if (arg1) (arg1)->top = arg2;
1477
1478}
1479
1480
1481float _wrap_BBox_top_get_face_86f062e835b3dd07(oneML::BBox *_swig_go_0) {
1482 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1483 float result;
1484 float _swig_go_result;
1485
1486 arg1 = *(oneML::BBox **)&_swig_go_0;
1487
1488 result = (float) ((arg1)->top);
1489 _swig_go_result = result;
1490 return _swig_go_result;
1491}
1492
1493
1494void _wrap_BBox_left_set_face_86f062e835b3dd07(oneML::BBox *_swig_go_0, float _swig_go_1) {
1495 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1496 float arg2 ;
1497
1498 arg1 = *(oneML::BBox **)&_swig_go_0;
1499 arg2 = (float)_swig_go_1;
1500
1501 if (arg1) (arg1)->left = arg2;
1502
1503}
1504
1505
1506float _wrap_BBox_left_get_face_86f062e835b3dd07(oneML::BBox *_swig_go_0) {
1507 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1508 float result;
1509 float _swig_go_result;
1510
1511 arg1 = *(oneML::BBox **)&_swig_go_0;
1512
1513 result = (float) ((arg1)->left);
1514 _swig_go_result = result;
1515 return _swig_go_result;
1516}
1517
1518
1519void _wrap_BBox_bottom_set_face_86f062e835b3dd07(oneML::BBox *_swig_go_0, float _swig_go_1) {
1520 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1521 float arg2 ;
1522
1523 arg1 = *(oneML::BBox **)&_swig_go_0;
1524 arg2 = (float)_swig_go_1;
1525
1526 if (arg1) (arg1)->bottom = arg2;
1527
1528}
1529
1530
1531float _wrap_BBox_bottom_get_face_86f062e835b3dd07(oneML::BBox *_swig_go_0) {
1532 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1533 float result;
1534 float _swig_go_result;
1535
1536 arg1 = *(oneML::BBox **)&_swig_go_0;
1537
1538 result = (float) ((arg1)->bottom);
1539 _swig_go_result = result;
1540 return _swig_go_result;
1541}
1542
1543
1544void _wrap_BBox_right_set_face_86f062e835b3dd07(oneML::BBox *_swig_go_0, float _swig_go_1) {
1545 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1546 float arg2 ;
1547
1548 arg1 = *(oneML::BBox **)&_swig_go_0;
1549 arg2 = (float)_swig_go_1;
1550
1551 if (arg1) (arg1)->right = arg2;
1552
1553}
1554
1555
1556float _wrap_BBox_right_get_face_86f062e835b3dd07(oneML::BBox *_swig_go_0) {
1557 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1558 float result;
1559 float _swig_go_result;
1560
1561 arg1 = *(oneML::BBox **)&_swig_go_0;
1562
1563 result = (float) ((arg1)->right);
1564 _swig_go_result = result;
1565 return _swig_go_result;
1566}
1567
1568
1569oneML::BBox *_wrap_new_BBox_face_86f062e835b3dd07() {
1570 oneML::BBox *result = 0 ;
1571 oneML::BBox *_swig_go_result;
1572
1573
1574 {
1575 try
1576 {
1577 result = (oneML::BBox *)new oneML::BBox();
1578 }
1579 catch (const std::invalid_argument& e)
1580 {
1581 SWIG_exception(SWIG_ValueError, e.what());
1582 }
1583 catch (const std::out_of_range& e)
1584 {
1585 SWIG_exception(SWIG_IndexError, e.what());
1586 }
1587 catch(const std::exception& e)
1588 {
1589 SWIG_exception(SWIG_RuntimeError, e.what());
1590 }
1591 }
1592 *(oneML::BBox **)&_swig_go_result = (oneML::BBox *)result;
1593 return _swig_go_result;
1594}
1595
1596
1597void _wrap_delete_BBox_face_86f062e835b3dd07(oneML::BBox *_swig_go_0) {
1598 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1599
1600 arg1 = *(oneML::BBox **)&_swig_go_0;
1601
1602 {
1603 try
1604 {
1605 delete arg1;
1606 }
1607 catch (const std::invalid_argument& e)
1608 {
1609 SWIG_exception(SWIG_ValueError, e.what());
1610 }
1611 catch (const std::out_of_range& e)
1612 {
1613 SWIG_exception(SWIG_IndexError, e.what());
1614 }
1615 catch(const std::exception& e)
1616 {
1617 SWIG_exception(SWIG_RuntimeError, e.what());
1618 }
1619 }
1620
1621}
1622
1623
1624intgo _wrap_Pose_Front_face_86f062e835b3dd07() {
1625 oneML::face::Pose result;
1626 intgo _swig_go_result;
1627
1628
1629 {
1630 try
1631 {
1632 result = oneML::face::Pose::Front;
1633
1634 }
1635 catch (const std::invalid_argument& e)
1636 {
1637 SWIG_exception(SWIG_ValueError, e.what());
1638 }
1639 catch (const std::out_of_range& e)
1640 {
1641 SWIG_exception(SWIG_IndexError, e.what());
1642 }
1643 catch(const std::exception& e)
1644 {
1645 SWIG_exception(SWIG_RuntimeError, e.what());
1646 }
1647 }
1648 _swig_go_result = (intgo)result;
1649 return _swig_go_result;
1650}
1651
1652
1653intgo _wrap_Pose_Left_face_86f062e835b3dd07() {
1654 oneML::face::Pose result;
1655 intgo _swig_go_result;
1656
1657
1658 {
1659 try
1660 {
1661 result = oneML::face::Pose::Left;
1662
1663 }
1664 catch (const std::invalid_argument& e)
1665 {
1666 SWIG_exception(SWIG_ValueError, e.what());
1667 }
1668 catch (const std::out_of_range& e)
1669 {
1670 SWIG_exception(SWIG_IndexError, e.what());
1671 }
1672 catch(const std::exception& e)
1673 {
1674 SWIG_exception(SWIG_RuntimeError, e.what());
1675 }
1676 }
1677 _swig_go_result = (intgo)result;
1678 return _swig_go_result;
1679}
1680
1681
1682intgo _wrap_Pose_Right_face_86f062e835b3dd07() {
1683 oneML::face::Pose result;
1684 intgo _swig_go_result;
1685
1686
1687 {
1688 try
1689 {
1690 result = oneML::face::Pose::Right;
1691
1692 }
1693 catch (const std::invalid_argument& e)
1694 {
1695 SWIG_exception(SWIG_ValueError, e.what());
1696 }
1697 catch (const std::out_of_range& e)
1698 {
1699 SWIG_exception(SWIG_IndexError, e.what());
1700 }
1701 catch(const std::exception& e)
1702 {
1703 SWIG_exception(SWIG_RuntimeError, e.what());
1704 }
1705 }
1706 _swig_go_result = (intgo)result;
1707 return _swig_go_result;
1708}
1709
1710
1711intgo _wrap_Pose_Up_face_86f062e835b3dd07() {
1712 oneML::face::Pose result;
1713 intgo _swig_go_result;
1714
1715
1716 {
1717 try
1718 {
1719 result = oneML::face::Pose::Up;
1720
1721 }
1722 catch (const std::invalid_argument& e)
1723 {
1724 SWIG_exception(SWIG_ValueError, e.what());
1725 }
1726 catch (const std::out_of_range& e)
1727 {
1728 SWIG_exception(SWIG_IndexError, e.what());
1729 }
1730 catch(const std::exception& e)
1731 {
1732 SWIG_exception(SWIG_RuntimeError, e.what());
1733 }
1734 }
1735 _swig_go_result = (intgo)result;
1736 return _swig_go_result;
1737}
1738
1739
1740intgo _wrap_Pose_Down_face_86f062e835b3dd07() {
1741 oneML::face::Pose result;
1742 intgo _swig_go_result;
1743
1744
1745 {
1746 try
1747 {
1748 result = oneML::face::Pose::Down;
1749
1750 }
1751 catch (const std::invalid_argument& e)
1752 {
1753 SWIG_exception(SWIG_ValueError, e.what());
1754 }
1755 catch (const std::out_of_range& e)
1756 {
1757 SWIG_exception(SWIG_IndexError, e.what());
1758 }
1759 catch(const std::exception& e)
1760 {
1761 SWIG_exception(SWIG_RuntimeError, e.what());
1762 }
1763 }
1764 _swig_go_result = (intgo)result;
1765 return _swig_go_result;
1766}
1767
1768
1769intgo _wrap_Pose_Undefined_face_86f062e835b3dd07() {
1770 oneML::face::Pose result;
1771 intgo _swig_go_result;
1772
1773
1774 {
1775 try
1776 {
1777 result = oneML::face::Pose::Undefined;
1778
1779 }
1780 catch (const std::invalid_argument& e)
1781 {
1782 SWIG_exception(SWIG_ValueError, e.what());
1783 }
1784 catch (const std::out_of_range& e)
1785 {
1786 SWIG_exception(SWIG_IndexError, e.what());
1787 }
1788 catch(const std::exception& e)
1789 {
1790 SWIG_exception(SWIG_RuntimeError, e.what());
1791 }
1792 }
1793 _swig_go_result = (intgo)result;
1794 return _swig_go_result;
1795}
1796
1797
1798std::vector< float > *_wrap_new_FloatVector__SWIG_0_face_86f062e835b3dd07() {
1799 std::vector< float > *result = 0 ;
1800 std::vector< float > *_swig_go_result;
1801
1802
1803 {
1804 try
1805 {
1806 result = (std::vector< float > *)new std::vector< float >();
1807 }
1808 catch (const std::invalid_argument& e)
1809 {
1810 SWIG_exception(SWIG_ValueError, e.what());
1811 }
1812 catch (const std::out_of_range& e)
1813 {
1814 SWIG_exception(SWIG_IndexError, e.what());
1815 }
1816 catch(const std::exception& e)
1817 {
1818 SWIG_exception(SWIG_RuntimeError, e.what());
1819 }
1820 }
1821 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1822 return _swig_go_result;
1823}
1824
1825
1826std::vector< float > *_wrap_new_FloatVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
1827 std::vector< float >::size_type arg1 ;
1828 std::vector< float > *result = 0 ;
1829 std::vector< float > *_swig_go_result;
1830
1831 arg1 = (size_t)_swig_go_0;
1832
1833 {
1834 try
1835 {
1836 result = (std::vector< float > *)new std::vector< float >(arg1);
1837 }
1838 catch (const std::invalid_argument& e)
1839 {
1840 SWIG_exception(SWIG_ValueError, e.what());
1841 }
1842 catch (const std::out_of_range& e)
1843 {
1844 SWIG_exception(SWIG_IndexError, e.what());
1845 }
1846 catch(const std::exception& e)
1847 {
1848 SWIG_exception(SWIG_RuntimeError, e.what());
1849 }
1850 }
1851 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1852 return _swig_go_result;
1853}
1854
1855
1856std::vector< float > *_wrap_new_FloatVector__SWIG_2_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
1857 std::vector< float > *arg1 = 0 ;
1858 std::vector< float > *result = 0 ;
1859 std::vector< float > *_swig_go_result;
1860
1861 arg1 = *(std::vector< float > **)&_swig_go_0;
1862
1863 {
1864 try
1865 {
1866 result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1);
1867 }
1868 catch (const std::invalid_argument& e)
1869 {
1870 SWIG_exception(SWIG_ValueError, e.what());
1871 }
1872 catch (const std::out_of_range& e)
1873 {
1874 SWIG_exception(SWIG_IndexError, e.what());
1875 }
1876 catch(const std::exception& e)
1877 {
1878 SWIG_exception(SWIG_RuntimeError, e.what());
1879 }
1880 }
1881 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1882 return _swig_go_result;
1883}
1884
1885
1886long long _wrap_FloatVector_size_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
1887 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1888 std::vector< float >::size_type result;
1889 long long _swig_go_result;
1890
1891 arg1 = *(std::vector< float > **)&_swig_go_0;
1892
1893 {
1894 try
1895 {
1896 result = ((std::vector< float > const *)arg1)->size();
1897 }
1898 catch (const std::invalid_argument& e)
1899 {
1900 SWIG_exception(SWIG_ValueError, e.what());
1901 }
1902 catch (const std::out_of_range& e)
1903 {
1904 SWIG_exception(SWIG_IndexError, e.what());
1905 }
1906 catch(const std::exception& e)
1907 {
1908 SWIG_exception(SWIG_RuntimeError, e.what());
1909 }
1910 }
1911 _swig_go_result = result;
1912 return _swig_go_result;
1913}
1914
1915
1916long long _wrap_FloatVector_capacity_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
1917 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1918 std::vector< float >::size_type result;
1919 long long _swig_go_result;
1920
1921 arg1 = *(std::vector< float > **)&_swig_go_0;
1922
1923 {
1924 try
1925 {
1926 result = ((std::vector< float > const *)arg1)->capacity();
1927 }
1928 catch (const std::invalid_argument& e)
1929 {
1930 SWIG_exception(SWIG_ValueError, e.what());
1931 }
1932 catch (const std::out_of_range& e)
1933 {
1934 SWIG_exception(SWIG_IndexError, e.what());
1935 }
1936 catch(const std::exception& e)
1937 {
1938 SWIG_exception(SWIG_RuntimeError, e.what());
1939 }
1940 }
1941 _swig_go_result = result;
1942 return _swig_go_result;
1943}
1944
1945
1946void _wrap_FloatVector_reserve_face_86f062e835b3dd07(std::vector< float > *_swig_go_0, long long _swig_go_1) {
1947 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1948 std::vector< float >::size_type arg2 ;
1949
1950 arg1 = *(std::vector< float > **)&_swig_go_0;
1951 arg2 = (size_t)_swig_go_1;
1952
1953 {
1954 try
1955 {
1956 (arg1)->reserve(arg2);
1957 }
1958 catch (const std::invalid_argument& e)
1959 {
1960 SWIG_exception(SWIG_ValueError, e.what());
1961 }
1962 catch (const std::out_of_range& e)
1963 {
1964 SWIG_exception(SWIG_IndexError, e.what());
1965 }
1966 catch(const std::exception& e)
1967 {
1968 SWIG_exception(SWIG_RuntimeError, e.what());
1969 }
1970 }
1971
1972}
1973
1974
1975bool _wrap_FloatVector_isEmpty_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
1976 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1977 bool result;
1978 bool _swig_go_result;
1979
1980 arg1 = *(std::vector< float > **)&_swig_go_0;
1981
1982 {
1983 try
1984 {
1985 result = (bool)((std::vector< float > const *)arg1)->empty();
1986 }
1987 catch (const std::invalid_argument& e)
1988 {
1989 SWIG_exception(SWIG_ValueError, e.what());
1990 }
1991 catch (const std::out_of_range& e)
1992 {
1993 SWIG_exception(SWIG_IndexError, e.what());
1994 }
1995 catch(const std::exception& e)
1996 {
1997 SWIG_exception(SWIG_RuntimeError, e.what());
1998 }
1999 }
2000 _swig_go_result = result;
2001 return _swig_go_result;
2002}
2003
2004
2005void _wrap_FloatVector_clear_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
2006 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
2007
2008 arg1 = *(std::vector< float > **)&_swig_go_0;
2009
2010 {
2011 try
2012 {
2013 (arg1)->clear();
2014 }
2015 catch (const std::invalid_argument& e)
2016 {
2017 SWIG_exception(SWIG_ValueError, e.what());
2018 }
2019 catch (const std::out_of_range& e)
2020 {
2021 SWIG_exception(SWIG_IndexError, e.what());
2022 }
2023 catch(const std::exception& e)
2024 {
2025 SWIG_exception(SWIG_RuntimeError, e.what());
2026 }
2027 }
2028
2029}
2030
2031
2032void _wrap_FloatVector_add_face_86f062e835b3dd07(std::vector< float > *_swig_go_0, float _swig_go_1) {
2033 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
2034 std::vector< float >::value_type *arg2 = 0 ;
2035
2036 arg1 = *(std::vector< float > **)&_swig_go_0;
2037 arg2 = (std::vector< float >::value_type *)&_swig_go_1;
2038
2039 {
2040 try
2041 {
2042 (arg1)->push_back((std::vector< float >::value_type const &)*arg2);
2043 }
2044 catch (const std::invalid_argument& e)
2045 {
2046 SWIG_exception(SWIG_ValueError, e.what());
2047 }
2048 catch (const std::out_of_range& e)
2049 {
2050 SWIG_exception(SWIG_IndexError, e.what());
2051 }
2052 catch(const std::exception& e)
2053 {
2054 SWIG_exception(SWIG_RuntimeError, e.what());
2055 }
2056 }
2057
2058}
2059
2060
2061float _wrap_FloatVector_get_face_86f062e835b3dd07(std::vector< float > *_swig_go_0, intgo _swig_go_1) {
2062 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
2063 int arg2 ;
2064 std::vector< float >::value_type *result = 0 ;
2065 float _swig_go_result;
2066
2067 arg1 = *(std::vector< float > **)&_swig_go_0;
2068 arg2 = (int)_swig_go_1;
2069
2070 {
2071 try
2072 {
2073 try {
2074 result = (std::vector< float >::value_type *) &std_vector_Sl_float_Sg__get(arg1,arg2);
2075 } catch(std::out_of_range &_e) {
2076 _swig_gopanic((&_e)->what());
2077 }
2078 }
2079 catch (const std::invalid_argument& e)
2080 {
2081 SWIG_exception(SWIG_ValueError, e.what());
2082 }
2083 catch (const std::out_of_range& e)
2084 {
2085 SWIG_exception(SWIG_IndexError, e.what());
2086 }
2087 catch(const std::exception& e)
2088 {
2089 SWIG_exception(SWIG_RuntimeError, e.what());
2090 }
2091 }
2092 _swig_go_result = (float)*result;
2093 return _swig_go_result;
2094}
2095
2096
2097void _wrap_FloatVector_set_face_86f062e835b3dd07(std::vector< float > *_swig_go_0, intgo _swig_go_1, float _swig_go_2) {
2098 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
2099 int arg2 ;
2100 std::vector< float >::value_type *arg3 = 0 ;
2101
2102 arg1 = *(std::vector< float > **)&_swig_go_0;
2103 arg2 = (int)_swig_go_1;
2104 arg3 = (std::vector< float >::value_type *)&_swig_go_2;
2105
2106 {
2107 try
2108 {
2109 try {
2110 std_vector_Sl_float_Sg__set(arg1,arg2,(float const &)*arg3);
2111 } catch(std::out_of_range &_e) {
2112 _swig_gopanic((&_e)->what());
2113 }
2114 }
2115 catch (const std::invalid_argument& e)
2116 {
2117 SWIG_exception(SWIG_ValueError, e.what());
2118 }
2119 catch (const std::out_of_range& e)
2120 {
2121 SWIG_exception(SWIG_IndexError, e.what());
2122 }
2123 catch(const std::exception& e)
2124 {
2125 SWIG_exception(SWIG_RuntimeError, e.what());
2126 }
2127 }
2128
2129}
2130
2131
2132void _wrap_delete_FloatVector_face_86f062e835b3dd07(std::vector< float > *_swig_go_0) {
2133 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
2134
2135 arg1 = *(std::vector< float > **)&_swig_go_0;
2136
2137 {
2138 try
2139 {
2140 delete arg1;
2141 }
2142 catch (const std::invalid_argument& e)
2143 {
2144 SWIG_exception(SWIG_ValueError, e.what());
2145 }
2146 catch (const std::out_of_range& e)
2147 {
2148 SWIG_exception(SWIG_IndexError, e.what());
2149 }
2150 catch(const std::exception& e)
2151 {
2152 SWIG_exception(SWIG_RuntimeError, e.what());
2153 }
2154 }
2155
2156}
2157
2158
2159std::vector< int > *_wrap_new_IntVector__SWIG_0_face_86f062e835b3dd07() {
2160 std::vector< int > *result = 0 ;
2161 std::vector< int > *_swig_go_result;
2162
2163
2164 {
2165 try
2166 {
2167 result = (std::vector< int > *)new std::vector< int >();
2168 }
2169 catch (const std::invalid_argument& e)
2170 {
2171 SWIG_exception(SWIG_ValueError, e.what());
2172 }
2173 catch (const std::out_of_range& e)
2174 {
2175 SWIG_exception(SWIG_IndexError, e.what());
2176 }
2177 catch(const std::exception& e)
2178 {
2179 SWIG_exception(SWIG_RuntimeError, e.what());
2180 }
2181 }
2182 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
2183 return _swig_go_result;
2184}
2185
2186
2187std::vector< int > *_wrap_new_IntVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
2188 std::vector< int >::size_type arg1 ;
2189 std::vector< int > *result = 0 ;
2190 std::vector< int > *_swig_go_result;
2191
2192 arg1 = (size_t)_swig_go_0;
2193
2194 {
2195 try
2196 {
2197 result = (std::vector< int > *)new std::vector< int >(arg1);
2198 }
2199 catch (const std::invalid_argument& e)
2200 {
2201 SWIG_exception(SWIG_ValueError, e.what());
2202 }
2203 catch (const std::out_of_range& e)
2204 {
2205 SWIG_exception(SWIG_IndexError, e.what());
2206 }
2207 catch(const std::exception& e)
2208 {
2209 SWIG_exception(SWIG_RuntimeError, e.what());
2210 }
2211 }
2212 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
2213 return _swig_go_result;
2214}
2215
2216
2217std::vector< int > *_wrap_new_IntVector__SWIG_2_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2218 std::vector< int > *arg1 = 0 ;
2219 std::vector< int > *result = 0 ;
2220 std::vector< int > *_swig_go_result;
2221
2222 arg1 = *(std::vector< int > **)&_swig_go_0;
2223
2224 {
2225 try
2226 {
2227 result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
2228 }
2229 catch (const std::invalid_argument& e)
2230 {
2231 SWIG_exception(SWIG_ValueError, e.what());
2232 }
2233 catch (const std::out_of_range& e)
2234 {
2235 SWIG_exception(SWIG_IndexError, e.what());
2236 }
2237 catch(const std::exception& e)
2238 {
2239 SWIG_exception(SWIG_RuntimeError, e.what());
2240 }
2241 }
2242 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
2243 return _swig_go_result;
2244}
2245
2246
2247long long _wrap_IntVector_size_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2248 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2249 std::vector< int >::size_type result;
2250 long long _swig_go_result;
2251
2252 arg1 = *(std::vector< int > **)&_swig_go_0;
2253
2254 {
2255 try
2256 {
2257 result = ((std::vector< int > const *)arg1)->size();
2258 }
2259 catch (const std::invalid_argument& e)
2260 {
2261 SWIG_exception(SWIG_ValueError, e.what());
2262 }
2263 catch (const std::out_of_range& e)
2264 {
2265 SWIG_exception(SWIG_IndexError, e.what());
2266 }
2267 catch(const std::exception& e)
2268 {
2269 SWIG_exception(SWIG_RuntimeError, e.what());
2270 }
2271 }
2272 _swig_go_result = result;
2273 return _swig_go_result;
2274}
2275
2276
2277long long _wrap_IntVector_capacity_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2278 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2279 std::vector< int >::size_type result;
2280 long long _swig_go_result;
2281
2282 arg1 = *(std::vector< int > **)&_swig_go_0;
2283
2284 {
2285 try
2286 {
2287 result = ((std::vector< int > const *)arg1)->capacity();
2288 }
2289 catch (const std::invalid_argument& e)
2290 {
2291 SWIG_exception(SWIG_ValueError, e.what());
2292 }
2293 catch (const std::out_of_range& e)
2294 {
2295 SWIG_exception(SWIG_IndexError, e.what());
2296 }
2297 catch(const std::exception& e)
2298 {
2299 SWIG_exception(SWIG_RuntimeError, e.what());
2300 }
2301 }
2302 _swig_go_result = result;
2303 return _swig_go_result;
2304}
2305
2306
2307void _wrap_IntVector_reserve_face_86f062e835b3dd07(std::vector< int > *_swig_go_0, long long _swig_go_1) {
2308 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2309 std::vector< int >::size_type arg2 ;
2310
2311 arg1 = *(std::vector< int > **)&_swig_go_0;
2312 arg2 = (size_t)_swig_go_1;
2313
2314 {
2315 try
2316 {
2317 (arg1)->reserve(arg2);
2318 }
2319 catch (const std::invalid_argument& e)
2320 {
2321 SWIG_exception(SWIG_ValueError, e.what());
2322 }
2323 catch (const std::out_of_range& e)
2324 {
2325 SWIG_exception(SWIG_IndexError, e.what());
2326 }
2327 catch(const std::exception& e)
2328 {
2329 SWIG_exception(SWIG_RuntimeError, e.what());
2330 }
2331 }
2332
2333}
2334
2335
2336bool _wrap_IntVector_isEmpty_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2337 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2338 bool result;
2339 bool _swig_go_result;
2340
2341 arg1 = *(std::vector< int > **)&_swig_go_0;
2342
2343 {
2344 try
2345 {
2346 result = (bool)((std::vector< int > const *)arg1)->empty();
2347 }
2348 catch (const std::invalid_argument& e)
2349 {
2350 SWIG_exception(SWIG_ValueError, e.what());
2351 }
2352 catch (const std::out_of_range& e)
2353 {
2354 SWIG_exception(SWIG_IndexError, e.what());
2355 }
2356 catch(const std::exception& e)
2357 {
2358 SWIG_exception(SWIG_RuntimeError, e.what());
2359 }
2360 }
2361 _swig_go_result = result;
2362 return _swig_go_result;
2363}
2364
2365
2366void _wrap_IntVector_clear_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2367 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2368
2369 arg1 = *(std::vector< int > **)&_swig_go_0;
2370
2371 {
2372 try
2373 {
2374 (arg1)->clear();
2375 }
2376 catch (const std::invalid_argument& e)
2377 {
2378 SWIG_exception(SWIG_ValueError, e.what());
2379 }
2380 catch (const std::out_of_range& e)
2381 {
2382 SWIG_exception(SWIG_IndexError, e.what());
2383 }
2384 catch(const std::exception& e)
2385 {
2386 SWIG_exception(SWIG_RuntimeError, e.what());
2387 }
2388 }
2389
2390}
2391
2392
2393void _wrap_IntVector_add_face_86f062e835b3dd07(std::vector< int > *_swig_go_0, intgo _swig_go_1) {
2394 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2395 std::vector< int >::value_type *arg2 = 0 ;
2396
2397 arg1 = *(std::vector< int > **)&_swig_go_0;
2398 arg2 = (std::vector< int >::value_type *)&_swig_go_1;
2399
2400 {
2401 try
2402 {
2403 (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2404 }
2405 catch (const std::invalid_argument& e)
2406 {
2407 SWIG_exception(SWIG_ValueError, e.what());
2408 }
2409 catch (const std::out_of_range& e)
2410 {
2411 SWIG_exception(SWIG_IndexError, e.what());
2412 }
2413 catch(const std::exception& e)
2414 {
2415 SWIG_exception(SWIG_RuntimeError, e.what());
2416 }
2417 }
2418
2419}
2420
2421
2422intgo _wrap_IntVector_get_face_86f062e835b3dd07(std::vector< int > *_swig_go_0, intgo _swig_go_1) {
2423 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2424 int arg2 ;
2425 std::vector< int >::value_type *result = 0 ;
2426 intgo _swig_go_result;
2427
2428 arg1 = *(std::vector< int > **)&_swig_go_0;
2429 arg2 = (int)_swig_go_1;
2430
2431 {
2432 try
2433 {
2434 try {
2435 result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2436 } catch(std::out_of_range &_e) {
2437 _swig_gopanic((&_e)->what());
2438 }
2439 }
2440 catch (const std::invalid_argument& e)
2441 {
2442 SWIG_exception(SWIG_ValueError, e.what());
2443 }
2444 catch (const std::out_of_range& e)
2445 {
2446 SWIG_exception(SWIG_IndexError, e.what());
2447 }
2448 catch(const std::exception& e)
2449 {
2450 SWIG_exception(SWIG_RuntimeError, e.what());
2451 }
2452 }
2453 _swig_go_result = (int)*result;
2454 return _swig_go_result;
2455}
2456
2457
2458void _wrap_IntVector_set_face_86f062e835b3dd07(std::vector< int > *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) {
2459 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2460 int arg2 ;
2461 std::vector< int >::value_type *arg3 = 0 ;
2462
2463 arg1 = *(std::vector< int > **)&_swig_go_0;
2464 arg2 = (int)_swig_go_1;
2465 arg3 = (std::vector< int >::value_type *)&_swig_go_2;
2466
2467 {
2468 try
2469 {
2470 try {
2471 std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2472 } catch(std::out_of_range &_e) {
2473 _swig_gopanic((&_e)->what());
2474 }
2475 }
2476 catch (const std::invalid_argument& e)
2477 {
2478 SWIG_exception(SWIG_ValueError, e.what());
2479 }
2480 catch (const std::out_of_range& e)
2481 {
2482 SWIG_exception(SWIG_IndexError, e.what());
2483 }
2484 catch(const std::exception& e)
2485 {
2486 SWIG_exception(SWIG_RuntimeError, e.what());
2487 }
2488 }
2489
2490}
2491
2492
2493void _wrap_delete_IntVector_face_86f062e835b3dd07(std::vector< int > *_swig_go_0) {
2494 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2495
2496 arg1 = *(std::vector< int > **)&_swig_go_0;
2497
2498 {
2499 try
2500 {
2501 delete arg1;
2502 }
2503 catch (const std::invalid_argument& e)
2504 {
2505 SWIG_exception(SWIG_ValueError, e.what());
2506 }
2507 catch (const std::out_of_range& e)
2508 {
2509 SWIG_exception(SWIG_IndexError, e.what());
2510 }
2511 catch(const std::exception& e)
2512 {
2513 SWIG_exception(SWIG_RuntimeError, e.what());
2514 }
2515 }
2516
2517}
2518
2519
2520std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_0_face_86f062e835b3dd07() {
2521 std::vector< oneML::BBox > *result = 0 ;
2522 std::vector< oneML::BBox > *_swig_go_result;
2523
2524
2525 {
2526 try
2527 {
2528 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >();
2529 }
2530 catch (const std::invalid_argument& e)
2531 {
2532 SWIG_exception(SWIG_ValueError, e.what());
2533 }
2534 catch (const std::out_of_range& e)
2535 {
2536 SWIG_exception(SWIG_IndexError, e.what());
2537 }
2538 catch(const std::exception& e)
2539 {
2540 SWIG_exception(SWIG_RuntimeError, e.what());
2541 }
2542 }
2543 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2544 return _swig_go_result;
2545}
2546
2547
2548std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
2549 std::vector< oneML::BBox >::size_type arg1 ;
2550 std::vector< oneML::BBox > *result = 0 ;
2551 std::vector< oneML::BBox > *_swig_go_result;
2552
2553 arg1 = (size_t)_swig_go_0;
2554
2555 {
2556 try
2557 {
2558 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >(arg1);
2559 }
2560 catch (const std::invalid_argument& e)
2561 {
2562 SWIG_exception(SWIG_ValueError, e.what());
2563 }
2564 catch (const std::out_of_range& e)
2565 {
2566 SWIG_exception(SWIG_IndexError, e.what());
2567 }
2568 catch(const std::exception& e)
2569 {
2570 SWIG_exception(SWIG_RuntimeError, e.what());
2571 }
2572 }
2573 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2574 return _swig_go_result;
2575}
2576
2577
2578std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2579 std::vector< oneML::BBox > *arg1 = 0 ;
2580 std::vector< oneML::BBox > *result = 0 ;
2581 std::vector< oneML::BBox > *_swig_go_result;
2582
2583 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2584
2585 {
2586 try
2587 {
2588 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >((std::vector< oneML::BBox > const &)*arg1);
2589 }
2590 catch (const std::invalid_argument& e)
2591 {
2592 SWIG_exception(SWIG_ValueError, e.what());
2593 }
2594 catch (const std::out_of_range& e)
2595 {
2596 SWIG_exception(SWIG_IndexError, e.what());
2597 }
2598 catch(const std::exception& e)
2599 {
2600 SWIG_exception(SWIG_RuntimeError, e.what());
2601 }
2602 }
2603 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2604 return _swig_go_result;
2605}
2606
2607
2608long long _wrap_BBoxVector_size_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2609 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2610 std::vector< oneML::BBox >::size_type result;
2611 long long _swig_go_result;
2612
2613 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2614
2615 {
2616 try
2617 {
2618 result = ((std::vector< oneML::BBox > const *)arg1)->size();
2619 }
2620 catch (const std::invalid_argument& e)
2621 {
2622 SWIG_exception(SWIG_ValueError, e.what());
2623 }
2624 catch (const std::out_of_range& e)
2625 {
2626 SWIG_exception(SWIG_IndexError, e.what());
2627 }
2628 catch(const std::exception& e)
2629 {
2630 SWIG_exception(SWIG_RuntimeError, e.what());
2631 }
2632 }
2633 _swig_go_result = result;
2634 return _swig_go_result;
2635}
2636
2637
2638long long _wrap_BBoxVector_capacity_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2639 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2640 std::vector< oneML::BBox >::size_type result;
2641 long long _swig_go_result;
2642
2643 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2644
2645 {
2646 try
2647 {
2648 result = ((std::vector< oneML::BBox > const *)arg1)->capacity();
2649 }
2650 catch (const std::invalid_argument& e)
2651 {
2652 SWIG_exception(SWIG_ValueError, e.what());
2653 }
2654 catch (const std::out_of_range& e)
2655 {
2656 SWIG_exception(SWIG_IndexError, e.what());
2657 }
2658 catch(const std::exception& e)
2659 {
2660 SWIG_exception(SWIG_RuntimeError, e.what());
2661 }
2662 }
2663 _swig_go_result = result;
2664 return _swig_go_result;
2665}
2666
2667
2668void _wrap_BBoxVector_reserve_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0, long long _swig_go_1) {
2669 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2670 std::vector< oneML::BBox >::size_type arg2 ;
2671
2672 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2673 arg2 = (size_t)_swig_go_1;
2674
2675 {
2676 try
2677 {
2678 (arg1)->reserve(arg2);
2679 }
2680 catch (const std::invalid_argument& e)
2681 {
2682 SWIG_exception(SWIG_ValueError, e.what());
2683 }
2684 catch (const std::out_of_range& e)
2685 {
2686 SWIG_exception(SWIG_IndexError, e.what());
2687 }
2688 catch(const std::exception& e)
2689 {
2690 SWIG_exception(SWIG_RuntimeError, e.what());
2691 }
2692 }
2693
2694}
2695
2696
2697bool _wrap_BBoxVector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2698 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2699 bool result;
2700 bool _swig_go_result;
2701
2702 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2703
2704 {
2705 try
2706 {
2707 result = (bool)((std::vector< oneML::BBox > const *)arg1)->empty();
2708 }
2709 catch (const std::invalid_argument& e)
2710 {
2711 SWIG_exception(SWIG_ValueError, e.what());
2712 }
2713 catch (const std::out_of_range& e)
2714 {
2715 SWIG_exception(SWIG_IndexError, e.what());
2716 }
2717 catch(const std::exception& e)
2718 {
2719 SWIG_exception(SWIG_RuntimeError, e.what());
2720 }
2721 }
2722 _swig_go_result = result;
2723 return _swig_go_result;
2724}
2725
2726
2727void _wrap_BBoxVector_clear_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2728 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2729
2730 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2731
2732 {
2733 try
2734 {
2735 (arg1)->clear();
2736 }
2737 catch (const std::invalid_argument& e)
2738 {
2739 SWIG_exception(SWIG_ValueError, e.what());
2740 }
2741 catch (const std::out_of_range& e)
2742 {
2743 SWIG_exception(SWIG_IndexError, e.what());
2744 }
2745 catch(const std::exception& e)
2746 {
2747 SWIG_exception(SWIG_RuntimeError, e.what());
2748 }
2749 }
2750
2751}
2752
2753
2754void _wrap_BBoxVector_add_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0, oneML::BBox *_swig_go_1) {
2755 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2756 std::vector< oneML::BBox >::value_type *arg2 = 0 ;
2757
2758 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2759 arg2 = *(std::vector< oneML::BBox >::value_type **)&_swig_go_1;
2760
2761 {
2762 try
2763 {
2764 (arg1)->push_back((std::vector< oneML::BBox >::value_type const &)*arg2);
2765 }
2766 catch (const std::invalid_argument& e)
2767 {
2768 SWIG_exception(SWIG_ValueError, e.what());
2769 }
2770 catch (const std::out_of_range& e)
2771 {
2772 SWIG_exception(SWIG_IndexError, e.what());
2773 }
2774 catch(const std::exception& e)
2775 {
2776 SWIG_exception(SWIG_RuntimeError, e.what());
2777 }
2778 }
2779
2780}
2781
2782
2783oneML::BBox *_wrap_BBoxVector_get_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0, intgo _swig_go_1) {
2784 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2785 int arg2 ;
2786 std::vector< oneML::BBox >::value_type *result = 0 ;
2787 oneML::BBox *_swig_go_result;
2788
2789 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2790 arg2 = (int)_swig_go_1;
2791
2792 {
2793 try
2794 {
2795 try {
2796 result = (std::vector< oneML::BBox >::value_type *) &std_vector_Sl_oneML_BBox_Sg__get(arg1,arg2);
2797 } catch(std::out_of_range &_e) {
2798 _swig_gopanic((&_e)->what());
2799 }
2800 }
2801 catch (const std::invalid_argument& e)
2802 {
2803 SWIG_exception(SWIG_ValueError, e.what());
2804 }
2805 catch (const std::out_of_range& e)
2806 {
2807 SWIG_exception(SWIG_IndexError, e.what());
2808 }
2809 catch(const std::exception& e)
2810 {
2811 SWIG_exception(SWIG_RuntimeError, e.what());
2812 }
2813 }
2814 *(std::vector< oneML::BBox >::value_type **)&_swig_go_result = result;
2815 return _swig_go_result;
2816}
2817
2818
2819void _wrap_BBoxVector_set_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0, intgo _swig_go_1, oneML::BBox *_swig_go_2) {
2820 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2821 int arg2 ;
2822 std::vector< oneML::BBox >::value_type *arg3 = 0 ;
2823
2824 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2825 arg2 = (int)_swig_go_1;
2826 arg3 = *(std::vector< oneML::BBox >::value_type **)&_swig_go_2;
2827
2828 {
2829 try
2830 {
2831 try {
2832 std_vector_Sl_oneML_BBox_Sg__set(arg1,arg2,(oneML::BBox const &)*arg3);
2833 } catch(std::out_of_range &_e) {
2834 _swig_gopanic((&_e)->what());
2835 }
2836 }
2837 catch (const std::invalid_argument& e)
2838 {
2839 SWIG_exception(SWIG_ValueError, e.what());
2840 }
2841 catch (const std::out_of_range& e)
2842 {
2843 SWIG_exception(SWIG_IndexError, e.what());
2844 }
2845 catch(const std::exception& e)
2846 {
2847 SWIG_exception(SWIG_RuntimeError, e.what());
2848 }
2849 }
2850
2851}
2852
2853
2854void _wrap_delete_BBoxVector_face_86f062e835b3dd07(std::vector< oneML::BBox > *_swig_go_0) {
2855 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2856
2857 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2858
2859 {
2860 try
2861 {
2862 delete arg1;
2863 }
2864 catch (const std::invalid_argument& e)
2865 {
2866 SWIG_exception(SWIG_ValueError, e.what());
2867 }
2868 catch (const std::out_of_range& e)
2869 {
2870 SWIG_exception(SWIG_IndexError, e.what());
2871 }
2872 catch(const std::exception& e)
2873 {
2874 SWIG_exception(SWIG_RuntimeError, e.what());
2875 }
2876 }
2877
2878}
2879
2880
2881std::array< float,5 > *_wrap_new_Landmark5Array__SWIG_0_face_86f062e835b3dd07() {
2882 std::array< float,5 > *result = 0 ;
2883 std::array< float,5 > *_swig_go_result;
2884
2885
2886 {
2887 try
2888 {
2889 result = (std::array< float,5 > *)new std::array< float,5 >();
2890 }
2891 catch (const std::invalid_argument& e)
2892 {
2893 SWIG_exception(SWIG_ValueError, e.what());
2894 }
2895 catch (const std::out_of_range& e)
2896 {
2897 SWIG_exception(SWIG_IndexError, e.what());
2898 }
2899 catch(const std::exception& e)
2900 {
2901 SWIG_exception(SWIG_RuntimeError, e.what());
2902 }
2903 }
2904 *(std::array< float,5 > **)&_swig_go_result = (std::array< float,5 > *)result;
2905 return _swig_go_result;
2906}
2907
2908
2909std::array< float,5 > *_wrap_new_Landmark5Array__SWIG_1_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0) {
2910 std::array< float,5 > *arg1 = 0 ;
2911 std::array< float,5 > *result = 0 ;
2912 std::array< float,5 > *_swig_go_result;
2913
2914 arg1 = *(std::array< float,5 > **)&_swig_go_0;
2915
2916 {
2917 try
2918 {
2919 result = (std::array< float,5 > *)new std::array< float,5 >((std::array< float,5 > const &)*arg1);
2920 }
2921 catch (const std::invalid_argument& e)
2922 {
2923 SWIG_exception(SWIG_ValueError, e.what());
2924 }
2925 catch (const std::out_of_range& e)
2926 {
2927 SWIG_exception(SWIG_IndexError, e.what());
2928 }
2929 catch(const std::exception& e)
2930 {
2931 SWIG_exception(SWIG_RuntimeError, e.what());
2932 }
2933 }
2934 *(std::array< float,5 > **)&_swig_go_result = (std::array< float,5 > *)result;
2935 return _swig_go_result;
2936}
2937
2938
2939long long _wrap_Landmark5Array_size_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0) {
2940 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
2941 std::array< float,5 >::size_type result;
2942 long long _swig_go_result;
2943
2944 arg1 = *(std::array< float,5 > **)&_swig_go_0;
2945
2946 {
2947 try
2948 {
2949 result = ((std::array< float,5 > const *)arg1)->size();
2950 }
2951 catch (const std::invalid_argument& e)
2952 {
2953 SWIG_exception(SWIG_ValueError, e.what());
2954 }
2955 catch (const std::out_of_range& e)
2956 {
2957 SWIG_exception(SWIG_IndexError, e.what());
2958 }
2959 catch(const std::exception& e)
2960 {
2961 SWIG_exception(SWIG_RuntimeError, e.what());
2962 }
2963 }
2964 _swig_go_result = result;
2965 return _swig_go_result;
2966}
2967
2968
2969bool _wrap_Landmark5Array_isEmpty_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0) {
2970 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
2971 bool result;
2972 bool _swig_go_result;
2973
2974 arg1 = *(std::array< float,5 > **)&_swig_go_0;
2975
2976 {
2977 try
2978 {
2979 result = (bool)((std::array< float,5 > const *)arg1)->empty();
2980 }
2981 catch (const std::invalid_argument& e)
2982 {
2983 SWIG_exception(SWIG_ValueError, e.what());
2984 }
2985 catch (const std::out_of_range& e)
2986 {
2987 SWIG_exception(SWIG_IndexError, e.what());
2988 }
2989 catch(const std::exception& e)
2990 {
2991 SWIG_exception(SWIG_RuntimeError, e.what());
2992 }
2993 }
2994 _swig_go_result = result;
2995 return _swig_go_result;
2996}
2997
2998
2999void _wrap_Landmark5Array_fill_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0, float _swig_go_1) {
3000 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
3001 float *arg2 = 0 ;
3002
3003 arg1 = *(std::array< float,5 > **)&_swig_go_0;
3004 arg2 = (float *)&_swig_go_1;
3005
3006 {
3007 try
3008 {
3009 (arg1)->fill((float const &)*arg2);
3010 }
3011 catch (const std::invalid_argument& e)
3012 {
3013 SWIG_exception(SWIG_ValueError, e.what());
3014 }
3015 catch (const std::out_of_range& e)
3016 {
3017 SWIG_exception(SWIG_IndexError, e.what());
3018 }
3019 catch(const std::exception& e)
3020 {
3021 SWIG_exception(SWIG_RuntimeError, e.what());
3022 }
3023 }
3024
3025}
3026
3027
3028float _wrap_Landmark5Array_get_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0, intgo _swig_go_1) {
3029 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
3030 int arg2 ;
3031 std::array< float,5 >::value_type *result = 0 ;
3032 float _swig_go_result;
3033
3034 arg1 = *(std::array< float,5 > **)&_swig_go_0;
3035 arg2 = (int)_swig_go_1;
3036
3037 {
3038 try
3039 {
3040 try {
3041 result = (std::array< float,5 >::value_type *) &std_array_Sl_float_Sc_5_Sg__get(arg1,arg2);
3042 } catch(std::out_of_range &_e) {
3043 _swig_gopanic((&_e)->what());
3044 }
3045 }
3046 catch (const std::invalid_argument& e)
3047 {
3048 SWIG_exception(SWIG_ValueError, e.what());
3049 }
3050 catch (const std::out_of_range& e)
3051 {
3052 SWIG_exception(SWIG_IndexError, e.what());
3053 }
3054 catch(const std::exception& e)
3055 {
3056 SWIG_exception(SWIG_RuntimeError, e.what());
3057 }
3058 }
3059 _swig_go_result = (float)*result;
3060 return _swig_go_result;
3061}
3062
3063
3064void _wrap_Landmark5Array_set_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0, intgo _swig_go_1, float _swig_go_2) {
3065 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
3066 int arg2 ;
3067 std::array< float,5 >::value_type *arg3 = 0 ;
3068
3069 arg1 = *(std::array< float,5 > **)&_swig_go_0;
3070 arg2 = (int)_swig_go_1;
3071 arg3 = (std::array< float,5 >::value_type *)&_swig_go_2;
3072
3073 {
3074 try
3075 {
3076 try {
3077 std_array_Sl_float_Sc_5_Sg__set(arg1,arg2,(float const &)*arg3);
3078 } catch(std::out_of_range &_e) {
3079 _swig_gopanic((&_e)->what());
3080 }
3081 }
3082 catch (const std::invalid_argument& e)
3083 {
3084 SWIG_exception(SWIG_ValueError, e.what());
3085 }
3086 catch (const std::out_of_range& e)
3087 {
3088 SWIG_exception(SWIG_IndexError, e.what());
3089 }
3090 catch(const std::exception& e)
3091 {
3092 SWIG_exception(SWIG_RuntimeError, e.what());
3093 }
3094 }
3095
3096}
3097
3098
3099void _wrap_delete_Landmark5Array_face_86f062e835b3dd07(std::array< float,5 > *_swig_go_0) {
3100 std::array< float,5 > *arg1 = (std::array< float,5 > *) 0 ;
3101
3102 arg1 = *(std::array< float,5 > **)&_swig_go_0;
3103
3104 {
3105 try
3106 {
3107 delete arg1;
3108 }
3109 catch (const std::invalid_argument& e)
3110 {
3111 SWIG_exception(SWIG_ValueError, e.what());
3112 }
3113 catch (const std::out_of_range& e)
3114 {
3115 SWIG_exception(SWIG_IndexError, e.what());
3116 }
3117 catch(const std::exception& e)
3118 {
3119 SWIG_exception(SWIG_RuntimeError, e.what());
3120 }
3121 }
3122
3123}
3124
3125
3126void _wrap_Landmark5_x_set_face_86f062e835b3dd07(oneML::face::FaceLandmark< 5 > *_swig_go_0, std::array< float,5 > *_swig_go_1) {
3127 oneML::face::FaceLandmark< 5 > *arg1 = (oneML::face::FaceLandmark< 5 > *) 0 ;
3128 std::array< float,5 > *arg2 = (std::array< float,5 > *) 0 ;
3129
3130 arg1 = *(oneML::face::FaceLandmark< 5 > **)&_swig_go_0;
3131 arg2 = *(std::array< float,5 > **)&_swig_go_1;
3132
3133 if (arg1) (arg1)->x = *arg2;
3134
3135}
3136
3137
3138std::array< float,5 > *_wrap_Landmark5_x_get_face_86f062e835b3dd07(oneML::face::FaceLandmark< 5 > *_swig_go_0) {
3139 oneML::face::FaceLandmark< 5 > *arg1 = (oneML::face::FaceLandmark< 5 > *) 0 ;
3140 std::array< float,5 > *result = 0 ;
3141 std::array< float,5 > *_swig_go_result;
3142
3143 arg1 = *(oneML::face::FaceLandmark< 5 > **)&_swig_go_0;
3144
3145 result = (std::array< float,5 > *)& ((arg1)->x);
3146 *(std::array< float,5 > **)&_swig_go_result = (std::array< float,5 > *)result;
3147 return _swig_go_result;
3148}
3149
3150
3151void _wrap_Landmark5_y_set_face_86f062e835b3dd07(oneML::face::FaceLandmark< 5 > *_swig_go_0, std::array< float,5 > *_swig_go_1) {
3152 oneML::face::FaceLandmark< 5 > *arg1 = (oneML::face::FaceLandmark< 5 > *) 0 ;
3153 std::array< float,5 > *arg2 = (std::array< float,5 > *) 0 ;
3154
3155 arg1 = *(oneML::face::FaceLandmark< 5 > **)&_swig_go_0;
3156 arg2 = *(std::array< float,5 > **)&_swig_go_1;
3157
3158 if (arg1) (arg1)->y = *arg2;
3159
3160}
3161
3162
3163std::array< float,5 > *_wrap_Landmark5_y_get_face_86f062e835b3dd07(oneML::face::FaceLandmark< 5 > *_swig_go_0) {
3164 oneML::face::FaceLandmark< 5 > *arg1 = (oneML::face::FaceLandmark< 5 > *) 0 ;
3165 std::array< float,5 > *result = 0 ;
3166 std::array< float,5 > *_swig_go_result;
3167
3168 arg1 = *(oneML::face::FaceLandmark< 5 > **)&_swig_go_0;
3169
3170 result = (std::array< float,5 > *)& ((arg1)->y);
3171 *(std::array< float,5 > **)&_swig_go_result = (std::array< float,5 > *)result;
3172 return _swig_go_result;
3173}
3174
3175
3176oneML::face::FaceLandmark< 5 > *_wrap_new_Landmark5_face_86f062e835b3dd07() {
3177 oneML::face::FaceLandmark< 5 > *result = 0 ;
3178 oneML::face::FaceLandmark< 5 > *_swig_go_result;
3179
3180
3181 {
3182 try
3183 {
3184 result = (oneML::face::FaceLandmark< 5 > *)new oneML::face::FaceLandmark< 5 >();
3185 }
3186 catch (const std::invalid_argument& e)
3187 {
3188 SWIG_exception(SWIG_ValueError, e.what());
3189 }
3190 catch (const std::out_of_range& e)
3191 {
3192 SWIG_exception(SWIG_IndexError, e.what());
3193 }
3194 catch(const std::exception& e)
3195 {
3196 SWIG_exception(SWIG_RuntimeError, e.what());
3197 }
3198 }
3199 *(oneML::face::FaceLandmark< 5 > **)&_swig_go_result = (oneML::face::FaceLandmark< 5 > *)result;
3200 return _swig_go_result;
3201}
3202
3203
3204void _wrap_delete_Landmark5_face_86f062e835b3dd07(oneML::face::FaceLandmark< 5 > *_swig_go_0) {
3205 oneML::face::FaceLandmark< 5 > *arg1 = (oneML::face::FaceLandmark< 5 > *) 0 ;
3206
3207 arg1 = *(oneML::face::FaceLandmark< 5 > **)&_swig_go_0;
3208
3209 {
3210 try
3211 {
3212 delete arg1;
3213 }
3214 catch (const std::invalid_argument& e)
3215 {
3216 SWIG_exception(SWIG_ValueError, e.what());
3217 }
3218 catch (const std::out_of_range& e)
3219 {
3220 SWIG_exception(SWIG_IndexError, e.what());
3221 }
3222 catch(const std::exception& e)
3223 {
3224 SWIG_exception(SWIG_RuntimeError, e.what());
3225 }
3226 }
3227
3228}
3229
3230
3231std::vector< oneML::face::FaceLandmark< 5 > > *_wrap_new_Landmarks5Vector__SWIG_0_face_86f062e835b3dd07() {
3232 std::vector< oneML::face::FaceLandmark< 5 > > *result = 0 ;
3233 std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_result;
3234
3235
3236 {
3237 try
3238 {
3239 result = (std::vector< oneML::face::FaceLandmark< 5 > > *)new std::vector< oneML::face::FaceLandmark< 5 > >();
3240 }
3241 catch (const std::invalid_argument& e)
3242 {
3243 SWIG_exception(SWIG_ValueError, e.what());
3244 }
3245 catch (const std::out_of_range& e)
3246 {
3247 SWIG_exception(SWIG_IndexError, e.what());
3248 }
3249 catch(const std::exception& e)
3250 {
3251 SWIG_exception(SWIG_RuntimeError, e.what());
3252 }
3253 }
3254 *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_result = (std::vector< oneML::face::FaceLandmark< 5 > > *)result;
3255 return _swig_go_result;
3256}
3257
3258
3259std::vector< oneML::face::FaceLandmark< 5 > > *_wrap_new_Landmarks5Vector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
3260 std::vector< oneML::face::FaceLandmark< 5 > >::size_type arg1 ;
3261 std::vector< oneML::face::FaceLandmark< 5 > > *result = 0 ;
3262 std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_result;
3263
3264 arg1 = (size_t)_swig_go_0;
3265
3266 {
3267 try
3268 {
3269 result = (std::vector< oneML::face::FaceLandmark< 5 > > *)new std::vector< oneML::face::FaceLandmark< 5 > >(arg1);
3270 }
3271 catch (const std::invalid_argument& e)
3272 {
3273 SWIG_exception(SWIG_ValueError, e.what());
3274 }
3275 catch (const std::out_of_range& e)
3276 {
3277 SWIG_exception(SWIG_IndexError, e.what());
3278 }
3279 catch(const std::exception& e)
3280 {
3281 SWIG_exception(SWIG_RuntimeError, e.what());
3282 }
3283 }
3284 *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_result = (std::vector< oneML::face::FaceLandmark< 5 > > *)result;
3285 return _swig_go_result;
3286}
3287
3288
3289std::vector< oneML::face::FaceLandmark< 5 > > *_wrap_new_Landmarks5Vector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3290 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = 0 ;
3291 std::vector< oneML::face::FaceLandmark< 5 > > *result = 0 ;
3292 std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_result;
3293
3294 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3295
3296 {
3297 try
3298 {
3299 result = (std::vector< oneML::face::FaceLandmark< 5 > > *)new std::vector< oneML::face::FaceLandmark< 5 > >((std::vector< oneML::face::FaceLandmark< 5 > > const &)*arg1);
3300 }
3301 catch (const std::invalid_argument& e)
3302 {
3303 SWIG_exception(SWIG_ValueError, e.what());
3304 }
3305 catch (const std::out_of_range& e)
3306 {
3307 SWIG_exception(SWIG_IndexError, e.what());
3308 }
3309 catch(const std::exception& e)
3310 {
3311 SWIG_exception(SWIG_RuntimeError, e.what());
3312 }
3313 }
3314 *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_result = (std::vector< oneML::face::FaceLandmark< 5 > > *)result;
3315 return _swig_go_result;
3316}
3317
3318
3319long long _wrap_Landmarks5Vector_size_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3320 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3321 std::vector< oneML::face::FaceLandmark< 5 > >::size_type result;
3322 long long _swig_go_result;
3323
3324 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3325
3326 {
3327 try
3328 {
3329 result = ((std::vector< oneML::face::FaceLandmark< 5 > > const *)arg1)->size();
3330 }
3331 catch (const std::invalid_argument& e)
3332 {
3333 SWIG_exception(SWIG_ValueError, e.what());
3334 }
3335 catch (const std::out_of_range& e)
3336 {
3337 SWIG_exception(SWIG_IndexError, e.what());
3338 }
3339 catch(const std::exception& e)
3340 {
3341 SWIG_exception(SWIG_RuntimeError, e.what());
3342 }
3343 }
3344 _swig_go_result = result;
3345 return _swig_go_result;
3346}
3347
3348
3349long long _wrap_Landmarks5Vector_capacity_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3350 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3351 std::vector< oneML::face::FaceLandmark< 5 > >::size_type result;
3352 long long _swig_go_result;
3353
3354 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3355
3356 {
3357 try
3358 {
3359 result = ((std::vector< oneML::face::FaceLandmark< 5 > > const *)arg1)->capacity();
3360 }
3361 catch (const std::invalid_argument& e)
3362 {
3363 SWIG_exception(SWIG_ValueError, e.what());
3364 }
3365 catch (const std::out_of_range& e)
3366 {
3367 SWIG_exception(SWIG_IndexError, e.what());
3368 }
3369 catch(const std::exception& e)
3370 {
3371 SWIG_exception(SWIG_RuntimeError, e.what());
3372 }
3373 }
3374 _swig_go_result = result;
3375 return _swig_go_result;
3376}
3377
3378
3379void _wrap_Landmarks5Vector_reserve_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0, long long _swig_go_1) {
3380 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3381 std::vector< oneML::face::FaceLandmark< 5 > >::size_type arg2 ;
3382
3383 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3384 arg2 = (size_t)_swig_go_1;
3385
3386 {
3387 try
3388 {
3389 (arg1)->reserve(arg2);
3390 }
3391 catch (const std::invalid_argument& e)
3392 {
3393 SWIG_exception(SWIG_ValueError, e.what());
3394 }
3395 catch (const std::out_of_range& e)
3396 {
3397 SWIG_exception(SWIG_IndexError, e.what());
3398 }
3399 catch(const std::exception& e)
3400 {
3401 SWIG_exception(SWIG_RuntimeError, e.what());
3402 }
3403 }
3404
3405}
3406
3407
3408bool _wrap_Landmarks5Vector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3409 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3410 bool result;
3411 bool _swig_go_result;
3412
3413 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3414
3415 {
3416 try
3417 {
3418 result = (bool)((std::vector< oneML::face::FaceLandmark< 5 > > const *)arg1)->empty();
3419 }
3420 catch (const std::invalid_argument& e)
3421 {
3422 SWIG_exception(SWIG_ValueError, e.what());
3423 }
3424 catch (const std::out_of_range& e)
3425 {
3426 SWIG_exception(SWIG_IndexError, e.what());
3427 }
3428 catch(const std::exception& e)
3429 {
3430 SWIG_exception(SWIG_RuntimeError, e.what());
3431 }
3432 }
3433 _swig_go_result = result;
3434 return _swig_go_result;
3435}
3436
3437
3438void _wrap_Landmarks5Vector_clear_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3439 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3440
3441 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3442
3443 {
3444 try
3445 {
3446 (arg1)->clear();
3447 }
3448 catch (const std::invalid_argument& e)
3449 {
3450 SWIG_exception(SWIG_ValueError, e.what());
3451 }
3452 catch (const std::out_of_range& e)
3453 {
3454 SWIG_exception(SWIG_IndexError, e.what());
3455 }
3456 catch(const std::exception& e)
3457 {
3458 SWIG_exception(SWIG_RuntimeError, e.what());
3459 }
3460 }
3461
3462}
3463
3464
3465void _wrap_Landmarks5Vector_add_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0, oneML::face::FaceLandmark< 5 > *_swig_go_1) {
3466 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3467 std::vector< oneML::face::FaceLandmark< 5 > >::value_type *arg2 = 0 ;
3468
3469 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3470 arg2 = *(std::vector< oneML::face::FaceLandmark< 5 > >::value_type **)&_swig_go_1;
3471
3472 {
3473 try
3474 {
3475 (arg1)->push_back((std::vector< oneML::face::FaceLandmark< 5 > >::value_type const &)*arg2);
3476 }
3477 catch (const std::invalid_argument& e)
3478 {
3479 SWIG_exception(SWIG_ValueError, e.what());
3480 }
3481 catch (const std::out_of_range& e)
3482 {
3483 SWIG_exception(SWIG_IndexError, e.what());
3484 }
3485 catch(const std::exception& e)
3486 {
3487 SWIG_exception(SWIG_RuntimeError, e.what());
3488 }
3489 }
3490
3491}
3492
3493
3494oneML::face::FaceLandmark< 5 > *_wrap_Landmarks5Vector_get_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0, intgo _swig_go_1) {
3495 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3496 int arg2 ;
3497 std::vector< oneML::face::FaceLandmark< 5 > >::value_type *result = 0 ;
3498 oneML::face::FaceLandmark< 5 > *_swig_go_result;
3499
3500 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3501 arg2 = (int)_swig_go_1;
3502
3503 {
3504 try
3505 {
3506 try {
3507 result = (std::vector< oneML::face::FaceLandmark< 5 > >::value_type *) &std_vector_Sl_oneML_face_FaceLandmark_Sl_5_Sg__Sg__get(arg1,arg2);
3508 } catch(std::out_of_range &_e) {
3509 _swig_gopanic((&_e)->what());
3510 }
3511 }
3512 catch (const std::invalid_argument& e)
3513 {
3514 SWIG_exception(SWIG_ValueError, e.what());
3515 }
3516 catch (const std::out_of_range& e)
3517 {
3518 SWIG_exception(SWIG_IndexError, e.what());
3519 }
3520 catch(const std::exception& e)
3521 {
3522 SWIG_exception(SWIG_RuntimeError, e.what());
3523 }
3524 }
3525 *(std::vector< oneML::face::FaceLandmark< 5 > >::value_type **)&_swig_go_result = result;
3526 return _swig_go_result;
3527}
3528
3529
3530void _wrap_Landmarks5Vector_set_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0, intgo _swig_go_1, oneML::face::FaceLandmark< 5 > *_swig_go_2) {
3531 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3532 int arg2 ;
3533 std::vector< oneML::face::FaceLandmark< 5 > >::value_type *arg3 = 0 ;
3534
3535 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3536 arg2 = (int)_swig_go_1;
3537 arg3 = *(std::vector< oneML::face::FaceLandmark< 5 > >::value_type **)&_swig_go_2;
3538
3539 {
3540 try
3541 {
3542 try {
3543 std_vector_Sl_oneML_face_FaceLandmark_Sl_5_Sg__Sg__set(arg1,arg2,(oneML::face::FaceLandmark< 5 > const &)*arg3);
3544 } catch(std::out_of_range &_e) {
3545 _swig_gopanic((&_e)->what());
3546 }
3547 }
3548 catch (const std::invalid_argument& e)
3549 {
3550 SWIG_exception(SWIG_ValueError, e.what());
3551 }
3552 catch (const std::out_of_range& e)
3553 {
3554 SWIG_exception(SWIG_IndexError, e.what());
3555 }
3556 catch(const std::exception& e)
3557 {
3558 SWIG_exception(SWIG_RuntimeError, e.what());
3559 }
3560 }
3561
3562}
3563
3564
3565void _wrap_delete_Landmarks5Vector_face_86f062e835b3dd07(std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_0) {
3566 std::vector< oneML::face::FaceLandmark< 5 > > *arg1 = (std::vector< oneML::face::FaceLandmark< 5 > > *) 0 ;
3567
3568 arg1 = *(std::vector< oneML::face::FaceLandmark< 5 > > **)&_swig_go_0;
3569
3570 {
3571 try
3572 {
3573 delete arg1;
3574 }
3575 catch (const std::invalid_argument& e)
3576 {
3577 SWIG_exception(SWIG_ValueError, e.what());
3578 }
3579 catch (const std::out_of_range& e)
3580 {
3581 SWIG_exception(SWIG_IndexError, e.what());
3582 }
3583 catch(const std::exception& e)
3584 {
3585 SWIG_exception(SWIG_RuntimeError, e.what());
3586 }
3587 }
3588
3589}
3590
3591
3592std::vector< oneML::face::FaceDetectorResult > *_wrap_new_FaceDetectorResultVector__SWIG_0_face_86f062e835b3dd07() {
3593 std::vector< oneML::face::FaceDetectorResult > *result = 0 ;
3594 std::vector< oneML::face::FaceDetectorResult > *_swig_go_result;
3595
3596
3597 {
3598 try
3599 {
3600 result = (std::vector< oneML::face::FaceDetectorResult > *)new std::vector< oneML::face::FaceDetectorResult >();
3601 }
3602 catch (const std::invalid_argument& e)
3603 {
3604 SWIG_exception(SWIG_ValueError, e.what());
3605 }
3606 catch (const std::out_of_range& e)
3607 {
3608 SWIG_exception(SWIG_IndexError, e.what());
3609 }
3610 catch(const std::exception& e)
3611 {
3612 SWIG_exception(SWIG_RuntimeError, e.what());
3613 }
3614 }
3615 *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_result = (std::vector< oneML::face::FaceDetectorResult > *)result;
3616 return _swig_go_result;
3617}
3618
3619
3620std::vector< oneML::face::FaceDetectorResult > *_wrap_new_FaceDetectorResultVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
3621 std::vector< oneML::face::FaceDetectorResult >::size_type arg1 ;
3622 std::vector< oneML::face::FaceDetectorResult > *result = 0 ;
3623 std::vector< oneML::face::FaceDetectorResult > *_swig_go_result;
3624
3625 arg1 = (size_t)_swig_go_0;
3626
3627 {
3628 try
3629 {
3630 result = (std::vector< oneML::face::FaceDetectorResult > *)new std::vector< oneML::face::FaceDetectorResult >(arg1);
3631 }
3632 catch (const std::invalid_argument& e)
3633 {
3634 SWIG_exception(SWIG_ValueError, e.what());
3635 }
3636 catch (const std::out_of_range& e)
3637 {
3638 SWIG_exception(SWIG_IndexError, e.what());
3639 }
3640 catch(const std::exception& e)
3641 {
3642 SWIG_exception(SWIG_RuntimeError, e.what());
3643 }
3644 }
3645 *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_result = (std::vector< oneML::face::FaceDetectorResult > *)result;
3646 return _swig_go_result;
3647}
3648
3649
3650std::vector< oneML::face::FaceDetectorResult > *_wrap_new_FaceDetectorResultVector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3651 std::vector< oneML::face::FaceDetectorResult > *arg1 = 0 ;
3652 std::vector< oneML::face::FaceDetectorResult > *result = 0 ;
3653 std::vector< oneML::face::FaceDetectorResult > *_swig_go_result;
3654
3655 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3656
3657 {
3658 try
3659 {
3660 result = (std::vector< oneML::face::FaceDetectorResult > *)new std::vector< oneML::face::FaceDetectorResult >((std::vector< oneML::face::FaceDetectorResult > const &)*arg1);
3661 }
3662 catch (const std::invalid_argument& e)
3663 {
3664 SWIG_exception(SWIG_ValueError, e.what());
3665 }
3666 catch (const std::out_of_range& e)
3667 {
3668 SWIG_exception(SWIG_IndexError, e.what());
3669 }
3670 catch(const std::exception& e)
3671 {
3672 SWIG_exception(SWIG_RuntimeError, e.what());
3673 }
3674 }
3675 *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_result = (std::vector< oneML::face::FaceDetectorResult > *)result;
3676 return _swig_go_result;
3677}
3678
3679
3680long long _wrap_FaceDetectorResultVector_size_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3681 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3682 std::vector< oneML::face::FaceDetectorResult >::size_type result;
3683 long long _swig_go_result;
3684
3685 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3686
3687 {
3688 try
3689 {
3690 result = ((std::vector< oneML::face::FaceDetectorResult > const *)arg1)->size();
3691 }
3692 catch (const std::invalid_argument& e)
3693 {
3694 SWIG_exception(SWIG_ValueError, e.what());
3695 }
3696 catch (const std::out_of_range& e)
3697 {
3698 SWIG_exception(SWIG_IndexError, e.what());
3699 }
3700 catch(const std::exception& e)
3701 {
3702 SWIG_exception(SWIG_RuntimeError, e.what());
3703 }
3704 }
3705 _swig_go_result = result;
3706 return _swig_go_result;
3707}
3708
3709
3710long long _wrap_FaceDetectorResultVector_capacity_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3711 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3712 std::vector< oneML::face::FaceDetectorResult >::size_type result;
3713 long long _swig_go_result;
3714
3715 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3716
3717 {
3718 try
3719 {
3720 result = ((std::vector< oneML::face::FaceDetectorResult > const *)arg1)->capacity();
3721 }
3722 catch (const std::invalid_argument& e)
3723 {
3724 SWIG_exception(SWIG_ValueError, e.what());
3725 }
3726 catch (const std::out_of_range& e)
3727 {
3728 SWIG_exception(SWIG_IndexError, e.what());
3729 }
3730 catch(const std::exception& e)
3731 {
3732 SWIG_exception(SWIG_RuntimeError, e.what());
3733 }
3734 }
3735 _swig_go_result = result;
3736 return _swig_go_result;
3737}
3738
3739
3740void _wrap_FaceDetectorResultVector_reserve_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0, long long _swig_go_1) {
3741 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3742 std::vector< oneML::face::FaceDetectorResult >::size_type arg2 ;
3743
3744 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3745 arg2 = (size_t)_swig_go_1;
3746
3747 {
3748 try
3749 {
3750 (arg1)->reserve(arg2);
3751 }
3752 catch (const std::invalid_argument& e)
3753 {
3754 SWIG_exception(SWIG_ValueError, e.what());
3755 }
3756 catch (const std::out_of_range& e)
3757 {
3758 SWIG_exception(SWIG_IndexError, e.what());
3759 }
3760 catch(const std::exception& e)
3761 {
3762 SWIG_exception(SWIG_RuntimeError, e.what());
3763 }
3764 }
3765
3766}
3767
3768
3769bool _wrap_FaceDetectorResultVector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3770 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3771 bool result;
3772 bool _swig_go_result;
3773
3774 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3775
3776 {
3777 try
3778 {
3779 result = (bool)((std::vector< oneML::face::FaceDetectorResult > const *)arg1)->empty();
3780 }
3781 catch (const std::invalid_argument& e)
3782 {
3783 SWIG_exception(SWIG_ValueError, e.what());
3784 }
3785 catch (const std::out_of_range& e)
3786 {
3787 SWIG_exception(SWIG_IndexError, e.what());
3788 }
3789 catch(const std::exception& e)
3790 {
3791 SWIG_exception(SWIG_RuntimeError, e.what());
3792 }
3793 }
3794 _swig_go_result = result;
3795 return _swig_go_result;
3796}
3797
3798
3799void _wrap_FaceDetectorResultVector_clear_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3800 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3801
3802 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3803
3804 {
3805 try
3806 {
3807 (arg1)->clear();
3808 }
3809 catch (const std::invalid_argument& e)
3810 {
3811 SWIG_exception(SWIG_ValueError, e.what());
3812 }
3813 catch (const std::out_of_range& e)
3814 {
3815 SWIG_exception(SWIG_IndexError, e.what());
3816 }
3817 catch(const std::exception& e)
3818 {
3819 SWIG_exception(SWIG_RuntimeError, e.what());
3820 }
3821 }
3822
3823}
3824
3825
3826void _wrap_FaceDetectorResultVector_add_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0, oneML::face::FaceDetectorResult *_swig_go_1) {
3827 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3828 std::vector< oneML::face::FaceDetectorResult >::value_type *arg2 = 0 ;
3829
3830 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3831 arg2 = *(std::vector< oneML::face::FaceDetectorResult >::value_type **)&_swig_go_1;
3832
3833 {
3834 try
3835 {
3836 (arg1)->push_back((std::vector< oneML::face::FaceDetectorResult >::value_type const &)*arg2);
3837 }
3838 catch (const std::invalid_argument& e)
3839 {
3840 SWIG_exception(SWIG_ValueError, e.what());
3841 }
3842 catch (const std::out_of_range& e)
3843 {
3844 SWIG_exception(SWIG_IndexError, e.what());
3845 }
3846 catch(const std::exception& e)
3847 {
3848 SWIG_exception(SWIG_RuntimeError, e.what());
3849 }
3850 }
3851
3852}
3853
3854
3855oneML::face::FaceDetectorResult *_wrap_FaceDetectorResultVector_get_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0, intgo _swig_go_1) {
3856 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3857 int arg2 ;
3858 std::vector< oneML::face::FaceDetectorResult >::value_type *result = 0 ;
3859 oneML::face::FaceDetectorResult *_swig_go_result;
3860
3861 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3862 arg2 = (int)_swig_go_1;
3863
3864 {
3865 try
3866 {
3867 try {
3868 result = (std::vector< oneML::face::FaceDetectorResult >::value_type *) &std_vector_Sl_oneML_face_FaceDetectorResult_Sg__get(arg1,arg2);
3869 } catch(std::out_of_range &_e) {
3870 _swig_gopanic((&_e)->what());
3871 }
3872 }
3873 catch (const std::invalid_argument& e)
3874 {
3875 SWIG_exception(SWIG_ValueError, e.what());
3876 }
3877 catch (const std::out_of_range& e)
3878 {
3879 SWIG_exception(SWIG_IndexError, e.what());
3880 }
3881 catch(const std::exception& e)
3882 {
3883 SWIG_exception(SWIG_RuntimeError, e.what());
3884 }
3885 }
3886 *(std::vector< oneML::face::FaceDetectorResult >::value_type **)&_swig_go_result = result;
3887 return _swig_go_result;
3888}
3889
3890
3891void _wrap_FaceDetectorResultVector_set_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0, intgo _swig_go_1, oneML::face::FaceDetectorResult *_swig_go_2) {
3892 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3893 int arg2 ;
3894 std::vector< oneML::face::FaceDetectorResult >::value_type *arg3 = 0 ;
3895
3896 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3897 arg2 = (int)_swig_go_1;
3898 arg3 = *(std::vector< oneML::face::FaceDetectorResult >::value_type **)&_swig_go_2;
3899
3900 {
3901 try
3902 {
3903 try {
3904 std_vector_Sl_oneML_face_FaceDetectorResult_Sg__set(arg1,arg2,(oneML::face::FaceDetectorResult const &)*arg3);
3905 } catch(std::out_of_range &_e) {
3906 _swig_gopanic((&_e)->what());
3907 }
3908 }
3909 catch (const std::invalid_argument& e)
3910 {
3911 SWIG_exception(SWIG_ValueError, e.what());
3912 }
3913 catch (const std::out_of_range& e)
3914 {
3915 SWIG_exception(SWIG_IndexError, e.what());
3916 }
3917 catch(const std::exception& e)
3918 {
3919 SWIG_exception(SWIG_RuntimeError, e.what());
3920 }
3921 }
3922
3923}
3924
3925
3926void _wrap_delete_FaceDetectorResultVector_face_86f062e835b3dd07(std::vector< oneML::face::FaceDetectorResult > *_swig_go_0) {
3927 std::vector< oneML::face::FaceDetectorResult > *arg1 = (std::vector< oneML::face::FaceDetectorResult > *) 0 ;
3928
3929 arg1 = *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_0;
3930
3931 {
3932 try
3933 {
3934 delete arg1;
3935 }
3936 catch (const std::invalid_argument& e)
3937 {
3938 SWIG_exception(SWIG_ValueError, e.what());
3939 }
3940 catch (const std::out_of_range& e)
3941 {
3942 SWIG_exception(SWIG_IndexError, e.what());
3943 }
3944 catch(const std::exception& e)
3945 {
3946 SWIG_exception(SWIG_RuntimeError, e.what());
3947 }
3948 }
3949
3950}
3951
3952
3953intgo _wrap_EMB_SIZE_get_face_86f062e835b3dd07() {
3954 int result;
3955 intgo _swig_go_result;
3956
3957
3958 result = (int)EMB_SIZE;
3959 _swig_go_result = result;
3960 return _swig_go_result;
3961}
3962
3963
3964intgo _wrap_N_LANDMARKS_get_face_86f062e835b3dd07() {
3965 int result;
3966 intgo _swig_go_result;
3967
3968
3969 result = (int)N_LANDMARKS;
3970 _swig_go_result = result;
3971 return _swig_go_result;
3972}
3973
3974
3975intgo _wrap_N_LANDMARKS_106_get_face_86f062e835b3dd07() {
3976 int result;
3977 intgo _swig_go_result;
3978
3979
3980 result = (int)N_LANDMARKS_106;
3981 _swig_go_result = result;
3982 return _swig_go_result;
3983}
3984
3985
3986oneML::face::FaceDetectorResult *_wrap_new_FaceDetectorResult_face_86f062e835b3dd07() {
3987 oneML::face::FaceDetectorResult *result = 0 ;
3988 oneML::face::FaceDetectorResult *_swig_go_result;
3989
3990
3991 {
3992 try
3993 {
3994 result = (oneML::face::FaceDetectorResult *)new oneML::face::FaceDetectorResult();
3995 }
3996 catch (const std::invalid_argument& e)
3997 {
3998 SWIG_exception(SWIG_ValueError, e.what());
3999 }
4000 catch (const std::out_of_range& e)
4001 {
4002 SWIG_exception(SWIG_IndexError, e.what());
4003 }
4004 catch(const std::exception& e)
4005 {
4006 SWIG_exception(SWIG_RuntimeError, e.what());
4007 }
4008 }
4009 *(oneML::face::FaceDetectorResult **)&_swig_go_result = (oneML::face::FaceDetectorResult *)result;
4010 return _swig_go_result;
4011}
4012
4013
4014intgo _wrap_FaceDetectorResult_GetSize_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4015 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4016 int result;
4017 intgo _swig_go_result;
4018
4019 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4020
4021 {
4022 try
4023 {
4024 result = (int)((oneML::face::FaceDetectorResult const *)arg1)->get_size();
4025 }
4026 catch (const std::invalid_argument& e)
4027 {
4028 SWIG_exception(SWIG_ValueError, e.what());
4029 }
4030 catch (const std::out_of_range& e)
4031 {
4032 SWIG_exception(SWIG_IndexError, e.what());
4033 }
4034 catch(const std::exception& e)
4035 {
4036 SWIG_exception(SWIG_RuntimeError, e.what());
4037 }
4038 }
4039 _swig_go_result = result;
4040 return _swig_go_result;
4041}
4042
4043
4044std::vector< float > *_wrap_FaceDetectorResult_GetScores_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4045 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4046 std::vector< float > result;
4047 std::vector< float > *_swig_go_result;
4048
4049 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4050
4051 {
4052 try
4053 {
4054 result = oneML_face_FaceDetectorResult_go_get_scores(arg1);
4055 }
4056 catch (const std::invalid_argument& e)
4057 {
4058 SWIG_exception(SWIG_ValueError, e.what());
4059 }
4060 catch (const std::out_of_range& e)
4061 {
4062 SWIG_exception(SWIG_IndexError, e.what());
4063 }
4064 catch(const std::exception& e)
4065 {
4066 SWIG_exception(SWIG_RuntimeError, e.what());
4067 }
4068 }
4069 *(std::vector< float > **)&_swig_go_result = new std::vector< float >(result);
4070 return _swig_go_result;
4071}
4072
4073
4074std::vector< oneML::BBox > *_wrap_FaceDetectorResult_GetBboxes_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4075 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4076 std::vector< oneML::face::BBox > result;
4077 std::vector< oneML::BBox > *_swig_go_result;
4078
4079 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4080
4081 {
4082 try
4083 {
4084 result = oneML_face_FaceDetectorResult_go_get_bboxes(arg1);
4085 }
4086 catch (const std::invalid_argument& e)
4087 {
4088 SWIG_exception(SWIG_ValueError, e.what());
4089 }
4090 catch (const std::out_of_range& e)
4091 {
4092 SWIG_exception(SWIG_IndexError, e.what());
4093 }
4094 catch(const std::exception& e)
4095 {
4096 SWIG_exception(SWIG_RuntimeError, e.what());
4097 }
4098 }
4099 *(std::vector< oneML::face::BBox > **)&_swig_go_result = new std::vector< oneML::face::BBox >(result);
4100 return _swig_go_result;
4101}
4102
4103
4104std::vector< oneML::face::FaceLandmark< 5 > > *_wrap_FaceDetectorResult_GetLandmarks_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4105 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4106 std::vector< oneML::face::FaceLandmark5 > result;
4107 std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_result;
4108
4109 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4110
4111 {
4112 try
4113 {
4114 result = oneML_face_FaceDetectorResult_go_get_landmarks(arg1);
4115 }
4116 catch (const std::invalid_argument& e)
4117 {
4118 SWIG_exception(SWIG_ValueError, e.what());
4119 }
4120 catch (const std::out_of_range& e)
4121 {
4122 SWIG_exception(SWIG_IndexError, e.what());
4123 }
4124 catch(const std::exception& e)
4125 {
4126 SWIG_exception(SWIG_RuntimeError, e.what());
4127 }
4128 }
4129 *(std::vector< oneML::face::FaceLandmark5 > **)&_swig_go_result = new std::vector< oneML::face::FaceLandmark5 >(result);
4130 return _swig_go_result;
4131}
4132
4133
4134std::vector< int > *_wrap_FaceDetectorResult_GetPoses_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4135 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4136 std::vector< int > result;
4137 std::vector< int > *_swig_go_result;
4138
4139 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4140
4141 {
4142 try
4143 {
4144 result = oneML_face_FaceDetectorResult_go_get_poses(arg1);
4145 }
4146 catch (const std::invalid_argument& e)
4147 {
4148 SWIG_exception(SWIG_ValueError, e.what());
4149 }
4150 catch (const std::out_of_range& e)
4151 {
4152 SWIG_exception(SWIG_IndexError, e.what());
4153 }
4154 catch(const std::exception& e)
4155 {
4156 SWIG_exception(SWIG_RuntimeError, e.what());
4157 }
4158 }
4159 *(std::vector< int > **)&_swig_go_result = new std::vector< int >(result);
4160 return _swig_go_result;
4161}
4162
4163
4164std::vector< int > *_wrap_FaceDetectorResult_GetReturnStatus_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4165 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4166 std::vector< int > result;
4167 std::vector< int > *_swig_go_result;
4168
4169 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4170
4171 {
4172 try
4173 {
4174 result = oneML_face_FaceDetectorResult_go_get_return_status(arg1);
4175 }
4176 catch (const std::invalid_argument& e)
4177 {
4178 SWIG_exception(SWIG_ValueError, e.what());
4179 }
4180 catch (const std::out_of_range& e)
4181 {
4182 SWIG_exception(SWIG_IndexError, e.what());
4183 }
4184 catch(const std::exception& e)
4185 {
4186 SWIG_exception(SWIG_RuntimeError, e.what());
4187 }
4188 }
4189 *(std::vector< int > **)&_swig_go_result = new std::vector< int >(result);
4190 return _swig_go_result;
4191}
4192
4193
4194void _wrap_delete_FaceDetectorResult_face_86f062e835b3dd07(oneML::face::FaceDetectorResult *_swig_go_0) {
4195 oneML::face::FaceDetectorResult *arg1 = (oneML::face::FaceDetectorResult *) 0 ;
4196
4197 arg1 = *(oneML::face::FaceDetectorResult **)&_swig_go_0;
4198
4199 {
4200 try
4201 {
4202 delete arg1;
4203 }
4204 catch (const std::invalid_argument& e)
4205 {
4206 SWIG_exception(SWIG_ValueError, e.what());
4207 }
4208 catch (const std::out_of_range& e)
4209 {
4210 SWIG_exception(SWIG_IndexError, e.what());
4211 }
4212 catch(const std::exception& e)
4213 {
4214 SWIG_exception(SWIG_RuntimeError, e.what());
4215 }
4216 }
4217
4218}
4219
4220
4221oneML::face::FaceDetector *_wrap_new_FaceDetector_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
4222 oneML::LicenseManager *arg1 = 0 ;
4223 oneML::face::FaceDetector *result = 0 ;
4224 oneML::face::FaceDetector *_swig_go_result;
4225
4226 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
4227
4228 {
4229 try
4230 {
4231 result = (oneML::face::FaceDetector *)new oneML::face::FaceDetector(*arg1);
4232 }
4233 catch (const std::invalid_argument& e)
4234 {
4235 SWIG_exception(SWIG_ValueError, e.what());
4236 }
4237 catch (const std::out_of_range& e)
4238 {
4239 SWIG_exception(SWIG_IndexError, e.what());
4240 }
4241 catch(const std::exception& e)
4242 {
4243 SWIG_exception(SWIG_RuntimeError, e.what());
4244 }
4245 }
4246 *(oneML::face::FaceDetector **)&_swig_go_result = (oneML::face::FaceDetector *)result;
4247 return _swig_go_result;
4248}
4249
4250
4251std::vector< oneML::face::FaceDetectorResult > *_wrap_FaceDetector_DetectBatch__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, std::vector< oneML::Image > *_swig_go_1) {
4252 oneML::face::FaceDetector *arg1 = (oneML::face::FaceDetector *) 0 ;
4253 std::vector< oneML::Image > *arg2 = 0 ;
4254 std::vector< oneML::face::FaceDetectorResult > result;
4255 std::vector< oneML::face::FaceDetectorResult > *_swig_go_result;
4256
4257 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
4258 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
4259
4260 {
4261 try
4262 {
4263 result = oneML_face_FaceDetector_go_detect_batch__SWIG_0(arg1,*arg2);
4264 }
4265 catch (const std::invalid_argument& e)
4266 {
4267 SWIG_exception(SWIG_ValueError, e.what());
4268 }
4269 catch (const std::out_of_range& e)
4270 {
4271 SWIG_exception(SWIG_IndexError, e.what());
4272 }
4273 catch(const std::exception& e)
4274 {
4275 SWIG_exception(SWIG_RuntimeError, e.what());
4276 }
4277 }
4278 *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_result = new std::vector< oneML::face::FaceDetectorResult >(result);
4279 return _swig_go_result;
4280}
4281
4282
4283std::vector< oneML::face::FaceDetectorResult > *_wrap_FaceDetector_DetectBatch__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, std::vector< oneML::Image > *_swig_go_1, float _swig_go_2) {
4284 oneML::face::FaceDetector *arg1 = (oneML::face::FaceDetector *) 0 ;
4285 std::vector< oneML::Image > *arg2 = 0 ;
4286 float arg3 ;
4287 std::vector< oneML::face::FaceDetectorResult > result;
4288 std::vector< oneML::face::FaceDetectorResult > *_swig_go_result;
4289
4290 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
4291 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
4292 arg3 = (float)_swig_go_2;
4293
4294 {
4295 try
4296 {
4297 result = oneML_face_FaceDetector_go_detect_batch__SWIG_1(arg1,*arg2,arg3);
4298 }
4299 catch (const std::invalid_argument& e)
4300 {
4301 SWIG_exception(SWIG_ValueError, e.what());
4302 }
4303 catch (const std::out_of_range& e)
4304 {
4305 SWIG_exception(SWIG_IndexError, e.what());
4306 }
4307 catch(const std::exception& e)
4308 {
4309 SWIG_exception(SWIG_RuntimeError, e.what());
4310 }
4311 }
4312 *(std::vector< oneML::face::FaceDetectorResult > **)&_swig_go_result = new std::vector< oneML::face::FaceDetectorResult >(result);
4313 return _swig_go_result;
4314}
4315
4316
4317oneML::face::FaceDetectorResult *_wrap_FaceDetector_Detect__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, oneML::Image *_swig_go_1) {
4318 oneML::face::FaceDetector *arg1 = (oneML::face::FaceDetector *) 0 ;
4319 oneML::Image *arg2 = 0 ;
4320 oneML::face::FaceDetectorResult result;
4321 oneML::face::FaceDetectorResult *_swig_go_result;
4322
4323 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
4324 arg2 = *(oneML::Image **)&_swig_go_1;
4325
4326 {
4327 try
4328 {
4329 result = oneML_face_FaceDetector_go_detect__SWIG_0(arg1,*arg2);
4330 }
4331 catch (const std::invalid_argument& e)
4332 {
4333 SWIG_exception(SWIG_ValueError, e.what());
4334 }
4335 catch (const std::out_of_range& e)
4336 {
4337 SWIG_exception(SWIG_IndexError, e.what());
4338 }
4339 catch(const std::exception& e)
4340 {
4341 SWIG_exception(SWIG_RuntimeError, e.what());
4342 }
4343 }
4344 *(oneML::face::FaceDetectorResult **)&_swig_go_result = new oneML::face::FaceDetectorResult(result);
4345 return _swig_go_result;
4346}
4347
4348
4349oneML::face::FaceDetectorResult *_wrap_FaceDetector_Detect__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, oneML::Image *_swig_go_1, float _swig_go_2) {
4350 oneML::face::FaceDetector *arg1 = (oneML::face::FaceDetector *) 0 ;
4351 oneML::Image *arg2 = 0 ;
4352 float arg3 ;
4353 oneML::face::FaceDetectorResult result;
4354 oneML::face::FaceDetectorResult *_swig_go_result;
4355
4356 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
4357 arg2 = *(oneML::Image **)&_swig_go_1;
4358 arg3 = (float)_swig_go_2;
4359
4360 {
4361 try
4362 {
4363 result = oneML_face_FaceDetector_go_detect__SWIG_1(arg1,*arg2,arg3);
4364 }
4365 catch (const std::invalid_argument& e)
4366 {
4367 SWIG_exception(SWIG_ValueError, e.what());
4368 }
4369 catch (const std::out_of_range& e)
4370 {
4371 SWIG_exception(SWIG_IndexError, e.what());
4372 }
4373 catch(const std::exception& e)
4374 {
4375 SWIG_exception(SWIG_RuntimeError, e.what());
4376 }
4377 }
4378 *(oneML::face::FaceDetectorResult **)&_swig_go_result = new oneML::face::FaceDetectorResult(result);
4379 return _swig_go_result;
4380}
4381
4382
4383void _wrap_delete_FaceDetector_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0) {
4384 oneML::face::FaceDetector *arg1 = (oneML::face::FaceDetector *) 0 ;
4385
4386 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
4387
4388 {
4389 try
4390 {
4391 delete arg1;
4392 }
4393 catch (const std::invalid_argument& e)
4394 {
4395 SWIG_exception(SWIG_ValueError, e.what());
4396 }
4397 catch (const std::out_of_range& e)
4398 {
4399 SWIG_exception(SWIG_IndexError, e.what());
4400 }
4401 catch(const std::exception& e)
4402 {
4403 SWIG_exception(SWIG_RuntimeError, e.what());
4404 }
4405 }
4406
4407}
4408
4409
4410intgo _wrap_FaceDetectorStatus_Empty_face_86f062e835b3dd07() {
4411 oneML::face::FaceDetectorStatus result;
4412 intgo _swig_go_result;
4413
4414
4415 {
4416 try
4417 {
4418 result = oneML::face::FaceDetectorStatus::Empty;
4419
4420 }
4421 catch (const std::invalid_argument& e)
4422 {
4423 SWIG_exception(SWIG_ValueError, e.what());
4424 }
4425 catch (const std::out_of_range& e)
4426 {
4427 SWIG_exception(SWIG_IndexError, e.what());
4428 }
4429 catch(const std::exception& e)
4430 {
4431 SWIG_exception(SWIG_RuntimeError, e.what());
4432 }
4433 }
4434 _swig_go_result = (intgo)result;
4435 return _swig_go_result;
4436}
4437
4438
4439intgo _wrap_FaceDetectorStatus_Success_face_86f062e835b3dd07() {
4440 oneML::face::FaceDetectorStatus result;
4441 intgo _swig_go_result;
4442
4443
4444 {
4445 try
4446 {
4447 result = oneML::face::FaceDetectorStatus::Success;
4448
4449 }
4450 catch (const std::invalid_argument& e)
4451 {
4452 SWIG_exception(SWIG_ValueError, e.what());
4453 }
4454 catch (const std::out_of_range& e)
4455 {
4456 SWIG_exception(SWIG_IndexError, e.what());
4457 }
4458 catch(const std::exception& e)
4459 {
4460 SWIG_exception(SWIG_RuntimeError, e.what());
4461 }
4462 }
4463 _swig_go_result = (intgo)result;
4464 return _swig_go_result;
4465}
4466
4467
4468intgo _wrap_FaceDetectorStatus_Fail_face_86f062e835b3dd07() {
4469 oneML::face::FaceDetectorStatus result;
4470 intgo _swig_go_result;
4471
4472
4473 {
4474 try
4475 {
4476 result = oneML::face::FaceDetectorStatus::Fail;
4477
4478 }
4479 catch (const std::invalid_argument& e)
4480 {
4481 SWIG_exception(SWIG_ValueError, e.what());
4482 }
4483 catch (const std::out_of_range& e)
4484 {
4485 SWIG_exception(SWIG_IndexError, e.what());
4486 }
4487 catch(const std::exception& e)
4488 {
4489 SWIG_exception(SWIG_RuntimeError, e.what());
4490 }
4491 }
4492 _swig_go_result = (intgo)result;
4493 return _swig_go_result;
4494}
4495
4496
4497std::array< float,512 > *_wrap_new_EmbeddingArray__SWIG_0_face_86f062e835b3dd07() {
4498 std::array< float,512 > *result = 0 ;
4499 std::array< float,512 > *_swig_go_result;
4500
4501
4502 {
4503 try
4504 {
4505 result = (std::array< float,512 > *)new std::array< float,512 >();
4506 }
4507 catch (const std::invalid_argument& e)
4508 {
4509 SWIG_exception(SWIG_ValueError, e.what());
4510 }
4511 catch (const std::out_of_range& e)
4512 {
4513 SWIG_exception(SWIG_IndexError, e.what());
4514 }
4515 catch(const std::exception& e)
4516 {
4517 SWIG_exception(SWIG_RuntimeError, e.what());
4518 }
4519 }
4520 *(std::array< float,512 > **)&_swig_go_result = (std::array< float,512 > *)result;
4521 return _swig_go_result;
4522}
4523
4524
4525std::array< float,512 > *_wrap_new_EmbeddingArray__SWIG_1_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0) {
4526 std::array< float,512 > *arg1 = 0 ;
4527 std::array< float,512 > *result = 0 ;
4528 std::array< float,512 > *_swig_go_result;
4529
4530 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4531
4532 {
4533 try
4534 {
4535 result = (std::array< float,512 > *)new std::array< float,512 >((std::array< float,512 > const &)*arg1);
4536 }
4537 catch (const std::invalid_argument& e)
4538 {
4539 SWIG_exception(SWIG_ValueError, e.what());
4540 }
4541 catch (const std::out_of_range& e)
4542 {
4543 SWIG_exception(SWIG_IndexError, e.what());
4544 }
4545 catch(const std::exception& e)
4546 {
4547 SWIG_exception(SWIG_RuntimeError, e.what());
4548 }
4549 }
4550 *(std::array< float,512 > **)&_swig_go_result = (std::array< float,512 > *)result;
4551 return _swig_go_result;
4552}
4553
4554
4555long long _wrap_EmbeddingArray_size_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0) {
4556 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4557 std::array< float,512 >::size_type result;
4558 long long _swig_go_result;
4559
4560 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4561
4562 {
4563 try
4564 {
4565 result = ((std::array< float,512 > const *)arg1)->size();
4566 }
4567 catch (const std::invalid_argument& e)
4568 {
4569 SWIG_exception(SWIG_ValueError, e.what());
4570 }
4571 catch (const std::out_of_range& e)
4572 {
4573 SWIG_exception(SWIG_IndexError, e.what());
4574 }
4575 catch(const std::exception& e)
4576 {
4577 SWIG_exception(SWIG_RuntimeError, e.what());
4578 }
4579 }
4580 _swig_go_result = result;
4581 return _swig_go_result;
4582}
4583
4584
4585bool _wrap_EmbeddingArray_isEmpty_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0) {
4586 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4587 bool result;
4588 bool _swig_go_result;
4589
4590 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4591
4592 {
4593 try
4594 {
4595 result = (bool)((std::array< float,512 > const *)arg1)->empty();
4596 }
4597 catch (const std::invalid_argument& e)
4598 {
4599 SWIG_exception(SWIG_ValueError, e.what());
4600 }
4601 catch (const std::out_of_range& e)
4602 {
4603 SWIG_exception(SWIG_IndexError, e.what());
4604 }
4605 catch(const std::exception& e)
4606 {
4607 SWIG_exception(SWIG_RuntimeError, e.what());
4608 }
4609 }
4610 _swig_go_result = result;
4611 return _swig_go_result;
4612}
4613
4614
4615void _wrap_EmbeddingArray_fill_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0, float _swig_go_1) {
4616 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4617 float *arg2 = 0 ;
4618
4619 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4620 arg2 = (float *)&_swig_go_1;
4621
4622 {
4623 try
4624 {
4625 (arg1)->fill((float const &)*arg2);
4626 }
4627 catch (const std::invalid_argument& e)
4628 {
4629 SWIG_exception(SWIG_ValueError, e.what());
4630 }
4631 catch (const std::out_of_range& e)
4632 {
4633 SWIG_exception(SWIG_IndexError, e.what());
4634 }
4635 catch(const std::exception& e)
4636 {
4637 SWIG_exception(SWIG_RuntimeError, e.what());
4638 }
4639 }
4640
4641}
4642
4643
4644float _wrap_EmbeddingArray_get_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0, intgo _swig_go_1) {
4645 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4646 int arg2 ;
4647 std::array< float,512 >::value_type *result = 0 ;
4648 float _swig_go_result;
4649
4650 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4651 arg2 = (int)_swig_go_1;
4652
4653 {
4654 try
4655 {
4656 try {
4657 result = (std::array< float,512 >::value_type *) &std_array_Sl_float_Sc_512_Sg__get(arg1,arg2);
4658 } catch(std::out_of_range &_e) {
4659 _swig_gopanic((&_e)->what());
4660 }
4661 }
4662 catch (const std::invalid_argument& e)
4663 {
4664 SWIG_exception(SWIG_ValueError, e.what());
4665 }
4666 catch (const std::out_of_range& e)
4667 {
4668 SWIG_exception(SWIG_IndexError, e.what());
4669 }
4670 catch(const std::exception& e)
4671 {
4672 SWIG_exception(SWIG_RuntimeError, e.what());
4673 }
4674 }
4675 _swig_go_result = (float)*result;
4676 return _swig_go_result;
4677}
4678
4679
4680void _wrap_EmbeddingArray_set_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0, intgo _swig_go_1, float _swig_go_2) {
4681 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4682 int arg2 ;
4683 std::array< float,512 >::value_type *arg3 = 0 ;
4684
4685 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4686 arg2 = (int)_swig_go_1;
4687 arg3 = (std::array< float,512 >::value_type *)&_swig_go_2;
4688
4689 {
4690 try
4691 {
4692 try {
4693 std_array_Sl_float_Sc_512_Sg__set(arg1,arg2,(float const &)*arg3);
4694 } catch(std::out_of_range &_e) {
4695 _swig_gopanic((&_e)->what());
4696 }
4697 }
4698 catch (const std::invalid_argument& e)
4699 {
4700 SWIG_exception(SWIG_ValueError, e.what());
4701 }
4702 catch (const std::out_of_range& e)
4703 {
4704 SWIG_exception(SWIG_IndexError, e.what());
4705 }
4706 catch(const std::exception& e)
4707 {
4708 SWIG_exception(SWIG_RuntimeError, e.what());
4709 }
4710 }
4711
4712}
4713
4714
4715void _wrap_delete_EmbeddingArray_face_86f062e835b3dd07(std::array< float,512 > *_swig_go_0) {
4716 std::array< float,512 > *arg1 = (std::array< float,512 > *) 0 ;
4717
4718 arg1 = *(std::array< float,512 > **)&_swig_go_0;
4719
4720 {
4721 try
4722 {
4723 delete arg1;
4724 }
4725 catch (const std::invalid_argument& e)
4726 {
4727 SWIG_exception(SWIG_ValueError, e.what());
4728 }
4729 catch (const std::out_of_range& e)
4730 {
4731 SWIG_exception(SWIG_IndexError, e.what());
4732 }
4733 catch(const std::exception& e)
4734 {
4735 SWIG_exception(SWIG_RuntimeError, e.what());
4736 }
4737 }
4738
4739}
4740
4741
4742std::vector< oneML::face::FaceEmbedderResult > *_wrap_new_FaceEmbedderResultVector__SWIG_0_face_86f062e835b3dd07() {
4743 std::vector< oneML::face::FaceEmbedderResult > *result = 0 ;
4744 std::vector< oneML::face::FaceEmbedderResult > *_swig_go_result;
4745
4746
4747 {
4748 try
4749 {
4750 result = (std::vector< oneML::face::FaceEmbedderResult > *)new std::vector< oneML::face::FaceEmbedderResult >();
4751 }
4752 catch (const std::invalid_argument& e)
4753 {
4754 SWIG_exception(SWIG_ValueError, e.what());
4755 }
4756 catch (const std::out_of_range& e)
4757 {
4758 SWIG_exception(SWIG_IndexError, e.what());
4759 }
4760 catch(const std::exception& e)
4761 {
4762 SWIG_exception(SWIG_RuntimeError, e.what());
4763 }
4764 }
4765 *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_result = (std::vector< oneML::face::FaceEmbedderResult > *)result;
4766 return _swig_go_result;
4767}
4768
4769
4770std::vector< oneML::face::FaceEmbedderResult > *_wrap_new_FaceEmbedderResultVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
4771 std::vector< oneML::face::FaceEmbedderResult >::size_type arg1 ;
4772 std::vector< oneML::face::FaceEmbedderResult > *result = 0 ;
4773 std::vector< oneML::face::FaceEmbedderResult > *_swig_go_result;
4774
4775 arg1 = (size_t)_swig_go_0;
4776
4777 {
4778 try
4779 {
4780 result = (std::vector< oneML::face::FaceEmbedderResult > *)new std::vector< oneML::face::FaceEmbedderResult >(arg1);
4781 }
4782 catch (const std::invalid_argument& e)
4783 {
4784 SWIG_exception(SWIG_ValueError, e.what());
4785 }
4786 catch (const std::out_of_range& e)
4787 {
4788 SWIG_exception(SWIG_IndexError, e.what());
4789 }
4790 catch(const std::exception& e)
4791 {
4792 SWIG_exception(SWIG_RuntimeError, e.what());
4793 }
4794 }
4795 *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_result = (std::vector< oneML::face::FaceEmbedderResult > *)result;
4796 return _swig_go_result;
4797}
4798
4799
4800std::vector< oneML::face::FaceEmbedderResult > *_wrap_new_FaceEmbedderResultVector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
4801 std::vector< oneML::face::FaceEmbedderResult > *arg1 = 0 ;
4802 std::vector< oneML::face::FaceEmbedderResult > *result = 0 ;
4803 std::vector< oneML::face::FaceEmbedderResult > *_swig_go_result;
4804
4805 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4806
4807 {
4808 try
4809 {
4810 result = (std::vector< oneML::face::FaceEmbedderResult > *)new std::vector< oneML::face::FaceEmbedderResult >((std::vector< oneML::face::FaceEmbedderResult > const &)*arg1);
4811 }
4812 catch (const std::invalid_argument& e)
4813 {
4814 SWIG_exception(SWIG_ValueError, e.what());
4815 }
4816 catch (const std::out_of_range& e)
4817 {
4818 SWIG_exception(SWIG_IndexError, e.what());
4819 }
4820 catch(const std::exception& e)
4821 {
4822 SWIG_exception(SWIG_RuntimeError, e.what());
4823 }
4824 }
4825 *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_result = (std::vector< oneML::face::FaceEmbedderResult > *)result;
4826 return _swig_go_result;
4827}
4828
4829
4830long long _wrap_FaceEmbedderResultVector_size_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
4831 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4832 std::vector< oneML::face::FaceEmbedderResult >::size_type result;
4833 long long _swig_go_result;
4834
4835 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4836
4837 {
4838 try
4839 {
4840 result = ((std::vector< oneML::face::FaceEmbedderResult > const *)arg1)->size();
4841 }
4842 catch (const std::invalid_argument& e)
4843 {
4844 SWIG_exception(SWIG_ValueError, e.what());
4845 }
4846 catch (const std::out_of_range& e)
4847 {
4848 SWIG_exception(SWIG_IndexError, e.what());
4849 }
4850 catch(const std::exception& e)
4851 {
4852 SWIG_exception(SWIG_RuntimeError, e.what());
4853 }
4854 }
4855 _swig_go_result = result;
4856 return _swig_go_result;
4857}
4858
4859
4860long long _wrap_FaceEmbedderResultVector_capacity_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
4861 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4862 std::vector< oneML::face::FaceEmbedderResult >::size_type result;
4863 long long _swig_go_result;
4864
4865 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4866
4867 {
4868 try
4869 {
4870 result = ((std::vector< oneML::face::FaceEmbedderResult > const *)arg1)->capacity();
4871 }
4872 catch (const std::invalid_argument& e)
4873 {
4874 SWIG_exception(SWIG_ValueError, e.what());
4875 }
4876 catch (const std::out_of_range& e)
4877 {
4878 SWIG_exception(SWIG_IndexError, e.what());
4879 }
4880 catch(const std::exception& e)
4881 {
4882 SWIG_exception(SWIG_RuntimeError, e.what());
4883 }
4884 }
4885 _swig_go_result = result;
4886 return _swig_go_result;
4887}
4888
4889
4890void _wrap_FaceEmbedderResultVector_reserve_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0, long long _swig_go_1) {
4891 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4892 std::vector< oneML::face::FaceEmbedderResult >::size_type arg2 ;
4893
4894 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4895 arg2 = (size_t)_swig_go_1;
4896
4897 {
4898 try
4899 {
4900 (arg1)->reserve(arg2);
4901 }
4902 catch (const std::invalid_argument& e)
4903 {
4904 SWIG_exception(SWIG_ValueError, e.what());
4905 }
4906 catch (const std::out_of_range& e)
4907 {
4908 SWIG_exception(SWIG_IndexError, e.what());
4909 }
4910 catch(const std::exception& e)
4911 {
4912 SWIG_exception(SWIG_RuntimeError, e.what());
4913 }
4914 }
4915
4916}
4917
4918
4919bool _wrap_FaceEmbedderResultVector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
4920 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4921 bool result;
4922 bool _swig_go_result;
4923
4924 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4925
4926 {
4927 try
4928 {
4929 result = (bool)((std::vector< oneML::face::FaceEmbedderResult > const *)arg1)->empty();
4930 }
4931 catch (const std::invalid_argument& e)
4932 {
4933 SWIG_exception(SWIG_ValueError, e.what());
4934 }
4935 catch (const std::out_of_range& e)
4936 {
4937 SWIG_exception(SWIG_IndexError, e.what());
4938 }
4939 catch(const std::exception& e)
4940 {
4941 SWIG_exception(SWIG_RuntimeError, e.what());
4942 }
4943 }
4944 _swig_go_result = result;
4945 return _swig_go_result;
4946}
4947
4948
4949void _wrap_FaceEmbedderResultVector_clear_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
4950 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4951
4952 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4953
4954 {
4955 try
4956 {
4957 (arg1)->clear();
4958 }
4959 catch (const std::invalid_argument& e)
4960 {
4961 SWIG_exception(SWIG_ValueError, e.what());
4962 }
4963 catch (const std::out_of_range& e)
4964 {
4965 SWIG_exception(SWIG_IndexError, e.what());
4966 }
4967 catch(const std::exception& e)
4968 {
4969 SWIG_exception(SWIG_RuntimeError, e.what());
4970 }
4971 }
4972
4973}
4974
4975
4976void _wrap_FaceEmbedderResultVector_add_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0, oneML::face::FaceEmbedderResult *_swig_go_1) {
4977 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
4978 std::vector< oneML::face::FaceEmbedderResult >::value_type *arg2 = 0 ;
4979
4980 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
4981 arg2 = *(std::vector< oneML::face::FaceEmbedderResult >::value_type **)&_swig_go_1;
4982
4983 {
4984 try
4985 {
4986 (arg1)->push_back((std::vector< oneML::face::FaceEmbedderResult >::value_type const &)*arg2);
4987 }
4988 catch (const std::invalid_argument& e)
4989 {
4990 SWIG_exception(SWIG_ValueError, e.what());
4991 }
4992 catch (const std::out_of_range& e)
4993 {
4994 SWIG_exception(SWIG_IndexError, e.what());
4995 }
4996 catch(const std::exception& e)
4997 {
4998 SWIG_exception(SWIG_RuntimeError, e.what());
4999 }
5000 }
5001
5002}
5003
5004
5005oneML::face::FaceEmbedderResult *_wrap_FaceEmbedderResultVector_get_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0, intgo _swig_go_1) {
5006 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
5007 int arg2 ;
5008 std::vector< oneML::face::FaceEmbedderResult >::value_type *result = 0 ;
5009 oneML::face::FaceEmbedderResult *_swig_go_result;
5010
5011 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
5012 arg2 = (int)_swig_go_1;
5013
5014 {
5015 try
5016 {
5017 try {
5018 result = (std::vector< oneML::face::FaceEmbedderResult >::value_type *) &std_vector_Sl_oneML_face_FaceEmbedderResult_Sg__get(arg1,arg2);
5019 } catch(std::out_of_range &_e) {
5020 _swig_gopanic((&_e)->what());
5021 }
5022 }
5023 catch (const std::invalid_argument& e)
5024 {
5025 SWIG_exception(SWIG_ValueError, e.what());
5026 }
5027 catch (const std::out_of_range& e)
5028 {
5029 SWIG_exception(SWIG_IndexError, e.what());
5030 }
5031 catch(const std::exception& e)
5032 {
5033 SWIG_exception(SWIG_RuntimeError, e.what());
5034 }
5035 }
5036 *(std::vector< oneML::face::FaceEmbedderResult >::value_type **)&_swig_go_result = result;
5037 return _swig_go_result;
5038}
5039
5040
5041void _wrap_FaceEmbedderResultVector_set_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0, intgo _swig_go_1, oneML::face::FaceEmbedderResult *_swig_go_2) {
5042 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
5043 int arg2 ;
5044 std::vector< oneML::face::FaceEmbedderResult >::value_type *arg3 = 0 ;
5045
5046 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
5047 arg2 = (int)_swig_go_1;
5048 arg3 = *(std::vector< oneML::face::FaceEmbedderResult >::value_type **)&_swig_go_2;
5049
5050 {
5051 try
5052 {
5053 try {
5054 std_vector_Sl_oneML_face_FaceEmbedderResult_Sg__set(arg1,arg2,(oneML::face::FaceEmbedderResult const &)*arg3);
5055 } catch(std::out_of_range &_e) {
5056 _swig_gopanic((&_e)->what());
5057 }
5058 }
5059 catch (const std::invalid_argument& e)
5060 {
5061 SWIG_exception(SWIG_ValueError, e.what());
5062 }
5063 catch (const std::out_of_range& e)
5064 {
5065 SWIG_exception(SWIG_IndexError, e.what());
5066 }
5067 catch(const std::exception& e)
5068 {
5069 SWIG_exception(SWIG_RuntimeError, e.what());
5070 }
5071 }
5072
5073}
5074
5075
5076void _wrap_delete_FaceEmbedderResultVector_face_86f062e835b3dd07(std::vector< oneML::face::FaceEmbedderResult > *_swig_go_0) {
5077 std::vector< oneML::face::FaceEmbedderResult > *arg1 = (std::vector< oneML::face::FaceEmbedderResult > *) 0 ;
5078
5079 arg1 = *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_0;
5080
5081 {
5082 try
5083 {
5084 delete arg1;
5085 }
5086 catch (const std::invalid_argument& e)
5087 {
5088 SWIG_exception(SWIG_ValueError, e.what());
5089 }
5090 catch (const std::out_of_range& e)
5091 {
5092 SWIG_exception(SWIG_IndexError, e.what());
5093 }
5094 catch(const std::exception& e)
5095 {
5096 SWIG_exception(SWIG_RuntimeError, e.what());
5097 }
5098 }
5099
5100}
5101
5102
5103oneML::face::FaceEmbedderResult *_wrap_new_FaceEmbedderResult_face_86f062e835b3dd07() {
5104 oneML::face::FaceEmbedderResult *result = 0 ;
5105 oneML::face::FaceEmbedderResult *_swig_go_result;
5106
5107
5108 {
5109 try
5110 {
5111 result = (oneML::face::FaceEmbedderResult *)new oneML::face::FaceEmbedderResult();
5112 }
5113 catch (const std::invalid_argument& e)
5114 {
5115 SWIG_exception(SWIG_ValueError, e.what());
5116 }
5117 catch (const std::out_of_range& e)
5118 {
5119 SWIG_exception(SWIG_IndexError, e.what());
5120 }
5121 catch(const std::exception& e)
5122 {
5123 SWIG_exception(SWIG_RuntimeError, e.what());
5124 }
5125 }
5126 *(oneML::face::FaceEmbedderResult **)&_swig_go_result = (oneML::face::FaceEmbedderResult *)result;
5127 return _swig_go_result;
5128}
5129
5130
5131intgo _wrap_FaceEmbedderResult_GetSize_face_86f062e835b3dd07(oneML::face::FaceEmbedderResult *_swig_go_0) {
5132 oneML::face::FaceEmbedderResult *arg1 = (oneML::face::FaceEmbedderResult *) 0 ;
5133 int result;
5134 intgo _swig_go_result;
5135
5136 arg1 = *(oneML::face::FaceEmbedderResult **)&_swig_go_0;
5137
5138 {
5139 try
5140 {
5141 result = (int)((oneML::face::FaceEmbedderResult const *)arg1)->get_size();
5142 }
5143 catch (const std::invalid_argument& e)
5144 {
5145 SWIG_exception(SWIG_ValueError, e.what());
5146 }
5147 catch (const std::out_of_range& e)
5148 {
5149 SWIG_exception(SWIG_IndexError, e.what());
5150 }
5151 catch(const std::exception& e)
5152 {
5153 SWIG_exception(SWIG_RuntimeError, e.what());
5154 }
5155 }
5156 _swig_go_result = result;
5157 return _swig_go_result;
5158}
5159
5160
5161std::array< float,512 > *_wrap_FaceEmbedderResult_GetEmbedding_face_86f062e835b3dd07(oneML::face::FaceEmbedderResult *_swig_go_0) {
5162 oneML::face::FaceEmbedderResult *arg1 = (oneML::face::FaceEmbedderResult *) 0 ;
5163 oneML::face::Embedding result;
5164 std::array< float,512 > *_swig_go_result;
5165
5166 arg1 = *(oneML::face::FaceEmbedderResult **)&_swig_go_0;
5167
5168 {
5169 try
5170 {
5171 result = oneML_face_FaceEmbedderResult_go_get_embedding(arg1);
5172 }
5173 catch (const std::invalid_argument& e)
5174 {
5175 SWIG_exception(SWIG_ValueError, e.what());
5176 }
5177 catch (const std::out_of_range& e)
5178 {
5179 SWIG_exception(SWIG_IndexError, e.what());
5180 }
5181 catch(const std::exception& e)
5182 {
5183 SWIG_exception(SWIG_RuntimeError, e.what());
5184 }
5185 }
5186 *(oneML::face::Embedding **)&_swig_go_result = new oneML::face::Embedding(result);
5187 return _swig_go_result;
5188}
5189
5190
5191intgo _wrap_FaceEmbedderResult_GetReturnStatus_face_86f062e835b3dd07(oneML::face::FaceEmbedderResult *_swig_go_0) {
5192 oneML::face::FaceEmbedderResult *arg1 = (oneML::face::FaceEmbedderResult *) 0 ;
5193 int result;
5194 intgo _swig_go_result;
5195
5196 arg1 = *(oneML::face::FaceEmbedderResult **)&_swig_go_0;
5197
5198 {
5199 try
5200 {
5201 result = (int)oneML_face_FaceEmbedderResult_go_get_return_status(arg1);
5202 }
5203 catch (const std::invalid_argument& e)
5204 {
5205 SWIG_exception(SWIG_ValueError, e.what());
5206 }
5207 catch (const std::out_of_range& e)
5208 {
5209 SWIG_exception(SWIG_IndexError, e.what());
5210 }
5211 catch(const std::exception& e)
5212 {
5213 SWIG_exception(SWIG_RuntimeError, e.what());
5214 }
5215 }
5216 _swig_go_result = result;
5217 return _swig_go_result;
5218}
5219
5220
5221void _wrap_delete_FaceEmbedderResult_face_86f062e835b3dd07(oneML::face::FaceEmbedderResult *_swig_go_0) {
5222 oneML::face::FaceEmbedderResult *arg1 = (oneML::face::FaceEmbedderResult *) 0 ;
5223
5224 arg1 = *(oneML::face::FaceEmbedderResult **)&_swig_go_0;
5225
5226 {
5227 try
5228 {
5229 delete arg1;
5230 }
5231 catch (const std::invalid_argument& e)
5232 {
5233 SWIG_exception(SWIG_ValueError, e.what());
5234 }
5235 catch (const std::out_of_range& e)
5236 {
5237 SWIG_exception(SWIG_IndexError, e.what());
5238 }
5239 catch(const std::exception& e)
5240 {
5241 SWIG_exception(SWIG_RuntimeError, e.what());
5242 }
5243 }
5244
5245}
5246
5247
5248oneML::face::FaceEmbedder *_wrap_new_FaceEmbedder_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
5249 oneML::LicenseManager *arg1 = 0 ;
5250 oneML::face::FaceEmbedder *result = 0 ;
5251 oneML::face::FaceEmbedder *_swig_go_result;
5252
5253 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
5254
5255 {
5256 try
5257 {
5258 result = (oneML::face::FaceEmbedder *)new oneML::face::FaceEmbedder(*arg1);
5259 }
5260 catch (const std::invalid_argument& e)
5261 {
5262 SWIG_exception(SWIG_ValueError, e.what());
5263 }
5264 catch (const std::out_of_range& e)
5265 {
5266 SWIG_exception(SWIG_IndexError, e.what());
5267 }
5268 catch(const std::exception& e)
5269 {
5270 SWIG_exception(SWIG_RuntimeError, e.what());
5271 }
5272 }
5273 *(oneML::face::FaceEmbedder **)&_swig_go_result = (oneML::face::FaceEmbedder *)result;
5274 return _swig_go_result;
5275}
5276
5277
5278oneML::face::FaceEmbedderResult *_wrap_FaceEmbedder_Embed__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, oneML::Image *_swig_go_1, bool _swig_go_2) {
5279 oneML::face::FaceEmbedder *arg1 = (oneML::face::FaceEmbedder *) 0 ;
5280 oneML::Image *arg2 = 0 ;
5281 bool arg3 ;
5282 oneML::face::FaceEmbedderResult result;
5283 oneML::face::FaceEmbedderResult *_swig_go_result;
5284
5285 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
5286 arg2 = *(oneML::Image **)&_swig_go_1;
5287 arg3 = (bool)_swig_go_2;
5288
5289 {
5290 try
5291 {
5292 result = oneML_face_FaceEmbedder_go_embed__SWIG_0(arg1,(oneML::Image const &)*arg2,arg3);
5293 }
5294 catch (const std::invalid_argument& e)
5295 {
5296 SWIG_exception(SWIG_ValueError, e.what());
5297 }
5298 catch (const std::out_of_range& e)
5299 {
5300 SWIG_exception(SWIG_IndexError, e.what());
5301 }
5302 catch(const std::exception& e)
5303 {
5304 SWIG_exception(SWIG_RuntimeError, e.what());
5305 }
5306 }
5307 *(oneML::face::FaceEmbedderResult **)&_swig_go_result = new oneML::face::FaceEmbedderResult(result);
5308 return _swig_go_result;
5309}
5310
5311
5312oneML::face::FaceEmbedderResult *_wrap_FaceEmbedder_Embed__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, oneML::Image *_swig_go_1) {
5313 oneML::face::FaceEmbedder *arg1 = (oneML::face::FaceEmbedder *) 0 ;
5314 oneML::Image *arg2 = 0 ;
5315 oneML::face::FaceEmbedderResult result;
5316 oneML::face::FaceEmbedderResult *_swig_go_result;
5317
5318 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
5319 arg2 = *(oneML::Image **)&_swig_go_1;
5320
5321 {
5322 try
5323 {
5324 result = oneML_face_FaceEmbedder_go_embed__SWIG_0(arg1,(oneML::Image const &)*arg2);
5325 }
5326 catch (const std::invalid_argument& e)
5327 {
5328 SWIG_exception(SWIG_ValueError, e.what());
5329 }
5330 catch (const std::out_of_range& e)
5331 {
5332 SWIG_exception(SWIG_IndexError, e.what());
5333 }
5334 catch(const std::exception& e)
5335 {
5336 SWIG_exception(SWIG_RuntimeError, e.what());
5337 }
5338 }
5339 *(oneML::face::FaceEmbedderResult **)&_swig_go_result = new oneML::face::FaceEmbedderResult(result);
5340 return _swig_go_result;
5341}
5342
5343
5344std::vector< oneML::face::FaceEmbedderResult > *_wrap_FaceEmbedder_EmbedBatch__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, std::vector< oneML::Image > *_swig_go_1, bool _swig_go_2) {
5345 oneML::face::FaceEmbedder *arg1 = (oneML::face::FaceEmbedder *) 0 ;
5346 std::vector< oneML::Image > *arg2 = 0 ;
5347 bool arg3 ;
5348 std::vector< oneML::face::FaceEmbedderResult > result;
5349 std::vector< oneML::face::FaceEmbedderResult > *_swig_go_result;
5350
5351 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
5352 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
5353 arg3 = (bool)_swig_go_2;
5354
5355 {
5356 try
5357 {
5358 result = oneML_face_FaceEmbedder_go_embed_batch__SWIG_0(arg1,(std::vector< oneML::Image > const &)*arg2,arg3);
5359 }
5360 catch (const std::invalid_argument& e)
5361 {
5362 SWIG_exception(SWIG_ValueError, e.what());
5363 }
5364 catch (const std::out_of_range& e)
5365 {
5366 SWIG_exception(SWIG_IndexError, e.what());
5367 }
5368 catch(const std::exception& e)
5369 {
5370 SWIG_exception(SWIG_RuntimeError, e.what());
5371 }
5372 }
5373 *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_result = new std::vector< oneML::face::FaceEmbedderResult >(result);
5374 return _swig_go_result;
5375}
5376
5377
5378std::vector< oneML::face::FaceEmbedderResult > *_wrap_FaceEmbedder_EmbedBatch__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, std::vector< oneML::Image > *_swig_go_1) {
5379 oneML::face::FaceEmbedder *arg1 = (oneML::face::FaceEmbedder *) 0 ;
5380 std::vector< oneML::Image > *arg2 = 0 ;
5381 std::vector< oneML::face::FaceEmbedderResult > result;
5382 std::vector< oneML::face::FaceEmbedderResult > *_swig_go_result;
5383
5384 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
5385 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
5386
5387 {
5388 try
5389 {
5390 result = oneML_face_FaceEmbedder_go_embed_batch__SWIG_0(arg1,(std::vector< oneML::Image > const &)*arg2);
5391 }
5392 catch (const std::invalid_argument& e)
5393 {
5394 SWIG_exception(SWIG_ValueError, e.what());
5395 }
5396 catch (const std::out_of_range& e)
5397 {
5398 SWIG_exception(SWIG_IndexError, e.what());
5399 }
5400 catch(const std::exception& e)
5401 {
5402 SWIG_exception(SWIG_RuntimeError, e.what());
5403 }
5404 }
5405 *(std::vector< oneML::face::FaceEmbedderResult > **)&_swig_go_result = new std::vector< oneML::face::FaceEmbedderResult >(result);
5406 return _swig_go_result;
5407}
5408
5409
5410void _wrap_delete_FaceEmbedder_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0) {
5411 oneML::face::FaceEmbedder *arg1 = (oneML::face::FaceEmbedder *) 0 ;
5412
5413 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
5414
5415 {
5416 try
5417 {
5418 delete arg1;
5419 }
5420 catch (const std::invalid_argument& e)
5421 {
5422 SWIG_exception(SWIG_ValueError, e.what());
5423 }
5424 catch (const std::out_of_range& e)
5425 {
5426 SWIG_exception(SWIG_IndexError, e.what());
5427 }
5428 catch(const std::exception& e)
5429 {
5430 SWIG_exception(SWIG_RuntimeError, e.what());
5431 }
5432 }
5433
5434}
5435
5436
5437intgo _wrap_FaceEmbedderStatus_Empty_face_86f062e835b3dd07() {
5438 oneML::face::FaceEmbedderStatus result;
5439 intgo _swig_go_result;
5440
5441
5442 {
5443 try
5444 {
5445 result = oneML::face::FaceEmbedderStatus::Empty;
5446
5447 }
5448 catch (const std::invalid_argument& e)
5449 {
5450 SWIG_exception(SWIG_ValueError, e.what());
5451 }
5452 catch (const std::out_of_range& e)
5453 {
5454 SWIG_exception(SWIG_IndexError, e.what());
5455 }
5456 catch(const std::exception& e)
5457 {
5458 SWIG_exception(SWIG_RuntimeError, e.what());
5459 }
5460 }
5461 _swig_go_result = (intgo)result;
5462 return _swig_go_result;
5463}
5464
5465
5466intgo _wrap_FaceEmbedderStatus_Success_face_86f062e835b3dd07() {
5467 oneML::face::FaceEmbedderStatus result;
5468 intgo _swig_go_result;
5469
5470
5471 {
5472 try
5473 {
5474 result = oneML::face::FaceEmbedderStatus::Success;
5475
5476 }
5477 catch (const std::invalid_argument& e)
5478 {
5479 SWIG_exception(SWIG_ValueError, e.what());
5480 }
5481 catch (const std::out_of_range& e)
5482 {
5483 SWIG_exception(SWIG_IndexError, e.what());
5484 }
5485 catch(const std::exception& e)
5486 {
5487 SWIG_exception(SWIG_RuntimeError, e.what());
5488 }
5489 }
5490 _swig_go_result = (intgo)result;
5491 return _swig_go_result;
5492}
5493
5494
5495intgo _wrap_FaceEmbedderStatus_Fail_face_86f062e835b3dd07() {
5496 oneML::face::FaceEmbedderStatus result;
5497 intgo _swig_go_result;
5498
5499
5500 {
5501 try
5502 {
5503 result = oneML::face::FaceEmbedderStatus::Fail;
5504
5505 }
5506 catch (const std::invalid_argument& e)
5507 {
5508 SWIG_exception(SWIG_ValueError, e.what());
5509 }
5510 catch (const std::out_of_range& e)
5511 {
5512 SWIG_exception(SWIG_IndexError, e.what());
5513 }
5514 catch(const std::exception& e)
5515 {
5516 SWIG_exception(SWIG_RuntimeError, e.what());
5517 }
5518 }
5519 _swig_go_result = (intgo)result;
5520 return _swig_go_result;
5521}
5522
5523
5524std::vector< oneML::face::FaceIdResult > *_wrap_new_FaceIdResultVector__SWIG_0_face_86f062e835b3dd07() {
5525 std::vector< oneML::face::FaceIdResult > *result = 0 ;
5526 std::vector< oneML::face::FaceIdResult > *_swig_go_result;
5527
5528
5529 {
5530 try
5531 {
5532 result = (std::vector< oneML::face::FaceIdResult > *)new std::vector< oneML::face::FaceIdResult >();
5533 }
5534 catch (const std::invalid_argument& e)
5535 {
5536 SWIG_exception(SWIG_ValueError, e.what());
5537 }
5538 catch (const std::out_of_range& e)
5539 {
5540 SWIG_exception(SWIG_IndexError, e.what());
5541 }
5542 catch(const std::exception& e)
5543 {
5544 SWIG_exception(SWIG_RuntimeError, e.what());
5545 }
5546 }
5547 *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_result = (std::vector< oneML::face::FaceIdResult > *)result;
5548 return _swig_go_result;
5549}
5550
5551
5552std::vector< oneML::face::FaceIdResult > *_wrap_new_FaceIdResultVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
5553 std::vector< oneML::face::FaceIdResult >::size_type arg1 ;
5554 std::vector< oneML::face::FaceIdResult > *result = 0 ;
5555 std::vector< oneML::face::FaceIdResult > *_swig_go_result;
5556
5557 arg1 = (size_t)_swig_go_0;
5558
5559 {
5560 try
5561 {
5562 result = (std::vector< oneML::face::FaceIdResult > *)new std::vector< oneML::face::FaceIdResult >(arg1);
5563 }
5564 catch (const std::invalid_argument& e)
5565 {
5566 SWIG_exception(SWIG_ValueError, e.what());
5567 }
5568 catch (const std::out_of_range& e)
5569 {
5570 SWIG_exception(SWIG_IndexError, e.what());
5571 }
5572 catch(const std::exception& e)
5573 {
5574 SWIG_exception(SWIG_RuntimeError, e.what());
5575 }
5576 }
5577 *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_result = (std::vector< oneML::face::FaceIdResult > *)result;
5578 return _swig_go_result;
5579}
5580
5581
5582std::vector< oneML::face::FaceIdResult > *_wrap_new_FaceIdResultVector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5583 std::vector< oneML::face::FaceIdResult > *arg1 = 0 ;
5584 std::vector< oneML::face::FaceIdResult > *result = 0 ;
5585 std::vector< oneML::face::FaceIdResult > *_swig_go_result;
5586
5587 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5588
5589 {
5590 try
5591 {
5592 result = (std::vector< oneML::face::FaceIdResult > *)new std::vector< oneML::face::FaceIdResult >((std::vector< oneML::face::FaceIdResult > const &)*arg1);
5593 }
5594 catch (const std::invalid_argument& e)
5595 {
5596 SWIG_exception(SWIG_ValueError, e.what());
5597 }
5598 catch (const std::out_of_range& e)
5599 {
5600 SWIG_exception(SWIG_IndexError, e.what());
5601 }
5602 catch(const std::exception& e)
5603 {
5604 SWIG_exception(SWIG_RuntimeError, e.what());
5605 }
5606 }
5607 *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_result = (std::vector< oneML::face::FaceIdResult > *)result;
5608 return _swig_go_result;
5609}
5610
5611
5612long long _wrap_FaceIdResultVector_size_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5613 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5614 std::vector< oneML::face::FaceIdResult >::size_type result;
5615 long long _swig_go_result;
5616
5617 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5618
5619 {
5620 try
5621 {
5622 result = ((std::vector< oneML::face::FaceIdResult > const *)arg1)->size();
5623 }
5624 catch (const std::invalid_argument& e)
5625 {
5626 SWIG_exception(SWIG_ValueError, e.what());
5627 }
5628 catch (const std::out_of_range& e)
5629 {
5630 SWIG_exception(SWIG_IndexError, e.what());
5631 }
5632 catch(const std::exception& e)
5633 {
5634 SWIG_exception(SWIG_RuntimeError, e.what());
5635 }
5636 }
5637 _swig_go_result = result;
5638 return _swig_go_result;
5639}
5640
5641
5642long long _wrap_FaceIdResultVector_capacity_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5643 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5644 std::vector< oneML::face::FaceIdResult >::size_type result;
5645 long long _swig_go_result;
5646
5647 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5648
5649 {
5650 try
5651 {
5652 result = ((std::vector< oneML::face::FaceIdResult > const *)arg1)->capacity();
5653 }
5654 catch (const std::invalid_argument& e)
5655 {
5656 SWIG_exception(SWIG_ValueError, e.what());
5657 }
5658 catch (const std::out_of_range& e)
5659 {
5660 SWIG_exception(SWIG_IndexError, e.what());
5661 }
5662 catch(const std::exception& e)
5663 {
5664 SWIG_exception(SWIG_RuntimeError, e.what());
5665 }
5666 }
5667 _swig_go_result = result;
5668 return _swig_go_result;
5669}
5670
5671
5672void _wrap_FaceIdResultVector_reserve_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0, long long _swig_go_1) {
5673 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5674 std::vector< oneML::face::FaceIdResult >::size_type arg2 ;
5675
5676 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5677 arg2 = (size_t)_swig_go_1;
5678
5679 {
5680 try
5681 {
5682 (arg1)->reserve(arg2);
5683 }
5684 catch (const std::invalid_argument& e)
5685 {
5686 SWIG_exception(SWIG_ValueError, e.what());
5687 }
5688 catch (const std::out_of_range& e)
5689 {
5690 SWIG_exception(SWIG_IndexError, e.what());
5691 }
5692 catch(const std::exception& e)
5693 {
5694 SWIG_exception(SWIG_RuntimeError, e.what());
5695 }
5696 }
5697
5698}
5699
5700
5701bool _wrap_FaceIdResultVector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5702 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5703 bool result;
5704 bool _swig_go_result;
5705
5706 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5707
5708 {
5709 try
5710 {
5711 result = (bool)((std::vector< oneML::face::FaceIdResult > const *)arg1)->empty();
5712 }
5713 catch (const std::invalid_argument& e)
5714 {
5715 SWIG_exception(SWIG_ValueError, e.what());
5716 }
5717 catch (const std::out_of_range& e)
5718 {
5719 SWIG_exception(SWIG_IndexError, e.what());
5720 }
5721 catch(const std::exception& e)
5722 {
5723 SWIG_exception(SWIG_RuntimeError, e.what());
5724 }
5725 }
5726 _swig_go_result = result;
5727 return _swig_go_result;
5728}
5729
5730
5731void _wrap_FaceIdResultVector_clear_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5732 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5733
5734 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5735
5736 {
5737 try
5738 {
5739 (arg1)->clear();
5740 }
5741 catch (const std::invalid_argument& e)
5742 {
5743 SWIG_exception(SWIG_ValueError, e.what());
5744 }
5745 catch (const std::out_of_range& e)
5746 {
5747 SWIG_exception(SWIG_IndexError, e.what());
5748 }
5749 catch(const std::exception& e)
5750 {
5751 SWIG_exception(SWIG_RuntimeError, e.what());
5752 }
5753 }
5754
5755}
5756
5757
5758void _wrap_FaceIdResultVector_add_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0, oneML::face::FaceIdResult *_swig_go_1) {
5759 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5760 std::vector< oneML::face::FaceIdResult >::value_type *arg2 = 0 ;
5761
5762 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5763 arg2 = *(std::vector< oneML::face::FaceIdResult >::value_type **)&_swig_go_1;
5764
5765 {
5766 try
5767 {
5768 (arg1)->push_back((std::vector< oneML::face::FaceIdResult >::value_type const &)*arg2);
5769 }
5770 catch (const std::invalid_argument& e)
5771 {
5772 SWIG_exception(SWIG_ValueError, e.what());
5773 }
5774 catch (const std::out_of_range& e)
5775 {
5776 SWIG_exception(SWIG_IndexError, e.what());
5777 }
5778 catch(const std::exception& e)
5779 {
5780 SWIG_exception(SWIG_RuntimeError, e.what());
5781 }
5782 }
5783
5784}
5785
5786
5787oneML::face::FaceIdResult *_wrap_FaceIdResultVector_get_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0, intgo _swig_go_1) {
5788 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5789 int arg2 ;
5790 std::vector< oneML::face::FaceIdResult >::value_type *result = 0 ;
5791 oneML::face::FaceIdResult *_swig_go_result;
5792
5793 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5794 arg2 = (int)_swig_go_1;
5795
5796 {
5797 try
5798 {
5799 try {
5800 result = (std::vector< oneML::face::FaceIdResult >::value_type *) &std_vector_Sl_oneML_face_FaceIdResult_Sg__get(arg1,arg2);
5801 } catch(std::out_of_range &_e) {
5802 _swig_gopanic((&_e)->what());
5803 }
5804 }
5805 catch (const std::invalid_argument& e)
5806 {
5807 SWIG_exception(SWIG_ValueError, e.what());
5808 }
5809 catch (const std::out_of_range& e)
5810 {
5811 SWIG_exception(SWIG_IndexError, e.what());
5812 }
5813 catch(const std::exception& e)
5814 {
5815 SWIG_exception(SWIG_RuntimeError, e.what());
5816 }
5817 }
5818 *(std::vector< oneML::face::FaceIdResult >::value_type **)&_swig_go_result = result;
5819 return _swig_go_result;
5820}
5821
5822
5823void _wrap_FaceIdResultVector_set_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0, intgo _swig_go_1, oneML::face::FaceIdResult *_swig_go_2) {
5824 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5825 int arg2 ;
5826 std::vector< oneML::face::FaceIdResult >::value_type *arg3 = 0 ;
5827
5828 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5829 arg2 = (int)_swig_go_1;
5830 arg3 = *(std::vector< oneML::face::FaceIdResult >::value_type **)&_swig_go_2;
5831
5832 {
5833 try
5834 {
5835 try {
5836 std_vector_Sl_oneML_face_FaceIdResult_Sg__set(arg1,arg2,(oneML::face::FaceIdResult const &)*arg3);
5837 } catch(std::out_of_range &_e) {
5838 _swig_gopanic((&_e)->what());
5839 }
5840 }
5841 catch (const std::invalid_argument& e)
5842 {
5843 SWIG_exception(SWIG_ValueError, e.what());
5844 }
5845 catch (const std::out_of_range& e)
5846 {
5847 SWIG_exception(SWIG_IndexError, e.what());
5848 }
5849 catch(const std::exception& e)
5850 {
5851 SWIG_exception(SWIG_RuntimeError, e.what());
5852 }
5853 }
5854
5855}
5856
5857
5858void _wrap_delete_FaceIdResultVector_face_86f062e835b3dd07(std::vector< oneML::face::FaceIdResult > *_swig_go_0) {
5859 std::vector< oneML::face::FaceIdResult > *arg1 = (std::vector< oneML::face::FaceIdResult > *) 0 ;
5860
5861 arg1 = *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_0;
5862
5863 {
5864 try
5865 {
5866 delete arg1;
5867 }
5868 catch (const std::invalid_argument& e)
5869 {
5870 SWIG_exception(SWIG_ValueError, e.what());
5871 }
5872 catch (const std::out_of_range& e)
5873 {
5874 SWIG_exception(SWIG_IndexError, e.what());
5875 }
5876 catch(const std::exception& e)
5877 {
5878 SWIG_exception(SWIG_RuntimeError, e.what());
5879 }
5880 }
5881
5882}
5883
5884
5885std::vector< std::string > *_wrap_new_StringVector__SWIG_0_face_86f062e835b3dd07() {
5886 std::vector< std::string > *result = 0 ;
5887 std::vector< std::string > *_swig_go_result;
5888
5889
5890 {
5891 try
5892 {
5893 result = (std::vector< std::string > *)new std::vector< std::string >();
5894 }
5895 catch (const std::invalid_argument& e)
5896 {
5897 SWIG_exception(SWIG_ValueError, e.what());
5898 }
5899 catch (const std::out_of_range& e)
5900 {
5901 SWIG_exception(SWIG_IndexError, e.what());
5902 }
5903 catch(const std::exception& e)
5904 {
5905 SWIG_exception(SWIG_RuntimeError, e.what());
5906 }
5907 }
5908 *(std::vector< std::string > **)&_swig_go_result = (std::vector< std::string > *)result;
5909 return _swig_go_result;
5910}
5911
5912
5913std::vector< std::string > *_wrap_new_StringVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
5914 std::vector< std::string >::size_type arg1 ;
5915 std::vector< std::string > *result = 0 ;
5916 std::vector< std::string > *_swig_go_result;
5917
5918 arg1 = (size_t)_swig_go_0;
5919
5920 {
5921 try
5922 {
5923 result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
5924 }
5925 catch (const std::invalid_argument& e)
5926 {
5927 SWIG_exception(SWIG_ValueError, e.what());
5928 }
5929 catch (const std::out_of_range& e)
5930 {
5931 SWIG_exception(SWIG_IndexError, e.what());
5932 }
5933 catch(const std::exception& e)
5934 {
5935 SWIG_exception(SWIG_RuntimeError, e.what());
5936 }
5937 }
5938 *(std::vector< std::string > **)&_swig_go_result = (std::vector< std::string > *)result;
5939 return _swig_go_result;
5940}
5941
5942
5943std::vector< std::string > *_wrap_new_StringVector__SWIG_2_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
5944 std::vector< std::string > *arg1 = 0 ;
5945 std::vector< std::string > *result = 0 ;
5946 std::vector< std::string > *_swig_go_result;
5947
5948 arg1 = *(std::vector< std::string > **)&_swig_go_0;
5949
5950 {
5951 try
5952 {
5953 result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
5954 }
5955 catch (const std::invalid_argument& e)
5956 {
5957 SWIG_exception(SWIG_ValueError, e.what());
5958 }
5959 catch (const std::out_of_range& e)
5960 {
5961 SWIG_exception(SWIG_IndexError, e.what());
5962 }
5963 catch(const std::exception& e)
5964 {
5965 SWIG_exception(SWIG_RuntimeError, e.what());
5966 }
5967 }
5968 *(std::vector< std::string > **)&_swig_go_result = (std::vector< std::string > *)result;
5969 return _swig_go_result;
5970}
5971
5972
5973long long _wrap_StringVector_size_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
5974 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
5975 std::vector< std::string >::size_type result;
5976 long long _swig_go_result;
5977
5978 arg1 = *(std::vector< std::string > **)&_swig_go_0;
5979
5980 {
5981 try
5982 {
5983 result = ((std::vector< std::string > const *)arg1)->size();
5984 }
5985 catch (const std::invalid_argument& e)
5986 {
5987 SWIG_exception(SWIG_ValueError, e.what());
5988 }
5989 catch (const std::out_of_range& e)
5990 {
5991 SWIG_exception(SWIG_IndexError, e.what());
5992 }
5993 catch(const std::exception& e)
5994 {
5995 SWIG_exception(SWIG_RuntimeError, e.what());
5996 }
5997 }
5998 _swig_go_result = result;
5999 return _swig_go_result;
6000}
6001
6002
6003long long _wrap_StringVector_capacity_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
6004 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6005 std::vector< std::string >::size_type result;
6006 long long _swig_go_result;
6007
6008 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6009
6010 {
6011 try
6012 {
6013 result = ((std::vector< std::string > const *)arg1)->capacity();
6014 }
6015 catch (const std::invalid_argument& e)
6016 {
6017 SWIG_exception(SWIG_ValueError, e.what());
6018 }
6019 catch (const std::out_of_range& e)
6020 {
6021 SWIG_exception(SWIG_IndexError, e.what());
6022 }
6023 catch(const std::exception& e)
6024 {
6025 SWIG_exception(SWIG_RuntimeError, e.what());
6026 }
6027 }
6028 _swig_go_result = result;
6029 return _swig_go_result;
6030}
6031
6032
6033void _wrap_StringVector_reserve_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0, long long _swig_go_1) {
6034 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6035 std::vector< std::string >::size_type arg2 ;
6036
6037 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6038 arg2 = (size_t)_swig_go_1;
6039
6040 {
6041 try
6042 {
6043 (arg1)->reserve(arg2);
6044 }
6045 catch (const std::invalid_argument& e)
6046 {
6047 SWIG_exception(SWIG_ValueError, e.what());
6048 }
6049 catch (const std::out_of_range& e)
6050 {
6051 SWIG_exception(SWIG_IndexError, e.what());
6052 }
6053 catch(const std::exception& e)
6054 {
6055 SWIG_exception(SWIG_RuntimeError, e.what());
6056 }
6057 }
6058
6059}
6060
6061
6062bool _wrap_StringVector_isEmpty_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
6063 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6064 bool result;
6065 bool _swig_go_result;
6066
6067 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6068
6069 {
6070 try
6071 {
6072 result = (bool)((std::vector< std::string > const *)arg1)->empty();
6073 }
6074 catch (const std::invalid_argument& e)
6075 {
6076 SWIG_exception(SWIG_ValueError, e.what());
6077 }
6078 catch (const std::out_of_range& e)
6079 {
6080 SWIG_exception(SWIG_IndexError, e.what());
6081 }
6082 catch(const std::exception& e)
6083 {
6084 SWIG_exception(SWIG_RuntimeError, e.what());
6085 }
6086 }
6087 _swig_go_result = result;
6088 return _swig_go_result;
6089}
6090
6091
6092void _wrap_StringVector_clear_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
6093 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6094
6095 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6096
6097 {
6098 try
6099 {
6100 (arg1)->clear();
6101 }
6102 catch (const std::invalid_argument& e)
6103 {
6104 SWIG_exception(SWIG_ValueError, e.what());
6105 }
6106 catch (const std::out_of_range& e)
6107 {
6108 SWIG_exception(SWIG_IndexError, e.what());
6109 }
6110 catch(const std::exception& e)
6111 {
6112 SWIG_exception(SWIG_RuntimeError, e.what());
6113 }
6114 }
6115
6116}
6117
6118
6119void _wrap_StringVector_add_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0, _gostring_ _swig_go_1) {
6120 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6121 std::vector< std::string >::value_type *arg2 = 0 ;
6122
6123 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6124
6125 std::vector< std::string >::value_type arg2_str(_swig_go_1.p, _swig_go_1.n);
6126 arg2 = &arg2_str;
6127
6128
6129 {
6130 try
6131 {
6132 (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
6133 }
6134 catch (const std::invalid_argument& e)
6135 {
6136 SWIG_exception(SWIG_ValueError, e.what());
6137 }
6138 catch (const std::out_of_range& e)
6139 {
6140 SWIG_exception(SWIG_IndexError, e.what());
6141 }
6142 catch(const std::exception& e)
6143 {
6144 SWIG_exception(SWIG_RuntimeError, e.what());
6145 }
6146 }
6147
6148}
6149
6150
6151_gostring_ _wrap_StringVector_get_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0, intgo _swig_go_1) {
6152 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6153 int arg2 ;
6154 std::vector< std::string >::value_type *result = 0 ;
6155 _gostring_ _swig_go_result;
6156
6157 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6158 arg2 = (int)_swig_go_1;
6159
6160 {
6161 try
6162 {
6163 try {
6164 result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
6165 } catch(std::out_of_range &_e) {
6166 _swig_gopanic((&_e)->what());
6167 }
6168 }
6169 catch (const std::invalid_argument& e)
6170 {
6171 SWIG_exception(SWIG_ValueError, e.what());
6172 }
6173 catch (const std::out_of_range& e)
6174 {
6175 SWIG_exception(SWIG_IndexError, e.what());
6176 }
6177 catch(const std::exception& e)
6178 {
6179 SWIG_exception(SWIG_RuntimeError, e.what());
6180 }
6181 }
6182 _swig_go_result = Swig_AllocateString((*result).data(), (*result).length());
6183 return _swig_go_result;
6184}
6185
6186
6187void _wrap_StringVector_set_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0, intgo _swig_go_1, _gostring_ _swig_go_2) {
6188 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6189 int arg2 ;
6190 std::vector< std::string >::value_type *arg3 = 0 ;
6191
6192 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6193 arg2 = (int)_swig_go_1;
6194
6195 std::vector< std::string >::value_type arg3_str(_swig_go_2.p, _swig_go_2.n);
6196 arg3 = &arg3_str;
6197
6198
6199 {
6200 try
6201 {
6202 try {
6203 std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
6204 } catch(std::out_of_range &_e) {
6205 _swig_gopanic((&_e)->what());
6206 }
6207 }
6208 catch (const std::invalid_argument& e)
6209 {
6210 SWIG_exception(SWIG_ValueError, e.what());
6211 }
6212 catch (const std::out_of_range& e)
6213 {
6214 SWIG_exception(SWIG_IndexError, e.what());
6215 }
6216 catch(const std::exception& e)
6217 {
6218 SWIG_exception(SWIG_RuntimeError, e.what());
6219 }
6220 }
6221
6222}
6223
6224
6225void _wrap_delete_StringVector_face_86f062e835b3dd07(std::vector< std::string > *_swig_go_0) {
6226 std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6227
6228 arg1 = *(std::vector< std::string > **)&_swig_go_0;
6229
6230 {
6231 try
6232 {
6233 delete arg1;
6234 }
6235 catch (const std::invalid_argument& e)
6236 {
6237 SWIG_exception(SWIG_ValueError, e.what());
6238 }
6239 catch (const std::out_of_range& e)
6240 {
6241 SWIG_exception(SWIG_IndexError, e.what());
6242 }
6243 catch(const std::exception& e)
6244 {
6245 SWIG_exception(SWIG_RuntimeError, e.what());
6246 }
6247 }
6248
6249}
6250
6251
6252std::vector< std::array< float,512 > > *_wrap_new_EmbeddingsVector__SWIG_0_face_86f062e835b3dd07() {
6253 std::vector< std::array< float,512 > > *result = 0 ;
6254 std::vector< std::array< float,512 > > *_swig_go_result;
6255
6256
6257 {
6258 try
6259 {
6260 result = (std::vector< std::array< float,512 > > *)new std::vector< std::array< float,512 > >();
6261 }
6262 catch (const std::invalid_argument& e)
6263 {
6264 SWIG_exception(SWIG_ValueError, e.what());
6265 }
6266 catch (const std::out_of_range& e)
6267 {
6268 SWIG_exception(SWIG_IndexError, e.what());
6269 }
6270 catch(const std::exception& e)
6271 {
6272 SWIG_exception(SWIG_RuntimeError, e.what());
6273 }
6274 }
6275 *(std::vector< std::array< float,512 > > **)&_swig_go_result = (std::vector< std::array< float,512 > > *)result;
6276 return _swig_go_result;
6277}
6278
6279
6280std::vector< std::array< float,512 > > *_wrap_new_EmbeddingsVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
6281 std::vector< std::array< float,512 > >::size_type arg1 ;
6282 std::vector< std::array< float,512 > > *result = 0 ;
6283 std::vector< std::array< float,512 > > *_swig_go_result;
6284
6285 arg1 = (size_t)_swig_go_0;
6286
6287 {
6288 try
6289 {
6290 result = (std::vector< std::array< float,512 > > *)new std::vector< std::array< float,512 > >(arg1);
6291 }
6292 catch (const std::invalid_argument& e)
6293 {
6294 SWIG_exception(SWIG_ValueError, e.what());
6295 }
6296 catch (const std::out_of_range& e)
6297 {
6298 SWIG_exception(SWIG_IndexError, e.what());
6299 }
6300 catch(const std::exception& e)
6301 {
6302 SWIG_exception(SWIG_RuntimeError, e.what());
6303 }
6304 }
6305 *(std::vector< std::array< float,512 > > **)&_swig_go_result = (std::vector< std::array< float,512 > > *)result;
6306 return _swig_go_result;
6307}
6308
6309
6310std::vector< std::array< float,512 > > *_wrap_new_EmbeddingsVector__SWIG_2_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6311 std::vector< std::array< float,512 > > *arg1 = 0 ;
6312 std::vector< std::array< float,512 > > *result = 0 ;
6313 std::vector< std::array< float,512 > > *_swig_go_result;
6314
6315 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6316
6317 {
6318 try
6319 {
6320 result = (std::vector< std::array< float,512 > > *)new std::vector< std::array< float,512 > >((std::vector< std::array< float,512 > > const &)*arg1);
6321 }
6322 catch (const std::invalid_argument& e)
6323 {
6324 SWIG_exception(SWIG_ValueError, e.what());
6325 }
6326 catch (const std::out_of_range& e)
6327 {
6328 SWIG_exception(SWIG_IndexError, e.what());
6329 }
6330 catch(const std::exception& e)
6331 {
6332 SWIG_exception(SWIG_RuntimeError, e.what());
6333 }
6334 }
6335 *(std::vector< std::array< float,512 > > **)&_swig_go_result = (std::vector< std::array< float,512 > > *)result;
6336 return _swig_go_result;
6337}
6338
6339
6340long long _wrap_EmbeddingsVector_size_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6341 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6342 std::vector< std::array< float,512 > >::size_type result;
6343 long long _swig_go_result;
6344
6345 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6346
6347 {
6348 try
6349 {
6350 result = ((std::vector< std::array< float,512 > > const *)arg1)->size();
6351 }
6352 catch (const std::invalid_argument& e)
6353 {
6354 SWIG_exception(SWIG_ValueError, e.what());
6355 }
6356 catch (const std::out_of_range& e)
6357 {
6358 SWIG_exception(SWIG_IndexError, e.what());
6359 }
6360 catch(const std::exception& e)
6361 {
6362 SWIG_exception(SWIG_RuntimeError, e.what());
6363 }
6364 }
6365 _swig_go_result = result;
6366 return _swig_go_result;
6367}
6368
6369
6370long long _wrap_EmbeddingsVector_capacity_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6371 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6372 std::vector< std::array< float,512 > >::size_type result;
6373 long long _swig_go_result;
6374
6375 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6376
6377 {
6378 try
6379 {
6380 result = ((std::vector< std::array< float,512 > > const *)arg1)->capacity();
6381 }
6382 catch (const std::invalid_argument& e)
6383 {
6384 SWIG_exception(SWIG_ValueError, e.what());
6385 }
6386 catch (const std::out_of_range& e)
6387 {
6388 SWIG_exception(SWIG_IndexError, e.what());
6389 }
6390 catch(const std::exception& e)
6391 {
6392 SWIG_exception(SWIG_RuntimeError, e.what());
6393 }
6394 }
6395 _swig_go_result = result;
6396 return _swig_go_result;
6397}
6398
6399
6400void _wrap_EmbeddingsVector_reserve_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0, long long _swig_go_1) {
6401 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6402 std::vector< std::array< float,512 > >::size_type arg2 ;
6403
6404 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6405 arg2 = (size_t)_swig_go_1;
6406
6407 {
6408 try
6409 {
6410 (arg1)->reserve(arg2);
6411 }
6412 catch (const std::invalid_argument& e)
6413 {
6414 SWIG_exception(SWIG_ValueError, e.what());
6415 }
6416 catch (const std::out_of_range& e)
6417 {
6418 SWIG_exception(SWIG_IndexError, e.what());
6419 }
6420 catch(const std::exception& e)
6421 {
6422 SWIG_exception(SWIG_RuntimeError, e.what());
6423 }
6424 }
6425
6426}
6427
6428
6429bool _wrap_EmbeddingsVector_isEmpty_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6430 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6431 bool result;
6432 bool _swig_go_result;
6433
6434 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6435
6436 {
6437 try
6438 {
6439 result = (bool)((std::vector< std::array< float,512 > > const *)arg1)->empty();
6440 }
6441 catch (const std::invalid_argument& e)
6442 {
6443 SWIG_exception(SWIG_ValueError, e.what());
6444 }
6445 catch (const std::out_of_range& e)
6446 {
6447 SWIG_exception(SWIG_IndexError, e.what());
6448 }
6449 catch(const std::exception& e)
6450 {
6451 SWIG_exception(SWIG_RuntimeError, e.what());
6452 }
6453 }
6454 _swig_go_result = result;
6455 return _swig_go_result;
6456}
6457
6458
6459void _wrap_EmbeddingsVector_clear_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6460 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6461
6462 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6463
6464 {
6465 try
6466 {
6467 (arg1)->clear();
6468 }
6469 catch (const std::invalid_argument& e)
6470 {
6471 SWIG_exception(SWIG_ValueError, e.what());
6472 }
6473 catch (const std::out_of_range& e)
6474 {
6475 SWIG_exception(SWIG_IndexError, e.what());
6476 }
6477 catch(const std::exception& e)
6478 {
6479 SWIG_exception(SWIG_RuntimeError, e.what());
6480 }
6481 }
6482
6483}
6484
6485
6486void _wrap_EmbeddingsVector_add_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0, std::array< float,512 > *_swig_go_1) {
6487 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6488 std::vector< std::array< float,512 > >::value_type *arg2 = 0 ;
6489
6490 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6491 arg2 = *(std::vector< std::array< float,512 > >::value_type **)&_swig_go_1;
6492
6493 {
6494 try
6495 {
6496 (arg1)->push_back((std::vector< std::array< float,512 > >::value_type const &)*arg2);
6497 }
6498 catch (const std::invalid_argument& e)
6499 {
6500 SWIG_exception(SWIG_ValueError, e.what());
6501 }
6502 catch (const std::out_of_range& e)
6503 {
6504 SWIG_exception(SWIG_IndexError, e.what());
6505 }
6506 catch(const std::exception& e)
6507 {
6508 SWIG_exception(SWIG_RuntimeError, e.what());
6509 }
6510 }
6511
6512}
6513
6514
6515std::array< float,512 > *_wrap_EmbeddingsVector_get_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0, intgo _swig_go_1) {
6516 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6517 int arg2 ;
6518 std::vector< std::array< float,512 > >::value_type *result = 0 ;
6519 std::array< float,512 > *_swig_go_result;
6520
6521 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6522 arg2 = (int)_swig_go_1;
6523
6524 {
6525 try
6526 {
6527 try {
6528 result = (std::vector< std::array< float,512 > >::value_type *) &std_vector_Sl_std_array_Sl_float_Sc_512_Sg__Sg__get(arg1,arg2);
6529 } catch(std::out_of_range &_e) {
6530 _swig_gopanic((&_e)->what());
6531 }
6532 }
6533 catch (const std::invalid_argument& e)
6534 {
6535 SWIG_exception(SWIG_ValueError, e.what());
6536 }
6537 catch (const std::out_of_range& e)
6538 {
6539 SWIG_exception(SWIG_IndexError, e.what());
6540 }
6541 catch(const std::exception& e)
6542 {
6543 SWIG_exception(SWIG_RuntimeError, e.what());
6544 }
6545 }
6546 *(std::vector< std::array< float,512 > >::value_type **)&_swig_go_result = result;
6547 return _swig_go_result;
6548}
6549
6550
6551void _wrap_EmbeddingsVector_set_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0, intgo _swig_go_1, std::array< float,512 > *_swig_go_2) {
6552 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6553 int arg2 ;
6554 std::vector< std::array< float,512 > >::value_type *arg3 = 0 ;
6555
6556 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6557 arg2 = (int)_swig_go_1;
6558 arg3 = *(std::vector< std::array< float,512 > >::value_type **)&_swig_go_2;
6559
6560 {
6561 try
6562 {
6563 try {
6564 std_vector_Sl_std_array_Sl_float_Sc_512_Sg__Sg__set(arg1,arg2,(std::array< float,512 > const &)*arg3);
6565 } catch(std::out_of_range &_e) {
6566 _swig_gopanic((&_e)->what());
6567 }
6568 }
6569 catch (const std::invalid_argument& e)
6570 {
6571 SWIG_exception(SWIG_ValueError, e.what());
6572 }
6573 catch (const std::out_of_range& e)
6574 {
6575 SWIG_exception(SWIG_IndexError, e.what());
6576 }
6577 catch(const std::exception& e)
6578 {
6579 SWIG_exception(SWIG_RuntimeError, e.what());
6580 }
6581 }
6582
6583}
6584
6585
6586void _wrap_delete_EmbeddingsVector_face_86f062e835b3dd07(std::vector< std::array< float,512 > > *_swig_go_0) {
6587 std::vector< std::array< float,512 > > *arg1 = (std::vector< std::array< float,512 > > *) 0 ;
6588
6589 arg1 = *(std::vector< std::array< float,512 > > **)&_swig_go_0;
6590
6591 {
6592 try
6593 {
6594 delete arg1;
6595 }
6596 catch (const std::invalid_argument& e)
6597 {
6598 SWIG_exception(SWIG_ValueError, e.what());
6599 }
6600 catch (const std::out_of_range& e)
6601 {
6602 SWIG_exception(SWIG_IndexError, e.what());
6603 }
6604 catch(const std::exception& e)
6605 {
6606 SWIG_exception(SWIG_RuntimeError, e.what());
6607 }
6608 }
6609
6610}
6611
6612
6613std::pair< bool,std::array< float,512 > > *_wrap_new_SamePersonResult__SWIG_0_face_86f062e835b3dd07() {
6614 std::pair< bool,std::array< float,512 > > *result = 0 ;
6615 std::pair< bool,std::array< float,512 > > *_swig_go_result;
6616
6617
6618 {
6619 try
6620 {
6621 result = (std::pair< bool,std::array< float,512 > > *)new std::pair< bool,std::array< float,512 > >();
6622 }
6623 catch (const std::invalid_argument& e)
6624 {
6625 SWIG_exception(SWIG_ValueError, e.what());
6626 }
6627 catch (const std::out_of_range& e)
6628 {
6629 SWIG_exception(SWIG_IndexError, e.what());
6630 }
6631 catch(const std::exception& e)
6632 {
6633 SWIG_exception(SWIG_RuntimeError, e.what());
6634 }
6635 }
6636 *(std::pair< bool,std::array< float,512 > > **)&_swig_go_result = (std::pair< bool,std::array< float,512 > > *)result;
6637 return _swig_go_result;
6638}
6639
6640
6641std::pair< bool,std::array< float,512 > > *_wrap_new_SamePersonResult__SWIG_1_face_86f062e835b3dd07(bool _swig_go_0, std::array< float,512 > *_swig_go_1) {
6642 bool arg1 ;
6643 std::array< float,512 > arg2 ;
6644 std::array< float,512 > *argp2 ;
6645 std::pair< bool,std::array< float,512 > > *result = 0 ;
6646 std::pair< bool,std::array< float,512 > > *_swig_go_result;
6647
6648 arg1 = (bool)_swig_go_0;
6649
6650 argp2 = (std::array< float,512 > *)_swig_go_1;
6651 if (argp2 == NULL) {
6652 _swig_gopanic("Attempt to dereference null std::array< float,512 >");
6653 }
6654 arg2 = (std::array< float,512 >)*argp2;
6655
6656
6657 {
6658 try
6659 {
6660 result = (std::pair< bool,std::array< float,512 > > *)new std::pair< bool,std::array< float,512 > >(arg1,arg2);
6661 }
6662 catch (const std::invalid_argument& e)
6663 {
6664 SWIG_exception(SWIG_ValueError, e.what());
6665 }
6666 catch (const std::out_of_range& e)
6667 {
6668 SWIG_exception(SWIG_IndexError, e.what());
6669 }
6670 catch(const std::exception& e)
6671 {
6672 SWIG_exception(SWIG_RuntimeError, e.what());
6673 }
6674 }
6675 *(std::pair< bool,std::array< float,512 > > **)&_swig_go_result = (std::pair< bool,std::array< float,512 > > *)result;
6676 return _swig_go_result;
6677}
6678
6679
6680std::pair< bool,std::array< float,512 > > *_wrap_new_SamePersonResult__SWIG_2_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0) {
6681 std::pair< bool,std::array< float,512 > > *arg1 = 0 ;
6682 std::pair< bool,std::array< float,512 > > *result = 0 ;
6683 std::pair< bool,std::array< float,512 > > *_swig_go_result;
6684
6685 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6686
6687 {
6688 try
6689 {
6690 result = (std::pair< bool,std::array< float,512 > > *)new std::pair< bool,std::array< float,512 > >((std::pair< bool,std::array< float,512 > > const &)*arg1);
6691 }
6692 catch (const std::invalid_argument& e)
6693 {
6694 SWIG_exception(SWIG_ValueError, e.what());
6695 }
6696 catch (const std::out_of_range& e)
6697 {
6698 SWIG_exception(SWIG_IndexError, e.what());
6699 }
6700 catch(const std::exception& e)
6701 {
6702 SWIG_exception(SWIG_RuntimeError, e.what());
6703 }
6704 }
6705 *(std::pair< bool,std::array< float,512 > > **)&_swig_go_result = (std::pair< bool,std::array< float,512 > > *)result;
6706 return _swig_go_result;
6707}
6708
6709
6710void _wrap_SamePersonResult_first_set_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0, bool _swig_go_1) {
6711 std::pair< bool,std::array< float,512 > > *arg1 = (std::pair< bool,std::array< float,512 > > *) 0 ;
6712 bool arg2 ;
6713
6714 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6715 arg2 = (bool)_swig_go_1;
6716
6717 if (arg1) (arg1)->first = arg2;
6718
6719}
6720
6721
6722bool _wrap_SamePersonResult_first_get_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0) {
6723 std::pair< bool,std::array< float,512 > > *arg1 = (std::pair< bool,std::array< float,512 > > *) 0 ;
6724 bool result;
6725 bool _swig_go_result;
6726
6727 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6728
6729 result = (bool) ((arg1)->first);
6730 _swig_go_result = result;
6731 return _swig_go_result;
6732}
6733
6734
6735void _wrap_SamePersonResult_second_set_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0, std::array< float,512 > *_swig_go_1) {
6736 std::pair< bool,std::array< float,512 > > *arg1 = (std::pair< bool,std::array< float,512 > > *) 0 ;
6737 std::array< float,512 > *arg2 = (std::array< float,512 > *) 0 ;
6738
6739 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6740 arg2 = *(std::array< float,512 > **)&_swig_go_1;
6741
6742 if (arg1) (arg1)->second = *arg2;
6743
6744}
6745
6746
6747std::array< float,512 > *_wrap_SamePersonResult_second_get_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0) {
6748 std::pair< bool,std::array< float,512 > > *arg1 = (std::pair< bool,std::array< float,512 > > *) 0 ;
6749 std::array< float,512 > *result = 0 ;
6750 std::array< float,512 > *_swig_go_result;
6751
6752 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6753
6754 result = (std::array< float,512 > *)& ((arg1)->second);
6755 *(std::array< float,512 > **)&_swig_go_result = (std::array< float,512 > *)result;
6756 return _swig_go_result;
6757}
6758
6759
6760void _wrap_delete_SamePersonResult_face_86f062e835b3dd07(std::pair< bool,std::array< float,512 > > *_swig_go_0) {
6761 std::pair< bool,std::array< float,512 > > *arg1 = (std::pair< bool,std::array< float,512 > > *) 0 ;
6762
6763 arg1 = *(std::pair< bool,std::array< float,512 > > **)&_swig_go_0;
6764
6765 {
6766 try
6767 {
6768 delete arg1;
6769 }
6770 catch (const std::invalid_argument& e)
6771 {
6772 SWIG_exception(SWIG_ValueError, e.what());
6773 }
6774 catch (const std::out_of_range& e)
6775 {
6776 SWIG_exception(SWIG_IndexError, e.what());
6777 }
6778 catch(const std::exception& e)
6779 {
6780 SWIG_exception(SWIG_RuntimeError, e.what());
6781 }
6782 }
6783
6784}
6785
6786
6787oneML::face::FaceIdResult *_wrap_new_FaceIdResult_face_86f062e835b3dd07() {
6788 oneML::face::FaceIdResult *result = 0 ;
6789 oneML::face::FaceIdResult *_swig_go_result;
6790
6791
6792 {
6793 try
6794 {
6795 result = (oneML::face::FaceIdResult *)new oneML::face::FaceIdResult();
6796 }
6797 catch (const std::invalid_argument& e)
6798 {
6799 SWIG_exception(SWIG_ValueError, e.what());
6800 }
6801 catch (const std::out_of_range& e)
6802 {
6803 SWIG_exception(SWIG_IndexError, e.what());
6804 }
6805 catch(const std::exception& e)
6806 {
6807 SWIG_exception(SWIG_RuntimeError, e.what());
6808 }
6809 }
6810 *(oneML::face::FaceIdResult **)&_swig_go_result = (oneML::face::FaceIdResult *)result;
6811 return _swig_go_result;
6812}
6813
6814
6815_gostring_ _wrap_FaceIdResult_GetId_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6816 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6817 std::string result;
6818 _gostring_ _swig_go_result;
6819
6820 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6821
6822 {
6823 try
6824 {
6825 result = ((oneML::face::FaceIdResult const *)arg1)->get_id();
6826 }
6827 catch (const std::invalid_argument& e)
6828 {
6829 SWIG_exception(SWIG_ValueError, e.what());
6830 }
6831 catch (const std::out_of_range& e)
6832 {
6833 SWIG_exception(SWIG_IndexError, e.what());
6834 }
6835 catch(const std::exception& e)
6836 {
6837 SWIG_exception(SWIG_RuntimeError, e.what());
6838 }
6839 }
6840 _swig_go_result = Swig_AllocateString((&result)->data(), (&result)->length());
6841 return _swig_go_result;
6842}
6843
6844
6845float _wrap_FaceIdResult_GetNearestNodeDistance_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6846 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6847 float result;
6848 float _swig_go_result;
6849
6850 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6851
6852 {
6853 try
6854 {
6855 result = (float)((oneML::face::FaceIdResult const *)arg1)->get_nearest_node_distance();
6856 }
6857 catch (const std::invalid_argument& e)
6858 {
6859 SWIG_exception(SWIG_ValueError, e.what());
6860 }
6861 catch (const std::out_of_range& e)
6862 {
6863 SWIG_exception(SWIG_IndexError, e.what());
6864 }
6865 catch(const std::exception& e)
6866 {
6867 SWIG_exception(SWIG_RuntimeError, e.what());
6868 }
6869 }
6870 _swig_go_result = result;
6871 return _swig_go_result;
6872}
6873
6874
6875float _wrap_FaceIdResult_GetCombinedDistance_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6876 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6877 float result;
6878 float _swig_go_result;
6879
6880 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6881
6882 {
6883 try
6884 {
6885 result = (float)((oneML::face::FaceIdResult const *)arg1)->get_combined_distance();
6886 }
6887 catch (const std::invalid_argument& e)
6888 {
6889 SWIG_exception(SWIG_ValueError, e.what());
6890 }
6891 catch (const std::out_of_range& e)
6892 {
6893 SWIG_exception(SWIG_IndexError, e.what());
6894 }
6895 catch(const std::exception& e)
6896 {
6897 SWIG_exception(SWIG_RuntimeError, e.what());
6898 }
6899 }
6900 _swig_go_result = result;
6901 return _swig_go_result;
6902}
6903
6904
6905bool _wrap_FaceIdResult_IsIdentifiable_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6906 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6907 bool result;
6908 bool _swig_go_result;
6909
6910 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6911
6912 {
6913 try
6914 {
6915 result = (bool)((oneML::face::FaceIdResult const *)arg1)->is_identifiable();
6916 }
6917 catch (const std::invalid_argument& e)
6918 {
6919 SWIG_exception(SWIG_ValueError, e.what());
6920 }
6921 catch (const std::out_of_range& e)
6922 {
6923 SWIG_exception(SWIG_IndexError, e.what());
6924 }
6925 catch(const std::exception& e)
6926 {
6927 SWIG_exception(SWIG_RuntimeError, e.what());
6928 }
6929 }
6930 _swig_go_result = result;
6931 return _swig_go_result;
6932}
6933
6934
6935intgo _wrap_FaceIdResult_GetReturnStatus_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6936 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6937 int result;
6938 intgo _swig_go_result;
6939
6940 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6941
6942 {
6943 try
6944 {
6945 result = (int)oneML_face_FaceIdResult_go_get_return_status(arg1);
6946 }
6947 catch (const std::invalid_argument& e)
6948 {
6949 SWIG_exception(SWIG_ValueError, e.what());
6950 }
6951 catch (const std::out_of_range& e)
6952 {
6953 SWIG_exception(SWIG_IndexError, e.what());
6954 }
6955 catch(const std::exception& e)
6956 {
6957 SWIG_exception(SWIG_RuntimeError, e.what());
6958 }
6959 }
6960 _swig_go_result = result;
6961 return _swig_go_result;
6962}
6963
6964
6965void _wrap_delete_FaceIdResult_face_86f062e835b3dd07(oneML::face::FaceIdResult *_swig_go_0) {
6966 oneML::face::FaceIdResult *arg1 = (oneML::face::FaceIdResult *) 0 ;
6967
6968 arg1 = *(oneML::face::FaceIdResult **)&_swig_go_0;
6969
6970 {
6971 try
6972 {
6973 delete arg1;
6974 }
6975 catch (const std::invalid_argument& e)
6976 {
6977 SWIG_exception(SWIG_ValueError, e.what());
6978 }
6979 catch (const std::out_of_range& e)
6980 {
6981 SWIG_exception(SWIG_IndexError, e.what());
6982 }
6983 catch(const std::exception& e)
6984 {
6985 SWIG_exception(SWIG_RuntimeError, e.what());
6986 }
6987 }
6988
6989}
6990
6991
6992oneML::face::FaceId *_wrap_new_FaceId__SWIG_0_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
6993 oneML::LicenseManager *arg1 = 0 ;
6994 oneML::face::FaceId *result = 0 ;
6995 oneML::face::FaceId *_swig_go_result;
6996
6997 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
6998
6999 {
7000 try
7001 {
7002 result = (oneML::face::FaceId *)new oneML::face::FaceId(*arg1);
7003 }
7004 catch (const std::invalid_argument& e)
7005 {
7006 SWIG_exception(SWIG_ValueError, e.what());
7007 }
7008 catch (const std::out_of_range& e)
7009 {
7010 SWIG_exception(SWIG_IndexError, e.what());
7011 }
7012 catch(const std::exception& e)
7013 {
7014 SWIG_exception(SWIG_RuntimeError, e.what());
7015 }
7016 }
7017 *(oneML::face::FaceId **)&_swig_go_result = (oneML::face::FaceId *)result;
7018 return _swig_go_result;
7019}
7020
7021
7022oneML::face::FaceId *_wrap_new_FaceId__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, oneML::LicenseManager *_swig_go_1) {
7023 oneML::face::FaceEmbedder *arg1 = 0 ;
7024 oneML::LicenseManager *arg2 = 0 ;
7025 oneML::face::FaceId *result = 0 ;
7026 oneML::face::FaceId *_swig_go_result;
7027
7028 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
7029 arg2 = *(oneML::LicenseManager **)&_swig_go_1;
7030
7031 {
7032 try
7033 {
7034 result = (oneML::face::FaceId *)new oneML::face::FaceId(*arg1,*arg2);
7035 }
7036 catch (const std::invalid_argument& e)
7037 {
7038 SWIG_exception(SWIG_ValueError, e.what());
7039 }
7040 catch (const std::out_of_range& e)
7041 {
7042 SWIG_exception(SWIG_IndexError, e.what());
7043 }
7044 catch(const std::exception& e)
7045 {
7046 SWIG_exception(SWIG_RuntimeError, e.what());
7047 }
7048 }
7049 *(oneML::face::FaceId **)&_swig_go_result = (oneML::face::FaceId *)result;
7050 return _swig_go_result;
7051}
7052
7053
7054oneML::face::FaceIdResult *_wrap_FaceId_Predict__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, oneML::Image *_swig_go_1) {
7055 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7056 oneML::Image *arg2 = 0 ;
7057 oneML::face::FaceIdResult result;
7058 oneML::face::FaceIdResult *_swig_go_result;
7059
7060 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7061 arg2 = *(oneML::Image **)&_swig_go_1;
7062
7063 {
7064 try
7065 {
7066 result = oneML_face_FaceId_go_predict__SWIG_0(arg1,(oneML::Image const &)*arg2);
7067 }
7068 catch (const std::invalid_argument& e)
7069 {
7070 SWIG_exception(SWIG_ValueError, e.what());
7071 }
7072 catch (const std::out_of_range& e)
7073 {
7074 SWIG_exception(SWIG_IndexError, e.what());
7075 }
7076 catch(const std::exception& e)
7077 {
7078 SWIG_exception(SWIG_RuntimeError, e.what());
7079 }
7080 }
7081 *(oneML::face::FaceIdResult **)&_swig_go_result = new oneML::face::FaceIdResult(result);
7082 return _swig_go_result;
7083}
7084
7085
7086oneML::face::FaceIdResult *_wrap_FaceId_Predict__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, oneML::Image *_swig_go_1, float _swig_go_2) {
7087 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7088 oneML::Image *arg2 = 0 ;
7089 float arg3 ;
7090 oneML::face::FaceIdResult result;
7091 oneML::face::FaceIdResult *_swig_go_result;
7092
7093 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7094 arg2 = *(oneML::Image **)&_swig_go_1;
7095 arg3 = (float)_swig_go_2;
7096
7097 {
7098 try
7099 {
7100 result = oneML_face_FaceId_go_predict__SWIG_1(arg1,(oneML::Image const &)*arg2,arg3);
7101 }
7102 catch (const std::invalid_argument& e)
7103 {
7104 SWIG_exception(SWIG_ValueError, e.what());
7105 }
7106 catch (const std::out_of_range& e)
7107 {
7108 SWIG_exception(SWIG_IndexError, e.what());
7109 }
7110 catch(const std::exception& e)
7111 {
7112 SWIG_exception(SWIG_RuntimeError, e.what());
7113 }
7114 }
7115 *(oneML::face::FaceIdResult **)&_swig_go_result = new oneML::face::FaceIdResult(result);
7116 return _swig_go_result;
7117}
7118
7119
7120std::vector< oneML::face::FaceIdResult > *_wrap_FaceId_PredictBatch__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, std::vector< oneML::Image > *_swig_go_1) {
7121 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7122 std::vector< oneML::Image > *arg2 = 0 ;
7123 std::vector< oneML::face::FaceIdResult > result;
7124 std::vector< oneML::face::FaceIdResult > *_swig_go_result;
7125
7126 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7127 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
7128
7129 {
7130 try
7131 {
7132 result = oneML_face_FaceId_go_predict_batch__SWIG_0(arg1,(std::vector< oneML::Image > const &)*arg2);
7133 }
7134 catch (const std::invalid_argument& e)
7135 {
7136 SWIG_exception(SWIG_ValueError, e.what());
7137 }
7138 catch (const std::out_of_range& e)
7139 {
7140 SWIG_exception(SWIG_IndexError, e.what());
7141 }
7142 catch(const std::exception& e)
7143 {
7144 SWIG_exception(SWIG_RuntimeError, e.what());
7145 }
7146 }
7147 *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_result = new std::vector< oneML::face::FaceIdResult >(result);
7148 return _swig_go_result;
7149}
7150
7151
7152std::vector< oneML::face::FaceIdResult > *_wrap_FaceId_PredictBatch__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, std::vector< oneML::Image > *_swig_go_1, float _swig_go_2) {
7153 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7154 std::vector< oneML::Image > *arg2 = 0 ;
7155 float arg3 ;
7156 std::vector< oneML::face::FaceIdResult > result;
7157 std::vector< oneML::face::FaceIdResult > *_swig_go_result;
7158
7159 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7160 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
7161 arg3 = (float)_swig_go_2;
7162
7163 {
7164 try
7165 {
7166 result = oneML_face_FaceId_go_predict_batch__SWIG_1(arg1,(std::vector< oneML::Image > const &)*arg2,arg3);
7167 }
7168 catch (const std::invalid_argument& e)
7169 {
7170 SWIG_exception(SWIG_ValueError, e.what());
7171 }
7172 catch (const std::out_of_range& e)
7173 {
7174 SWIG_exception(SWIG_IndexError, e.what());
7175 }
7176 catch(const std::exception& e)
7177 {
7178 SWIG_exception(SWIG_RuntimeError, e.what());
7179 }
7180 }
7181 *(std::vector< oneML::face::FaceIdResult > **)&_swig_go_result = new std::vector< oneML::face::FaceIdResult >(result);
7182 return _swig_go_result;
7183}
7184
7185
7186bool _wrap_FaceId_IsTheSamePersonImg__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, oneML::Image *_swig_go_1, oneML::Image *_swig_go_2) {
7187 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7188 oneML::Image *arg2 = 0 ;
7189 oneML::Image *arg3 = 0 ;
7190 bool result;
7191 bool _swig_go_result;
7192
7193 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7194 arg2 = *(oneML::Image **)&_swig_go_1;
7195 arg3 = *(oneML::Image **)&_swig_go_2;
7196
7197 {
7198 try
7199 {
7200 result = (bool)oneML_face_FaceId_go_is_the_same_person_img__SWIG_0(arg1,(oneML::Image const &)*arg2,(oneML::Image const &)*arg3);
7201 }
7202 catch (const std::invalid_argument& e)
7203 {
7204 SWIG_exception(SWIG_ValueError, e.what());
7205 }
7206 catch (const std::out_of_range& e)
7207 {
7208 SWIG_exception(SWIG_IndexError, e.what());
7209 }
7210 catch(const std::exception& e)
7211 {
7212 SWIG_exception(SWIG_RuntimeError, e.what());
7213 }
7214 }
7215 _swig_go_result = result;
7216 return _swig_go_result;
7217}
7218
7219
7220bool _wrap_FaceId_IsTheSamePersonImg__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, oneML::Image *_swig_go_1, oneML::Image *_swig_go_2, float _swig_go_3) {
7221 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7222 oneML::Image *arg2 = 0 ;
7223 oneML::Image *arg3 = 0 ;
7224 float arg4 ;
7225 bool result;
7226 bool _swig_go_result;
7227
7228 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7229 arg2 = *(oneML::Image **)&_swig_go_1;
7230 arg3 = *(oneML::Image **)&_swig_go_2;
7231 arg4 = (float)_swig_go_3;
7232
7233 {
7234 try
7235 {
7236 result = (bool)oneML_face_FaceId_go_is_the_same_person_img__SWIG_1(arg1,(oneML::Image const &)*arg2,(oneML::Image const &)*arg3,arg4);
7237 }
7238 catch (const std::invalid_argument& e)
7239 {
7240 SWIG_exception(SWIG_ValueError, e.what());
7241 }
7242 catch (const std::out_of_range& e)
7243 {
7244 SWIG_exception(SWIG_IndexError, e.what());
7245 }
7246 catch(const std::exception& e)
7247 {
7248 SWIG_exception(SWIG_RuntimeError, e.what());
7249 }
7250 }
7251 _swig_go_result = result;
7252 return _swig_go_result;
7253}
7254
7255
7256std::pair< bool,std::array< float,512 > > *_wrap_FaceId_IsTheSamePersonEmb__SWIG_0_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, std::array< float,512 > *_swig_go_1, oneML::Image *_swig_go_2) {
7257 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7258 oneML::face::Embedding *arg2 = 0 ;
7259 oneML::Image *arg3 = 0 ;
7260 std::pair< bool,oneML::face::Embedding > result;
7261 std::pair< bool,std::array< float,512 > > *_swig_go_result;
7262
7263 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7264 arg2 = *(oneML::face::Embedding **)&_swig_go_1;
7265 arg3 = *(oneML::Image **)&_swig_go_2;
7266
7267 {
7268 try
7269 {
7270 result = oneML_face_FaceId_go_is_the_same_person_emb__SWIG_0(arg1,*arg2,*arg3);
7271 }
7272 catch (const std::invalid_argument& e)
7273 {
7274 SWIG_exception(SWIG_ValueError, e.what());
7275 }
7276 catch (const std::out_of_range& e)
7277 {
7278 SWIG_exception(SWIG_IndexError, e.what());
7279 }
7280 catch(const std::exception& e)
7281 {
7282 SWIG_exception(SWIG_RuntimeError, e.what());
7283 }
7284 }
7285 *(std::pair< bool,oneML::face::Embedding > **)&_swig_go_result = new std::pair< bool,oneML::face::Embedding >(result);
7286 return _swig_go_result;
7287}
7288
7289
7290std::pair< bool,std::array< float,512 > > *_wrap_FaceId_IsTheSamePersonEmb__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, std::array< float,512 > *_swig_go_1, oneML::Image *_swig_go_2, float _swig_go_3) {
7291 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7292 oneML::face::Embedding *arg2 = 0 ;
7293 oneML::Image *arg3 = 0 ;
7294 float arg4 ;
7295 std::pair< bool,oneML::face::Embedding > result;
7296 std::pair< bool,std::array< float,512 > > *_swig_go_result;
7297
7298 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7299 arg2 = *(oneML::face::Embedding **)&_swig_go_1;
7300 arg3 = *(oneML::Image **)&_swig_go_2;
7301 arg4 = (float)_swig_go_3;
7302
7303 {
7304 try
7305 {
7306 result = oneML_face_FaceId_go_is_the_same_person_emb__SWIG_1(arg1,*arg2,*arg3,arg4);
7307 }
7308 catch (const std::invalid_argument& e)
7309 {
7310 SWIG_exception(SWIG_ValueError, e.what());
7311 }
7312 catch (const std::out_of_range& e)
7313 {
7314 SWIG_exception(SWIG_IndexError, e.what());
7315 }
7316 catch(const std::exception& e)
7317 {
7318 SWIG_exception(SWIG_RuntimeError, e.what());
7319 }
7320 }
7321 *(std::pair< bool,oneML::face::Embedding > **)&_swig_go_result = new std::pair< bool,oneML::face::Embedding >(result);
7322 return _swig_go_result;
7323}
7324
7325
7326intgo _wrap_FaceId_RegisterIdEmb_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, std::array< float,512 > *_swig_go_2) {
7327 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7328 std::string *arg2 = 0 ;
7329 oneML::face::Embedding *arg3 = 0 ;
7330 int result;
7331 intgo _swig_go_result;
7332
7333 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7334
7335 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7336 arg2 = &arg2_str;
7337
7338 arg3 = *(oneML::face::Embedding **)&_swig_go_2;
7339
7340 {
7341 try
7342 {
7343 result = (int)oneML_face_FaceId_go_register_id_emb(arg1,(std::string const &)*arg2,(std::array< float,512 > const &)*arg3);
7344 }
7345 catch (const std::invalid_argument& e)
7346 {
7347 SWIG_exception(SWIG_ValueError, e.what());
7348 }
7349 catch (const std::out_of_range& e)
7350 {
7351 SWIG_exception(SWIG_IndexError, e.what());
7352 }
7353 catch(const std::exception& e)
7354 {
7355 SWIG_exception(SWIG_RuntimeError, e.what());
7356 }
7357 }
7358 _swig_go_result = result;
7359 return _swig_go_result;
7360}
7361
7362
7363std::array< float,512 > *_wrap_FaceId_RegisterIdImages_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, std::vector< oneML::Image > *_swig_go_2, bool _swig_go_3) {
7364 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7365 std::string *arg2 = 0 ;
7366 std::vector< oneML::Image > *arg3 = 0 ;
7367 bool *arg4 = 0 ;
7368 oneML::face::Embedding result;
7369 std::array< float,512 > *_swig_go_result;
7370
7371 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7372
7373 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7374 arg2 = &arg2_str;
7375
7376 arg3 = *(std::vector< oneML::Image > **)&_swig_go_2;
7377 arg4 = (bool *)&_swig_go_3;
7378
7379 {
7380 try
7381 {
7382 result = oneML_face_FaceId_go_register_id_images(arg1,(std::string const &)*arg2,(std::vector< oneML::Image > const &)*arg3,(bool const &)*arg4);
7383 }
7384 catch (const std::invalid_argument& e)
7385 {
7386 SWIG_exception(SWIG_ValueError, e.what());
7387 }
7388 catch (const std::out_of_range& e)
7389 {
7390 SWIG_exception(SWIG_IndexError, e.what());
7391 }
7392 catch(const std::exception& e)
7393 {
7394 SWIG_exception(SWIG_RuntimeError, e.what());
7395 }
7396 }
7397 *(oneML::face::Embedding **)&_swig_go_result = new oneML::face::Embedding(result);
7398 return _swig_go_result;
7399}
7400
7401
7402std::array< float,512 > *_wrap_FaceId_RegisterIdImage_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, oneML::Image *_swig_go_2) {
7403 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7404 std::string *arg2 = 0 ;
7405 oneML::Image *arg3 = 0 ;
7406 oneML::face::Embedding result;
7407 std::array< float,512 > *_swig_go_result;
7408
7409 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7410
7411 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7412 arg2 = &arg2_str;
7413
7414 arg3 = *(oneML::Image **)&_swig_go_2;
7415
7416 {
7417 try
7418 {
7419 result = oneML_face_FaceId_go_register_id_image(arg1,(std::string const &)*arg2,(oneML::Image const &)*arg3);
7420 }
7421 catch (const std::invalid_argument& e)
7422 {
7423 SWIG_exception(SWIG_ValueError, e.what());
7424 }
7425 catch (const std::out_of_range& e)
7426 {
7427 SWIG_exception(SWIG_IndexError, e.what());
7428 }
7429 catch(const std::exception& e)
7430 {
7431 SWIG_exception(SWIG_RuntimeError, e.what());
7432 }
7433 }
7434 *(oneML::face::Embedding **)&_swig_go_result = new oneML::face::Embedding(result);
7435 return _swig_go_result;
7436}
7437
7438
7439void _wrap_FaceId_UpdateEmbeddingDynamicallyImg_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, oneML::Image *_swig_go_2, std::array< float,512 > *_swig_go_3) {
7440 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7441 std::string *arg2 = 0 ;
7442 oneML::Image *arg3 = 0 ;
7443 oneML::face::Embedding *arg4 = 0 ;
7444
7445 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7446
7447 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7448 arg2 = &arg2_str;
7449
7450 arg3 = *(oneML::Image **)&_swig_go_2;
7451 arg4 = *(oneML::face::Embedding **)&_swig_go_3;
7452
7453 {
7454 try
7455 {
7456 oneML_face_FaceId_go_update_embedding_dynamically_img(arg1,(std::string const &)*arg2,(oneML::Image const &)*arg3,(std::array< float,512 > const &)*arg4);
7457 }
7458 catch (const std::invalid_argument& e)
7459 {
7460 SWIG_exception(SWIG_ValueError, e.what());
7461 }
7462 catch (const std::out_of_range& e)
7463 {
7464 SWIG_exception(SWIG_IndexError, e.what());
7465 }
7466 catch(const std::exception& e)
7467 {
7468 SWIG_exception(SWIG_RuntimeError, e.what());
7469 }
7470 }
7471
7472}
7473
7474
7475void _wrap_FaceId_UpdateEmbeddingDynamicallyEmb_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, std::array< float,512 > *_swig_go_2, std::array< float,512 > *_swig_go_3) {
7476 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7477 std::string *arg2 = 0 ;
7478 oneML::face::Embedding *arg3 = 0 ;
7479 oneML::face::Embedding *arg4 = 0 ;
7480
7481 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7482
7483 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7484 arg2 = &arg2_str;
7485
7486 arg3 = *(oneML::face::Embedding **)&_swig_go_2;
7487 arg4 = *(oneML::face::Embedding **)&_swig_go_3;
7488
7489 {
7490 try
7491 {
7492 oneML_face_FaceId_go_update_embedding_dynamically_emb(arg1,(std::string const &)*arg2,(std::array< float,512 > const &)*arg3,(std::array< float,512 > const &)*arg4);
7493 }
7494 catch (const std::invalid_argument& e)
7495 {
7496 SWIG_exception(SWIG_ValueError, e.what());
7497 }
7498 catch (const std::out_of_range& e)
7499 {
7500 SWIG_exception(SWIG_IndexError, e.what());
7501 }
7502 catch(const std::exception& e)
7503 {
7504 SWIG_exception(SWIG_RuntimeError, e.what());
7505 }
7506 }
7507
7508}
7509
7510
7511void _wrap_FaceId_UpdateEmbedding_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1, std::array< float,512 > *_swig_go_2) {
7512 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7513 std::string *arg2 = 0 ;
7514 oneML::face::Embedding *arg3 = 0 ;
7515
7516 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7517
7518 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7519 arg2 = &arg2_str;
7520
7521 arg3 = *(oneML::face::Embedding **)&_swig_go_2;
7522
7523 {
7524 try
7525 {
7526 oneML_face_FaceId_go_update_embedding(arg1,(std::string const &)*arg2,(std::array< float,512 > const &)*arg3);
7527 }
7528 catch (const std::invalid_argument& e)
7529 {
7530 SWIG_exception(SWIG_ValueError, e.what());
7531 }
7532 catch (const std::out_of_range& e)
7533 {
7534 SWIG_exception(SWIG_IndexError, e.what());
7535 }
7536 catch(const std::exception& e)
7537 {
7538 SWIG_exception(SWIG_RuntimeError, e.what());
7539 }
7540 }
7541
7542}
7543
7544
7545void _wrap_FaceId_RemoveId_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0, _gostring_ _swig_go_1) {
7546 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7547 std::string *arg2 = 0 ;
7548
7549 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7550
7551 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
7552 arg2 = &arg2_str;
7553
7554
7555 {
7556 try
7557 {
7558 oneML_face_FaceId_go_remove_id(arg1,(std::string const &)*arg2);
7559 }
7560 catch (const std::invalid_argument& e)
7561 {
7562 SWIG_exception(SWIG_ValueError, e.what());
7563 }
7564 catch (const std::out_of_range& e)
7565 {
7566 SWIG_exception(SWIG_IndexError, e.what());
7567 }
7568 catch(const std::exception& e)
7569 {
7570 SWIG_exception(SWIG_RuntimeError, e.what());
7571 }
7572 }
7573
7574}
7575
7576
7577std::vector< std::string > *_wrap_FaceId_GetIds_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0) {
7578 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7579 std::vector< std::string > result;
7580 std::vector< std::string > *_swig_go_result;
7581
7582 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7583
7584 {
7585 try
7586 {
7587 result = oneML_face_FaceId_go_get_ids(arg1);
7588 }
7589 catch (const std::invalid_argument& e)
7590 {
7591 SWIG_exception(SWIG_ValueError, e.what());
7592 }
7593 catch (const std::out_of_range& e)
7594 {
7595 SWIG_exception(SWIG_IndexError, e.what());
7596 }
7597 catch(const std::exception& e)
7598 {
7599 SWIG_exception(SWIG_RuntimeError, e.what());
7600 }
7601 }
7602 *(std::vector< std::string > **)&_swig_go_result = new std::vector< std::string >(result);
7603 return _swig_go_result;
7604}
7605
7606
7607void _wrap_delete_FaceId_face_86f062e835b3dd07(oneML::face::FaceId *_swig_go_0) {
7608 oneML::face::FaceId *arg1 = (oneML::face::FaceId *) 0 ;
7609
7610 arg1 = *(oneML::face::FaceId **)&_swig_go_0;
7611
7612 {
7613 try
7614 {
7615 delete arg1;
7616 }
7617 catch (const std::invalid_argument& e)
7618 {
7619 SWIG_exception(SWIG_ValueError, e.what());
7620 }
7621 catch (const std::out_of_range& e)
7622 {
7623 SWIG_exception(SWIG_IndexError, e.what());
7624 }
7625 catch(const std::exception& e)
7626 {
7627 SWIG_exception(SWIG_RuntimeError, e.what());
7628 }
7629 }
7630
7631}
7632
7633
7634intgo _wrap_FaceIdStatus_Empty_face_86f062e835b3dd07() {
7635 oneML::face::FaceIdStatus result;
7636 intgo _swig_go_result;
7637
7638
7639 {
7640 try
7641 {
7642 result = oneML::face::FaceIdStatus::Empty;
7643
7644 }
7645 catch (const std::invalid_argument& e)
7646 {
7647 SWIG_exception(SWIG_ValueError, e.what());
7648 }
7649 catch (const std::out_of_range& e)
7650 {
7651 SWIG_exception(SWIG_IndexError, e.what());
7652 }
7653 catch(const std::exception& e)
7654 {
7655 SWIG_exception(SWIG_RuntimeError, e.what());
7656 }
7657 }
7658 _swig_go_result = (intgo)result;
7659 return _swig_go_result;
7660}
7661
7662
7663intgo _wrap_FaceIdStatus_Success_face_86f062e835b3dd07() {
7664 oneML::face::FaceIdStatus result;
7665 intgo _swig_go_result;
7666
7667
7668 {
7669 try
7670 {
7671 result = oneML::face::FaceIdStatus::Success;
7672
7673 }
7674 catch (const std::invalid_argument& e)
7675 {
7676 SWIG_exception(SWIG_ValueError, e.what());
7677 }
7678 catch (const std::out_of_range& e)
7679 {
7680 SWIG_exception(SWIG_IndexError, e.what());
7681 }
7682 catch(const std::exception& e)
7683 {
7684 SWIG_exception(SWIG_RuntimeError, e.what());
7685 }
7686 }
7687 _swig_go_result = (intgo)result;
7688 return _swig_go_result;
7689}
7690
7691
7692intgo _wrap_FaceIdStatus_Fail_face_86f062e835b3dd07() {
7693 oneML::face::FaceIdStatus result;
7694 intgo _swig_go_result;
7695
7696
7697 {
7698 try
7699 {
7700 result = oneML::face::FaceIdStatus::Fail;
7701
7702 }
7703 catch (const std::invalid_argument& e)
7704 {
7705 SWIG_exception(SWIG_ValueError, e.what());
7706 }
7707 catch (const std::out_of_range& e)
7708 {
7709 SWIG_exception(SWIG_IndexError, e.what());
7710 }
7711 catch(const std::exception& e)
7712 {
7713 SWIG_exception(SWIG_RuntimeError, e.what());
7714 }
7715 }
7716 _swig_go_result = (intgo)result;
7717 return _swig_go_result;
7718}
7719
7720
7721std::vector< oneML::face::FacePadResult > *_wrap_new_FacePadResultVector__SWIG_0_face_86f062e835b3dd07() {
7722 std::vector< oneML::face::FacePadResult > *result = 0 ;
7723 std::vector< oneML::face::FacePadResult > *_swig_go_result;
7724
7725
7726 {
7727 try
7728 {
7729 result = (std::vector< oneML::face::FacePadResult > *)new std::vector< oneML::face::FacePadResult >();
7730 }
7731 catch (const std::invalid_argument& e)
7732 {
7733 SWIG_exception(SWIG_ValueError, e.what());
7734 }
7735 catch (const std::out_of_range& e)
7736 {
7737 SWIG_exception(SWIG_IndexError, e.what());
7738 }
7739 catch(const std::exception& e)
7740 {
7741 SWIG_exception(SWIG_RuntimeError, e.what());
7742 }
7743 }
7744 *(std::vector< oneML::face::FacePadResult > **)&_swig_go_result = (std::vector< oneML::face::FacePadResult > *)result;
7745 return _swig_go_result;
7746}
7747
7748
7749std::vector< oneML::face::FacePadResult > *_wrap_new_FacePadResultVector__SWIG_1_face_86f062e835b3dd07(long long _swig_go_0) {
7750 std::vector< oneML::face::FacePadResult >::size_type arg1 ;
7751 std::vector< oneML::face::FacePadResult > *result = 0 ;
7752 std::vector< oneML::face::FacePadResult > *_swig_go_result;
7753
7754 arg1 = (size_t)_swig_go_0;
7755
7756 {
7757 try
7758 {
7759 result = (std::vector< oneML::face::FacePadResult > *)new std::vector< oneML::face::FacePadResult >(arg1);
7760 }
7761 catch (const std::invalid_argument& e)
7762 {
7763 SWIG_exception(SWIG_ValueError, e.what());
7764 }
7765 catch (const std::out_of_range& e)
7766 {
7767 SWIG_exception(SWIG_IndexError, e.what());
7768 }
7769 catch(const std::exception& e)
7770 {
7771 SWIG_exception(SWIG_RuntimeError, e.what());
7772 }
7773 }
7774 *(std::vector< oneML::face::FacePadResult > **)&_swig_go_result = (std::vector< oneML::face::FacePadResult > *)result;
7775 return _swig_go_result;
7776}
7777
7778
7779std::vector< oneML::face::FacePadResult > *_wrap_new_FacePadResultVector__SWIG_2_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
7780 std::vector< oneML::face::FacePadResult > *arg1 = 0 ;
7781 std::vector< oneML::face::FacePadResult > *result = 0 ;
7782 std::vector< oneML::face::FacePadResult > *_swig_go_result;
7783
7784 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7785
7786 {
7787 try
7788 {
7789 result = (std::vector< oneML::face::FacePadResult > *)new std::vector< oneML::face::FacePadResult >((std::vector< oneML::face::FacePadResult > const &)*arg1);
7790 }
7791 catch (const std::invalid_argument& e)
7792 {
7793 SWIG_exception(SWIG_ValueError, e.what());
7794 }
7795 catch (const std::out_of_range& e)
7796 {
7797 SWIG_exception(SWIG_IndexError, e.what());
7798 }
7799 catch(const std::exception& e)
7800 {
7801 SWIG_exception(SWIG_RuntimeError, e.what());
7802 }
7803 }
7804 *(std::vector< oneML::face::FacePadResult > **)&_swig_go_result = (std::vector< oneML::face::FacePadResult > *)result;
7805 return _swig_go_result;
7806}
7807
7808
7809long long _wrap_FacePadResultVector_size_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
7810 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7811 std::vector< oneML::face::FacePadResult >::size_type result;
7812 long long _swig_go_result;
7813
7814 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7815
7816 {
7817 try
7818 {
7819 result = ((std::vector< oneML::face::FacePadResult > const *)arg1)->size();
7820 }
7821 catch (const std::invalid_argument& e)
7822 {
7823 SWIG_exception(SWIG_ValueError, e.what());
7824 }
7825 catch (const std::out_of_range& e)
7826 {
7827 SWIG_exception(SWIG_IndexError, e.what());
7828 }
7829 catch(const std::exception& e)
7830 {
7831 SWIG_exception(SWIG_RuntimeError, e.what());
7832 }
7833 }
7834 _swig_go_result = result;
7835 return _swig_go_result;
7836}
7837
7838
7839long long _wrap_FacePadResultVector_capacity_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
7840 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7841 std::vector< oneML::face::FacePadResult >::size_type result;
7842 long long _swig_go_result;
7843
7844 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7845
7846 {
7847 try
7848 {
7849 result = ((std::vector< oneML::face::FacePadResult > const *)arg1)->capacity();
7850 }
7851 catch (const std::invalid_argument& e)
7852 {
7853 SWIG_exception(SWIG_ValueError, e.what());
7854 }
7855 catch (const std::out_of_range& e)
7856 {
7857 SWIG_exception(SWIG_IndexError, e.what());
7858 }
7859 catch(const std::exception& e)
7860 {
7861 SWIG_exception(SWIG_RuntimeError, e.what());
7862 }
7863 }
7864 _swig_go_result = result;
7865 return _swig_go_result;
7866}
7867
7868
7869void _wrap_FacePadResultVector_reserve_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0, long long _swig_go_1) {
7870 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7871 std::vector< oneML::face::FacePadResult >::size_type arg2 ;
7872
7873 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7874 arg2 = (size_t)_swig_go_1;
7875
7876 {
7877 try
7878 {
7879 (arg1)->reserve(arg2);
7880 }
7881 catch (const std::invalid_argument& e)
7882 {
7883 SWIG_exception(SWIG_ValueError, e.what());
7884 }
7885 catch (const std::out_of_range& e)
7886 {
7887 SWIG_exception(SWIG_IndexError, e.what());
7888 }
7889 catch(const std::exception& e)
7890 {
7891 SWIG_exception(SWIG_RuntimeError, e.what());
7892 }
7893 }
7894
7895}
7896
7897
7898bool _wrap_FacePadResultVector_isEmpty_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
7899 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7900 bool result;
7901 bool _swig_go_result;
7902
7903 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7904
7905 {
7906 try
7907 {
7908 result = (bool)((std::vector< oneML::face::FacePadResult > const *)arg1)->empty();
7909 }
7910 catch (const std::invalid_argument& e)
7911 {
7912 SWIG_exception(SWIG_ValueError, e.what());
7913 }
7914 catch (const std::out_of_range& e)
7915 {
7916 SWIG_exception(SWIG_IndexError, e.what());
7917 }
7918 catch(const std::exception& e)
7919 {
7920 SWIG_exception(SWIG_RuntimeError, e.what());
7921 }
7922 }
7923 _swig_go_result = result;
7924 return _swig_go_result;
7925}
7926
7927
7928void _wrap_FacePadResultVector_clear_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
7929 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7930
7931 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7932
7933 {
7934 try
7935 {
7936 (arg1)->clear();
7937 }
7938 catch (const std::invalid_argument& e)
7939 {
7940 SWIG_exception(SWIG_ValueError, e.what());
7941 }
7942 catch (const std::out_of_range& e)
7943 {
7944 SWIG_exception(SWIG_IndexError, e.what());
7945 }
7946 catch(const std::exception& e)
7947 {
7948 SWIG_exception(SWIG_RuntimeError, e.what());
7949 }
7950 }
7951
7952}
7953
7954
7955void _wrap_FacePadResultVector_add_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0, oneML::face::FacePadResult *_swig_go_1) {
7956 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7957 std::vector< oneML::face::FacePadResult >::value_type *arg2 = 0 ;
7958
7959 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7960 arg2 = *(std::vector< oneML::face::FacePadResult >::value_type **)&_swig_go_1;
7961
7962 {
7963 try
7964 {
7965 (arg1)->push_back((std::vector< oneML::face::FacePadResult >::value_type const &)*arg2);
7966 }
7967 catch (const std::invalid_argument& e)
7968 {
7969 SWIG_exception(SWIG_ValueError, e.what());
7970 }
7971 catch (const std::out_of_range& e)
7972 {
7973 SWIG_exception(SWIG_IndexError, e.what());
7974 }
7975 catch(const std::exception& e)
7976 {
7977 SWIG_exception(SWIG_RuntimeError, e.what());
7978 }
7979 }
7980
7981}
7982
7983
7984oneML::face::FacePadResult *_wrap_FacePadResultVector_get_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0, intgo _swig_go_1) {
7985 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
7986 int arg2 ;
7987 std::vector< oneML::face::FacePadResult >::value_type *result = 0 ;
7988 oneML::face::FacePadResult *_swig_go_result;
7989
7990 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
7991 arg2 = (int)_swig_go_1;
7992
7993 {
7994 try
7995 {
7996 try {
7997 result = (std::vector< oneML::face::FacePadResult >::value_type *) &std_vector_Sl_oneML_face_FacePadResult_Sg__get(arg1,arg2);
7998 } catch(std::out_of_range &_e) {
7999 _swig_gopanic((&_e)->what());
8000 }
8001 }
8002 catch (const std::invalid_argument& e)
8003 {
8004 SWIG_exception(SWIG_ValueError, e.what());
8005 }
8006 catch (const std::out_of_range& e)
8007 {
8008 SWIG_exception(SWIG_IndexError, e.what());
8009 }
8010 catch(const std::exception& e)
8011 {
8012 SWIG_exception(SWIG_RuntimeError, e.what());
8013 }
8014 }
8015 *(std::vector< oneML::face::FacePadResult >::value_type **)&_swig_go_result = result;
8016 return _swig_go_result;
8017}
8018
8019
8020void _wrap_FacePadResultVector_set_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0, intgo _swig_go_1, oneML::face::FacePadResult *_swig_go_2) {
8021 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
8022 int arg2 ;
8023 std::vector< oneML::face::FacePadResult >::value_type *arg3 = 0 ;
8024
8025 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
8026 arg2 = (int)_swig_go_1;
8027 arg3 = *(std::vector< oneML::face::FacePadResult >::value_type **)&_swig_go_2;
8028
8029 {
8030 try
8031 {
8032 try {
8033 std_vector_Sl_oneML_face_FacePadResult_Sg__set(arg1,arg2,(oneML::face::FacePadResult const &)*arg3);
8034 } catch(std::out_of_range &_e) {
8035 _swig_gopanic((&_e)->what());
8036 }
8037 }
8038 catch (const std::invalid_argument& e)
8039 {
8040 SWIG_exception(SWIG_ValueError, e.what());
8041 }
8042 catch (const std::out_of_range& e)
8043 {
8044 SWIG_exception(SWIG_IndexError, e.what());
8045 }
8046 catch(const std::exception& e)
8047 {
8048 SWIG_exception(SWIG_RuntimeError, e.what());
8049 }
8050 }
8051
8052}
8053
8054
8055void _wrap_delete_FacePadResultVector_face_86f062e835b3dd07(std::vector< oneML::face::FacePadResult > *_swig_go_0) {
8056 std::vector< oneML::face::FacePadResult > *arg1 = (std::vector< oneML::face::FacePadResult > *) 0 ;
8057
8058 arg1 = *(std::vector< oneML::face::FacePadResult > **)&_swig_go_0;
8059
8060 {
8061 try
8062 {
8063 delete arg1;
8064 }
8065 catch (const std::invalid_argument& e)
8066 {
8067 SWIG_exception(SWIG_ValueError, e.what());
8068 }
8069 catch (const std::out_of_range& e)
8070 {
8071 SWIG_exception(SWIG_IndexError, e.what());
8072 }
8073 catch(const std::exception& e)
8074 {
8075 SWIG_exception(SWIG_RuntimeError, e.what());
8076 }
8077 }
8078
8079}
8080
8081
8082intgo _wrap_PadType_Rgb_face_86f062e835b3dd07() {
8083 oneML::face::PadType result;
8084 intgo _swig_go_result;
8085
8086
8087 {
8088 try
8089 {
8090 result = oneML::face::PadType::Rgb;
8091
8092 }
8093 catch (const std::invalid_argument& e)
8094 {
8095 SWIG_exception(SWIG_ValueError, e.what());
8096 }
8097 catch (const std::out_of_range& e)
8098 {
8099 SWIG_exception(SWIG_IndexError, e.what());
8100 }
8101 catch(const std::exception& e)
8102 {
8103 SWIG_exception(SWIG_RuntimeError, e.what());
8104 }
8105 }
8106 _swig_go_result = (intgo)result;
8107 return _swig_go_result;
8108}
8109
8110
8111intgo _wrap_PadType_Paper_face_86f062e835b3dd07() {
8112 oneML::face::PadType result;
8113 intgo _swig_go_result;
8114
8115
8116 {
8117 try
8118 {
8119 result = oneML::face::PadType::Paper;
8120
8121 }
8122 catch (const std::invalid_argument& e)
8123 {
8124 SWIG_exception(SWIG_ValueError, e.what());
8125 }
8126 catch (const std::out_of_range& e)
8127 {
8128 SWIG_exception(SWIG_IndexError, e.what());
8129 }
8130 catch(const std::exception& e)
8131 {
8132 SWIG_exception(SWIG_RuntimeError, e.what());
8133 }
8134 }
8135 _swig_go_result = (intgo)result;
8136 return _swig_go_result;
8137}
8138
8139
8140oneML::face::FacePadResult *_wrap_new_FacePadResult_face_86f062e835b3dd07() {
8141 oneML::face::FacePadResult *result = 0 ;
8142 oneML::face::FacePadResult *_swig_go_result;
8143
8144
8145 {
8146 try
8147 {
8148 result = (oneML::face::FacePadResult *)new oneML::face::FacePadResult();
8149 }
8150 catch (const std::invalid_argument& e)
8151 {
8152 SWIG_exception(SWIG_ValueError, e.what());
8153 }
8154 catch (const std::out_of_range& e)
8155 {
8156 SWIG_exception(SWIG_IndexError, e.what());
8157 }
8158 catch(const std::exception& e)
8159 {
8160 SWIG_exception(SWIG_RuntimeError, e.what());
8161 }
8162 }
8163 *(oneML::face::FacePadResult **)&_swig_go_result = (oneML::face::FacePadResult *)result;
8164 return _swig_go_result;
8165}
8166
8167
8168float _wrap_FacePadResult_GetSpoofProb_face_86f062e835b3dd07(oneML::face::FacePadResult *_swig_go_0) {
8169 oneML::face::FacePadResult *arg1 = (oneML::face::FacePadResult *) 0 ;
8170 float result;
8171 float _swig_go_result;
8172
8173 arg1 = *(oneML::face::FacePadResult **)&_swig_go_0;
8174
8175 {
8176 try
8177 {
8178 result = (float)((oneML::face::FacePadResult const *)arg1)->get_spoof_prob();
8179 }
8180 catch (const std::invalid_argument& e)
8181 {
8182 SWIG_exception(SWIG_ValueError, e.what());
8183 }
8184 catch (const std::out_of_range& e)
8185 {
8186 SWIG_exception(SWIG_IndexError, e.what());
8187 }
8188 catch(const std::exception& e)
8189 {
8190 SWIG_exception(SWIG_RuntimeError, e.what());
8191 }
8192 }
8193 _swig_go_result = result;
8194 return _swig_go_result;
8195}
8196
8197
8198bool _wrap_FacePadResult_IsSpoof_face_86f062e835b3dd07(oneML::face::FacePadResult *_swig_go_0) {
8199 oneML::face::FacePadResult *arg1 = (oneML::face::FacePadResult *) 0 ;
8200 bool result;
8201 bool _swig_go_result;
8202
8203 arg1 = *(oneML::face::FacePadResult **)&_swig_go_0;
8204
8205 {
8206 try
8207 {
8208 result = (bool)((oneML::face::FacePadResult const *)arg1)->is_spoof();
8209 }
8210 catch (const std::invalid_argument& e)
8211 {
8212 SWIG_exception(SWIG_ValueError, e.what());
8213 }
8214 catch (const std::out_of_range& e)
8215 {
8216 SWIG_exception(SWIG_IndexError, e.what());
8217 }
8218 catch(const std::exception& e)
8219 {
8220 SWIG_exception(SWIG_RuntimeError, e.what());
8221 }
8222 }
8223 _swig_go_result = result;
8224 return _swig_go_result;
8225}
8226
8227
8228intgo _wrap_FacePadResult_GetReturnStatus_face_86f062e835b3dd07(oneML::face::FacePadResult *_swig_go_0) {
8229 oneML::face::FacePadResult *arg1 = (oneML::face::FacePadResult *) 0 ;
8230 int result;
8231 intgo _swig_go_result;
8232
8233 arg1 = *(oneML::face::FacePadResult **)&_swig_go_0;
8234
8235 {
8236 try
8237 {
8238 result = (int)oneML_face_FacePadResult_go_get_return_status(arg1);
8239 }
8240 catch (const std::invalid_argument& e)
8241 {
8242 SWIG_exception(SWIG_ValueError, e.what());
8243 }
8244 catch (const std::out_of_range& e)
8245 {
8246 SWIG_exception(SWIG_IndexError, e.what());
8247 }
8248 catch(const std::exception& e)
8249 {
8250 SWIG_exception(SWIG_RuntimeError, e.what());
8251 }
8252 }
8253 _swig_go_result = result;
8254 return _swig_go_result;
8255}
8256
8257
8258void _wrap_delete_FacePadResult_face_86f062e835b3dd07(oneML::face::FacePadResult *_swig_go_0) {
8259 oneML::face::FacePadResult *arg1 = (oneML::face::FacePadResult *) 0 ;
8260
8261 arg1 = *(oneML::face::FacePadResult **)&_swig_go_0;
8262
8263 {
8264 try
8265 {
8266 delete arg1;
8267 }
8268 catch (const std::invalid_argument& e)
8269 {
8270 SWIG_exception(SWIG_ValueError, e.what());
8271 }
8272 catch (const std::out_of_range& e)
8273 {
8274 SWIG_exception(SWIG_IndexError, e.what());
8275 }
8276 catch(const std::exception& e)
8277 {
8278 SWIG_exception(SWIG_RuntimeError, e.what());
8279 }
8280 }
8281
8282}
8283
8284
8285oneML::face::FacePad *_wrap_new_FacePad_face_86f062e835b3dd07(intgo _swig_go_0, oneML::LicenseManager *_swig_go_1) {
8286 oneML::face::PadType arg1 ;
8287 oneML::LicenseManager *arg2 = 0 ;
8288 oneML::face::FacePad *result = 0 ;
8289 oneML::face::FacePad *_swig_go_result;
8290
8291 arg1 = (oneML::face::PadType)_swig_go_0;
8292 arg2 = *(oneML::LicenseManager **)&_swig_go_1;
8293
8294 {
8295 try
8296 {
8297 result = (oneML::face::FacePad *)new oneML::face::FacePad(arg1,*arg2);
8298 }
8299 catch (const std::invalid_argument& e)
8300 {
8301 SWIG_exception(SWIG_ValueError, e.what());
8302 }
8303 catch (const std::out_of_range& e)
8304 {
8305 SWIG_exception(SWIG_IndexError, e.what());
8306 }
8307 catch(const std::exception& e)
8308 {
8309 SWIG_exception(SWIG_RuntimeError, e.what());
8310 }
8311 }
8312 *(oneML::face::FacePad **)&_swig_go_result = (oneML::face::FacePad *)result;
8313 return _swig_go_result;
8314}
8315
8316
8317std::vector< oneML::face::FacePadResult > *_wrap_FacePad_ClassifyBatch__SWIG_0_face_86f062e835b3dd07(oneML::face::FacePad *_swig_go_0, std::vector< oneML::Image > *_swig_go_1) {
8318 oneML::face::FacePad *arg1 = (oneML::face::FacePad *) 0 ;
8319 std::vector< oneML::Image > *arg2 = 0 ;
8320 std::vector< oneML::face::FacePadResult > result;
8321 std::vector< oneML::face::FacePadResult > *_swig_go_result;
8322
8323 arg1 = *(oneML::face::FacePad **)&_swig_go_0;
8324 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
8325
8326 {
8327 try
8328 {
8329 result = oneML_face_FacePad_go_classify_batch__SWIG_0(arg1,*arg2);
8330 }
8331 catch (const std::invalid_argument& e)
8332 {
8333 SWIG_exception(SWIG_ValueError, e.what());
8334 }
8335 catch (const std::out_of_range& e)
8336 {
8337 SWIG_exception(SWIG_IndexError, e.what());
8338 }
8339 catch(const std::exception& e)
8340 {
8341 SWIG_exception(SWIG_RuntimeError, e.what());
8342 }
8343 }
8344 *(std::vector< oneML::face::FacePadResult > **)&_swig_go_result = new std::vector< oneML::face::FacePadResult >(result);
8345 return _swig_go_result;
8346}
8347
8348
8349std::vector< oneML::face::FacePadResult > *_wrap_FacePad_ClassifyBatch__SWIG_1_face_86f062e835b3dd07(oneML::face::FacePad *_swig_go_0, std::vector< oneML::Image > *_swig_go_1, float _swig_go_2) {
8350 oneML::face::FacePad *arg1 = (oneML::face::FacePad *) 0 ;
8351 std::vector< oneML::Image > *arg2 = 0 ;
8352 float arg3 ;
8353 std::vector< oneML::face::FacePadResult > result;
8354 std::vector< oneML::face::FacePadResult > *_swig_go_result;
8355
8356 arg1 = *(oneML::face::FacePad **)&_swig_go_0;
8357 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
8358 arg3 = (float)_swig_go_2;
8359
8360 {
8361 try
8362 {
8363 result = oneML_face_FacePad_go_classify_batch__SWIG_1(arg1,*arg2,arg3);
8364 }
8365 catch (const std::invalid_argument& e)
8366 {
8367 SWIG_exception(SWIG_ValueError, e.what());
8368 }
8369 catch (const std::out_of_range& e)
8370 {
8371 SWIG_exception(SWIG_IndexError, e.what());
8372 }
8373 catch(const std::exception& e)
8374 {
8375 SWIG_exception(SWIG_RuntimeError, e.what());
8376 }
8377 }
8378 *(std::vector< oneML::face::FacePadResult > **)&_swig_go_result = new std::vector< oneML::face::FacePadResult >(result);
8379 return _swig_go_result;
8380}
8381
8382
8383oneML::face::FacePadResult *_wrap_FacePad_Classify__SWIG_0_face_86f062e835b3dd07(oneML::face::FacePad *_swig_go_0, oneML::Image *_swig_go_1) {
8384 oneML::face::FacePad *arg1 = (oneML::face::FacePad *) 0 ;
8385 oneML::Image *arg2 = 0 ;
8386 oneML::face::FacePadResult result;
8387 oneML::face::FacePadResult *_swig_go_result;
8388
8389 arg1 = *(oneML::face::FacePad **)&_swig_go_0;
8390 arg2 = *(oneML::Image **)&_swig_go_1;
8391
8392 {
8393 try
8394 {
8395 result = oneML_face_FacePad_go_classify__SWIG_0(arg1,*arg2);
8396 }
8397 catch (const std::invalid_argument& e)
8398 {
8399 SWIG_exception(SWIG_ValueError, e.what());
8400 }
8401 catch (const std::out_of_range& e)
8402 {
8403 SWIG_exception(SWIG_IndexError, e.what());
8404 }
8405 catch(const std::exception& e)
8406 {
8407 SWIG_exception(SWIG_RuntimeError, e.what());
8408 }
8409 }
8410 *(oneML::face::FacePadResult **)&_swig_go_result = new oneML::face::FacePadResult(result);
8411 return _swig_go_result;
8412}
8413
8414
8415oneML::face::FacePadResult *_wrap_FacePad_Classify__SWIG_1_face_86f062e835b3dd07(oneML::face::FacePad *_swig_go_0, oneML::Image *_swig_go_1, float _swig_go_2) {
8416 oneML::face::FacePad *arg1 = (oneML::face::FacePad *) 0 ;
8417 oneML::Image *arg2 = 0 ;
8418 float arg3 ;
8419 oneML::face::FacePadResult result;
8420 oneML::face::FacePadResult *_swig_go_result;
8421
8422 arg1 = *(oneML::face::FacePad **)&_swig_go_0;
8423 arg2 = *(oneML::Image **)&_swig_go_1;
8424 arg3 = (float)_swig_go_2;
8425
8426 {
8427 try
8428 {
8429 result = oneML_face_FacePad_go_classify__SWIG_1(arg1,*arg2,arg3);
8430 }
8431 catch (const std::invalid_argument& e)
8432 {
8433 SWIG_exception(SWIG_ValueError, e.what());
8434 }
8435 catch (const std::out_of_range& e)
8436 {
8437 SWIG_exception(SWIG_IndexError, e.what());
8438 }
8439 catch(const std::exception& e)
8440 {
8441 SWIG_exception(SWIG_RuntimeError, e.what());
8442 }
8443 }
8444 *(oneML::face::FacePadResult **)&_swig_go_result = new oneML::face::FacePadResult(result);
8445 return _swig_go_result;
8446}
8447
8448
8449void _wrap_delete_FacePad_face_86f062e835b3dd07(oneML::face::FacePad *_swig_go_0) {
8450 oneML::face::FacePad *arg1 = (oneML::face::FacePad *) 0 ;
8451
8452 arg1 = *(oneML::face::FacePad **)&_swig_go_0;
8453
8454 {
8455 try
8456 {
8457 delete arg1;
8458 }
8459 catch (const std::invalid_argument& e)
8460 {
8461 SWIG_exception(SWIG_ValueError, e.what());
8462 }
8463 catch (const std::out_of_range& e)
8464 {
8465 SWIG_exception(SWIG_IndexError, e.what());
8466 }
8467 catch(const std::exception& e)
8468 {
8469 SWIG_exception(SWIG_RuntimeError, e.what());
8470 }
8471 }
8472
8473}
8474
8475
8476intgo _wrap_FacePadStatus_Empty_face_86f062e835b3dd07() {
8477 oneML::face::FacePadStatus result;
8478 intgo _swig_go_result;
8479
8480
8481 {
8482 try
8483 {
8484 result = oneML::face::FacePadStatus::Empty;
8485
8486 }
8487 catch (const std::invalid_argument& e)
8488 {
8489 SWIG_exception(SWIG_ValueError, e.what());
8490 }
8491 catch (const std::out_of_range& e)
8492 {
8493 SWIG_exception(SWIG_IndexError, e.what());
8494 }
8495 catch(const std::exception& e)
8496 {
8497 SWIG_exception(SWIG_RuntimeError, e.what());
8498 }
8499 }
8500 _swig_go_result = (intgo)result;
8501 return _swig_go_result;
8502}
8503
8504
8505intgo _wrap_FacePadStatus_Success_face_86f062e835b3dd07() {
8506 oneML::face::FacePadStatus result;
8507 intgo _swig_go_result;
8508
8509
8510 {
8511 try
8512 {
8513 result = oneML::face::FacePadStatus::Success;
8514
8515 }
8516 catch (const std::invalid_argument& e)
8517 {
8518 SWIG_exception(SWIG_ValueError, e.what());
8519 }
8520 catch (const std::out_of_range& e)
8521 {
8522 SWIG_exception(SWIG_IndexError, e.what());
8523 }
8524 catch(const std::exception& e)
8525 {
8526 SWIG_exception(SWIG_RuntimeError, e.what());
8527 }
8528 }
8529 _swig_go_result = (intgo)result;
8530 return _swig_go_result;
8531}
8532
8533
8534intgo _wrap_FacePadStatus_DigitalPadFail_face_86f062e835b3dd07() {
8535 oneML::face::FacePadStatus result;
8536 intgo _swig_go_result;
8537
8538
8539 {
8540 try
8541 {
8542 result = oneML::face::FacePadStatus::DigitalPadFail;
8543
8544 }
8545 catch (const std::invalid_argument& e)
8546 {
8547 SWIG_exception(SWIG_ValueError, e.what());
8548 }
8549 catch (const std::out_of_range& e)
8550 {
8551 SWIG_exception(SWIG_IndexError, e.what());
8552 }
8553 catch(const std::exception& e)
8554 {
8555 SWIG_exception(SWIG_RuntimeError, e.what());
8556 }
8557 }
8558 _swig_go_result = (intgo)result;
8559 return _swig_go_result;
8560}
8561
8562
8563intgo _wrap_FacePadStatus_PaperPadFail_face_86f062e835b3dd07() {
8564 oneML::face::FacePadStatus result;
8565 intgo _swig_go_result;
8566
8567
8568 {
8569 try
8570 {
8571 result = oneML::face::FacePadStatus::PaperPadFail;
8572
8573 }
8574 catch (const std::invalid_argument& e)
8575 {
8576 SWIG_exception(SWIG_ValueError, e.what());
8577 }
8578 catch (const std::out_of_range& e)
8579 {
8580 SWIG_exception(SWIG_IndexError, e.what());
8581 }
8582 catch(const std::exception& e)
8583 {
8584 SWIG_exception(SWIG_RuntimeError, e.what());
8585 }
8586 }
8587 _swig_go_result = (intgo)result;
8588 return _swig_go_result;
8589}
8590
8591
8592oneML::Utils *_wrap_new_Utils_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
8593 oneML::LicenseManager *arg1 = 0 ;
8594 oneML::Utils *result = 0 ;
8595 oneML::Utils *_swig_go_result;
8596
8597 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
8598
8599 {
8600 try
8601 {
8602 result = (oneML::Utils *)new oneML::Utils(*arg1);
8603 }
8604 catch (const std::invalid_argument& e)
8605 {
8606 SWIG_exception(SWIG_ValueError, e.what());
8607 }
8608 catch (const std::out_of_range& e)
8609 {
8610 SWIG_exception(SWIG_IndexError, e.what());
8611 }
8612 catch(const std::exception& e)
8613 {
8614 SWIG_exception(SWIG_RuntimeError, e.what());
8615 }
8616 }
8617 *(oneML::Utils **)&_swig_go_result = (oneML::Utils *)result;
8618 return _swig_go_result;
8619}
8620
8621
8622oneML::Image *_wrap_Utils_CropAlignFaceLandmark_face_86f062e835b3dd07(oneML::Utils *_swig_go_0, oneML::Image *_swig_go_1, oneML::face::FaceLandmark< 5 > *_swig_go_2) {
8623 oneML::Utils *arg1 = (oneML::Utils *) 0 ;
8624 oneML::Image *arg2 = 0 ;
8625 oneML::face::FaceLandmark5 *arg3 = 0 ;
8626 oneML::Image result;
8627 oneML::Image *_swig_go_result;
8628
8629 arg1 = *(oneML::Utils **)&_swig_go_0;
8630 arg2 = *(oneML::Image **)&_swig_go_1;
8631 arg3 = *(oneML::face::FaceLandmark5 **)&_swig_go_2;
8632
8633 {
8634 try
8635 {
8636 result = oneML_Utils__crop_align_face_landmark(arg1,*arg2,*arg3);
8637 }
8638 catch (const std::invalid_argument& e)
8639 {
8640 SWIG_exception(SWIG_ValueError, e.what());
8641 }
8642 catch (const std::out_of_range& e)
8643 {
8644 SWIG_exception(SWIG_IndexError, e.what());
8645 }
8646 catch(const std::exception& e)
8647 {
8648 SWIG_exception(SWIG_RuntimeError, e.what());
8649 }
8650 }
8651 *(oneML::Image **)&_swig_go_result = new oneML::Image(result);
8652 return _swig_go_result;
8653}
8654
8655
8656oneML::Image *_wrap_Utils_ReadImageCV_face_86f062e835b3dd07(oneML::Utils *_swig_go_0, _gostring_ _swig_go_1) {
8657 oneML::Utils *arg1 = (oneML::Utils *) 0 ;
8658 std::string *arg2 = 0 ;
8659 oneML::Image result;
8660 oneML::Image *_swig_go_result;
8661
8662 arg1 = *(oneML::Utils **)&_swig_go_0;
8663
8664 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
8665 arg2 = &arg2_str;
8666
8667
8668 {
8669 try
8670 {
8671 result = oneML_Utils__read_image_cv(arg1,(std::string const &)*arg2);
8672 }
8673 catch (const std::invalid_argument& e)
8674 {
8675 SWIG_exception(SWIG_ValueError, e.what());
8676 }
8677 catch (const std::out_of_range& e)
8678 {
8679 SWIG_exception(SWIG_IndexError, e.what());
8680 }
8681 catch(const std::exception& e)
8682 {
8683 SWIG_exception(SWIG_RuntimeError, e.what());
8684 }
8685 }
8686 *(oneML::Image **)&_swig_go_result = new oneML::Image(result);
8687 return _swig_go_result;
8688}
8689
8690
8691void _wrap_delete_Utils_face_86f062e835b3dd07(oneML::Utils *_swig_go_0) {
8692 oneML::Utils *arg1 = (oneML::Utils *) 0 ;
8693
8694 arg1 = *(oneML::Utils **)&_swig_go_0;
8695
8696 {
8697 try
8698 {
8699 delete arg1;
8700 }
8701 catch (const std::invalid_argument& e)
8702 {
8703 SWIG_exception(SWIG_ValueError, e.what());
8704 }
8705 catch (const std::out_of_range& e)
8706 {
8707 SWIG_exception(SWIG_IndexError, e.what());
8708 }
8709 catch(const std::exception& e)
8710 {
8711 SWIG_exception(SWIG_RuntimeError, e.what());
8712 }
8713 }
8714
8715}
8716
8717
8718intgo _wrap_LicenseActivationType_NotFound_face_86f062e835b3dd07() {
8719 oneML::LicenseActivationType result;
8720 intgo _swig_go_result;
8721
8722
8723 {
8724 try
8725 {
8726 result = oneML::LicenseActivationType::NotFound;
8727
8728 }
8729 catch (const std::invalid_argument& e)
8730 {
8731 SWIG_exception(SWIG_ValueError, e.what());
8732 }
8733 catch (const std::out_of_range& e)
8734 {
8735 SWIG_exception(SWIG_IndexError, e.what());
8736 }
8737 catch(const std::exception& e)
8738 {
8739 SWIG_exception(SWIG_RuntimeError, e.what());
8740 }
8741 }
8742 _swig_go_result = (intgo)result;
8743 return _swig_go_result;
8744}
8745
8746
8747intgo _wrap_LicenseActivationType_KeyOnline_face_86f062e835b3dd07() {
8748 oneML::LicenseActivationType result;
8749 intgo _swig_go_result;
8750
8751
8752 {
8753 try
8754 {
8755 result = oneML::LicenseActivationType::KeyOnline;
8756
8757 }
8758 catch (const std::invalid_argument& e)
8759 {
8760 SWIG_exception(SWIG_ValueError, e.what());
8761 }
8762 catch (const std::out_of_range& e)
8763 {
8764 SWIG_exception(SWIG_IndexError, e.what());
8765 }
8766 catch(const std::exception& e)
8767 {
8768 SWIG_exception(SWIG_RuntimeError, e.what());
8769 }
8770 }
8771 _swig_go_result = (intgo)result;
8772 return _swig_go_result;
8773}
8774
8775
8776intgo _wrap_LicenseActivationType_TrialOnline_face_86f062e835b3dd07() {
8777 oneML::LicenseActivationType result;
8778 intgo _swig_go_result;
8779
8780
8781 {
8782 try
8783 {
8784 result = oneML::LicenseActivationType::TrialOnline;
8785
8786 }
8787 catch (const std::invalid_argument& e)
8788 {
8789 SWIG_exception(SWIG_ValueError, e.what());
8790 }
8791 catch (const std::out_of_range& e)
8792 {
8793 SWIG_exception(SWIG_IndexError, e.what());
8794 }
8795 catch(const std::exception& e)
8796 {
8797 SWIG_exception(SWIG_RuntimeError, e.what());
8798 }
8799 }
8800 _swig_go_result = (intgo)result;
8801 return _swig_go_result;
8802}
8803
8804
8805intgo _wrap_LicenseStatus_Ok_face_86f062e835b3dd07() {
8806 oneML::LicenseStatus result;
8807 intgo _swig_go_result;
8808
8809
8810 {
8811 try
8812 {
8813 result = oneML::LicenseStatus::Ok;
8814
8815 }
8816 catch (const std::invalid_argument& e)
8817 {
8818 SWIG_exception(SWIG_ValueError, e.what());
8819 }
8820 catch (const std::out_of_range& e)
8821 {
8822 SWIG_exception(SWIG_IndexError, e.what());
8823 }
8824 catch(const std::exception& e)
8825 {
8826 SWIG_exception(SWIG_RuntimeError, e.what());
8827 }
8828 }
8829 _swig_go_result = (intgo)result;
8830 return _swig_go_result;
8831}
8832
8833
8834intgo _wrap_LicenseStatus_Error_face_86f062e835b3dd07() {
8835 oneML::LicenseStatus result;
8836 intgo _swig_go_result;
8837
8838
8839 {
8840 try
8841 {
8842 result = oneML::LicenseStatus::Error;
8843
8844 }
8845 catch (const std::invalid_argument& e)
8846 {
8847 SWIG_exception(SWIG_ValueError, e.what());
8848 }
8849 catch (const std::out_of_range& e)
8850 {
8851 SWIG_exception(SWIG_IndexError, e.what());
8852 }
8853 catch(const std::exception& e)
8854 {
8855 SWIG_exception(SWIG_RuntimeError, e.what());
8856 }
8857 }
8858 _swig_go_result = (intgo)result;
8859 return _swig_go_result;
8860}
8861
8862
8863intgo _wrap_LicenseStatus_Expired_face_86f062e835b3dd07() {
8864 oneML::LicenseStatus result;
8865 intgo _swig_go_result;
8866
8867
8868 {
8869 try
8870 {
8871 result = oneML::LicenseStatus::Expired;
8872
8873 }
8874 catch (const std::invalid_argument& e)
8875 {
8876 SWIG_exception(SWIG_ValueError, e.what());
8877 }
8878 catch (const std::out_of_range& e)
8879 {
8880 SWIG_exception(SWIG_IndexError, e.what());
8881 }
8882 catch(const std::exception& e)
8883 {
8884 SWIG_exception(SWIG_RuntimeError, e.what());
8885 }
8886 }
8887 _swig_go_result = (intgo)result;
8888 return _swig_go_result;
8889}
8890
8891
8892intgo _wrap_LicenseStatus_Suspended_face_86f062e835b3dd07() {
8893 oneML::LicenseStatus result;
8894 intgo _swig_go_result;
8895
8896
8897 {
8898 try
8899 {
8900 result = oneML::LicenseStatus::Suspended;
8901
8902 }
8903 catch (const std::invalid_argument& e)
8904 {
8905 SWIG_exception(SWIG_ValueError, e.what());
8906 }
8907 catch (const std::out_of_range& e)
8908 {
8909 SWIG_exception(SWIG_IndexError, e.what());
8910 }
8911 catch(const std::exception& e)
8912 {
8913 SWIG_exception(SWIG_RuntimeError, e.what());
8914 }
8915 }
8916 _swig_go_result = (intgo)result;
8917 return _swig_go_result;
8918}
8919
8920
8921oneML::LicenseManager *_wrap_new_LicenseManager__SWIG_0_face_86f062e835b3dd07() {
8922 oneML::LicenseManager *result = 0 ;
8923 oneML::LicenseManager *_swig_go_result;
8924
8925
8926 {
8927 try
8928 {
8929 result = (oneML::LicenseManager *)new oneML::LicenseManager();
8930 }
8931 catch (const std::invalid_argument& e)
8932 {
8933 SWIG_exception(SWIG_ValueError, e.what());
8934 }
8935 catch (const std::out_of_range& e)
8936 {
8937 SWIG_exception(SWIG_IndexError, e.what());
8938 }
8939 catch(const std::exception& e)
8940 {
8941 SWIG_exception(SWIG_RuntimeError, e.what());
8942 }
8943 }
8944 *(oneML::LicenseManager **)&_swig_go_result = (oneML::LicenseManager *)result;
8945 return _swig_go_result;
8946}
8947
8948
8949void _wrap_delete_LicenseManager_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
8950 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
8951
8952 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
8953
8954 {
8955 try
8956 {
8957 delete arg1;
8958 }
8959 catch (const std::invalid_argument& e)
8960 {
8961 SWIG_exception(SWIG_ValueError, e.what());
8962 }
8963 catch (const std::out_of_range& e)
8964 {
8965 SWIG_exception(SWIG_IndexError, e.what());
8966 }
8967 catch(const std::exception& e)
8968 {
8969 SWIG_exception(SWIG_RuntimeError, e.what());
8970 }
8971 }
8972
8973}
8974
8975
8976oneML::LicenseManager *_wrap_new_LicenseManager__SWIG_1_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
8977 oneML::LicenseManager *arg1 = 0 ;
8978 oneML::LicenseManager *result = 0 ;
8979 oneML::LicenseManager *_swig_go_result;
8980
8981 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
8982
8983 {
8984 try
8985 {
8986 result = (oneML::LicenseManager *)new oneML::LicenseManager((oneML::LicenseManager const &)*arg1);
8987 }
8988 catch (const std::invalid_argument& e)
8989 {
8990 SWIG_exception(SWIG_ValueError, e.what());
8991 }
8992 catch (const std::out_of_range& e)
8993 {
8994 SWIG_exception(SWIG_IndexError, e.what());
8995 }
8996 catch(const std::exception& e)
8997 {
8998 SWIG_exception(SWIG_RuntimeError, e.what());
8999 }
9000 }
9001 *(oneML::LicenseManager **)&_swig_go_result = (oneML::LicenseManager *)result;
9002 return _swig_go_result;
9003}
9004
9005
9006void _wrap_LicenseManager_SetKey_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0, _gostring_ _swig_go_1) {
9007 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9008 std::string *arg2 = 0 ;
9009
9010 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9011
9012 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
9013 arg2 = &arg2_str;
9014
9015
9016 {
9017 try
9018 {
9019 (arg1)->set_key((std::string const &)*arg2);
9020 }
9021 catch (const std::invalid_argument& e)
9022 {
9023 SWIG_exception(SWIG_ValueError, e.what());
9024 }
9025 catch (const std::out_of_range& e)
9026 {
9027 SWIG_exception(SWIG_IndexError, e.what());
9028 }
9029 catch(const std::exception& e)
9030 {
9031 SWIG_exception(SWIG_RuntimeError, e.what());
9032 }
9033 }
9034
9035}
9036
9037
9038_gostring_ _wrap_LicenseManager_GetKey_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9039 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9040 std::string result;
9041 _gostring_ _swig_go_result;
9042
9043 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9044
9045 {
9046 try
9047 {
9048 result = ((oneML::LicenseManager const *)arg1)->get_key();
9049 }
9050 catch (const std::invalid_argument& e)
9051 {
9052 SWIG_exception(SWIG_ValueError, e.what());
9053 }
9054 catch (const std::out_of_range& e)
9055 {
9056 SWIG_exception(SWIG_IndexError, e.what());
9057 }
9058 catch(const std::exception& e)
9059 {
9060 SWIG_exception(SWIG_RuntimeError, e.what());
9061 }
9062 }
9063 _swig_go_result = Swig_AllocateString((&result)->data(), (&result)->length());
9064 return _swig_go_result;
9065}
9066
9067
9068intgo _wrap_LicenseManager_ActivateKey_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9069 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9070 oneML::LicenseStatus result;
9071 intgo _swig_go_result;
9072
9073 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9074
9075 {
9076 try
9077 {
9078 result = (oneML::LicenseStatus)(arg1)->activate_key();
9079 }
9080 catch (const std::invalid_argument& e)
9081 {
9082 SWIG_exception(SWIG_ValueError, e.what());
9083 }
9084 catch (const std::out_of_range& e)
9085 {
9086 SWIG_exception(SWIG_IndexError, e.what());
9087 }
9088 catch(const std::exception& e)
9089 {
9090 SWIG_exception(SWIG_RuntimeError, e.what());
9091 }
9092 }
9093 _swig_go_result = (intgo)result;
9094 return _swig_go_result;
9095}
9096
9097
9098intgo _wrap_LicenseManager_ActivateTrial_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9099 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9100 oneML::LicenseStatus result;
9101 intgo _swig_go_result;
9102
9103 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9104
9105 {
9106 try
9107 {
9108 result = (oneML::LicenseStatus)(arg1)->activate_trial();
9109 }
9110 catch (const std::invalid_argument& e)
9111 {
9112 SWIG_exception(SWIG_ValueError, e.what());
9113 }
9114 catch (const std::out_of_range& e)
9115 {
9116 SWIG_exception(SWIG_IndexError, e.what());
9117 }
9118 catch(const std::exception& e)
9119 {
9120 SWIG_exception(SWIG_RuntimeError, e.what());
9121 }
9122 }
9123 _swig_go_result = (intgo)result;
9124 return _swig_go_result;
9125}
9126
9127
9128_gostring_ _wrap_LicenseManager_GetMachineCode_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9129 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9130 std::string result;
9131 _gostring_ _swig_go_result;
9132
9133 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9134
9135 {
9136 try
9137 {
9138 result = ((oneML::LicenseManager const *)arg1)->get_machine_code();
9139 }
9140 catch (const std::invalid_argument& e)
9141 {
9142 SWIG_exception(SWIG_ValueError, e.what());
9143 }
9144 catch (const std::out_of_range& e)
9145 {
9146 SWIG_exception(SWIG_IndexError, e.what());
9147 }
9148 catch(const std::exception& e)
9149 {
9150 SWIG_exception(SWIG_RuntimeError, e.what());
9151 }
9152 }
9153 _swig_go_result = Swig_AllocateString((&result)->data(), (&result)->length());
9154 return _swig_go_result;
9155}
9156
9157
9158bool _wrap_LicenseManager_IsTrial_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9159 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9160 bool result;
9161 bool _swig_go_result;
9162
9163 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9164
9165 {
9166 try
9167 {
9168 result = (bool)((oneML::LicenseManager const *)arg1)->is_trial();
9169 }
9170 catch (const std::invalid_argument& e)
9171 {
9172 SWIG_exception(SWIG_ValueError, e.what());
9173 }
9174 catch (const std::out_of_range& e)
9175 {
9176 SWIG_exception(SWIG_IndexError, e.what());
9177 }
9178 catch(const std::exception& e)
9179 {
9180 SWIG_exception(SWIG_RuntimeError, e.what());
9181 }
9182 }
9183 _swig_go_result = result;
9184 return _swig_go_result;
9185}
9186
9187
9188intgo _wrap_LicenseManager_ValidateActivation_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9189 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9190 oneML::LicenseStatus result;
9191 intgo _swig_go_result;
9192
9193 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9194
9195 {
9196 try
9197 {
9198 result = (oneML::LicenseStatus)((oneML::LicenseManager const *)arg1)->validate_activation();
9199 }
9200 catch (const std::invalid_argument& e)
9201 {
9202 SWIG_exception(SWIG_ValueError, e.what());
9203 }
9204 catch (const std::out_of_range& e)
9205 {
9206 SWIG_exception(SWIG_IndexError, e.what());
9207 }
9208 catch(const std::exception& e)
9209 {
9210 SWIG_exception(SWIG_RuntimeError, e.what());
9211 }
9212 }
9213 _swig_go_result = (intgo)result;
9214 return _swig_go_result;
9215}
9216
9217
9218intgo _wrap_LicenseManager_GetActivationType_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9219 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9220 oneML::LicenseActivationType result;
9221 intgo _swig_go_result;
9222
9223 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9224
9225 {
9226 try
9227 {
9228 result = (oneML::LicenseActivationType)((oneML::LicenseManager const *)arg1)->get_activation_type();
9229 }
9230 catch (const std::invalid_argument& e)
9231 {
9232 SWIG_exception(SWIG_ValueError, e.what());
9233 }
9234 catch (const std::out_of_range& e)
9235 {
9236 SWIG_exception(SWIG_IndexError, e.what());
9237 }
9238 catch(const std::exception& e)
9239 {
9240 SWIG_exception(SWIG_RuntimeError, e.what());
9241 }
9242 }
9243 _swig_go_result = (intgo)result;
9244 return _swig_go_result;
9245}
9246
9247
9248long long _wrap_LicenseManager_GetActivationExpiryDate_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9249 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9250 uint64_t result;
9251 long long _swig_go_result;
9252
9253 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9254
9255 {
9256 try
9257 {
9258 result = (uint64_t)((oneML::LicenseManager const *)arg1)->get_activation_expiry_date();
9259 }
9260 catch (const std::invalid_argument& e)
9261 {
9262 SWIG_exception(SWIG_ValueError, e.what());
9263 }
9264 catch (const std::out_of_range& e)
9265 {
9266 SWIG_exception(SWIG_IndexError, e.what());
9267 }
9268 catch(const std::exception& e)
9269 {
9270 SWIG_exception(SWIG_RuntimeError, e.what());
9271 }
9272 }
9273 _swig_go_result = result;
9274 return _swig_go_result;
9275}
9276
9277
9278long long _wrap_LicenseManager_GetActivationSuspendedDate_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9279 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
9280 uint64_t result;
9281 long long _swig_go_result;
9282
9283 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9284
9285 {
9286 try
9287 {
9288 result = (uint64_t)((oneML::LicenseManager const *)arg1)->get_activation_suspended_date();
9289 }
9290 catch (const std::invalid_argument& e)
9291 {
9292 SWIG_exception(SWIG_ValueError, e.what());
9293 }
9294 catch (const std::out_of_range& e)
9295 {
9296 SWIG_exception(SWIG_IndexError, e.what());
9297 }
9298 catch(const std::exception& e)
9299 {
9300 SWIG_exception(SWIG_RuntimeError, e.what());
9301 }
9302 }
9303 _swig_go_result = result;
9304 return _swig_go_result;
9305}
9306
9307
9308void _wrap_EKYCOps_blur_check_set_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0, bool _swig_go_1) {
9309 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9310 bool arg2 ;
9311
9312 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9313 arg2 = (bool)_swig_go_1;
9314
9315 if (arg1) (arg1)->blur_check = arg2;
9316
9317}
9318
9319
9320bool _wrap_EKYCOps_blur_check_get_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0) {
9321 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9322 bool result;
9323 bool _swig_go_result;
9324
9325 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9326
9327 result = (bool) ((arg1)->blur_check);
9328 _swig_go_result = result;
9329 return _swig_go_result;
9330}
9331
9332
9333void _wrap_EKYCOps_face_blur_check_set_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0, bool _swig_go_1) {
9334 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9335 bool arg2 ;
9336
9337 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9338 arg2 = (bool)_swig_go_1;
9339
9340 if (arg1) (arg1)->face_blur_check = arg2;
9341
9342}
9343
9344
9345bool _wrap_EKYCOps_face_blur_check_get_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0) {
9346 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9347 bool result;
9348 bool _swig_go_result;
9349
9350 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9351
9352 result = (bool) ((arg1)->face_blur_check);
9353 _swig_go_result = result;
9354 return _swig_go_result;
9355}
9356
9357
9358void _wrap_EKYCOps_pad_check_set_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0, bool _swig_go_1) {
9359 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9360 bool arg2 ;
9361
9362 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9363 arg2 = (bool)_swig_go_1;
9364
9365 if (arg1) (arg1)->pad_check = arg2;
9366
9367}
9368
9369
9370bool _wrap_EKYCOps_pad_check_get_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0) {
9371 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9372 bool result;
9373 bool _swig_go_result;
9374
9375 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9376
9377 result = (bool) ((arg1)->pad_check);
9378 _swig_go_result = result;
9379 return _swig_go_result;
9380}
9381
9382
9383void _wrap_EKYCOps_pose_check_set_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0, bool _swig_go_1) {
9384 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9385 bool arg2 ;
9386
9387 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9388 arg2 = (bool)_swig_go_1;
9389
9390 if (arg1) (arg1)->pose_check = arg2;
9391
9392}
9393
9394
9395bool _wrap_EKYCOps_pose_check_get_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0) {
9396 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9397 bool result;
9398 bool _swig_go_result;
9399
9400 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9401
9402 result = (bool) ((arg1)->pose_check);
9403 _swig_go_result = result;
9404 return _swig_go_result;
9405}
9406
9407
9408oneML::face::EKYCOps *_wrap_new_EKYCOps__SWIG_0_face_86f062e835b3dd07() {
9409 oneML::face::EKYCOps *result = 0 ;
9410 oneML::face::EKYCOps *_swig_go_result;
9411
9412
9413 {
9414 try
9415 {
9416 result = (oneML::face::EKYCOps *)new oneML::face::EKYCOps();
9417 }
9418 catch (const std::invalid_argument& e)
9419 {
9420 SWIG_exception(SWIG_ValueError, e.what());
9421 }
9422 catch (const std::out_of_range& e)
9423 {
9424 SWIG_exception(SWIG_IndexError, e.what());
9425 }
9426 catch(const std::exception& e)
9427 {
9428 SWIG_exception(SWIG_RuntimeError, e.what());
9429 }
9430 }
9431 *(oneML::face::EKYCOps **)&_swig_go_result = (oneML::face::EKYCOps *)result;
9432 return _swig_go_result;
9433}
9434
9435
9436oneML::face::EKYCOps *_wrap_new_EKYCOps__SWIG_1_face_86f062e835b3dd07(bool _swig_go_0) {
9437 bool arg1 ;
9438 oneML::face::EKYCOps *result = 0 ;
9439 oneML::face::EKYCOps *_swig_go_result;
9440
9441 arg1 = (bool)_swig_go_0;
9442
9443 {
9444 try
9445 {
9446 result = (oneML::face::EKYCOps *)new oneML::face::EKYCOps(arg1);
9447 }
9448 catch (const std::invalid_argument& e)
9449 {
9450 SWIG_exception(SWIG_ValueError, e.what());
9451 }
9452 catch (const std::out_of_range& e)
9453 {
9454 SWIG_exception(SWIG_IndexError, e.what());
9455 }
9456 catch(const std::exception& e)
9457 {
9458 SWIG_exception(SWIG_RuntimeError, e.what());
9459 }
9460 }
9461 *(oneML::face::EKYCOps **)&_swig_go_result = (oneML::face::EKYCOps *)result;
9462 return _swig_go_result;
9463}
9464
9465
9466oneML::face::EKYCOps *_wrap_new_EKYCOps__SWIG_2_face_86f062e835b3dd07(bool _swig_go_0, bool _swig_go_1, bool _swig_go_2, bool _swig_go_3) {
9467 bool arg1 ;
9468 bool arg2 ;
9469 bool arg3 ;
9470 bool arg4 ;
9471 oneML::face::EKYCOps *result = 0 ;
9472 oneML::face::EKYCOps *_swig_go_result;
9473
9474 arg1 = (bool)_swig_go_0;
9475 arg2 = (bool)_swig_go_1;
9476 arg3 = (bool)_swig_go_2;
9477 arg4 = (bool)_swig_go_3;
9478
9479 {
9480 try
9481 {
9482 result = (oneML::face::EKYCOps *)new oneML::face::EKYCOps(arg1,arg2,arg3,arg4);
9483 }
9484 catch (const std::invalid_argument& e)
9485 {
9486 SWIG_exception(SWIG_ValueError, e.what());
9487 }
9488 catch (const std::out_of_range& e)
9489 {
9490 SWIG_exception(SWIG_IndexError, e.what());
9491 }
9492 catch(const std::exception& e)
9493 {
9494 SWIG_exception(SWIG_RuntimeError, e.what());
9495 }
9496 }
9497 *(oneML::face::EKYCOps **)&_swig_go_result = (oneML::face::EKYCOps *)result;
9498 return _swig_go_result;
9499}
9500
9501
9502void _wrap_delete_EKYCOps_face_86f062e835b3dd07(oneML::face::EKYCOps *_swig_go_0) {
9503 oneML::face::EKYCOps *arg1 = (oneML::face::EKYCOps *) 0 ;
9504
9505 arg1 = *(oneML::face::EKYCOps **)&_swig_go_0;
9506
9507 {
9508 try
9509 {
9510 delete arg1;
9511 }
9512 catch (const std::invalid_argument& e)
9513 {
9514 SWIG_exception(SWIG_ValueError, e.what());
9515 }
9516 catch (const std::out_of_range& e)
9517 {
9518 SWIG_exception(SWIG_IndexError, e.what());
9519 }
9520 catch(const std::exception& e)
9521 {
9522 SWIG_exception(SWIG_RuntimeError, e.what());
9523 }
9524 }
9525
9526}
9527
9528
9529oneML::face::EKYCResult *_wrap_new_EKYCResult_face_86f062e835b3dd07() {
9530 oneML::face::EKYCResult *result = 0 ;
9531 oneML::face::EKYCResult *_swig_go_result;
9532
9533
9534 {
9535 try
9536 {
9537 result = (oneML::face::EKYCResult *)new oneML::face::EKYCResult();
9538 }
9539 catch (const std::invalid_argument& e)
9540 {
9541 SWIG_exception(SWIG_ValueError, e.what());
9542 }
9543 catch (const std::out_of_range& e)
9544 {
9545 SWIG_exception(SWIG_IndexError, e.what());
9546 }
9547 catch(const std::exception& e)
9548 {
9549 SWIG_exception(SWIG_RuntimeError, e.what());
9550 }
9551 }
9552 *(oneML::face::EKYCResult **)&_swig_go_result = (oneML::face::EKYCResult *)result;
9553 return _swig_go_result;
9554}
9555
9556
9557float _wrap_EKYCResult_GetDistance_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9558 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9559 float result;
9560 float _swig_go_result;
9561
9562 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9563
9564 {
9565 try
9566 {
9567 result = (float)((oneML::face::EKYCResult const *)arg1)->get_distance();
9568 }
9569 catch (const std::invalid_argument& e)
9570 {
9571 SWIG_exception(SWIG_ValueError, e.what());
9572 }
9573 catch (const std::out_of_range& e)
9574 {
9575 SWIG_exception(SWIG_IndexError, e.what());
9576 }
9577 catch(const std::exception& e)
9578 {
9579 SWIG_exception(SWIG_RuntimeError, e.what());
9580 }
9581 }
9582 _swig_go_result = result;
9583 return _swig_go_result;
9584}
9585
9586
9587bool _wrap_EKYCResult_IsSamePerson_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9588 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9589 bool result;
9590 bool _swig_go_result;
9591
9592 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9593
9594 {
9595 try
9596 {
9597 result = (bool)((oneML::face::EKYCResult const *)arg1)->is_same_person();
9598 }
9599 catch (const std::invalid_argument& e)
9600 {
9601 SWIG_exception(SWIG_ValueError, e.what());
9602 }
9603 catch (const std::out_of_range& e)
9604 {
9605 SWIG_exception(SWIG_IndexError, e.what());
9606 }
9607 catch(const std::exception& e)
9608 {
9609 SWIG_exception(SWIG_RuntimeError, e.what());
9610 }
9611 }
9612 _swig_go_result = result;
9613 return _swig_go_result;
9614}
9615
9616
9617void _wrap_EKYCResult_get_bbox_scores_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0, float *_swig_go_1, float *_swig_go_2) {
9618 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9619 float *arg2 = 0 ;
9620 float *arg3 = 0 ;
9621
9622 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9623 arg2 = *(float **)&_swig_go_1;
9624 arg3 = *(float **)&_swig_go_2;
9625
9626 {
9627 try
9628 {
9629 ((oneML::face::EKYCResult const *)arg1)->get_bbox_scores(*arg2,*arg3);
9630 }
9631 catch (const std::invalid_argument& e)
9632 {
9633 SWIG_exception(SWIG_ValueError, e.what());
9634 }
9635 catch (const std::out_of_range& e)
9636 {
9637 SWIG_exception(SWIG_IndexError, e.what());
9638 }
9639 catch(const std::exception& e)
9640 {
9641 SWIG_exception(SWIG_RuntimeError, e.what());
9642 }
9643 }
9644
9645}
9646
9647
9648std::vector< oneML::BBox > *_wrap_EKYCResult_GetBboxes_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9649 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9650 std::vector< oneML::face::BBox > result;
9651 std::vector< oneML::BBox > *_swig_go_result;
9652
9653 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9654
9655 {
9656 try
9657 {
9658 result = oneML_face_EKYCResult_go_get_bboxes(arg1);
9659 }
9660 catch (const std::invalid_argument& e)
9661 {
9662 SWIG_exception(SWIG_ValueError, e.what());
9663 }
9664 catch (const std::out_of_range& e)
9665 {
9666 SWIG_exception(SWIG_IndexError, e.what());
9667 }
9668 catch(const std::exception& e)
9669 {
9670 SWIG_exception(SWIG_RuntimeError, e.what());
9671 }
9672 }
9673 *(std::vector< oneML::face::BBox > **)&_swig_go_result = new std::vector< oneML::face::BBox >(result);
9674 return _swig_go_result;
9675}
9676
9677
9678std::vector< float > *_wrap_EKYCResult_GetBboxScores_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9679 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9680 std::vector< float > result;
9681 std::vector< float > *_swig_go_result;
9682
9683 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9684
9685 {
9686 try
9687 {
9688 result = oneML_face_EKYCResult_go_get_bbox_scores(arg1);
9689 }
9690 catch (const std::invalid_argument& e)
9691 {
9692 SWIG_exception(SWIG_ValueError, e.what());
9693 }
9694 catch (const std::out_of_range& e)
9695 {
9696 SWIG_exception(SWIG_IndexError, e.what());
9697 }
9698 catch(const std::exception& e)
9699 {
9700 SWIG_exception(SWIG_RuntimeError, e.what());
9701 }
9702 }
9703 *(std::vector< float > **)&_swig_go_result = new std::vector< float >(result);
9704 return _swig_go_result;
9705}
9706
9707
9708std::vector< oneML::face::FaceLandmark< 5 > > *_wrap_EKYCResult_GetLandmarks_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9709 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9710 std::vector< oneML::face::FaceLandmark5 > result;
9711 std::vector< oneML::face::FaceLandmark< 5 > > *_swig_go_result;
9712
9713 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9714
9715 {
9716 try
9717 {
9718 result = oneML_face_EKYCResult_go_get_landmarks(arg1);
9719 }
9720 catch (const std::invalid_argument& e)
9721 {
9722 SWIG_exception(SWIG_ValueError, e.what());
9723 }
9724 catch (const std::out_of_range& e)
9725 {
9726 SWIG_exception(SWIG_IndexError, e.what());
9727 }
9728 catch(const std::exception& e)
9729 {
9730 SWIG_exception(SWIG_RuntimeError, e.what());
9731 }
9732 }
9733 *(std::vector< oneML::face::FaceLandmark5 > **)&_swig_go_result = new std::vector< oneML::face::FaceLandmark5 >(result);
9734 return _swig_go_result;
9735}
9736
9737
9738std::vector< int > *_wrap_EKYCResult_GetFacePoses_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9739 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9740 std::vector< int > result;
9741 std::vector< int > *_swig_go_result;
9742
9743 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9744
9745 {
9746 try
9747 {
9748 result = oneML_face_EKYCResult_go_get_face_poses(arg1);
9749 }
9750 catch (const std::invalid_argument& e)
9751 {
9752 SWIG_exception(SWIG_ValueError, e.what());
9753 }
9754 catch (const std::out_of_range& e)
9755 {
9756 SWIG_exception(SWIG_IndexError, e.what());
9757 }
9758 catch(const std::exception& e)
9759 {
9760 SWIG_exception(SWIG_RuntimeError, e.what());
9761 }
9762 }
9763 *(std::vector< int > **)&_swig_go_result = new std::vector< int >(result);
9764 return _swig_go_result;
9765}
9766
9767
9768intgo _wrap_EKYCResult_GetReturnStatus_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9769 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9770 int result;
9771 intgo _swig_go_result;
9772
9773 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9774
9775 {
9776 try
9777 {
9778 result = (int)oneML_face_EKYCResult_go_get_return_status(arg1);
9779 }
9780 catch (const std::invalid_argument& e)
9781 {
9782 SWIG_exception(SWIG_ValueError, e.what());
9783 }
9784 catch (const std::out_of_range& e)
9785 {
9786 SWIG_exception(SWIG_IndexError, e.what());
9787 }
9788 catch(const std::exception& e)
9789 {
9790 SWIG_exception(SWIG_RuntimeError, e.what());
9791 }
9792 }
9793 _swig_go_result = result;
9794 return _swig_go_result;
9795}
9796
9797
9798void _wrap_delete_EKYCResult_face_86f062e835b3dd07(oneML::face::EKYCResult *_swig_go_0) {
9799 oneML::face::EKYCResult *arg1 = (oneML::face::EKYCResult *) 0 ;
9800
9801 arg1 = *(oneML::face::EKYCResult **)&_swig_go_0;
9802
9803 {
9804 try
9805 {
9806 delete arg1;
9807 }
9808 catch (const std::invalid_argument& e)
9809 {
9810 SWIG_exception(SWIG_ValueError, e.what());
9811 }
9812 catch (const std::out_of_range& e)
9813 {
9814 SWIG_exception(SWIG_IndexError, e.what());
9815 }
9816 catch(const std::exception& e)
9817 {
9818 SWIG_exception(SWIG_RuntimeError, e.what());
9819 }
9820 }
9821
9822}
9823
9824
9825oneML::face::EKYC *_wrap_new_EKYC__SWIG_0_face_86f062e835b3dd07(oneML::LicenseManager *_swig_go_0) {
9826 oneML::LicenseManager *arg1 = 0 ;
9827 oneML::face::EKYC *result = 0 ;
9828 oneML::face::EKYC *_swig_go_result;
9829
9830 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
9831
9832 {
9833 try
9834 {
9835 result = (oneML::face::EKYC *)new oneML::face::EKYC(*arg1);
9836 }
9837 catch (const std::invalid_argument& e)
9838 {
9839 SWIG_exception(SWIG_ValueError, e.what());
9840 }
9841 catch (const std::out_of_range& e)
9842 {
9843 SWIG_exception(SWIG_IndexError, e.what());
9844 }
9845 catch(const std::exception& e)
9846 {
9847 SWIG_exception(SWIG_RuntimeError, e.what());
9848 }
9849 }
9850 *(oneML::face::EKYC **)&_swig_go_result = (oneML::face::EKYC *)result;
9851 return _swig_go_result;
9852}
9853
9854
9855oneML::face::EKYC *_wrap_new_EKYC__SWIG_1_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, oneML::face::FaceEmbedder *_swig_go_1, oneML::LicenseManager *_swig_go_2) {
9856 oneML::face::FaceDetector *arg1 = 0 ;
9857 oneML::face::FaceEmbedder *arg2 = 0 ;
9858 oneML::LicenseManager *arg3 = 0 ;
9859 oneML::face::EKYC *result = 0 ;
9860 oneML::face::EKYC *_swig_go_result;
9861
9862 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
9863 arg2 = *(oneML::face::FaceEmbedder **)&_swig_go_1;
9864 arg3 = *(oneML::LicenseManager **)&_swig_go_2;
9865
9866 {
9867 try
9868 {
9869 result = (oneML::face::EKYC *)new oneML::face::EKYC(*arg1,*arg2,*arg3);
9870 }
9871 catch (const std::invalid_argument& e)
9872 {
9873 SWIG_exception(SWIG_ValueError, e.what());
9874 }
9875 catch (const std::out_of_range& e)
9876 {
9877 SWIG_exception(SWIG_IndexError, e.what());
9878 }
9879 catch(const std::exception& e)
9880 {
9881 SWIG_exception(SWIG_RuntimeError, e.what());
9882 }
9883 }
9884 *(oneML::face::EKYC **)&_swig_go_result = (oneML::face::EKYC *)result;
9885 return _swig_go_result;
9886}
9887
9888
9889oneML::face::EKYC *_wrap_new_EKYC__SWIG_2_face_86f062e835b3dd07(oneML::face::FaceEmbedder *_swig_go_0, oneML::LicenseManager *_swig_go_1) {
9890 oneML::face::FaceEmbedder *arg1 = 0 ;
9891 oneML::LicenseManager *arg2 = 0 ;
9892 oneML::face::EKYC *result = 0 ;
9893 oneML::face::EKYC *_swig_go_result;
9894
9895 arg1 = *(oneML::face::FaceEmbedder **)&_swig_go_0;
9896 arg2 = *(oneML::LicenseManager **)&_swig_go_1;
9897
9898 {
9899 try
9900 {
9901 result = (oneML::face::EKYC *)new oneML::face::EKYC(*arg1,*arg2);
9902 }
9903 catch (const std::invalid_argument& e)
9904 {
9905 SWIG_exception(SWIG_ValueError, e.what());
9906 }
9907 catch (const std::out_of_range& e)
9908 {
9909 SWIG_exception(SWIG_IndexError, e.what());
9910 }
9911 catch(const std::exception& e)
9912 {
9913 SWIG_exception(SWIG_RuntimeError, e.what());
9914 }
9915 }
9916 *(oneML::face::EKYC **)&_swig_go_result = (oneML::face::EKYC *)result;
9917 return _swig_go_result;
9918}
9919
9920
9921oneML::face::EKYC *_wrap_new_EKYC__SWIG_3_face_86f062e835b3dd07(oneML::face::FaceDetector *_swig_go_0, oneML::LicenseManager *_swig_go_1) {
9922 oneML::face::FaceDetector *arg1 = 0 ;
9923 oneML::LicenseManager *arg2 = 0 ;
9924 oneML::face::EKYC *result = 0 ;
9925 oneML::face::EKYC *_swig_go_result;
9926
9927 arg1 = *(oneML::face::FaceDetector **)&_swig_go_0;
9928 arg2 = *(oneML::LicenseManager **)&_swig_go_1;
9929
9930 {
9931 try
9932 {
9933 result = (oneML::face::EKYC *)new oneML::face::EKYC(*arg1,*arg2);
9934 }
9935 catch (const std::invalid_argument& e)
9936 {
9937 SWIG_exception(SWIG_ValueError, e.what());
9938 }
9939 catch (const std::out_of_range& e)
9940 {
9941 SWIG_exception(SWIG_IndexError, e.what());
9942 }
9943 catch(const std::exception& e)
9944 {
9945 SWIG_exception(SWIG_RuntimeError, e.what());
9946 }
9947 }
9948 *(oneML::face::EKYC **)&_swig_go_result = (oneML::face::EKYC *)result;
9949 return _swig_go_result;
9950}
9951
9952
9953oneML::face::EKYCResult *_wrap_EKYC_Run__SWIG_0_face_86f062e835b3dd07(oneML::face::EKYC *_swig_go_0, oneML::Image *_swig_go_1, oneML::Image *_swig_go_2, oneML::face::EKYCOps *_swig_go_3, oneML::face::EKYCOps *_swig_go_4) {
9954 oneML::face::EKYC *arg1 = (oneML::face::EKYC *) 0 ;
9955 oneML::Image *arg2 = 0 ;
9956 oneML::Image *arg3 = 0 ;
9957 oneML::face::EKYCOps *arg4 = 0 ;
9958 oneML::face::EKYCOps *arg5 = 0 ;
9959 oneML::face::EKYCResult result;
9960 oneML::face::EKYCResult *_swig_go_result;
9961
9962 arg1 = *(oneML::face::EKYC **)&_swig_go_0;
9963 arg2 = *(oneML::Image **)&_swig_go_1;
9964 arg3 = *(oneML::Image **)&_swig_go_2;
9965 arg4 = *(oneML::face::EKYCOps **)&_swig_go_3;
9966 arg5 = *(oneML::face::EKYCOps **)&_swig_go_4;
9967
9968 {
9969 try
9970 {
9971 result = oneML_face_EKYC_go_run__SWIG_0(arg1,*arg2,*arg3,(oneML::face::EKYCOps const &)*arg4,(oneML::face::EKYCOps const &)*arg5);
9972 }
9973 catch (const std::invalid_argument& e)
9974 {
9975 SWIG_exception(SWIG_ValueError, e.what());
9976 }
9977 catch (const std::out_of_range& e)
9978 {
9979 SWIG_exception(SWIG_IndexError, e.what());
9980 }
9981 catch(const std::exception& e)
9982 {
9983 SWIG_exception(SWIG_RuntimeError, e.what());
9984 }
9985 }
9986 *(oneML::face::EKYCResult **)&_swig_go_result = new oneML::face::EKYCResult(result);
9987 return _swig_go_result;
9988}
9989
9990
9991oneML::face::EKYCResult *_wrap_EKYC_Run__SWIG_1_face_86f062e835b3dd07(oneML::face::EKYC *_swig_go_0, oneML::Image *_swig_go_1, oneML::Image *_swig_go_2, oneML::face::EKYCOps *_swig_go_3, oneML::face::EKYCOps *_swig_go_4, float _swig_go_5) {
9992 oneML::face::EKYC *arg1 = (oneML::face::EKYC *) 0 ;
9993 oneML::Image *arg2 = 0 ;
9994 oneML::Image *arg3 = 0 ;
9995 oneML::face::EKYCOps *arg4 = 0 ;
9996 oneML::face::EKYCOps *arg5 = 0 ;
9997 float arg6 ;
9998 oneML::face::EKYCResult result;
9999 oneML::face::EKYCResult *_swig_go_result;
10000
10001 arg1 = *(oneML::face::EKYC **)&_swig_go_0;
10002 arg2 = *(oneML::Image **)&_swig_go_1;
10003 arg3 = *(oneML::Image **)&_swig_go_2;
10004 arg4 = *(oneML::face::EKYCOps **)&_swig_go_3;
10005 arg5 = *(oneML::face::EKYCOps **)&_swig_go_4;
10006 arg6 = (float)_swig_go_5;
10007
10008 {
10009 try
10010 {
10011 result = oneML_face_EKYC_go_run__SWIG_1(arg1,*arg2,*arg3,(oneML::face::EKYCOps const &)*arg4,(oneML::face::EKYCOps const &)*arg5,arg6);
10012 }
10013 catch (const std::invalid_argument& e)
10014 {
10015 SWIG_exception(SWIG_ValueError, e.what());
10016 }
10017 catch (const std::out_of_range& e)
10018 {
10019 SWIG_exception(SWIG_IndexError, e.what());
10020 }
10021 catch(const std::exception& e)
10022 {
10023 SWIG_exception(SWIG_RuntimeError, e.what());
10024 }
10025 }
10026 *(oneML::face::EKYCResult **)&_swig_go_result = new oneML::face::EKYCResult(result);
10027 return _swig_go_result;
10028}
10029
10030
10031void _wrap_delete_EKYC_face_86f062e835b3dd07(oneML::face::EKYC *_swig_go_0) {
10032 oneML::face::EKYC *arg1 = (oneML::face::EKYC *) 0 ;
10033
10034 arg1 = *(oneML::face::EKYC **)&_swig_go_0;
10035
10036 {
10037 try
10038 {
10039 delete arg1;
10040 }
10041 catch (const std::invalid_argument& e)
10042 {
10043 SWIG_exception(SWIG_ValueError, e.what());
10044 }
10045 catch (const std::out_of_range& e)
10046 {
10047 SWIG_exception(SWIG_IndexError, e.what());
10048 }
10049 catch(const std::exception& e)
10050 {
10051 SWIG_exception(SWIG_RuntimeError, e.what());
10052 }
10053 }
10054
10055}
10056
10057
10058intgo _wrap_EKYCStatus_Empty_face_86f062e835b3dd07() {
10059 oneML::face::EKYCStatus result;
10060 intgo _swig_go_result;
10061
10062
10063 {
10064 try
10065 {
10066 result = oneML::face::EKYCStatus::Empty;
10067
10068 }
10069 catch (const std::invalid_argument& e)
10070 {
10071 SWIG_exception(SWIG_ValueError, e.what());
10072 }
10073 catch (const std::out_of_range& e)
10074 {
10075 SWIG_exception(SWIG_IndexError, e.what());
10076 }
10077 catch(const std::exception& e)
10078 {
10079 SWIG_exception(SWIG_RuntimeError, e.what());
10080 }
10081 }
10082 _swig_go_result = (intgo)result;
10083 return _swig_go_result;
10084}
10085
10086
10087intgo _wrap_EKYCStatus_Success_face_86f062e835b3dd07() {
10088 oneML::face::EKYCStatus result;
10089 intgo _swig_go_result;
10090
10091
10092 {
10093 try
10094 {
10095 result = oneML::face::EKYCStatus::Success;
10096
10097 }
10098 catch (const std::invalid_argument& e)
10099 {
10100 SWIG_exception(SWIG_ValueError, e.what());
10101 }
10102 catch (const std::out_of_range& e)
10103 {
10104 SWIG_exception(SWIG_IndexError, e.what());
10105 }
10106 catch(const std::exception& e)
10107 {
10108 SWIG_exception(SWIG_RuntimeError, e.what());
10109 }
10110 }
10111 _swig_go_result = (intgo)result;
10112 return _swig_go_result;
10113}
10114
10115
10116intgo _wrap_EKYCStatus_ImageBlurCheckFail_face_86f062e835b3dd07() {
10117 oneML::face::EKYCStatus result;
10118 intgo _swig_go_result;
10119
10120
10121 {
10122 try
10123 {
10124 result = oneML::face::EKYCStatus::ImageBlurCheckFail;
10125
10126 }
10127 catch (const std::invalid_argument& e)
10128 {
10129 SWIG_exception(SWIG_ValueError, e.what());
10130 }
10131 catch (const std::out_of_range& e)
10132 {
10133 SWIG_exception(SWIG_IndexError, e.what());
10134 }
10135 catch(const std::exception& e)
10136 {
10137 SWIG_exception(SWIG_RuntimeError, e.what());
10138 }
10139 }
10140 _swig_go_result = (intgo)result;
10141 return _swig_go_result;
10142}
10143
10144
10145intgo _wrap_EKYCStatus_DigitalPadFail_face_86f062e835b3dd07() {
10146 oneML::face::EKYCStatus result;
10147 intgo _swig_go_result;
10148
10149
10150 {
10151 try
10152 {
10153 result = oneML::face::EKYCStatus::DigitalPadFail;
10154
10155 }
10156 catch (const std::invalid_argument& e)
10157 {
10158 SWIG_exception(SWIG_ValueError, e.what());
10159 }
10160 catch (const std::out_of_range& e)
10161 {
10162 SWIG_exception(SWIG_IndexError, e.what());
10163 }
10164 catch(const std::exception& e)
10165 {
10166 SWIG_exception(SWIG_RuntimeError, e.what());
10167 }
10168 }
10169 _swig_go_result = (intgo)result;
10170 return _swig_go_result;
10171}
10172
10173
10174intgo _wrap_EKYCStatus_PaperPadFail_face_86f062e835b3dd07() {
10175 oneML::face::EKYCStatus result;
10176 intgo _swig_go_result;
10177
10178
10179 {
10180 try
10181 {
10182 result = oneML::face::EKYCStatus::PaperPadFail;
10183
10184 }
10185 catch (const std::invalid_argument& e)
10186 {
10187 SWIG_exception(SWIG_ValueError, e.what());
10188 }
10189 catch (const std::out_of_range& e)
10190 {
10191 SWIG_exception(SWIG_IndexError, e.what());
10192 }
10193 catch(const std::exception& e)
10194 {
10195 SWIG_exception(SWIG_RuntimeError, e.what());
10196 }
10197 }
10198 _swig_go_result = (intgo)result;
10199 return _swig_go_result;
10200}
10201
10202
10203intgo _wrap_EKYCStatus_NoFaceFound_face_86f062e835b3dd07() {
10204 oneML::face::EKYCStatus result;
10205 intgo _swig_go_result;
10206
10207
10208 {
10209 try
10210 {
10211 result = oneML::face::EKYCStatus::NoFaceFound;
10212
10213 }
10214 catch (const std::invalid_argument& e)
10215 {
10216 SWIG_exception(SWIG_ValueError, e.what());
10217 }
10218 catch (const std::out_of_range& e)
10219 {
10220 SWIG_exception(SWIG_IndexError, e.what());
10221 }
10222 catch(const std::exception& e)
10223 {
10224 SWIG_exception(SWIG_RuntimeError, e.what());
10225 }
10226 }
10227 _swig_go_result = (intgo)result;
10228 return _swig_go_result;
10229}
10230
10231
10232intgo _wrap_EKYCStatus_FaceBlurCheckFail_face_86f062e835b3dd07() {
10233 oneML::face::EKYCStatus result;
10234 intgo _swig_go_result;
10235
10236
10237 {
10238 try
10239 {
10240 result = oneML::face::EKYCStatus::FaceBlurCheckFail;
10241
10242 }
10243 catch (const std::invalid_argument& e)
10244 {
10245 SWIG_exception(SWIG_ValueError, e.what());
10246 }
10247 catch (const std::out_of_range& e)
10248 {
10249 SWIG_exception(SWIG_IndexError, e.what());
10250 }
10251 catch(const std::exception& e)
10252 {
10253 SWIG_exception(SWIG_RuntimeError, e.what());
10254 }
10255 }
10256 _swig_go_result = (intgo)result;
10257 return _swig_go_result;
10258}
10259
10260
10261intgo _wrap_EKYCStatus_FaceNotFrontal_face_86f062e835b3dd07() {
10262 oneML::face::EKYCStatus result;
10263 intgo _swig_go_result;
10264
10265
10266 {
10267 try
10268 {
10269 result = oneML::face::EKYCStatus::FaceNotFrontal;
10270
10271 }
10272 catch (const std::invalid_argument& e)
10273 {
10274 SWIG_exception(SWIG_ValueError, e.what());
10275 }
10276 catch (const std::out_of_range& e)
10277 {
10278 SWIG_exception(SWIG_IndexError, e.what());
10279 }
10280 catch(const std::exception& e)
10281 {
10282 SWIG_exception(SWIG_RuntimeError, e.what());
10283 }
10284 }
10285 _swig_go_result = (intgo)result;
10286 return _swig_go_result;
10287}
10288
10289
10290#ifdef __cplusplus
10291}
10292#endif
10293
View as plain text