Версия: 3.25.1 (последняя)

Распознавание лиц

Обзор

Face SDK позволяет выполнять следующие операции сравнения биометрических шаблонов лиц:

Верификация (1:1) — сравнение двух шаблонов лиц на принадлежность одному и тому же человеку (сравнение двух лиц).
Идентификация (1:N) — сравнение одного биометрического шаблона лица с другими шаблонами лиц (поиск лица по базе лиц).

Результатом распознавания является оценка сходства между сравниваемыми шаблонами.

Процессинг-блоки

FACE_TEMPLATE_EXTRACTOR — извлекает биометрический шаблон лица из изображения.
VERIFICATION_MODULE — сравнивает два шаблона лиц, проверяя их схожесть.
MATCHER_MODULE — ищет похожие лица в базе данных.

Классы для работы с модулями распознавания лиц

ContextTemplate - хранит биометрический шаблон лица в бинарном формате. Используется для сравнения и поиска в модулях распознавания.
DynamicTemplateIndex - хранит коллекцию биометрических шаблонов для быстрого поиска в MATCHER_MODULE. Поддерживает добавление и удаление шаблонов без пересоздания индекса.

Модификации и версии процессинг-блоков распознавания лиц

Модификация процессинг-блока FACE_TEMPLATE_EXTRACTOR определяет скорость генерации шаблона и точность распознавания. Чем выше скорость работы, тем ниже точность.

Серии модификаций:

30-1000 - стандартные модификации, подходят для ПК.
30m-1000m - оптимизированы для мобильных процессоров, работают быстрее, но с меньшей точностью по сравнению со стандартной серией.

30-1000
30m-1000m

Модификация	Версия	Размер шаблона (байты)	Создание шаблона (мс) PC*	Создание шаблона (мс) Mobile**
30	1	280	19	50
50	1	288	31	92
100	1	280	68	212
1000	1	296	611	2200

Модификация	Версия	Размер шаблона (байты)	Создание шаблона (мс) PC*	Создание шаблона (мс) Mobile**
30m	1	280	14	30
50m	1	288	25	53
100m	1	280	55	102
1000m	1	296	543	1100

* – Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz.
** – MediaTek Helio G95.

примечание

Модификация по умолчанию - "1000".

Для процессинг-блоков VERIFICATION_MODULE и MATCHER_MODULE модификация и версия определяют тип шаблона, с которым данные модули будут работать.

Описание ContextTemplate и DynamicTemplateIndex

ContextTemplate

Создание ContextTemplate

Экземпляр ContextTemplate можно создать несколькими способами:

Получить после работы модуля FACE_TEMPLATE_EXTRACTOR.
Вызвать метод service.loadContextTemplate. Этот метод позволяет загрузить объект ContextTemplate из бинарного потока данных.

Методы ContextTemplate

// Получение названия модификации шаблона
std::string getMethodName() const;

// Размер шаблона
size_t size() const;

// Сохранение в бинарный поток данных
void save(std::ostream &binary_stream) const;

# Получение названия модификации шаблона
def get_method_name(self) -> str:

# Размер шаблона
def size(self) -> int:

# Сохранение в массив байтов
def save(self, binary_stream: BytesIO):

// Получение названия модификации шаблона
String getMethodName();

// Размер шаблона
int size();

// Сохранение в массив байтов
Uint8List save();

// Удаление шаблона
void dispose();

// Получение названия модификации шаблона
String getMethodName();

// Размер шаблона
long size();

// Сохранение в бинарный поток данных
void save(Stream binary_stream)

// Получение названия модификации шаблона
String getMethodName();

// Размер шаблона
int size();

// Сохранение в бинарный поток данных
void save(OutputStream binary_stream)

// Удаление шаблона
void dispose();

// Получение названия модификации шаблона
fun getMethodName(): String?

// Размер шаблона
fun size(): int?

// Сохранение в бинарный поток данных
fun save(binary_stream: OutputStream!)

// Удаление шаблона
fun dispose();

DynamicTemplateIndex

