Enrollment 28.2.0
Loading...
Searching...
No Matches
IrisExecutor.h
Go to the documentation of this file.
1
9
10#pragma once
11
12#include "enrollment/Exception/CallbackError.h"
13#include "enrollment/Export.h"
14#include "enrollment/Logger/Logger.h"
15#include <cstdint>
16#include <memory>
17#include <mutex>
18#include <stddef.h>
19#include <string>
20
21namespace inno
22{
23 // Functions and types suitable for DLL interface
24 extern "C"
25 {
26// See doc/Main.markdown "Header and Binary parts" for reason why we use pragma pack 1
27#pragma pack(push, 1)
28 struct INNO_ENROLLMENT_API inno_IrisCrop_Rectangle
29 {
30 int topLeftX;
31 int topLeftY;
32 int topRightX;
33 int topRightY;
34 int bottomRightX;
35 int bottomRightY;
36 int bottomLeftX;
37 int bottomLeftY;
38 };
39
40 struct INNO_ENROLLMENT_API inno_IrisDetector_result
41 {
42 static const unsigned int MaxIrises = 2;
43 void* irises[MaxIrises];
44 float confidences[MaxIrises];
45 inno_IrisCrop_Rectangle pupilRoundingBoxes[MaxIrises];
46 inno_IrisCrop_Rectangle irisRoundingBoxes[MaxIrises];
47 };
48
49#pragma pack(pop)
50 using IrisDestroyer = void (*)(void*);
51 using IrisAllocator = uint8_t* (*)(void*, size_t);
52 using inno_AddPoint = void(void*, int, int);
53 }
54 class IrisExecutor
55 {
56 public:
57 static constexpr size_t MaxErrorMessage = 200;
58 virtual inno_IrisDetector_result Detect(const std::shared_ptr<Logger>& log,
59 unsigned int height,
60 unsigned int width,
61 unsigned int dpi,
62 const uint8_t* data,
63 float minIrisSize,
64 float maxIrisSize,
65 unsigned int detectorType,
66 ErrorCallbacks errorCallbacks) = 0;
67 virtual void Extract(void* irisItem,
68 IrisAllocator allocator,
69 void* container,
70 unsigned int extractorType,
71 ErrorCallbacks errorCallbacks) = 0;
72 virtual void Match(const uint8_t* probe,
73 size_t probeSize,
74 const uint8_t* gallery,
75 size_t gallerySize,
76 float* score,
77 ErrorCallbacks errorCallbacks) = 0;
78 virtual void IrisQuality(const uint8_t* tmpl,
79 size_t tmplSize,
80 int32_t* quality,
81 ErrorCallbacks errorCallbacks) = 0;
82 virtual void GetTemplateVersion(const uint8_t* tmpl,
83 size_t tmplSize,
84 uint32_t* modelVersion,
85 uint32_t* enrollmentVersion,
86 ErrorCallbacks errorCallbacks) = 0;
87 virtual IrisDestroyer DestroyImpl() = 0;
88
89 virtual void CalculateEyelid(void* irisItem,
90 size_t xCoordinateCount,
91 inno_AddPoint addPoint,
92 void* addContainer,
93 ErrorCallbacks errorCallbacks) = 0;
94
95 IrisExecutor() = default;
96 virtual ~IrisExecutor() = default;
97 IrisExecutor(const IrisExecutor&) = delete;
98 IrisExecutor(IrisExecutor&&) = delete;
99 IrisExecutor& operator=(const IrisExecutor&) = delete;
100 IrisExecutor& operator=(IrisExecutor&&) = delete;
101 };
102
103 extern "C"
104 {
105 INNO_ENROLLMENT_API inno_IrisDetector_result inno_local_IrisDetector_Detect(LoggerCallBacks logCallbacks,
106 unsigned int height,
107 unsigned int width,
108 unsigned int dpi,
109 const uint8_t* data,
110 float minIrisSize,
111 float maxIrisSize,
112 unsigned int detectorType,
113 ErrorCallbacks errorCallbacks);
114 INNO_ENROLLMENT_API void inno_local_Iris_ReleaseItem(void* irisItem);
115
116 INNO_ENROLLMENT_API void inno_local_Iris_TemplateQuality(const uint8_t* tmpl,
117 size_t tmplSize,
118 int32_t* quality,
119 ErrorCallbacks errorCallbacks);
120
121 INNO_ENROLLMENT_API void inno_local_Iris_GetTemplateVersion(const uint8_t* tmpl,
122 size_t tmplSize,
123 uint32_t* modelVersion,
124 uint32_t* enrollmentVersion,
125 ErrorCallbacks errorCallbacks);
126
127 INNO_ENROLLMENT_API void inno_local_Iris_Extract(void* irisItem,
128 IrisAllocator allocator,
129 void* container,
130 unsigned int extractorType,
131 ErrorCallbacks errorCallbacks);
132 INNO_ENROLLMENT_API void inno_local_Iris_Match(const uint8_t* probe,
133 size_t probeSize,
134 const uint8_t* gallery,
135 size_t gallerySize,
136 float* score,
137 ErrorCallbacks errorCallbacks);
138 INNO_ENROLLMENT_API int inno_local_Iris_TemplateInfo(const uint8_t* tmpl,
139 size_t tmplSize,
140 int32_t* quality,
141 uint32_t* modelVersion,
142 ErrorCallbacks errorCallbacks);
143
144 INNO_ENROLLMENT_API void inno_local_Iris_CalculateEyelid(void* irisItem,
145 size_t xCoordinateCount,
146 inno_AddPoint addPoint,
147 void* addContainer,
148 ErrorCallbacks errorCallbacks);
149 }
150
151 class LocalIrisExecutor : public IrisExecutor
152 {
153 public:
154 inno_IrisDetector_result Detect(const std::shared_ptr<Logger>& log,
155 unsigned int height,
156 unsigned int width,
157 unsigned int dpi,
158 const uint8_t* data,
159 float minIrisSize,
160 float maxIrisSize,
161 unsigned int detectorType,
162 ErrorCallbacks errorCallbacks) final
163 {
164 const CallbackLogger slog(log);
165 return inno_local_IrisDetector_Detect(
166 slog.GetCallbacks(), height, width, dpi, data, minIrisSize, maxIrisSize, detectorType, errorCallbacks);
167 }
168 void Extract(void* irisItem,
169 IrisAllocator allocator,
170 void* container,
171 unsigned int extractorType,
172 ErrorCallbacks errorCallbacks) final
173 {
174 inno_local_Iris_Extract(irisItem, allocator, container, extractorType, errorCallbacks);
175 }
176 void Match(const uint8_t* probe,
177 size_t probeSize,
178 const uint8_t* gallery,
179 size_t gallerySize,
180 float* score,
181 ErrorCallbacks errorCallbacks) final
182 {
183 inno_local_Iris_Match(probe, probeSize, gallery, gallerySize, score, errorCallbacks);
184 }
185 IrisDestroyer DestroyImpl() final
186 {
187 return inno_local_Iris_ReleaseItem;
188 }
189
190 void IrisQuality(const uint8_t* tmpl, size_t tmplSize, int32_t* quality, ErrorCallbacks errorCallbacks) final
191 {
192 inno_local_Iris_TemplateQuality(tmpl, tmplSize, quality, errorCallbacks);
193 }
194
195 void GetTemplateVersion(const uint8_t* tmpl,
196 size_t tmplSize,
197 uint32_t* modelVersion,
198 uint32_t* enrollmentVersion,
199 ErrorCallbacks errorCallbacks) final
200 {
201 inno_local_Iris_GetTemplateVersion(tmpl, tmplSize, modelVersion, enrollmentVersion, errorCallbacks);
202 }
203
204 void CalculateEyelid(void* irisItem,
205 size_t xCoordinateCount,
206 inno_AddPoint addPoint,
207 void* addContainer,
208 ErrorCallbacks errorCallbacks) final
209 {
210 inno_local_Iris_CalculateEyelid(irisItem, xCoordinateCount, addPoint, addContainer, errorCallbacks);
211 }
212
213 LocalIrisExecutor() = default;
214 virtual ~LocalIrisExecutor() = default;
215 LocalIrisExecutor(const LocalIrisExecutor&) = delete;
216 LocalIrisExecutor(LocalIrisExecutor&&) = delete;
217 LocalIrisExecutor& operator=(const LocalIrisExecutor&) = delete;
218 LocalIrisExecutor& operator=(LocalIrisExecutor&&) = delete;
219 };
220
221 extern "C"
222 {
223 struct inno_grcp_IrisChannel;
224 INNO_ENROLLMENT_API inno_grcp_IrisChannel* inno_grpc_Iris_Channel_Create(const char* endpoint);
225 INNO_ENROLLMENT_API void inno_grpc_Iris_Channel_Destroy(inno_grcp_IrisChannel* channel);
226
227 INNO_ENROLLMENT_API inno_IrisDetector_result inno_grpc_IrisDetector_Detect(inno_grcp_IrisChannel* channel,
228 LoggerCallBacks logCallbacks,
229 unsigned int height,
230 unsigned int width,
231 unsigned int dpi,
232 const uint8_t* data,
233 float minIrisSize,
234 float maxIrisSize,
235 unsigned int detectorType,
236 ErrorCallbacks errorCallbacks);
237 INNO_ENROLLMENT_API void inno_grpc_Iris_ReleaseItem(void* irisItem);
238
239 INNO_ENROLLMENT_API void inno_grpc_Iris_TemplateQuality(void* irisItem,
240 const uint8_t* tmpl,
241 size_t tmplSize,
242 int32_t* quality,
243 ErrorCallbacks errorCallbacks);
244
245 INNO_ENROLLMENT_API void inno_grpc_Iris_GetTemplateVersion(void* irisItem,
246 const uint8_t* tmpl,
247 size_t tmplSize,
248 uint32_t* modelVersion,
249 uint32_t* enrollmentVersion,
250 ErrorCallbacks errorCallbacks);
251
252 INNO_ENROLLMENT_API void inno_grpc_Iris_Extract(void* irisItem,
253 IrisAllocator allocator,
254 void* container,
255 unsigned int extractorType,
256 ErrorCallbacks errorCallbacks);
257 INNO_ENROLLMENT_API void inno_grpc_Iris_Match(void* irisItem,
258 const uint8_t* probe,
259 size_t probeSize,
260 const uint8_t* gallery,
261 size_t gallerySize,
262 float* score,
263 ErrorCallbacks errorCallbacks);
264 INNO_ENROLLMENT_API void inno_grpc_Iris_CalculateEyelid(void* irisItem,
265 size_t xCoordinateCount,
266 inno_AddPoint addPoint,
267 void* addContainer,
268 ErrorCallbacks errorCallbacks);
269 }
270
271 class GrpcIrisExecutor : public IrisExecutor
272 {
273 public:
274 inno_IrisDetector_result Detect(const std::shared_ptr<Logger>& log,
275 unsigned int height,
276 unsigned int width,
277 unsigned int dpi,
278 const uint8_t* data,
279 float minIrisSize,
280 float maxIrisSize,
281 unsigned int detectorType,
282 ErrorCallbacks errorCallbacks) final
283 {
284 const CallbackLogger slog(log);
285 return inno_grpc_IrisDetector_Detect(channel.get(),
286 slog.GetCallbacks(),
287 height,
288 width,
289 dpi,
290 data,
291 minIrisSize,
292 maxIrisSize,
293 detectorType,
294 errorCallbacks);
295 }
296 void Extract(void* irisItem,
297 IrisAllocator allocator,
298 void* container,
299 unsigned int extractorType,
300 ErrorCallbacks errorCallbacks) final
301 {
302 inno_grpc_Iris_Extract(irisItem, allocator, container, extractorType, errorCallbacks);
303 }
304 void Match(const uint8_t* probe,
305 size_t probeSize,
306 const uint8_t* gallery,
307 size_t gallerySize,
308 float* score,
309 ErrorCallbacks errorCallbacks) final
310 {
311 inno_grpc_Iris_Match(channel.get(), probe, probeSize, gallery, gallerySize, score, errorCallbacks);
312 }
313 IrisDestroyer DestroyImpl() final
314 {
315 return inno_grpc_Iris_ReleaseItem;
316 }
317
318 void IrisQuality(const uint8_t* tmpl, size_t tmplSize, int32_t* quality, ErrorCallbacks errorCallbacks) final
319 {
320 inno_grpc_Iris_TemplateQuality(channel.get(), tmpl, tmplSize, quality, errorCallbacks);
321 }
322
323 void GetTemplateVersion(const uint8_t* tmpl,
324 size_t tmplSize,
325 uint32_t* modelVersion,
326 uint32_t* enrollmentVersion,
327 ErrorCallbacks errorCallbacks) final
328 {
329 inno_grpc_Iris_GetTemplateVersion(
330 channel.get(), tmpl, tmplSize, modelVersion, enrollmentVersion, errorCallbacks);
331 }
332
333 void CalculateEyelid(void* irisItem,
334 size_t xCoordinateCount,
335 inno_AddPoint addPoint,
336 void* addContainer,
337 ErrorCallbacks errorCallbacks) final
338 {
339 inno_grpc_Iris_CalculateEyelid(irisItem, xCoordinateCount, addPoint, addContainer, errorCallbacks);
340 }
341
347 explicit GrpcIrisExecutor(const std::string& endPoint)
348 : channel(inno_grpc_Iris_Channel_Create(endPoint.c_str()), inno_grpc_Iris_Channel_Destroy)
349 {
350 }
351
352 GrpcIrisExecutor() = delete;
353 virtual ~GrpcIrisExecutor() = default;
354 GrpcIrisExecutor(const GrpcIrisExecutor&) = delete;
355 GrpcIrisExecutor(GrpcIrisExecutor&&) = delete;
356 GrpcIrisExecutor& operator=(const GrpcIrisExecutor&) = delete;
357 GrpcIrisExecutor& operator=(GrpcIrisExecutor&&) = delete;
358
359 private:
360 std::unique_ptr<inno_grcp_IrisChannel, void (*)(inno_grcp_IrisChannel*)> channel;
361 };
362
368 */
369 class GlobalIrisExecutor
370 {
371 public:
375 */
376 static std::shared_ptr<IrisExecutor> Get()
377 {
378 return GlobalIrisExecutor::Instance().GetInternal();
379 }
380
385 */
386 static void Set(std::shared_ptr<IrisExecutor> executor)
387 {
388 if (executor == nullptr)
389 {
390 throw NullArgumentException("executor can not be null");
391 }
392
393 GlobalIrisExecutor::Instance().SetInternal(std::move(executor));
394 }
395
396 GlobalIrisExecutor() = delete;
397 virtual ~GlobalIrisExecutor() = default;
398 GlobalIrisExecutor(const GlobalIrisExecutor&) = delete;
399 GlobalIrisExecutor(GlobalIrisExecutor&&) = delete;
400 GlobalIrisExecutor& operator=(const GlobalIrisExecutor&) = delete;
401 GlobalIrisExecutor& operator=(GlobalIrisExecutor&&) = delete;
402
403 private:
404 std::shared_ptr<IrisExecutor> pe;
405 std::mutex peMux;
406
407 static GlobalIrisExecutor& Instance()
408 {
409 static GlobalIrisExecutor e(std::make_shared<LocalIrisExecutor>());
410 return e;
411 }
412
413 std::shared_ptr<IrisExecutor> GetInternal()
414 {
415 const std::scoped_lock lock(peMux);
416 return pe;
417 }
418
419 void SetInternal(std::shared_ptr<IrisExecutor> executor)
420 {
421 const std::scoped_lock lock(peMux);
422 pe = std::move(executor);
423 }
424
425 explicit GlobalIrisExecutor(std::shared_ptr<IrisExecutor> e)
426 : pe(std::move(e))
427 {
428 }
429 };
430} // namespace inno
GlobalIrisExecutor
Holds instance of IrisExecutor.
Definition IrisExecutor.h:369
GlobalIrisExecutor::Set
static void Set(std::shared_ptr< IrisExecutor > executor)
Sets new global executor.
Definition IrisExecutor.h:385
GlobalIrisExecutor::Get
static std::shared_ptr< IrisExecutor > Get()
Provides current executor.
Definition IrisExecutor.h:375
NullArgumentException
Null argument is not allowed.
Definition EnrollmentException.h:156
LoggerCallBacks
LoggerCallBacks contains logger handle and function pointers as callbacks.
Definition Logger.h:137