Rhino Speech-to-Intent Engine

// Create an instance of RhinoManager
RhinoManager manager = new RhinoManager(
    modelPath,
    "/PATH/TO/YOUR/CONTEXT_MODEL",
    sensitivity,
    new RhinoManagerCallback() {
        @Override
        public void invoke(RhinoInference inference) {
            if (inference.getIsUnderstood()) {
              string intent = inference.getIntent()
              Map<string,string> slots = inference.getSlots()
              // Insert inferece callback here
            }
        }
    });
 
// Process audio
manager.start()

// Create an instance of RhinoManager
let rhinoManager = RhinoManager(
  modelPath: modelFilePath,
  contextPath:  "/PATH/TO/YOUR/CONTEXT_MODEL",
  sensitivity: sensitivity,
  onInferenceCallback: ((Inference) -> Void) = {
    // Insert inference callback here
}
);
 
// Process audio
try rhinoManager.start()

// Create an instance of Rhino
let handle = Rhino.create("/PATH/TO/YOUR/CONTEXT_MODEL")
 
// Process audio
while (true) {
    let result = handle.process(getNextAudioFrame());
    if ("isUnderstood" in result) {
      let intent = result.intent
      let slots = result.slots
      // Insert inference callback here
    }
}

// Create an instance of Rhino
let handle = new Rhino("/PATH/TO/YOUR/CONTEXT_MODEL");
 
// Process audio
while (true) {
  let isFinalized = handle.process(frame)
  if (isFinalized) {
    let inference = handle.getInference()
    // Insert inference callback here
  }
}

// Create an instance of Rhino
Rhino handle = Rhino.Create(contextPath: "/PATH/TO/YOUR/CONTEXT_MODEL");
 
// Process audio
while (true) {
  bool isFinalized = handle.Process(GetNextAudioFrame());   
  if(isFinalized)
  {
    Inference inference = handle.GetInference();
    if(inference.IsUnderstood)
    {
        string intent = inference.Intent;
        Dictionary<string, string> slots = inference.Slots;
        // Insert inference callback here
    }
}

// Create an instance of Rhino
Rhino handle = new Rhino.Builder().setKeywordPath("/PATH/TO/YOUR/CONTEXT_MODEL").build();
 
// Process audio
while (true) {
  boolean isFinalized = handle.process(getNextAudioFrame());
  if(isFinalized) {
      RhinoInference inference = handle.getInference();
      if(inference.getIsUnderstood()) {
          string intent = inference.getIntent()
          Map<string,string> slots = inference.getSlots()
          // Insert inference callback here
    }
  }
}

// Create an instance of Rhino
pv_rhino_t *handle;
pv_rhino_init(model_file_path, context_file_path, &rhino);
 
// Process audio
while (true) {
    pv_rhino_process(rhino, pcm, &is_finalized);
 
    if (is_finalized) {
        pv_rhino_is_understood(rhino, &is_understood);
        
        if (is_understood) {
            pv_rhino_get_intent(rhino, &intent, &num_slots, &slots, &values);
            // Insert inference callback here
        }
    }
}