roc-embedded.h

// Copyright © 2015-2022 Rank One Computing Corporation. All rights reserved.

#ifndef ROC_EMBEDDED_H
#define ROC_EMBEDDED_H

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#if defined ROC_LIBRARY || defined BR_LIBRARY
#  if defined _WIN32 || defined __CYGWIN__
#    define ROC_EXPORT __declspec(dllexport)
#  else
#    define ROC_EXPORT __attribute__((visibility("default")))
#  endif
#else
#  if defined _WIN32 || defined __CYGWIN__
#    define ROC_EXPORT __declspec(dllimport)
#  else
#    define ROC_EXPORT
#  endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

#ifndef SWIG_ROC_VIDEO

#ifdef SWIG_ROC_EMBEDDED
%module roc_embedded
%begin %{
#define SWIG_PYTHON_STRICT_BYTE_CHAR
%}
%include cpointer.i
%include carrays.i
#if defined(SWIGPYTHON) || defined(SWIGJAVA)
%include cdata.i
#endif // SWIGPYTHON || SWIGJAVA
%include stdint.i
%{
#include "roc.h"
%}
#ifdef SWIGJAVA
SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
SWIG_JAVABODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
%include enumtypeunsafe.swg
%native (roc_preinitialize_android) roc_string roc_preinitialize_android(jobject);
%{
JNIEXPORT jstring JNICALL
Java_io_rankone_rocsdk_embedded_rocJNI_roc_1preinitialize_1android(JNIEnv *,
                                                                   jclass,
                                                                   jobject);
%}

// https://stackoverflow.com/a/33543680
%typemap(jni) uint8_t *UBYTE "jbyteArray"
%typemap(jtype) uint8_t *UBYTE "byte[]"
%typemap(jstype) uint8_t *UBYTE "byte[]"
%typemap(in) uint8_t *UBYTE {
  $1 = (uint8_t *) JCALL2(GetByteArrayElements, jenv, $input, 0);
}
%typemap(argout) uint8_t *UBYTE {
  JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0);
}
%typemap(javain) uint8_t *UBYTE "$javainput"
%typemap(freearg) uint8_t *UBYTE ""
%apply uint8_t *UBYTE { uint8_t *input_byte_array };
%apply uint8_t *UBYTE { uint8_t *output_byte_array };
%apply uint8_t *UBYTE { uint8_t *y_in };
%apply uint8_t *UBYTE { uint8_t *u_in };
%apply uint8_t *UBYTE { uint8_t *v_in };
#endif // SWIGJAVA
#ifdef SWIGCSHARP
%apply void *VOID_INT_PTR { void * }
%include "arrays_csharp.i"
%apply uint8_t INPUT[]  { uint8_t *input_byte_array }
%apply uint8_t OUTPUT[] { uint8_t *output_byte_array }
%apply uint8_t INPUT[]  { uint8_t *y_in }
%apply uint8_t INPUT[]  { uint8_t *u_in }
%apply uint8_t INPUT[]  { uint8_t *v_in }
%typemap(csbase) roc_algorithm_options "long"
#endif // SWIGSCHARP
%pointer_functions(int, int)
%pointer_functions(float, float)
%pointer_functions(size_t, size_t)
%pointer_functions(roc_similarity, roc_similarity)
%pointer_functions(roc_string, roc_string)
%pointer_functions(roc_buffer, roc_buffer)
%pointer_functions(roc_time, roc_time)
%pointer_functions(roc_algorithm_options, roc_algorithm_options)
%array_functions(uint8_t, uint8_t_array)
%array_functions(float, float_array)
%array_functions(roc_template, roc_template_array)
%array_functions(roc_similarity, roc_similarity_array)
%array_functions(roc_person_id, roc_person_id_array)
%array_functions(roc_detection, roc_detection_array)
%array_functions(roc_landmark, roc_landmark_array)
%array_functions(roc_roi, roc_roi_array)
#endif // SWIG_ROC_EMBEDDED

#define ROC_VERSION_MAJOR 2

#define ROC_VERSION_MINOR 4

#define ROC_VERSION_PATCH 0

#define ROC_VERSION_STRING "2.4.0"

ROC_EXPORT int roc_version_major();

ROC_EXPORT int roc_version_minor();

ROC_EXPORT int roc_version_patch();

ROC_EXPORT const char *roc_version_string();

#define ROC_COPYRIGHT "Copyright © 2015-2022 Rank One Computing Corporation. All rights reserved."

ROC_EXPORT const char *roc_copyright();
 // end of versioning

#endif // !SWIG_ROC_VIDEO

typedef const char *roc_error;

#ifndef SWIG_ROC_VIDEO

#define ROC_ATTEMPT(EXPRESSION)           \
{                                         \
    const roc_error error = (EXPRESSION); \
    if (error)                            \
        return error;                     \
}

ROC_EXPORT void roc_ensure(roc_error error);

