initializeFromBuffers method

Future<void> initializeFromBuffers({
  1. required Uint8List palmDetectionBytes,
  2. required Uint8List handLandmarkBytes,
  3. Uint8List? gestureEmbedderBytes,
  4. Uint8List? gestureClassifierBytes,
  5. HandMode mode = HandMode.boxesAndLandmarks,
  6. HandLandmarkModel landmarkModel = HandLandmarkModel.full,
  7. double detectorConf = 0.45,
  8. double palmNmsIou = 0.45,
  9. double palmRoiScale = 2.6,
  10. int maxDetections = 10,
  11. double minLandmarkScore = 0.5,
  12. bool enableTracking = false,
  13. TrackingConfig trackingConfig = const TrackingConfig(),
  14. int interpreterPoolSize = 1,
  15. PerformanceConfig performanceConfig = const PerformanceConfig(),
  16. bool enableGestures = false,
  17. double gestureMinConfidence = 0.5,
  18. bool useCompiledModel = false,
  19. Set<Accelerator> accelerators = const {Accelerator.gpu, Accelerator.cpu},
  20. Precision precision = Precision.fp16,
})

Initializes the hand detector from pre-loaded model bytes.

Used when asset loading from the main isolate is not available, or when bytes have already been loaded. Spawns the background isolate with the provided model data.

Parameters:

  • palmDetectionBytes: Raw bytes of the palm detection TFLite model
  • handLandmarkBytes: Raw bytes of the hand landmark TFLite model
  • gestureEmbedderBytes: Raw bytes of the gesture embedder model (optional; required for gesture recognition)
  • gestureClassifierBytes: Raw bytes of the gesture classifier model (optional; required for gesture recognition)
  • mode: Detection mode. Default: HandMode.boxesAndLandmarks
  • landmarkModel: Hand landmark model variant. Default: HandLandmarkModel.full
  • detectorConf: Palm detection confidence threshold. Default: 0.45
  • palmNmsIou: IoU threshold for palm non-maximum suppression. Default: 0.45
  • palmRoiScale: Expansion factor for the palm ROI fed to the landmark model. Default: 2.6
  • trackingConfig: ROI tuning used when enableTracking is true. Default: TrackingConfig
  • maxDetections: Maximum number of hands to detect. Default: 10
  • minLandmarkScore: Minimum landmark confidence score. Default: 0.5
  • interpreterPoolSize: Number of landmark model interpreter instances. Default: 1. Forced to 1 when a performance delegate (XNNPACK/auto) is enabled.
  • performanceConfig: TensorFlow Lite performance configuration. Default: auto
  • enableGestures: Whether to run gesture recognition. Default: false
  • gestureMinConfidence: Minimum confidence for gesture recognition. Default: 0.5

Implementation

Future<void> initializeFromBuffers({
  required Uint8List palmDetectionBytes,
  required Uint8List handLandmarkBytes,
  Uint8List? gestureEmbedderBytes,
  Uint8List? gestureClassifierBytes,
  HandMode mode = HandMode.boxesAndLandmarks,
  HandLandmarkModel landmarkModel = HandLandmarkModel.full,
  double detectorConf = 0.45,
  double palmNmsIou = 0.45,
  double palmRoiScale = 2.6,
  int maxDetections = 10,
  double minLandmarkScore = 0.5,
  bool enableTracking = false,
  TrackingConfig trackingConfig = const TrackingConfig(),
  int interpreterPoolSize = 1,
  PerformanceConfig performanceConfig = const PerformanceConfig(),
  bool enableGestures = false,
  double gestureMinConfidence = 0.5,
  bool useCompiledModel = false,
  Set<Accelerator> accelerators = const {Accelerator.gpu, Accelerator.cpu},
  Precision precision = Precision.fp16,
}) async {
  if (isReady) {
    throw StateError('HandDetector already initialized');
  }

  final effectivePoolSize = performanceConfig.mode == PerformanceMode.disabled
      ? interpreterPoolSize
      : 1;

  final worker = _HandDetectorWorker();

  try {
    await worker.initialize(
      palmDetectionBytes: palmDetectionBytes,
      handLandmarkBytes: handLandmarkBytes,
      gestureEmbedderBytes: gestureEmbedderBytes,
      gestureClassifierBytes: gestureClassifierBytes,
      mode: mode,
      landmarkModel: landmarkModel,
      detectorConf: detectorConf,
      palmNmsIou: palmNmsIou,
      palmRoiScale: palmRoiScale,
      maxDetections: maxDetections,
      minLandmarkScore: minLandmarkScore,
      enableTracking: enableTracking,
      trackingConfig: trackingConfig,
      interpreterPoolSize: effectivePoolSize,
      performanceConfig: performanceConfig,
      enableGestures: enableGestures,
      gestureMinConfidence: gestureMinConfidence,
      useCompiledModel: useCompiledModel,
      accelerators: accelerators,
      precision: precision,
    );
  } catch (e) {
    if (worker.isReady) {
      await worker.dispose();
    }
    rethrow;
  }

  _worker = worker;
}