Beispiel #1
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            try
            {
                log.LogInformation("C# HTTP trigger function processed a request.");

                string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                CameraAnalysisResult cameraAnalysisResult = JsonConvert.DeserializeObject <CameraAnalysisResult>(requestBody);

                List <string> lines = new List <string>()
                {
                };

                lines.Add($"Camera: {cameraAnalysisResult.CameraId}");
                foreach (var image in cameraAnalysisResult.ImageAnalysisResults)
                {
                    lines.Add($"{NonBreakingSpace(5)}- Time: {image.Timestamp}");
                    lines.Add($"{NonBreakingSpace(5)}- Image: {image.ImageUri}");
                    lines.Add($"{NonBreakingSpace(5)}- Detected events:");

                    foreach (var result in image.Results)
                    {
                        lines.Add($"{NonBreakingSpace(10)}- {result.TagName}");
                    }
                }

                string text = string.Join(_lineSep, lines);

                return(new OkObjectResult(text));
            }
            catch (Exception e)
            {
                log.LogInformation($"FormatEmail failed. Exception message: {e}");
                throw e;
            }
        }
        static async Task <MessageResponse> AnalyzeImage(EnvSettings.CameraDevice camera)
        {
            try
            {
                List <ImageAnalysisResult> imageAnalysisResults = new List <ImageAnalysisResult>()
                {
                };

                // Get details for AI module tags' folders
                foreach (var module in camera.AIModules)
                {
                    foreach (var tag in module.Tags)
                    {
                        // Check if it is time to analyze images for current tag
                        if (_counterValue % tag.AnalyzeTimeInterval != 0)
                        {
                            continue;
                        }

                        // Analyze each image in the tag's folder
                        string   tagFolder = Path.Combine(camera.LocalFolder, camera.FactoryId, module.Name, tag.Name);
                        string[] images    = Directory.GetFiles(tagFolder);

                        _consoleLogger.LogDebug($"Found {images.Length} images in folder {tagFolder}");

                        // Analyze image files asyncrhonously
                        Task <ImageAnalysisResult>[] tasks = new Task <ImageAnalysisResult> [images.Length];
                        for (int i = 0; i < images.Length; i++)
                        {
                            string filePath = Path.Combine(tagFolder, images[i]);
                            tasks[i] = AnalyzeImage(filePath, camera.FactoryId, camera.Id, module, tag, camera.OutputFolder);
                        }

                        // Wait for tasks to complete
                        var taskResults = await Task.WhenAll(tasks);

                        // Add to bigger list
                        imageAnalysisResults.AddRange(taskResults.Where(x => x != null));

                        /// Clean up local tag folder is not needed since
                        /// every image is deleted during the inner method.
                    }
                }

                // Send message to hub only if there are any results to report
                if (imageAnalysisResults.Count() > 0)
                {
                    // Create camera results object
                    CameraAnalysisResult cameraResults = new CameraAnalysisResult(camera.FactoryId, camera.Id, imageAnalysisResults);

                    // Send message to hub for notification purposes
                    _consoleLogger.LogTrace($"Sending notification message to hub for camera {camera.Id}. # of results: {cameraResults.ImageAnalysisResults.Length}");

                    // Create hub message and set its properties
                    Message message = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(cameraResults)));
                    message.Properties.Add("messageType", "notification");

                    // Send notification message
                    await SendMessageToHub(message);

                    // Log it
                    _consoleLogger.LogTrace($"Sent notification message for camera {camera.Id}");
                }
            }
            catch (Exception e)
            {
                _consoleLogger.LogCritical("AnalyzeImage caught an exception: {0}", e);
            }

            return(MessageResponse.Completed);
        }