typedef void (*roc_log_callback)(const char*);

ROC_EXPORT roc_error roc_set_logging(bool stdout_,
                                     const char *filename,
                                     roc_log_callback callback);

ROC_EXPORT bool roc_log(const char *message);

ROC_EXPORT bool roc_log_no_callback(const char *message);
 // end of error_handling

typedef struct roc_uuid
{
    uint8_t data[16];

#if defined(__cplusplus) && !defined(SWIG)

    inline bool operator==(const roc_uuid &other) const
    {
        bool roc_uuid_is_equal(roc_uuid, roc_uuid);
        return roc_uuid_is_equal(*this, other);
    }

    inline bool operator!=(const roc_uuid &other) const
    {
        bool roc_uuid_is_equal(roc_uuid, roc_uuid);
        return !roc_uuid_is_equal(*this, other);
    }

    inline bool operator<(const roc_uuid &other) const
    {
        bool roc_uuid_is_less_than(roc_uuid, roc_uuid);
        return roc_uuid_is_less_than(*this, other);
    }

    inline operator bool() const
    {
        bool roc_uuid_is_null(roc_uuid);
        return !roc_uuid_is_null(*this);
    }
#endif // __cplusplus && !SWIG
} roc_uuid;

#ifdef __cplusplus

inline unsigned int qHash(const roc_uuid &a)
{
    unsigned int result;
    memcpy(&result, &a.data[0], sizeof(unsigned int));
    return result;
}
#endif // __cplusplus

ROC_EXPORT roc_uuid roc_uuid_from_bytes(const uint8_t *input_byte_array,
                                        size_t length);

ROC_EXPORT roc_uuid roc_uuid_from_int(uint64_t val);

ROC_EXPORT uint64_t roc_uuid_to_int(roc_uuid uuid);

ROC_EXPORT roc_uuid roc_uuid_get_null();

ROC_EXPORT bool roc_uuid_is_null(roc_uuid uuid);

ROC_EXPORT bool roc_uuid_is_equal(roc_uuid a,
                                  roc_uuid b);

ROC_EXPORT bool roc_uuid_is_less_than(roc_uuid a,
                                      roc_uuid b);

typedef roc_uuid roc_template_id;

typedef roc_uuid roc_person_id;

typedef roc_uuid roc_group_id;

typedef roc_uuid roc_camera_id;

typedef roc_uuid *roc_uuid_array;

typedef roc_uuid_array roc_person_id_array;

ROC_EXPORT void roc_free_uuid_array(roc_uuid_array *uuid_array);

typedef struct roc_hash
{
    uint8_t data[20];

#if defined(__cplusplus) && !defined(SWIG)

    inline bool operator==(const roc_hash &other) const
    {
        bool roc_hash_is_equal(roc_hash, roc_hash);
        return roc_hash_is_equal(*this, other);
    }

    inline bool operator!=(const roc_hash &other) const
    {
        bool roc_hash_is_equal(roc_hash, roc_hash);
        return !roc_hash_is_equal(*this, other);
    }

    inline bool operator<(const roc_hash &other) const
    {
        bool roc_hash_is_less_than(roc_hash, roc_hash);
        return roc_hash_is_less_than(*this, other);
    }

    inline operator bool() const
    {
        bool roc_hash_is_null(roc_hash);
        return !roc_hash_is_null(*this);
    }
#endif // __cplusplus && !SWIG
} roc_hash;

ROC_EXPORT roc_hash roc_hash_from_bytes(const uint8_t *input_byte_array,
                                        size_t length);

ROC_EXPORT roc_hash roc_hash_get_null();

ROC_EXPORT bool roc_hash_is_null(roc_hash hash);

ROC_EXPORT bool roc_hash_is_equal(roc_hash a,
                                  roc_hash b);

ROC_EXPORT bool roc_hash_is_less_than(roc_hash a,
                                      roc_hash b);

ROC_EXPORT roc_hash roc_hash_from_uuid(roc_uuid uuid);

ROC_EXPORT roc_uuid roc_hash_to_uuid(roc_hash hash);

typedef roc_hash roc_media_id;

typedef roc_hash roc_archive_id;

typedef uint64_t roc_time;

#ifndef SWIG

#define ROC_NO_TIMESTAMP 0xFFFFFFFFFFFFFFFF
#else // SWIG
%constant uint64_t ROC_NO_TIMESTAMP = 0xFFFFFFFFFFFFFFFF;
#endif // !SWIG
 // end of identifiers_and_hashses

#endif // !SWIG_ROC_VIDEO

typedef enum roc_color_space
{
    ROC_GRAY8,

    ROC_BGR24
} roc_color_space;

typedef struct roc_image
{
    uint8_t *data; 
    size_t width;  
    size_t height; 
    size_t step;   
    roc_color_space color_space; 
    roc_media_id media_id; 
    roc_camera_id camera_id; 
    roc_time timestamp; 
} roc_image;