Создание DynamicTemplateIndex

Для создания экземпляра DynamicTemplateIndex используется метод service.createDynamicTemplateIndex. Метод принимает контейнер-Контекст с следующими параметрами:

max_license_count (тип: long) - Максимальное количество шаблонов, которое может содержать индекс. Не может превышать лимит, указанный в лицензии. Значение по умолчанию — 100.
capacity (тип: long) - Резервирует место для шаблонов в индексе. Значение по умолчанию — max_license_count.
async (тип: bool) - Если указано true, включается асинхронный режим для операций добавления и удаления шаблонов. Это позволяет выполнять эти операции параллельно. Режим находится в бета-версии.
model_version (тип: string) - Модификация и версия модели, например, "1000_1". Этот параметр определяет, с шаблонами какой модификации модуля FACE_TEMPLATE_EXTRACTOR будет работать индекс.

Методы DynamicTemplateIndex

// Получение названия метода шаблонов в базе
std::string getMethodName() const;

// Количество шаблонов в базе
size_t size() const;

// Текущая вместимость базы
size_t capacity() const;

// Получение UUID шаблона по индексу в базе
std::string getUUID(size_t index) const;

// Получение шаблона по UUID
pbio::ContextTemplate::Ptr at(const std::string& uuid) const;

// Получение шаблона по индексу в базе
pbio::ContextTemplate::Ptr at(int64_t index) const;

// Добавление шаблона в базу
void add(pbio::Template::Ptr templ, const std::string& uuid);
void add(const std::vector<pbio::Template::Ptr>& templates, const std::vector<std::string>& uuids);

void add(pbio::ContextTemplate::Ptr templ, const std::string& uuid);
void add(const std::vector<pbio::ContextTemplate::Ptr>& templates, const std::vector<std::string>& uuids);

// Удаление шаблона из базы по UUID
void remove(const std::string& uuid);
void remove(const std::vector<std::string>& uuids);

// Слияние баз шаблонов
// otherIndex становится невалидным
void concat(DynamicTemplateIndex::Ptr otherIndex);

# Получение названия метода шаблонов в базе
def get_method_name(self) -> str:

# Количество шаблонов в базе
def size(self) -> int:

# Текущая вместимость базы
def capacity(self) -> int:

# Получение UUID шаблона по индексу в базе
def get_uuid(self, i: int) -> str:

# Получение шаблона по UUID
def at(self, uuid: str) -> ContextTemplate:

# Получение шаблона по индексу
def get(self, index: int) -> ContextTemplate:

# Добавление шаблона в базу
def add(self, template: ContextTemplate, uuid: str) -> None:
def add(self, template: Template, uuid: str) -> None:
def add(self, templates: Union[List[Template], List[ContextTemplate]], uuids: List[str]) -> None:

# Удаление шаблона из базы
def remove(self, uuid: str) -> None:
def remove(self, uuids: List[str]) -> None:

# Слияние баз шаблонов
# other_index становится невалидным
def concat(self, other_index: "DynamicTemplateIndex") -> None:

/// Получение названия метода шаблонов в базе
String getMethodName();

/// Количество шаблонов в базе
int size();

/// Текущая вместимость базы
int capacity();

/// Получение UUID шаблона по индексу в базе
String getUUID(int index);

/// Получение шаблона по UUID
ContextTemplate at(String uuid);

/// Получение шаблона по индексу
ContextTemplate get(int index);

/// Добавление шаблона в базу
void addContextTemplate(ContextTemplate template, String uuid);
void addContextTemplates(List<ContextTemplate> templates, List<String> uuids);

void addRecognizerTemplate(Template template, String uuid);
void addRecognizerTemplates(List<Template> templates, List<String> uuids);

/// Удаление шаблона из базы
void removeByUuid(String uuid);
void removeByUuids(List<String> uuids);

/// Слияние баз шаблонов
/// otherIndex становится невалидным
void concat(DynamicTemplateIndex otherIndex);

/// Удаление базы шаблонов
void dispose();

// Получение названия метода шаблонов в базе
String getMethodName();

