face_sdk_3divi 1.6.0

3DiVi Face SDK plugin. Implements Face Recognition, Face Detection and Face Keypoints Detection.

3DiVi FaceSDK Plugin

This plugin offers a trial of the core functionalities of 3DiVi Face SDK, featuring advanced Face Recognition technology ranked highly by NIST. Key features include:

• Face Detection
• Facial Keypoints Detection
• Face Verification (1:1)

Please, note that this package contains only a demo license, so your runtime usage is limited in time. For a trial license, please contact us.

Installation

First, add face_sdk_3divi and face_sdk_3divi_models as a dependency in your pubspec.yaml file.

Requirements

Physical device with minimal Android API level 21(Android 5.0) or iOS 10.0

Android

• Create Flutter project with Kotlin
• Add imports to your android/app/src/main/kotlin/com/.../MainActivity.kt

import android.content.pm.ApplicationInfo
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

• Replace your MainActivity class with

class MainActivity : FlutterActivity() {

	companion object {
		init {
			System.loadLibrary("facerec")
		}

		private const val CHANNEL = "samples.flutter.dev/facesdk"
	}

	private fun getNativeLibDir(): String {
		return applicationInfo.nativeLibraryDir
	}

	override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
		super.configureFlutterEngine(flutterEngine)
		MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)
			.setMethodCallHandler { call, result ->
				when (call.method) {
					"getNativeLibDir" -> result.success(getNativeLibDir())
					else -> result.notImplemented()
				}
			}
	}
} 

• Add these lines to android/app/build.gradle.kts in android section

sourceSets {
    getByName("main") {
      jniLibs.srcDirs("${projectDir}/../../assets/lib")
  }
}

iOS

Copy libraries

• Create directory assets/lib in your project directory
• Copy face_sdk_3divi/assets/lib/facerec.framework and face_sdk_3divi/assets/lib/onnxruntime.framework to assets/lib
• Open ios/Runner.xcworkspace in XCode
• In Target Navigator select "Runner", go to "General" tab, "Frameworks, Libraries, and Embedded Content" section and click "+". In the opened window "Add Other..."->"Add Files" and select facerec.framework, onnxruntime.framework in Finder
• Remove facerec.framework, onnxruntime.framework in "Build Phases" tab, "Link Binary With Libraries" section Setup project
• Add permissions to ios/Runner/Info.plist in dict tag

<key>NSCameraUsageDescription</key>
<string>Camera used for detection and recognition</string>
<key>NSMicrophoneUsageDescription</key>
<string>Microphone description</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>Photo library description</string>

• Replace your ios/Runner/AppDelegate.swift with

import UIKit
import Flutter

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    let batteryChannel = FlutterMethodChannel(name: "samples.flutter.dev/facesdk",
                                              binaryMessenger: controller.binaryMessenger)
    batteryChannel.setMethodCallHandler({
      (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
      // Note: this method is invoked on the UI thread.
        guard call.method == "getNativeLibDir" else {
          result(FlutterMethodNotImplemented)
          return
        }
        result(Bundle.main.privateFrameworksPath)
    })

    GeneratedPluginRegistrant.register(with: self)
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}

Creating Face SDK components

Create Face SDK service

import 'package:face_sdk_3divi/face_sdk_3divi.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Creating main Face SDK component
  // With FacerecService you can create other Face SDK components, such as ProcessingBlock, Context, Recognizer, Capturer
  FacerecService service = await FaceSdkPlugin.createFacerecService();
}

Create Face SDK async processing blocks

import 'package:face_sdk_3divi/face_sdk_3divi.dart';

// AsyncProcessingBlock uses Isolate

// Creating AsyncProcessingBlock component for detecting faces
Future<AsyncProcessingBlock> createFaceDetector(FacerecService service) async {
  return await service.createAsyncProcessingBlock({"unit_type": "FACE_DETECTOR", "modification": "blf_front"});
}