#ifndef SWIG_ROC_VIDEO

typedef struct roc_roi
{
    float x; 
    float y; 
    float width; 
    float height; 
} roc_roi;

ROC_EXPORT roc_roi roc_roi_get(float x,
                               float y,
                               float width,
                               float height);

ROC_EXPORT bool roc_roi_is_null(roc_roi roi);

ROC_EXPORT bool roc_roi_is_fractional(roc_roi roi);

ROC_EXPORT bool roc_roi_within(roc_roi test,
                               roc_roi reference,
                               size_t image_width,
                               size_t image_height,
                               float min_overlap);

ROC_EXPORT bool roc_roi_within_set(roc_roi test,
                                   const roc_roi *include,
                                   size_t num_include,
                                   const roc_roi *exclude,
                                   size_t num_exclude,
                                   size_t image_width,
                                   size_t image_height,
                                   float min_overlap);

ROC_EXPORT roc_error roc_new_image(size_t width,
                                   size_t height,
                                   size_t step,
                                   roc_color_space color_space,
                                   roc_media_id media_id,
                                   roc_camera_id camera_id,
                                   roc_time timestamp,
                                   const uint8_t *input_byte_array,
                                   roc_image *image);

ROC_EXPORT roc_error roc_copy_image(roc_image src, roc_image *dst);

ROC_EXPORT roc_error roc_rotate(roc_image *image, int degrees);

ROC_EXPORT roc_error roc_swap_channels(roc_image image);

ROC_EXPORT roc_error roc_bgr2gray(roc_image src, roc_image *dst);

ROC_EXPORT roc_error roc_gray2bgr(roc_image src, roc_image *dst);

ROC_EXPORT roc_error roc_to_rgba(roc_image src,
                                 uint8_t *output_byte_array);

ROC_EXPORT roc_error roc_from_rgba(const uint8_t *input_byte_array,
                                   size_t width,
                                   size_t height,
                                   size_t step,
                                   roc_image *image);

ROC_EXPORT roc_error roc_from_bgra(const uint8_t *input_byte_array,
                                   size_t width,
                                   size_t height,
                                   size_t step,
                                   roc_image *image);

ROC_EXPORT roc_error roc_from_yuv(const uint8_t *y_in,
                                  const uint8_t *u_in,
                                  const uint8_t *v_in,
                                  size_t y_row_stride,
                                  size_t uv_row_stride,
                                  size_t uv_pixel_stride,
                                  size_t width,
                                  size_t height,
                                  roc_image *image);

ROC_EXPORT roc_error roc_enhance_contrast(const roc_image src,
                                          float clip_limit,
                                          int num_tiles,
                                          roc_image *dst);

ROC_EXPORT roc_error roc_read_ppm(const char *file_name, roc_image *image);

ROC_EXPORT roc_error roc_write_ppm(const char *file_name, roc_image image);

ROC_EXPORT roc_error roc_free_image(roc_image image);

typedef const char *roc_string;

ROC_EXPORT roc_error roc_set_string(const char *src, roc_string *dst);

ROC_EXPORT roc_error roc_free_string(roc_string *str);

typedef const uint8_t *roc_buffer;

ROC_EXPORT roc_error roc_free_buffer(roc_buffer *buffer);
 // end of image_format

typedef enum roc_pose_options
{
    ROC_POSE_FRONTAL = 0,

    ROC_POSE_LEFT_PROFILE = 1,

    ROC_POSE_RIGHT_PROFILE = 2,

    ROC_POSE_NUM_POSES = 3,
} roc_pose_options;

typedef uint32_t roc_pose;

ROC_EXPORT const char *roc_pose_to_string(roc_pose pose);

typedef struct roc_landmark
{
    float x; 
    float y; 
} roc_landmark;

ROC_EXPORT bool roc_landmark_is_visible(roc_landmark l);

typedef struct roc_detection
{
    float x; 
    float y; 
    float width;  
    float height; 
    float rotation;   
    float confidence; 
    roc_pose pose;    
    roc_landmark right_eye; 
    roc_landmark left_eye; 
    roc_landmark nose; 
    roc_landmark right_mouth_corner; 
    roc_landmark left_mouth_corner; 
    roc_landmark chin; 
    int32_t image_width; 
    int32_t image_height; 
} roc_detection;

#ifndef SWIG

#define ROC_SUGGESTED_RELATIVE_MIN_SIZE 0.04f
#else // SWIG
%constant float ROC_SUGGESTED_RELATIVE_MIN_SIZE = 0.04f;
#endif // !SWIG

#ifndef SWIG

#define ROC_SUGGESTED_ABSOLUTE_MIN_SIZE 20
#else // SWIG
%constant unsigned ROC_SUGGESTED_ABSOLUTE_MIN_SIZE = 20;
#endif // !SWIG

#ifndef SWIG