// Количество шаблонов в базе
long size();

// Текущая вместимость базы
long capacity();

// Получение UUID шаблона по индексу в базе
string GetUUID(int i);

// Получение шаблона по UUID
ContextTemplate At(string uuid);

// Получение шаблона по индексу
ContextTemplate Get(int i);

// Добавление шаблона в базу
void Add(ContextTemplate templ, string uuid);
void Add(List<ContextTemplate> templates, List<string> uuids);

void Add(Template templ, string uuid);
void Add(List<Template> templates, List<string> uuids);

// Удаление шаблона из базы
void Remove(string uuid);
void Remove(List<string> uuids);

// Слияние баз шаблонов
void Concat(DynamicTemplateIndex other_index);

// Получение названия метода шаблонов в базе
String getMethodName();

// Количество шаблонов в базе
int size();

// Текущая вместимость базы
long capacity();

// Получение UUID шаблона по индексу в базе
String getUUID(final long i);

// Получение шаблона по UUID
ContextTemplate at(final String uuid);

// Получение шаблона по индексу
ContextTemplate get(final long i);

// Добавление шаблона в базу
void addContextTemplate(final ContextTemplate templ, final String uuid);
void addContextTemplate(final Vector<ContextTemplate> templates, final Vector<String> uuids);

void addTemplate(final Template templ, final String uuid);
void addTemplate(final Vector<Template> templates, final Vector<String> uuids);

// Удаление шаблона из базы
void remove(final String uuid);
void remove(final Vector<String> uuids);

// Слияние баз шаблонов
// otherIndex становится невалидным
void concat(final DynamicTemplateIndex otherIndex);

// Удаление базы шаблонов
void dispose()

// Получение названия метода шаблонов в базе
fun getMethodName(): String?

// Количество шаблонов в базе
fun size(): int?

// Текущая вместимость базы
fun capacity(): Long

// Получение UUID шаблона по индексу в базе
fun getUUID(i: Long): String!

// Получение шаблона по UUID
fun at(uuid: String!) ContextTemplate!

// Получение шаблона по индексу
fun get(i: Long): ContextTemplate!

// Добавление шаблона в базу
fun addContextTemplate(templ: ContextTemplate!, uuid: String!)
fun addContextTemplate(templates: Vector<ContextTemplate!>!, uuids: Vector<String!>!)

fun addTemplate(templ: Template!, uuid: String!)
fun addTemplate(templates: Vector<Template!>!, uuids: Vector<String!>!)

// Удаление шаблона из базы
fun remove(uuid: String!)
fun remove(uuids: Vector<String!>!)

// Слияние баз шаблонов
// otherIndex становится невалидным
fun concat(otherIndex: DynamicTemplateIndex!)

// Удаление базы шаблонов
fun dispose()

Спецификация процессинг-блоков распознавания

Перечень настраиваемых параметров процессинг-блоков

Face template extractor

Входной контейнер Context должен содержать бинарное изображение и массив объектов, полученных после работы процессинг-блоков детекции лица и фиттера:

Нажмите, чтобы развернуть спецификацию входного контейнера Context

{
    "image" : {
        "format": "NDARRAY",
        "blob": "data pointer",
        "dtype": "uint8_t",
        "shape": [height, width, channels]
    },
    "objects": [{
        "id": {"type": "long", "minimum": 0},
        "class": "face",
        "confidence": {"double",  "minimum": 0,  "maximum": 1},
        "bbox": [x1, y2, x2, y2]
        "keypoints": {
            "left_eye_brow_left":   {"proj" : [x, y]},
            "left_eye_brow_up":     {"proj" : [x, y]},
            "left_eye_brow_right":  {"proj" : [x, y]},
            "right_eye_brow_left":  {"proj" : [x, y]},
            "right_eye_brow_up":    {"proj" : [x, y]},
            "right_eye_brow_right": {"proj" : [x, y]},
            "left_eye_left":        {"proj" : [x, y]},
            "left_eye":             {"proj" : [x, y]},
            "left_eye_right":       {"proj" : [x, y]},
            "right_eye_left":       {"proj" : [x, y]},
            "right_eye":            {"proj" : [x, y]},
            "right_eye_right":      {"proj" : [x, y]},
            "left_ear_bottom":      {"proj" : [x, y]},
            "nose_left":            {"proj" : [x, y]},
            "nose":                 {"proj" : [x, y]},
            "nose_right":           {"proj" : [x, y]},
            "right_ear_bottom":     {"proj" : [x, y]},
            "mouth_left":           {"proj" : [x, y]},
            "mouth":                {"proj" : [x, y]},
            "mouth_right":          {"proj" : [x, y]},
            "chin":                 {"proj" : [x, y]},
            "points": ["proj": [x, y]]
        }
    }]
}

