/*
         * END - DETECT OBJECTS - LOCAL IMAGE
         */

        /*
         * DETECT DOMAIN-SPECIFIC CONTENT
         * Recognizes landmarks or celebrities in an image.
         */
        public static async Task DetectDomainSpecific(ComputerVisionClient client, string urlImage, string localImage)
        {
            Console.WriteLine("----------------------------------------------------------");
            Console.WriteLine("DETECT DOMAIN-SPECIFIC CONTENT - URL & LOCAL IMAGE");
            Console.WriteLine();

            // Detect the domain-specific content in a URL image.
            DomainModelResults resultsUrl = await client.AnalyzeImageByDomainAsync("landmarks", urlImage);

            // Display results.
            Console.WriteLine($"Detecting landmarks in the URL image {Path.GetFileName(urlImage)}...");

            var     jsonUrl       = JsonConvert.SerializeObject(resultsUrl.Result);
            JObject resultJsonUrl = JObject.Parse(jsonUrl);

            Console.WriteLine($"Landmark detected: {resultJsonUrl["landmarks"][0]["name"]} " +
                              $"with confidence {resultJsonUrl["landmarks"][0]["confidence"]}.");
            Console.WriteLine();

            // Detect the domain-specific content in a local image.
            using (Stream imageStream = File.OpenRead(localImage))
            {
                // Change "celebrities" to "landmarks" if that is the domain you are interested in.
                DomainModelResults resultsLocal = await client.AnalyzeImageByDomainInStreamAsync("celebrities", imageStream);

                Console.WriteLine($"Detecting celebrities in the local image {Path.GetFileName(localImage)}...");
                // Display results.
                var     jsonLocal       = JsonConvert.SerializeObject(resultsLocal.Result);
                JObject resultJsonLocal = JObject.Parse(jsonLocal);
                Console.WriteLine($"Celebrity detected: {resultJsonLocal["celebrities"][2]["name"]} " +
                                  $"with confidence {resultJsonLocal["celebrities"][2]["confidence"]}");
            }
            Console.WriteLine();
        }
예제 #2
0
        /// <summary>
        /// Sends a URL to Cognitive Services and performs analysis against a given domain.
        /// </summary>
        /// <param name="imageUrl">The URL of the image to analyze.</param>
        /// <param name="domainModel">The domain model to analyze against.</param>
        /// <returns>Awaitable domain-specific analysis result.</returns>
        private async Task <DomainModelResults> AnalyzeInDomainUrlAsync(string imageUrl, ModelDescription domainModel)
        {
            // -----------------------------------------------------------------------
            // KEY SAMPLE CODE STARTS HERE
            // -----------------------------------------------------------------------

            //
            // Create Cognitive Services Vision API Service client.
            //
            using (var client = new ComputerVisionClient(Credentials)
            {
                Endpoint = Endpoint
            })
            {
                Log("ComputerVisionClient is created");

                //
                // Analyze the URL against the given domain.
                //
                Log("Calling ComputerVisionClient.AnalyzeImageByDomainAsync()...");
                string             language       = (_language.SelectedItem as RecognizeLanguage).ShortCode;
                DomainModelResults analysisResult = await client.AnalyzeImageByDomainAsync(domainModel.Name, imageUrl, language);

                return(analysisResult);
            }
            // -----------------------------------------------------------------------
            // KEY SAMPLE CODE ENDS HERE
            // -----------------------------------------------------------------------
        }
예제 #3
0
        // Analyze a remote image
        private static async Task RecognizeDomainSpecificContentFromUrlAsync(ComputerVisionClient computerVision, string imageUrl, string specificDomain)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                Console.WriteLine("\nInvalid remote image url:\n{0} \n", imageUrl);
                return;
            }

            DomainModelResults analysis = await computerVision.AnalyzeImageByDomainAsync(specificDomain, imageUrl);  //change the first parameter to "landmarks" if that is the domain you are interested in

            Console.WriteLine(imageUrl);
            DisplayResults(analysis);
        }
        /*
         * DETECT DOMAIN-SPECIFIC CONTENT
         * Recognizes landmarks or celebrities in an image.
         */

        // supported domains "landmarks" and "celebrities"
        public static async Task <JObject> DetectDomainSpecific(ComputerVisionClient client, Uri imageUri, string domains)
        {
            Console.WriteLine("----------------------------------------------------------");
            Console.WriteLine("DETECT DOMAIN-SPECIFIC CONTENT");
            Console.WriteLine();

            JObject resultJsonUrl = null;

            // Http Urls
            if (imageUri.Scheme == Uri.UriSchemeHttps || imageUri.Scheme == Uri.UriSchemeHttp)
            {
                // Detect the domain-specific content in a URL image.
                DomainModelResults resultsUrl = await client.AnalyzeImageByDomainAsync(domains, imageUri.ToString());

                // Display results.
                Console.WriteLine($"Detecting {domains} in the URL image {Path.GetFileName(imageUri.AbsolutePath)}...");

                var jsonUrl = JsonConvert.SerializeObject(resultsUrl.Result);
                resultJsonUrl = JObject.Parse(jsonUrl);
            }
            else if (imageUri.Scheme == Uri.UriSchemeFile)
            {
                // Detect the domain-specific content in a local image.
                using (Stream imageStream = File.OpenRead(imageUri.AbsolutePath))
                {
                    Console.WriteLine($"Detecting {domains} in the local file image {Path.GetFileName(imageUri.AbsolutePath)}...");

                    DomainModelResults resultsLocal = await client.AnalyzeImageByDomainInStreamAsync(domains, imageStream);

                    // return results.
                    var jsonLocal = JsonConvert.SerializeObject(resultsLocal.Result);
                    resultJsonUrl = JObject.Parse(jsonLocal);
                }
            }
            Console.WriteLine();

            return(resultJsonUrl);
        }