#define ROC_SUGGESTED_FALSE_DETECTION_RATE 0.02f
#else // SWIG
%constant float ROC_SUGGESTED_FALSE_DETECTION_RATE = 0.02f;
#endif // !SWIG

#ifndef SWIG

#define ROC_OBJECT_SUGGESTED_FALSE_DETECTION_RATE 0.005f
#else // SWIG
%constant float ROC_OBJECT_SUGGESTED_FALSE_DETECTION_RATE = 0.005f;
#endif // !SWIG

#ifndef SWIG

#define ROC_GUN_SUGGESTED_FALSE_DETECTION_RATE 0.1f
#else // SWIG
%constant float ROC_GUN_SUGGESTED_FALSE_DETECTION_RATE = 0.1f;
#endif // !SWIG

#ifndef SWIG

#define ROC_TEXT_SUGGESTED_FALSE_DETECTION_RATE 0.02f
#else // SWIG
%constant float ROC_TEXT_SUGGESTED_FALSE_DETECTION_RATE = 0.02f;
#endif // !SWIG

#ifndef SWIG

#define ROC_FINGERPRINT_SUGGESTED_FALSE_DETECTION_RATE 0.5f
#else // SWIG
%constant float ROC_FINGERPRINT_SUGGESTED_FALSE_DETECTION_RATE = 0.5f;
#endif // !SWIG

#ifndef SWIG

  #define ROC_NO_MIN_QUALITY -FLT_MAX
  #else // SWIG
  %constant float ROC_NO_MIN_QUALITY = -FLT_MAX;
  #endif // !SWIG

  #ifndef SWIG

   #define ROC_TEXT_SUGGESTED_MIN_QUALITY 0.8f
   #else // SWIG
   %constant float ROC_TEXT_SUGGESTED_MIN_QUALITY = 0.8f;
   #endif // !SWIG

   #ifndef SWIG

   #define ROC_TATTOO_SUGGESTED_MIN_QUALITY 0.0f
   #else // SWIG
   %constant float ROC_TATTOO_SUGGESTED_MIN_QUALITY = 0.0f;
   #endif // !SWIG

   #ifndef SWIG

   #define ROC_FINGERPRINT_SUGGESTED_MIN_QUALITY -3.0f
   #else // SWIG
   %constant float ROC_FINGERPRINT_SUGGESTED_MIN_QUALITY = -3.0f;
   #endif // !SWIG

   #ifndef SWIG

   #define ROC_DEEP_SUGGESTED_MIN_QUALITY -0.2f
   #else // SWIG
   %constant float ROC_DEEP_SUGGESTED_MIN_QUALITY = -0.2f;
   #endif // !SWIG

   #ifndef SWIG

   #define ROC_FAST_SUGGESTED_MIN_QUALITY -FLT_MAX
   #else // SWIG
   %constant float ROC_FAST_SUGGESTED_MIN_QUALITY = -FLT_MAX;
   #endif // !SWIG

   #ifndef SWIG

   #define ROC_STANDARD_SUGGESTED_MIN_QUALITY -FLT_MAX
   #else // SWIG
   %constant float ROC_STANDARD_SUGGESTED_MIN_QUALITY = -FLT_MAX;
   #endif // !SWIG

ROC_EXPORT roc_error roc_adaptive_minimum_size(size_t image_width,
                                               size_t image_height,
                                               float relative_min_size,
                                               size_t absolute_min_size,
                                               size_t *adaptive_min_size);

typedef int64_t roc_algorithm_id;