После выполнения процессинг-блока оценки в каждом объекте массива "objects" поле "face_template" будет содержать биометрический шаблон в поле "template" и уникальный идентификатор в поле "uuid". Шаблон хранится в объекте класса ContextTemplate. Выданный uuid можно использовать для работы с DynamicTemplateIndex или заменить на собственный идентификатор.

Нажмите, чтобы развернуть спецификацию выходного контейнера Context

[{
    "keypoints": {},
    "face_template": {
        "template": {"ContextTemplate"},
        "uuid": {"string"}
    }
}]

Verification module

Входной контейнер Context должен содержать два биометрических шаблона записанные в поля "template1" и "template2". Тип шаблона должен соответствовать модификации процессинг-блока.

Нажмите, чтобы развернуть спецификацию входного контейнера Context

{
    "template1" : {
        "template": {"ContextTemplate"}
    },
    "template2" : {
        "template": {"ContextTemplate"}
    }
}

После вызова процессинг-блока верификации результат будет помещён в "result".

Нажмите, чтобы развернуть спецификацию выходного контейнера Context

{
    "template2": {},
    "result": {
        "distance": {"double",  "minimum": 0},
        "score": {"double",  "minimum": 0,  "maximum": 1},
        "far": {"double",  "minimum": 0,  "maximum": 1},
        "frr": {"double",  "minimum": 0,  "maximum": 1},
    }
}

Matcher module

Входной контейнер Context должен содержать объект класса DynamicTemplateIndex в поле "template_index" и набор искомых биометрических шаблонов, помещённых в другой объект класса DynamicTemplateIndex в поле "queries", либо один шаблон в виде объекта класса ContextTemplate.

Нажмите, чтобы развернуть спецификацию входного контейнера Context

{
    "queries": {"DynamicTemplateIndex"},
    "template_index": {"DynamicTemplateIndex"}
}

ИЛИ

{
    "queries": {"ContextTemplate"},
    "template_index": {"DynamicTemplateIndex"}
}

После вызова процессинг-блока верификации результат будет помещён в массив "results".

Нажмите, чтобы развернуть спецификацию выходного контейнера Context

{
    "template_index": {"DynamicTemplateIndex"}
    "result": [{
        "index": {"long", "minimum": 0}
        "uuid": {"string"}
        "distance": {"double",  "minimum": 0},
        "score": {"double",  "minimum": 0,  "maximum": 1},
        "far": {"double",  "minimum": 0,  "maximum": 1},
        "frr": {"double",  "minimum": 0,  "maximum": 1},
    }]
}

Результаты распознавания

distance – расстояние между сравниваемыми векторами шаблонов. Чем меньше значение, тем выше уверенность в корректном распознавании.
far – вероятность ошибочных подтверждений, когда система принимает изображения разных людей за изображение одного и того же человека.
frr – вероятность ошибочных отказов, когда система принимает два изображения одного и того же человека за изображения разных людей.
score – степень схожести лиц от 0 (0%) до 1 (100%). Высокая степень схожести означает, что два биометрических шаблона принадлежат одному и тому же человеку.
index - позиция найденого шаблона внутри объекта DynamicTemplateIndex. (только для MATCHER_MODULE)
uuid - уникальный идентификатор шаблона, переданный при добавлении в DynamicTemplateIndex. (только для MATCHER_MODULE)

