Beispiel #1
0
        /// <summary> Executes the analysis operation asynchronously, then returns either the result, or any exception that was thrown. </summary>
        /// <param name="vFrame"> The frame. </param>
        /// <returns> A Task&lt;NewResultEventArgs&gt; </returns>
        private async Task <NewResultEventArgs> DoAnalyzeFrame(VideoFrame vFrame)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            var fcn = AnalysisFunction;

            if (fcn != null)
            {
                NewResultEventArgs output = new NewResultEventArgs(vFrame);
                var task = fcn(vFrame);

                try
                {
                    if (task == await Task.WhenAny(task, Task.Delay(AnalysisTimeout, source.Token)))
                    {
                        output.AnalysisResult = await task;
                        source.Cancel();
                    }
                    else
                    {
                        output.TimedOut = true;
                    }
                }
                catch (Exception ex)
                {
                    output.Exception = ex;
                }

                return(output);
            }
            else
            {
                return(null);
            }
        }
Beispiel #2
0
        /// <summary> Executes the analysis operation asynchronously, then returns either the
        ///     result, or any exception that was thrown. </summary>
        /// <param name="frame"> The frame. </param>
        /// <returns> A Task&lt;NewResultEventArgs&gt; </returns>
        protected async Task <NewResultEventArgs> DoAnalyzeFrame(VideoFrame frame)
        {
            CancellationTokenSource source = new CancellationTokenSource();

            // Make a local reference to the function, just in case someone sets
            // AnalysisFunction = null before we can call it.
            var fcn = AnalysisFunction;

            if (fcn != null)
            {
                NewResultEventArgs output = new NewResultEventArgs(frame);
                var task = fcn(frame);
                try
                {
                    if (task == await Task.WhenAny(task, Task.Delay(AnalysisTimeout, source.Token)))
                    {
                        output.Analysis = await task;
                        source.Cancel();
                    }
                    else
                    {
                        output.TimedOut = true;
                    }
                }
                catch (Exception ae)
                {
                    output.Exception = ae;
                }
                return(output);
            }
            else
            {
                return(null);
            }
        }
        private void OnUpdateAnalysisResult(object sender, NewResultEventArgs newResultEventArgs)
        {
            var result = newResultEventArgs.AnalysisResult?.Emotions?.FirstOrDefault();

            if (result == null)
            {
                return;
            }
            Scores = result.Scores;
        }
 /// <summary> Raises the new result event. </summary>
 /// <param name="args"> Event information to send to registered event handlers. </param>
 protected void OnNewResultAvailable(NewResultEventArgs args)
 {
     NewResultAvailable?.Invoke(this, args);
 }