#ifdef  __cplusplus
enum roc_algorithm_options : roc_algorithm_id
#else // !__cplusplus
typedef enum roc_algorithm_options
#endif //  __cplusplus
{
    ROC_NO_ALGORITHM_OPTIONS = 0x0,

    ROC_STANDARD_REPRESENTATION = 0x1,

    ROC_FAST_REPRESENTATION = 0x2,

    ROC_OBJECT_REPRESENTATION = 0x4,

    ROC_DEEP_REPRESENTATION = 0x8,

    ROC_TATTOO_REPRESENTATION = 0x10,

    ROC_COLOR_REPRESENTATION = 0x20,

    ROC_TEXT_REPRESENTATION = 0x40,

    ROC_FINGERPRINT_REPRESENTATION = 0x80,

    ROC_STANDARD_DETECTION = 0x100,

    ROC_FRONTAL_DETECTION = 0x200,

    ROC_TATTOO_DETECTION = 0x400,

    ROC_TEXT_DETECTION = 0x800,

    ROC_MANUAL_DETECTION = 0x1000,

    ROC_ENHANCE_CONTRAST = 0x2000,

    ROC_IGNORE_PARTIAL = 0x4000,

    ROC_ANALYTICS = 0x10000,

    ROC_IGNORE_ARTWORK = 0x20000,

    ROC_LANDMARKS = 0x40000,

    ROC_PITCHYAW = 0x80000,

    ROC_ICAO_METRICS = 0x100000,

    ROC_ICAO_BACKGROUND = 0x400000,

    ROC_SPOOF = 0x200000,

    ROC_THUMBNAIL = 0x1000000,

    ROC_SERIAL = 0x2000000,

    ROC_FILTER_TEXT = 0x4000000,

    // NOTE: Start first object detector at 32-bit boundary
    ROC_AIRPLANE_DETECTION = 0x100000000,

    ROC_BICYCLE_DETECTION = 0x200000000,

    ROC_BOAT_DETECTION = 0x400000000,

    ROC_BUS_DETECTION = 0x800000000,

    ROC_CAR_DETECTION = 0x1000000000,

    ROC_GUN_DETECTION = 0x2000000000,

    ROC_LICENSE_PLATE_DETECTION = 0x4000000000,

    ROC_MILITARY_VEHICLE_DETECTION = 0x8000000000,

    ROC_MOTORCYCLE_DETECTION = 0x10000000000,

    ROC_PERSON_DETECTION = 0x20000000000,

    ROC_TRUCK_DETECTION = 0x40000000000,

    ROC_ALL_OBJECT_DETECTION = ( ROC_AIRPLANE_DETECTION
                               | ROC_BICYCLE_DETECTION
                               | ROC_BOAT_DETECTION
                               | ROC_BUS_DETECTION
                               | ROC_CAR_DETECTION
                               | ROC_GUN_DETECTION
                               | ROC_MILITARY_VEHICLE_DETECTION
                               | ROC_MOTORCYCLE_DETECTION
                               | ROC_PERSON_DETECTION
                               | ROC_TRUCK_DETECTION ),

    ROC_FINGERPRINT_DETECTION = 0x80000000000

}
#ifdef  __cplusplus
;
#else // !__cplusplus
roc_algorithm_options;
#endif //  __cplusplus

typedef enum roc_color_options
{
    ROC_COLOR_NONE = 0x0,

    ROC_COLOR_WHITE = 0x1,

    ROC_COLOR_GREY = 0x2,

    ROC_COLOR_BLACK = 0x4,

    ROC_COLOR_RED = 0x8,

    ROC_COLOR_ORANGE = 0x10,

    ROC_COLOR_YELLOW = 0x20,

    ROC_COLOR_GREEN = 0x40,

    ROC_COLOR_BLUE = 0x80,

    ROC_COLOR_VIOLET = 0x100,

    ROC_COLOR_PINK = 0x200,

    ROC_COLOR_BROWN = 0x400
} roc_color_options;

typedef int64_t roc_color_selection;

typedef uint8_t roc_finger_id;

typedef enum roc_finger_options
{
    ROC_NO_FINGER = 0x0,

    ROC_THUMB = 0x1,

    ROC_INDEX_FINGER = 0x2,

    ROC_MIDDLE_FINGER = 0x4,

    ROC_RING_FINGER = 0x8,

    ROC_LITTLE_FINGER = 0x10,

    ROC_EXTRA_FINGER = 0x20,

    ROC_RIGHT_HAND = 0x40,

    ROC_LEFT_HAND = 0x80,

    ROC_FOUR_FINGERS = ROC_INDEX_FINGER | ROC_MIDDLE_FINGER
                     | ROC_RING_FINGER  | ROC_LITTLE_FINGER,

    ROC_ANY_FINGER = ROC_THUMB | ROC_FOUR_FINGERS,

    ROC_ANY_HAND = ROC_RIGHT_HAND | ROC_LEFT_HAND,

    ROC_UNKNOWN_FINGER = ROC_ANY_HAND | ROC_ANY_FINGER
} roc_finger_options;

ROC_EXPORT roc_error roc_algorithm_option_to_string(roc_algorithm_options
                                                               algorithm_option,
                                                    const char **str);

ROC_EXPORT roc_error roc_algorithm_option_from_string(const char *str,
                                                      roc_algorithm_options
                                                             *algorithm_option);

ROC_EXPORT roc_error roc_finger_id_to_string(roc_finger_id finger_id,
                                             roc_string *str);

ROC_EXPORT roc_error roc_finger_id_from_string(roc_string str,
                                               roc_finger_id *finger_id);


ROC_EXPORT roc_error roc_check_template_version(roc_algorithm_id algorithm_id);

#ifndef SWIG

#define ROC_STANDARD_FV_SIZE 261
#else // SWIG
%constant uint32_t ROC_STANDARD_FV_SIZE = 261;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEEP_FV_SIZE 261
#else // SWIG
%constant uint32_t ROC_DEEP_FV_SIZE = 261;
#endif // !SWIG

#ifndef SWIG

#define ROC_OBJECT_FV_SIZE 262
#else // SWIG
%constant uint32_t ROC_OBJECT_FV_SIZE = 262;
#endif // !SWIG