// Creating AsyncProcessingBlock component for constructing face landmarks after detecting
Future<AsyncProcessingBlock> createFaceFitter(FacerecService service) async {
  return await service.createAsyncProcessingBlock({"unit_type": "FACE_FITTER", "modification": "tddfa_faster"});
}

// Creating AsyncProcessingBlock component for extracting face template after detecting and constructing face landmarks
// With this templates you can recognize faces
Future<AsyncProcessingBlock> createTemplateExtractor(FacerecService service) async {
  return await service.createAsyncProcessingBlock({"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "30"});
}

// Creating AsyncProcessingBlock component for recognizing faces
Future<AsyncProcessingBlock> createVerificationModule(FacerecService service) async {
  return await service.createAsyncProcessingBlock({"unit_type": "VERIFICATION_MODULE", "modification": "30"});
}

Create Face SDK processing blocks

import 'package:face_sdk_3divi/face_sdk_3divi.dart';

// Creating ProcessingBlock component for detecting faces
Future<ProcessingBlock> createFaceDetector(FacerecService service) async {
  return service.createProcessingBlock({"unit_type": "FACE_DETECTOR", "modification": "blf_front"});
}

// Creating ProcessingBlock component for constructing face landmarks after detecting
Future<ProcessingBlock> createFaceFitter(FacerecService service) async {
  return service.createProcessingBlock({"unit_type": "FACE_FITTER", "modification": "tddfa_faster"});
}

// Creating ProcessingBlock component for extracting face template after detecting and constructing face landmarks
Future<ProcessingBlock> createTemplateExtractor(FacerecService service) async {
  return service.createProcessingBlock({"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "30"});
}

// Creating ProcessingBlock component for recognizing faces
Future<ProcessingBlock> createVerificationModule(FacerecService service) async {
  return service.createProcessingBlock({"unit_type": "VERIFICATION_MODULE", "modification": "30"});
}

Using Face SDK processing blocks

import 'package:face_sdk_3divi/face_sdk_3divi.dart';

/**
* @param image Image for camera plugin
* @param baseAngle Native camera image rotation(0 - no rotation, 1 - 90°, 2 - 270°, 3 - 180°)
*/
Context? createTemplate(
    CameraImage image, 
    FacerecService service, 
    AsyncProcessingBlock faceDetector, 
    AsyncProcessingBlock faceFitter, 
    AsyncProcessingBlock faceTemplateExtractor, 
    int baseAngle
) {
    Context data = service.createContextFromCameraImage(image, baseAngle); // creates JSON-like container with data for processing

    try {
      await faceDetector.process(data); // detect faces
      
      // all detected objects stored in data["objects"] array
      // you can access to any object by index

      if (data["objects"].len() > 1) {
        data.dispose(); // release resources

        print("More than 1 face detected");

        return null;
      } else if (data["objects"].len() == 0) {
        data.dispose(); // release resources

        print("No face detected");

        return null;
      }

      await faceFitter.process(data); // construct face landmarks
      
      await faceTemplateExtractor.process(data); // extract face template
    } catch (e) {
      print("Exception: $e");
    }
    
    // data Context information format
    // please note, all x and y are normalized coordinates with respect to image width/height
    /*
    {
        "objects": [{
            "id": {"type": "long", "minimum": 0},
            "class": "face",
            "confidence": {"double",  "minimum": 0,  "maximum": 1},
            "bbox": [x1, y2, x2, y2],
            "face_template": {
              "template": ContextTemplate,
              "uuid": "string"
            }
            "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]]
            }
        }]
    }
    */

    return data;
}

Support

Please do not hesitate to contact us if you need any assistance or want to report a bug / suggest an improvement.

Advanced SDK

Advanced SDK version is presented here. It offers a comprehensive suite of features, including:

• Face Identification (1:N)
• Liveness / Face Antispoofing algorithms to prevent fraud
• Face Image Quality to enhance recognition accuracy
• Age, Gender and Emotions Estimation
• Face Recognition on server side
• Flexible licensing
• Advance Tech Support
• and much more !