Rhino Speech-to-Intent Engine

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

constructor(private rhinoService: RhinoService) {
  // Subscribe to Rhino inference events
  this.inferenceDetection = rhinoService.inference$.subscribe(
    inference => {
      // Insert inference logic here
  })
}

async ngOnInit() {
  await this.rhinoService.init(
    RhinoWorkerFactory, 
    { context: { base64: /* Base64 representation of .rhn file */} }
  )
}

// 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 logic 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 logic here
    }
}

// Create an instance of RhinoManager
RhinoManager manager = await RhinoManager.create(
    "/PATH/TO/YOUR/CONTEXT_MODEL",
    (inference) => {
      if(inference['isUnderstood']){
        String intent = inference['intent']
        Map<String, String> inference = inference['slots']
        // Insert inference logic here
      }
    });
    
// Process audio
await manager.process()

// Create an instance of Rhino
handle = NewRhino("/PATH/TO/YOUR/CONTEXT_MODEL")
err := rhino.Init()
if err != nil {
    // handle error
}

// Process audio
for {
    isFinalized, err := handle.Process(getNextFrameAudio())
    if isFinalized {
        inference, err := handle.GetInference()
        if inference.IsUnderstood {
            intent := inference.Intent
            slots := inference.Slots
            // Insert inference logic here          
        }
    }
}

// Create an instance of RhinoManager
let rhinoManager = RhinoManager(
  contextPath:  "/PATH/TO/YOUR/CONTEXT_MODEL",
  onInference: { inference in  
    if inference.isUnderstood {
      let intent:String = inference.intent
      let slots:Dictionary<String,String> = inference.slots
      // Insert inference logic here
    }
  }
);

// Process audio
try rhinoManager.start()

// 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 logic 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 logic here
  }
}

const inferenceEventHandler = (rhinoInference) => {
  // Insert inference logic here
};

const {
  isLoaded,
  isListening,
  isError,
  pushToTalk, // Function to trigger Rhino to start
} = useRhino(
  RhinoWorkerFactory,
  { context: { base64: /* Base64 representation of .rhn file */ }, start: true },
  inferenceEventHandler
);

// Create an instance of RhinoManager
let manager = await RhinoManager.create(
    "/PATH/TO/YOUR/CONTEXT_MODEL",
    (inference) => {
      if(inference['isUnderstood'] === true){
        let intent = inference['intent'];
        let slots = inference['slots'];
        // Insert inference logic here
      }
    });
    
// Process audio
await manager.process()

// Create an instance of Rhino
RhinoManager manager = RhinoManager.Create(
    "/PATH/TO/YOUR/CONTEXT_MODEL",
    (inference) => 
    {
      if(inference.IsUnderstood)
      {
        string intent = inference.Intent;
        Dictionary<string, string> slots = inference.Slots;
        // Insert inference logic here
      }
    });

manager.Start();

<Rhino
  ref="rhino"
  v-bind:rhinoFactoryArgs="{
    context: { base64: /* Base64 representation of .rhn file */ },
  }"
  v-bind:rhinoFactory="factory"
  v-on:rhn-inference="rhnInferenceFn"
/>

methods: {
  rhnInferenceFn: function (inference) {
    // Insert inference logic here
  }
}

async function startRhino() {
  // Create Rhino Web Worker
  const rhinoWorker = await RhinoWorkerFactory.create({
      context: { base64: /* Base64 representation of .rhn file */, }, start: false });

  rhinoWorker.onmessage = (msg) => {
    if (msg.data.command === "rhn-inference") {
      // Insert inference logic here
      rhinoWorker.postMessage({ command: "pause" });
    }
  }

  // Access microphone and send downsampled audio to Porcupine Worker
  await WebVoiceProcessor.init({engines: [rhinoWorker]});
}