#ifndef SWIG

#define ROC_FAST_FV_SIZE 261
#else // SWIG
%constant uint32_t ROC_FAST_FV_SIZE = 261;
#endif // !SWIG

#ifndef SWIG

#define ROC_TATTOO_FV_SIZE 37
#else // SWIG
%constant uint32_t ROC_TATTOO_FV_SIZE = 37;
#endif // !SWIG

#ifndef SWIG

#define ROC_FINGERPRINT_FV_SIZE 262
#else // SWIG
%constant uint32_t ROC_FINGERPRINT_FV_SIZE = 262;
#endif // !SWIG


#ifndef SWIG

#define ROC_TEMPLATE_VERSION (((int64_t) ROC_VERSION_MAJOR << 61) + ((int64_t) ROC_VERSION_MINOR << 55))
#else // SWIG
%constant int64_t ROC_TEMPLATE_VERSION = (((int64_t) ROC_VERSION_MAJOR << 61) + ((int64_t) ROC_VERSION_MINOR << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_FAST_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 3 << 55))
#else // SWIG
%constant int64_t ROC_FAST_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 3 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_STANDARD_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 1 << 55))
#else // SWIG
%constant int64_t ROC_STANDARD_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 1 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_DEEP_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 4 << 55))
#else // SWIG
%constant int64_t ROC_DEEP_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 4 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_TATTOO_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 3 << 55))
#else // SWIG
%constant int64_t ROC_TATTOO_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 3 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_FINGERPRINT_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 4 << 55))
#else // SWIG
%constant int64_t ROC_FINGERPRINT_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 4 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_OBJECT_COMPATIBILITY_VERSION (((int64_t) 2 << 61) + ((int64_t) 1 << 55))
#else // SWIG
%constant int64_t ROC_OBJECT_COMPATIBILITY_VERSION = (((int64_t) 2 << 61) + ((int64_t) 1 << 55));
#endif // !SWIG

#ifndef SWIG

#define ROC_TEMPLATE_VERSION_MASK 0x7F80000000000000
#else // SWIG
%constant int64_t ROC_TEMPLATE_VERSION_MASK = 0x7F80000000000000;
#endif // !SWIG

#ifndef SWIG

#define ROC_NO_MIN_QUALITY -FLT_MAX
#else // SWIG
%constant float ROC_NO_MIN_QUALITY = -FLT_MAX;
#endif // !SWIG

#ifndef SWIG

#define ROC_TEXT_SUGGESTED_MIN_QUALITY 0.8f
#else // SWIG
%constant float ROC_TEXT_SUGGESTED_MIN_QUALITY = 0.8f;
#endif // !SWIG

#ifndef SWIG

#define ROC_TATTOO_SUGGESTED_MIN_QUALITY 0.0f
#else // SWIG
%constant float ROC_TATTOO_SUGGESTED_MIN_QUALITY = 0.0f;
#endif // !SWIG

#ifndef SWIG

#define ROC_FINGERPRINT_SUGGESTED_MIN_QUALITY -3.0f
#else // SWIG
%constant float ROC_FINGERPRINT_SUGGESTED_MIN_QUALITY = -3.0f;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEEP_SUGGESTED_MIN_QUALITY -0.2f
#else // SWIG
%constant float ROC_DEEP_SUGGESTED_MIN_QUALITY = -0.2f;
#endif // !SWIG

#ifndef SWIG

#define ROC_FAST_SUGGESTED_MIN_QUALITY -FLT_MAX
#else // SWIG
%constant float ROC_FAST_SUGGESTED_MIN_QUALITY = -FLT_MAX;
#endif // !SWIG

#ifndef SWIG

#define ROC_STANDARD_SUGGESTED_MIN_QUALITY -FLT_MAX
#else // SWIG
%constant float ROC_STANDARD_SUGGESTED_MIN_QUALITY = -FLT_MAX;
#endif // !SWIG

ROC_EXPORT float roc_get_suggested_quality_threshold(
                     roc_algorithm_id algorithm_id);

typedef struct roc_template
{
    roc_algorithm_id algorithm_id; 
    roc_time timestamp; 
    roc_template_id template_id; 
    roc_person_id person_id; 
    roc_media_id media_id; 
    roc_camera_id camera_id; 
    roc_archive_id archive_id; 
    roc_detection detection; 
    uint32_t md_size; 
    uint32_t fv_size; 
    uint32_t tn_size; 
    const char *md; 
    const uint8_t *fv; 
    const uint8_t *tn; 
} roc_template;

extern const size_t ROC_EXPORT roc_template_header_size;

ROC_EXPORT roc_error roc_new_template(roc_template *template_,
                                      uint32_t md_size,
                                      uint32_t fv_size,
                                      uint32_t tn_size);

ROC_EXPORT roc_error roc_new_color_template(roc_template *template_,
                         const roc_color_selection color_selection,
                         const char *object_type);