Примеры работы с процессинг-блоками распознавания лиц

Извлечение шаблонов лица

Для получения шаблона лица на изображении выполните следующие действия:

Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "FACE_TEMPLATE_EXTRACTOR" и "modification" и "version" интересующей вас модификации.
Пример создания процессинг-блока можно найти здесь
Перечень настраиваемых параметров процессинг-блоков
Передайте Context-контейнер, полученный после работы процессинг-блоков детекции лица и фиттера.
Вызовите процессинг-блок извлечения шаблонов лица.

auto configCtx = service->createContext();
configCtx["unit_type"] = "FACE_TEMPLATE_EXTRACTOR";
configCtx["modification"] = "{modification}";
pbio::ProcessingBlock blockFaceExtractor = service->createProcessingBlock(configCtx);

//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------

faceDetector(ioData)
faceFitter(ioData)
blockFaceExtractor(ioData);

configCtx = {"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "{modification}" }
blockFaceExtractor = service.create_processing_block(configCtx)

#------------------
# создание процессинг-блока и Context-контейнера с бинарным изображением
#------------------

faceDetector(ioData)
faceFitter(ioData)
blockFaceExtractor(ioData)

ProcessingBlock blockFaceExtractor = service.createProcessingBlock({"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "{modification}"});

//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------

faceDetector.process(ioData);
faceFitter.process(ioData);
blockFaceExtractor.process(ioData);

Dictionary<object, object> configCtx = new();
configCtx["unit_type"] = "FACE_TEMPLATE_EXTRACTOR";
configCtx["modification"] = "{modification}";
ProcessingBlock blockFaceExtractor = service.CreateProcessingBlock(configCtx);

//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------

faceDetector.Invoke(ioData);
faceFitter.Invoke(ioData);
blockFaceExtractor.Invoke(ioData);

Context configCtx = service.createContext();
configCtx.get("unit_type").setString("FACE_TEMPLATE_EXTRACTOR");
configCtx.get("modification").setString("{modification}");

ProcessingBlock blockFaceExtractor = service.createProcessingBlock(configCtx);

//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------

faceDetector.process(ioData);
faceFitter.process(ioData);
blockFaceExtractor.process(ioData);

val configCtx = service.createContext()
configCtx["unit_type"].string = "FACE_TEMPLATE_EXTRACTOR"
configCtx["modification"].string = "{modification}"

val blockFaceExtractor = service.createProcessingBlock(configCtx)

//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------

faceDetector.process(ioData)
faceFitter.process(ioData)
blockFaceExtractor.process(ioData)

Сохранение шаблона лица

Для сохранения шаблона лица в файле выполните следующие действия:

Получите объект ContextTemplate из данных.
Откройте бинарный файл для записи.
Сохраните шаблон в файл с помощью метода save().

pbio::ContextTemplate::Ptr face_template = ioData["objects"][0]["face_template"]["template"].getContextTemplate();

std::ofstream out("template.bin", std::ios::binary);

face_template->save(out);

face_template = ioData["objects"][0]["face_template"]["template"]

with open("template.bin", "wb") as file:
    face_template.save(file)

ContextTemplate faceTemplate = ioData["objects"][0]["face_template"]["template"].get_value();

File out = File("template.bin");

await out.writeAsBytes(faceTemplate.save());

ContextTemplate faceTemplate = ioData["objects"][0]["face_template"]["template"].GetContextTemplate();

using Stream fileStream = new FileStream("template.bin", FileMode.Create, FileAccess.Write);
faceTemplate.save(fileStream);

ContextTemplate faceTemplate = ioData.get("objects").get(0).get("face_template").get("template").getContextTemplate();

try (FileOutputStream stream = new FileOutputStream("template.bin"))
{
    faceTemplate.save(stream);
}
catch (IOException ioe)
{
    ioe.printStackTrace();
}

val faceTemplate = ioData["objects"][0]["face_template"]["template"].contextTemplate

try {
    val stream = FileOutputStream("template.bin")

    faceTemplate.save(stream)
} catch (ioe: IOException) {
    ioe.printStackTrace()
}

Загрузка шаблона лица

Для загрузки шаблона лица из файла выполните следующие действия:

Откройте файл для чтения бинарных данных.
Загрузите шаблон с помощью loadContextTemplate().

std::ifstream input("template.bin", std::ios::binary);

pbio::ContextTemplate::Ptr face_template = service->loadContextTemplate(input);

with open("template.bin", "rb") as file:
    face_template = service.load_context_template(file)

File input = File("template.bin");
Uint8List templateBytes = await input.readAsBytes();

ContextTemplate faceTemplate = service.loadContextTemplate(templateBytes);
});

using Stream fileStream = new FileStream("template.bin", FileMode.Open, FileAccess.Read);
ContextTemplate faceTemplate = service.loadContextTemplate(fileStream);

try (FileInputStream stream = new FileInputStream("template.bin"))
{
    ContextTemplate faceTemplate = service.loadContextTemplate(stream);
}
catch (IOException ioe)
{
    ioe.printStackTrace();
}

try {
    val stream = FileInputStream("template.bin")

    val faceTemplate = service.loadContextTemplate(stream)
} catch (ioe: IOException) {
    ioe.printStackTrace()
}

Верификация лиц

Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "VERIFICATION_MODULE" и "modification" и "version" интересующей вас модификации.
Сформируйте Context-контейнер и добавьте биометрические шаблоны в поля "template1" и "template2":.
- Вы можете добавить содержимое поля "face_template", полученного при вызове модуля "FACE_TEMPLATE_EXTRACTOR", в поля "template1" и "template2"
- Либо создать новый Context-контейнер и добавить в него объект класса ContextTemplate.
Вызовите процессинг-блок верификации.

pbio::Context verificationConfig = service->createContext();
verificationConfig["unit_type"] = "VERIFICATION_MODULE";
verificationConfig["modification"] = "{modification}";

pbio::ProcessingBlock verificationModule = service->createProcessingBlock(verificationConfig);

pbio::Context verificationData = service->createContext();
verificationData["template1"] = ioData["objects"][0]["face_template"];
verificationData["template2"]["template"] = face_template;

verificationModule(verificationData);

configCtx = {"unit_type": "VERIFICATION_MODULE", "modification": "{modification}"}
verificationModule = service.create_processing_block(configCtx)

verificationData = service.create_context({})
verificationData["template1"] = ioData["objects"][0]["face_template"]
verificationData["template2"]["template"] = face_template

verificationModule(verificationData)

ProcessingBlock verificationModule = service.createProcessingBlock({"unit_type": "VERIFICATION_MODULE", "modification": "{modification}"});

Context verificationData = service.createContext({"template1": {}, "template2": {}});
verificationData["template1"].placeValues(ioData["objects"][0]["face_template"])
verificationData["template2"]["template"].placeValues(faceTemplate)

verificationData = verificationModule.process(verificationData);

Dictionary<object, object> verificationConfig = new();
verificationConfig["unit_type"] = "VERIFICATION_MODULE";
verificationConfig["modification"] = "{modification}";
ProcessingBlock verificationModule = service.CreateProcessingBlock(verificationConfig);

Context verificationData = service.CreateContext(null);
verificationData["template1"] = ioData["objects"][0]["face_template"];
verificationData["template2"]["template"].SetContextTemplate(faceTemplate);

verificationModule.Invoke(verificationData);

Context verificationConfig = service.createContext();
verificationConfig.get("unit_type").setString("VERIFICATION_MODULE");
verificationConfig.get("modification").setString("{modification}");

ProcessingBlock verificationModule = service.createProcessingBlock(verificationConfig);

Context verificationData = service.createContext();
verificationData.get("template1").setContext(ioData.get("objects").get(0).get("face_template"));
verificationData.get("template2").get("template").setContextTemplate(faceTemplate);

verificationModule.process(verificationData);

val verificationConfig = service.createContext()
verificationConfig["unit_type"].string = "VERIFICATION_MODULE"
verificationConfig["modification"].string = "{modification}"

val verificationModule = service.createProcessingBlock(verificationConfig)

val verificationData = service.createContext()
verificationData["template1"].setContext(ioData["objects"][0]["face_template"])
verificationData["template2"]["template"].contextTemplate = faceTemplate;

verificationModule.process(verificationData)

Формирование DynamicTemplateIndex

Для формирование DynamicTemplateIndex выполните следующие действия:

Сформируйте контейнер-Context и укажите поля "model_version" и "max_license_count" и передайте этот контейнер в метод createDynamicTemplateIndex
Добавьте шаблоны в индекс с помощью метода add(), передав ContextTemplate и uuid

pbio::Context indexConfig = service->createContext();

indexConfig["model_version"] = "{modification}_1";
indexConfig["max_license_count"] = 1000;

pbio::DynamicTemplateIndex::Ptr template_index = service->createDynamicTemplateIndex(indexConfig);

for (const pbio::Context& object : ioData["objects"])
{
    template_index->add(object["face_template"]["template"].getContextTemplate(), "<uuid>");
}

index_config = service.create_context({
    "capacity": 1000,
    "model_version": "{modification}_1",
    "async": False,
    "max_license_count": 1000
})

template_index = service.create_dynamic_template_index(index_config)

for object in ioData["objects"]:
    template_index.add(object["face_template"]["template"].get_value(), "<uuid>")

Context indexConfig = service.createContext({
    "capacity": 1000,
    "model_version": "{modification}_1",
    "async": false,
    "max_license_count": 1000
});

DynamicTemplateIndex templateIndex = service.createDynamicTemplateIndex(indexConfig);

for (int i = 0; i < ioData["objects"].len(); i++){
    templateIndex.add(ioData["objects"][i]["face_template"]["template"].get_value(), "<uuid>");
}

Context indexConfig = service.CreateContext
(
    new()
    {
        { "capacity", 1000 },
        { "model_version", "{modification}_1" },
        { "async", false },
        { "max_license_count", 1000 }
    }
);

DynamicTemplateIndex templateIndex = service.createDynamicTemplateIndex(indexConfig);

for (int i = 0; i < (int)ioData["objects"].Length(); i++)
{
    templateIndex.Add(ioData["objects"][i]["face_template"]["template"].GetContextTemplate());
}

Context indexConfig = service.createContext();

indexConfig.get("capacity").setLong(1000);
indexConfig.get("model_version").setString("{modification}_1");
indexConfig.get("async").setBool(false);
indexConfig.get("max_license_count").setLong(1000);

DynamicTemplateIndex templateIndex = service.createDynamicTemplateIndex(indexConfig);

Context objects = ioData.get("objects");
for (int i = 0; i < objects.size(); i++)
{
    templateIndex.add(objects.get(i).get("face_template").get("template").getContextTemplate(), "<uuid>");
}

val indexConfig = service.createContext()

indexConfig["capacity"].long = 1000
indexConfig["model_version"].string = "{modification}_1"
indexConfig["async"].bool = false
indexConfig["max_license_count"].long = 1000

val templateIndex = service.createDynamicTemplateIndex(indexConfig)

val templatesData = service.createContext()
val objects = ioData["objects"]
for (i in 0 until objects.size()) {
    templateIndex.add(objects[i]["face_template"]["template"].contextTemplate, "<uuid>")
}

примечание

Передаваемый uuid должен быть уникальным

Поиск лиц по базе

Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "MATCHER_MODULE" и "modification" и "version" интересующей вас модификации.
Сформируйте входной Context-контейнер согласно спецификации для "MATCHER_MODULE".
Вызовите процессинг-блок для поиска по базе.

pbio::Context matcherConfig = service->createContext();
matcherConfig["unit_type"] = "MATCHER_MODULE";
matcherConfig["modification"] = "{modification}";

pbio::ProcessingBlock matcherModule = service->createProcessingBlock(matcherConfig);

// Forming the input Context container for matcherModule
pbio::Context matcherData = service->createContext();
matcherData["template_index"] = template_index;
matcherData["queries"] = ioData["objects"][0]["face_template"]["template"];

matcherModule(matcherData);

matcher_module = service.create_processing_block({"unit_type": "MATCHER_MODULE", "modification": "{modification}"})
matcher_data = service.create_context({})

matcher_data["template_index"] = template_index
matcher_data["queries"] = ioData["objects"][0]["face_template"]["template"]

matcher_module(matcher_data)

matcherModule = service.createProcessingBlock({"unit_type": "MATCHER_MODULE", "modification": "{modification}"});

// Forming the input Context container for matcherModule
Context matcherData = service.createContext({"template_index": {}, "queries": []});

matcherData["template_index"] = templateIndex;
matcherData["queries"] = ioData["objects"][0]["face_template"]["template"];

matcherModule.process(matcherData);

Dictionary<object, object> matcherConfig = new();
matcherConfig["unit_type"] = "MATCHER_MODULE";
matcherConfig["modification"] = "{modification}";
ProcessingBlock matcherModule = service.CreateProcessingBlock(matcherConfig);

// Creating the input Context container for matcherModule
Context matcherData = service.CreateContext(new Dictionary<object, object>{
        { "template_index", templateIndex},
        { "queries", ioData["objects"][0]["face_template"]["template"] },
});

matcherModule.Invoke(matcherData);

Context matcherConfig = service.createContext();
matcherConfig.get("unit_type").setString("MATCHER_MODULE");
matcherConfig.get("modification").setString("{modification}");

ProcessingBlock matcherModule = service.createProcessingBlock(matcherConfig);

// Forming the input Context container for matcherModule
Context matcherData = service.createContext();
matcherData.get("template_index").setDynamicTemplateIndex(templateIndex);
matcherData.get("queries").setContextTemplate(ioData.get("objects").get(0).get("face_template").get("template").getContextTemplate());

matcherModule.process(matcherData);

val matcherConfig = service.createContext()
matcherConfig["unit_type"].string = "MATCHER_MODULE"
matcherConfig["modification"].string ="{modification}"

val matcherModule = service.createProcessingBlock(matcherConfig)

// Forming the input Context container for matcherModule
val matcherData = service.createContext()
matcherData["template_index"].dynamicTemplateIndex = templateIndex
matcherData["queries"] = ioData["objects"][0]["face_template"]["template"]

matcherModule.process(matcherData)

Обзор​

Процессинг-блоки​

Классы для работы с модулями распознавания лиц​

Модификации и версии процессинг-блоков распознавания лиц​

Описание ContextTemplate и DynamicTemplateIndex​

ContextTemplate​

Создание ContextTemplate​

Методы ContextTemplate​

DynamicTemplateIndex​

Создание DynamicTemplateIndex​

Методы DynamicTemplateIndex​

Спецификация процессинг-блоков распознавания​

Face template extractor​

Verification module​

Matcher module​

Результаты распознавания​

Примеры работы с процессинг-блоками распознавания лиц​

Извлечение шаблонов лица​

Сохранение шаблона лица​

Загрузка шаблона лица​

Верификация лиц​

Формирование DynamicTemplateIndex​

Поиск лиц по базе​

Обзор

Процессинг-блоки

Классы для работы с модулями распознавания лиц

Модификации и версии процессинг-блоков распознавания лиц

Описание ContextTemplate и DynamicTemplateIndex

ContextTemplate

Создание ContextTemplate

Методы ContextTemplate

DynamicTemplateIndex

Создание DynamicTemplateIndex

Методы DynamicTemplateIndex

Спецификация процессинг-блоков распознавания

Face template extractor

Verification module

Matcher module

Результаты распознавания

Примеры работы с процессинг-блоками распознавания лиц

Извлечение шаблонов лица

Сохранение шаблона лица

Загрузка шаблона лица

Верификация лиц

Формирование DynamicTemplateIndex

Поиск лиц по базе