예제 #5
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            string cognitive_service_key      = Environment.GetEnvironmentVariable("cognitive_service_key");
            string cognitive_service_endpoint = Environment.GetEnvironmentVariable("cognitive_service_endpoint");

            string  requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            dynamic data        = JsonConvert.DeserializeObject(requestBody);
            string  imageURL    = data.imageurl;
            //imageURL = "https://www.thehansindia.com/assets/9583_rahul-modi.jpg";

            dynamic result = new JObject();

            var credentials = new ApiKeyServiceClientCredentials(cognitive_service_key);

            ComputerVisionClient computerVision = new ComputerVisionClient(credentials,
                                                                           new System.Net.Http.DelegatingHandler[] { });

            // Specify the Azure region
            computerVision.Endpoint = cognitive_service_endpoint;

            // Analyzing image from remote URL
            if (!Uri.IsWellFormedUriString(imageURL, UriKind.Absolute))
            {
                log.LogError(
                    "\nInvalid remoteImageUrl:\n{0} \n", imageURL);
                log.LogInformation("invalid image URL provided.");
            }
            else
            {
                ImageAnalysis analysis = new ImageAnalysis();
                try
                {
                    analysis = await computerVision.AnalyzeImageAsync(imageURL, features);

                    // Getting caption
                    result.caption = "";
                    if (analysis.Description.Captions.Count != 0)
                    {
                        result.caption = analysis.Description.Captions[0].Text;
                    }

                    // Getting faces
                    dynamic faces       = new JArray();
                    dynamic celebrities = new JArray();
                    if (analysis.Faces.Count != 0)
                    {
                        foreach (var face in analysis.Faces)
                        {
                            dynamic faceObject = new JObject();
                            faceObject.rectangle = $"({face.FaceRectangle.Left.ToString()}, " +
                                                   $"{face.FaceRectangle.Top.ToString()}, " +
                                                   $"{face.FaceRectangle.Height.ToString()}, " +
                                                   $"{face.FaceRectangle.Width.ToString()})";
                            faceObject.age    = face.Age;
                            faceObject.gender = face.Gender.ToString();
                            faces.Add(faceObject);
                        }

                        var celebRecognition = await computerVision.AnalyzeImageByDomainAsync("celebrities", imageURL);

                        dynamic celebResult = JsonConvert.DeserializeObject(celebRecognition.Result.ToString());
                        if (celebResult.celebrities.Count > 1)
                        {
                            foreach (var celeb in celebResult.celebrities)
                            {
                                celebrities.Add(celeb);
                            }
                        }
                    }
                    result.faces       = faces;
                    result.celebrities = celebrities;

                    // Getting categories
                    dynamic categories = new JArray();
                    if (analysis.Categories.Count != 0)
                    {
                        foreach (var category in analysis.Categories)
                        {
                            categories.Add(category.Name);
                        }
                    }
                    result.categories = categories;

                    // Getting brands
                    dynamic brands = new JArray();
                    if (analysis.Brands.Count != 0)
                    {
                        foreach (var brand in analysis.Brands)
                        {
                            brands.Add(brand.Name);
                        }
                    }
                    result.brands = brands;

                    // Getting objects
                    dynamic objects = new JArray();
                    if (analysis.Objects.Count != 0)
                    {
                        foreach (var objectItem in analysis.Objects)
                        {
                            dynamic objObject = new JObject();
                            objObject.name      = objectItem.ObjectProperty;
                            objObject.rectangle = $"({objectItem.Rectangle.X.ToString()}, " +
                                                  $"{objectItem.Rectangle.Y.ToString()}, " +
                                                  $"{objectItem.Rectangle.H.ToString()}, " +
                                                  $"{objectItem.Rectangle.W.ToString()})";
                            objects.Add(objObject);
                        }
                    }
                    result.objects = objects;

                    // Getting tags
                    dynamic tags = new JArray();
                    if (analysis.Tags.Count != 0)
                    {
                        foreach (var tag in analysis.Tags)
                        {
                            tags.Add(tag.Name);
                        }
                    }
                    result.tags = tags;
                }
                catch (Exception ex)
                {
                    string exception = ex.Message;
                }
            }

            return(imageURL != null
                ? (ActionResult) new OkObjectResult($"{result.ToString()}")
                : new BadRequestObjectResult("{ \"error\": \"Please pass a valid image URL in the request\""));
        }