ROC_EXPORT roc_error roc_new_person_color_template(roc_template *template_,
                         const roc_color_selection torso_color_selection,
                         const roc_color_selection thigh_color_selection);

ROC_EXPORT roc_error roc_free_template(roc_template *template_);

ROC_EXPORT roc_error roc_copy_template(const roc_template src,
                                       roc_template *dst);

ROC_EXPORT roc_error roc_flatten(const roc_template template_,
                                 uint8_t *output_byte_array);

ROC_EXPORT roc_error roc_unflatten(const uint8_t *input_byte_array,
                                   roc_template *template_);

ROC_EXPORT roc_error roc_flattened_bytes(const roc_template template_,
                                         size_t *bytes);

ROC_EXPORT void roc_flattened_version(const uint8_t *input_byte_array,
                                      int *major_version,
                                      int *minor_version);

ROC_EXPORT void *roc_cast(uint8_t *pointer);
 // end of template_format

typedef enum roc_event_reasons
{
   ROC_NO_EVENT = 0x0000,

   ROC_NEW_TRACK = 0x0001,

   ROC_NEW_PROBE = 0x0002,

   ROC_BETTER_PROBE = 0x0004,

   ROC_BETTER_CANDIDATE = 0x0008,

   ROC_MERGED_TRACKS = 0x0010,

   ROC_NEW_START_TIME = 0x0020,

   ROC_NEW_STOP_TIME = 0x0040,

   ROC_NEW_CAMERA = 0x0080,

   ROC_NEW_WATCHLIST = 0x0100,

   ROC_MORE_TEMPLATES = 0x0200,

   ROC_FINALIZED_TRACK = 0x0400,

   ROC_ELAPSED_THRESHOLD = 0x0800,

   ROC_ELAPSED_INTERVAL = 0x1000,

   ROC_ANY = ROC_NEW_TRACK | ROC_MORE_TEMPLATES
} roc_event_reasons;
typedef uint32_t roc_event_type;

ROC_EXPORT roc_error roc_event_type_to_string(roc_event_type event_type,
                                                           const char **str);

ROC_EXPORT roc_error roc_event_type_from_string(const char *str,
                                              roc_event_type *event_type);
 // end of tracking

typedef float roc_similarity;

#ifndef SWIG

#define ROC_MAX_SIMILARITY (1.f)
#else // SWIG
%constant float ROC_MAX_SIMILARITY = 1.f;
#endif // !SWIG

#ifndef SWIG

#define ROC_MIN_SIMILARITY (0.f)
#else // SWIG
%constant float ROC_MIN_SIMILARITY = 0.f;
#endif // !SWIG

#ifndef SWIG

#define ROC_INVALID_SIMILARITY (-1.f)
#else // SWIG
%constant float ROC_INVALID_SIMILARITY = -1.f;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEFAULT_SEARCH_THRESHOLD (0.65f)
#else // SWIG
%constant float ROC_DEFAULT_SEARCH_THRESHOLD = 0.65f;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEFAULT_VERIFICATION_THRESHOLD (0.55f)
#else // SWIG
%constant float ROC_DEFAULT_VERIFICATION_THRESHOLD = 0.55f;
#endif // !SWIG

#ifndef SWIG

#define ROC_CONVENIENT_SPOOF_THRESHOLD (0.45f)
#else // SWIG
%constant float ROC_CONVENIENT_SPOOF_THRESHOLD = 0.45f;
#endif // !SWIG

#ifndef SWIG

#define ROC_SECURE_SPOOF_THRESHOLD (0.3f)
#else // SWIG
%constant float ROC_SECURE_SPOOF_THRESHOLD = 0.3f;
#endif // !SWIG

ROC_EXPORT roc_error roc_fuse(roc_similarity *raw,
                              size_t n,
                              roc_similarity *fused);
 // end of similarity

#ifndef SWIGJAVA

ROC_EXPORT roc_error roc_preinitialize_android(void *JNIEnv, void *jobject);
 // end of android

#endif // !SWIGJAVA

ROC_EXPORT roc_error roc_get_host_id(roc_string *host_id);

ROC_EXPORT roc_error roc_is_hardware_compatible();

typedef void (*roc_progress)(float);
 // end of initialization

typedef enum roc_embedded_error
{
    ROC_NOT_SUPPORTED = -1,

    ROC_SUCCESS = 0,

    ROC_ERROR_LICENSE = 1,

    ROC_ERROR_MALLOC = 2,

    ROC_ERROR_COLORSPACE = 3,

    ROC_ERROR_LICENSE_FILE = 4,

    ROC_ERROR_LICENSE_UNSUPPORTED = 5,

    ROC_ERROR_LICENSE_LOCKED = 6,

    ROC_ERROR_SNPE_RUNTIME_NOT_INITALIZED = 7,

    ROC_ERROR_SNPE_EXECUTE_FAILED = 8

} roc_embedded_error;

ROC_EXPORT roc_embedded_error
roc_embedded_initialize(const char *license_file);

ROC_EXPORT roc_embedded_error
roc_embedded_finalize();

ROC_EXPORT const char *
roc_embedded_error_to_string(roc_embedded_error error);

ROC_EXPORT roc_embedded_error
roc_embedded_detect_faces(roc_image image,
                          size_t min_size,
                          int k,
                          float false_detection_rate,
                          size_t *n,
                          roc_detection *detections);

ROC_EXPORT roc_embedded_error
roc_embedded_detect_faces_accurate(roc_image image,
                                   size_t min_size,
                                   int k,
                                   float false_detection_rate,
                                   size_t *n,
                                   roc_detection *detections);

ROC_EXPORT roc_error roc_landmarks_to_detection(const roc_landmark *right_eye,
                                                const roc_landmark *left_eye,
                                                const roc_landmark *chin,
                                                roc_detection *detection);

ROC_EXPORT int roc_num_landmarks_for_pose(roc_pose pose);

ROC_EXPORT roc_embedded_error
roc_embedded_landmark_face(roc_image image,
                           roc_detection *detection,
                           roc_landmark *landmarks,
                           roc_landmark *right_eye,
                           roc_landmark *left_eye,
                           roc_landmark *chin,
                           float *pitch,
                           float *yaw);

ROC_EXPORT roc_embedded_error
roc_embedded_liveness(roc_image image,
                      roc_landmark right_eye,
                      roc_landmark left_eye,
                      roc_landmark chin,
                      float *spoof);

typedef struct roc_embedded_gender
{
    float female; 
    float male;   
} roc_embedded_gender;

typedef struct roc_embedded_geographic_origin
{
    float african;         
    float east_asian;      
    float european;        
    float latin_american;  
    float middle_eastern;  
    float south_asian;     
    float southeast_asian; 
} roc_embedded_geographic_origin;

typedef struct roc_embedded_emotion
{
    float anger;    
    float disgust;  
    float fear;     
    float joy;      
    float neutral;  
    float sadness;  
    float surprise; 
} roc_embedded_emotion;

typedef struct roc_embedded_artwork
{
    float cartoon;  
    float human;    
    float painting; 
} roc_embedded_artwork;

typedef struct roc_embedded_glasses
{
    float none; 
    float sun;  
    float eye;  
} roc_embedded_glasses;

typedef struct roc_embedded_mask
{
    float mask;    
    float no_mask; 
} roc_embedded_mask;

ROC_EXPORT roc_embedded_error
roc_embedded_represent_face(roc_image image,
                            roc_detection detection,
                            roc_landmark right_eye,
                            roc_landmark left_eye,
                            roc_landmark chin,
                            uint8_t *feature_vector,
                            float *quality,
                            float *age,
                            float *facial_hair,
                            roc_embedded_gender *gender,
                            roc_embedded_geographic_origin *geographic_origin,
                            roc_embedded_emotion *emotion,
                            roc_embedded_artwork *artwork,
                            roc_embedded_glasses *glasses,
                            roc_embedded_mask *mask,
                            float *spoof,
                            float *gaussianblur);

ROC_EXPORT roc_embedded_error
roc_embedded_represent_face_unlocked(roc_image image,
                                     roc_detection detection,
                                     roc_landmark right_eye,
                                     roc_landmark left_eye,
                                     roc_landmark chin,
                                     float *unlocked_feature_vector,
                                     float *quality,
                                     float *age,
                                     float *facial_hair,
                                     roc_embedded_gender *gender,
                                     roc_embedded_geographic_origin *geographic_origin,
                                     roc_embedded_emotion *emotion,
                                     roc_embedded_artwork *artwork,
                                     roc_embedded_glasses *glasses,
                                     roc_embedded_mask *mask,
                                     float *spoof,
                                     float *gaussianblur);

ROC_EXPORT roc_similarity
roc_embedded_compare_templates(const uint8_t *a,
                               size_t a_size,
                               const uint8_t *b,
                               size_t b_size);

typedef struct roc_embedded_array
{
    int element_size; 
    int size; 
    char *data; 
} roc_embedded_array;

ROC_EXPORT void
roc_embedded_array_initialize(roc_embedded_array *array,
                              int element_size);

ROC_EXPORT roc_embedded_error
roc_embedded_array_append(roc_embedded_array *array,
                          const void *element);

ROC_EXPORT void
roc_embedded_array_get(roc_embedded_array array,
                       int index,
                       void *element);

ROC_EXPORT void
roc_embedded_array_free(roc_embedded_array *array);

ROC_EXPORT uint32_t
roc_embedded_checksum(const uint8_t *data, const int size);
 // end of embedded

#endif // !SWIG_ROC_VIDEO

#ifdef __cplusplus
}
#endif

#endif // ROC_EMBEDDED_H