コード例 #1
0
        public async Task <AnalyzePictureResult> AnalyzePicture(string pictureUrl)
        {
            try
            {
                var result = await _computerVisionClient.AnalyzeImageAsync(pictureUrl, details : new[] { Details.Landmarks }, visualFeatures : new[] { VisualFeatureTypes.Color, VisualFeatureTypes.Description });

                // Get most likely description
                var description = result.Description.Captions.OrderByDescending(d => d.Confidence).FirstOrDefault()?.Text ?? "nothing! No description found";

                // Get accent color
                var accentColor = Color.FromHex($"#{result.Color.AccentColor}");

                // Determine if there are any landmarks to be seen
                var landmark = result.Categories.FirstOrDefault(c => c.Detail != null && c.Detail.Landmarks.Any());

                var landmarkDescription = "";

                landmarkDescription = landmark != null?landmark.Detail.Landmarks.OrderByDescending(l => l.Confidence).First().Name : "";

                // Wrap in our result object and send along
                return(new AnalyzePictureResult(description, accentColor, landmarkDescription));
            }
            catch
            {
                return(new AnalyzePictureResult());
            }
        }
コード例 #2
0
ファイル: Geordi.cs プロジェクト: jamesjoyce96/Rossy
        public AnalysisResult Analyze(string imageUrl, string utterance)
        {
            var rosetta  = new Rosetta(RossyConfig.RosettaConfig);
            var intent   = rosetta.GuessIntent(utterance);
            var analyzer = GetAnalyzer(intent);
            List <VisualFeatureTypes> features = analyzer.SetupAnalysisFeatures();

            var client = new ComputerVisionClient(new ApiKeyServiceClientCredentials(RossyConfig.GeordiConfig.SubscriptionKey))
            {
                Endpoint = RossyConfig.GeordiConfig.Endpoint
            };
            ImageAnalysis imageAnalysis = client.AnalyzeImageAsync(imageUrl, features).Result;

            string log      = analyzer.ProduceLog(imageAnalysis);
            var    language = rosetta.GuessLanguage(utterance);
            string speechText;

            switch (language)
            {
            case "it":
                speechText = analyzer.ProduceSpeechTextItalian(imageAnalysis);
                break;

            case "en":
            default:
                speechText = analyzer.ProduceSpeechTextEnglish(imageAnalysis);
                break;
            }

            return(new AnalysisResult(speechText, log));
        }
コード例 #3
0
        public async Task <IActionResult> Details(string imageUrl) //string language
        {
            ViewBag.ImageUrl = imageUrl;
            ComputerVisionClient      client   = Client.Authenticate();
            List <VisualFeatureTypes> features = new List <VisualFeatureTypes>()
            {
                VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
                VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
                VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
                VisualFeatureTypes.Objects
            };

            //
            Path.GetFileName(imageUrl);

            // Redirects to Invalid Image view if Computer Vision returns an error
            // Assumes Error is due to a bad image url - is not of a direct image e.g., google.com
            try
            {
                ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, features);

                return(View(results));
            }
            catch (Exception e)
            {
                return(RedirectToAction("InvalidImage"));
            }
        }
コード例 #4
0
        public static async Task Main(string[] args)
        {
            Console.WriteLine("BirdOrNot");
            Console.WriteLine("-----------------");
            Console.WriteLine("Url: ");

            var url = Console.ReadLine();

            var AzureComputerVisionSubscriptionKey = Environment.GetEnvironmentVariable("AzureComputerVisionSubscriptionKey");
            var AzureComputerVisionEndpoint        = Environment.GetEnvironmentVariable("AzureComputerVisionEndpoint");

            var computerVisionClient = new ComputerVisionClient(new ApiKeyServiceClientCredentials(AzureComputerVisionSubscriptionKey))
            {
                Endpoint = AzureComputerVisionEndpoint
            };

            var imageAnalysis = await computerVisionClient.AnalyzeImageAsync(url, new List <VisualFeatureTypes>
            {
                VisualFeatureTypes.Objects
            });

            var isBird = imageAnalysis.Objects.Any(x => x.ObjectProperty.Equals("bird") || CheckForBirdRecursive(x.Parent));

            Console.WriteLine(isBird ? "It is a bird." : "It is not a bird.");
        }
コード例 #5
0
        public async Task <string> GetAnalysisAsync(string imageUrl)
        {
            List <VisualFeatureTypes> features = new List <VisualFeatureTypes>()
            {
                VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
                VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
                VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
                VisualFeatureTypes.Objects
            };

            var client = new ComputerVisionClient(new ApiKeyServiceClientCredentials("0d38d688442d4918a4b0d8f0866a0c27"))
            {
                Endpoint = "https://cvision-dicoding.cognitiveservices.azure.com/"
            };

            var results = await client.AnalyzeImageAsync(imageUrl, features);

            foreach (var caption in results.Description.Captions)
            {
                return(caption.Text);
            }

            return(null);
        }
コード例 #6
0
        /// <summary>
        /// Analyze the image from an http based image url
        /// </summary>
        /// <param name="imageUrl">Http url of image</param>
        /// <returns></returns>
        public async Task <ImageAnalysis> AnalyzeImageFromUrlAsync(string imageUrl)
        {
            if (!imageUrl.StartsWith("http"))
            {
                throw new Exception("Image must be a publicly accessible url. Provide an image url of http or https type");
            }
            List <VisualFeatureTypes> features = new List <VisualFeatureTypes>()
            {
                VisualFeatureTypes.Categories,
                VisualFeatureTypes.Brands,
                VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces,
                VisualFeatureTypes.Tags,
                VisualFeatureTypes.Objects,
                VisualFeatureTypes.Adult
            };
            List <Details> details = new List <Details>()
            {
                Details.Celebrities,
                Details.Landmarks
            };
            ImageAnalysis result = await visionClient.AnalyzeImageAsync(imageUrl, features, details);

            return(result);
        }
コード例 #7
0
 private static async Task AnalyzeRemoteAsync(ComputerVisionClient computerVision, string fileURLWithSAS, CognitiveImageAnalysis cognitiveImageAnalysis)
 {
     try
     {
         if (ValidateImage(1, fileURLWithSAS))
         {
             cognitiveImageAnalysis.imageAnalysis = await computerVision.AnalyzeImageAsync(fileURLWithSAS, features);
         }
         else
         {
             cognitiveImageAnalysis.error = "Image Validation Failed for ImageAnalysis API";
         }
     }
     catch (Exception e)
     {
         if (e is ComputerVisionErrorException)
         {
             ComputerVisionErrorException ex = (ComputerVisionErrorException)e;
             cognitiveImageAnalysis.error = ex.Message.ToString() + " due to " + ex.Response.Content;
         }
         else
         {
             cognitiveImageAnalysis.error = e.Message.ToString();
         }
     }
 }
        public static async Task AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
        {
            Console.WriteLine("----------------------------------------------------------");
            Console.WriteLine("ANALYZE IMAGE - URL");
            Console.WriteLine();

            // Creating a list that defines the features to be extracted from the image.

            List <VisualFeatureTypes?> features = new List <VisualFeatureTypes?>()
            {
                VisualFeatureTypes.Tags
            };

            Console.WriteLine($"Analyzing the image {Path.GetFileName(imageUrl)}...");
            Console.WriteLine();
            // Analyze the URL image
            ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures : features);

            // Image tags and their confidence score
            Console.WriteLine("Tags:");
            foreach (var tag in results.Tags)
            {
                Console.WriteLine($"{tag.Name} {tag.Confidence}");
            }
            Console.WriteLine();
        }
コード例 #9
0
        private static async Task AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
        {
            var features = new List <VisualFeatureTypes>()
            {
                VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
                VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
                VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
                VisualFeatureTypes.Objects
            };

            Console.WriteLine($"Analyzing the image {Path.GetFileName(imageUrl)}...");
            Console.WriteLine();
            // Analyze the URL image
            var results = await client.AnalyzeImageAsync(imageUrl, features);

            // Summarizes the image content.
            Console.WriteLine("Summary:");
            foreach (var caption in results.Description.Captions)
            {
                var json = JsonConvert.SerializeObject(results, Formatting.Indented);
                Console.WriteLine($"{caption.Text} with confidence {caption.Confidence}");
            }
            Console.WriteLine();
        }
コード例 #10
0
        public static async Task <ImageDetails> AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
        {
            var imageDetails = new ImageDetails();

            imageDetails.ImageUrl = imageUrl;

            // Creating a list that defines the features to be extracted from the image.
            List <VisualFeatureTypes> features = new List <VisualFeatureTypes>()
            {
                VisualFeatureTypes.Description,
                VisualFeatureTypes.Tags
            };

            ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, features);

            foreach (var caption in results.Description.Captions)
            {
                imageDetails.Description.Captions.Add(
                    new Caption
                {
                    Text       = caption.Text,
                    Confidence = caption.Confidence
                }
                    );
            }

            foreach (var tag in results.Tags)
            {
                imageDetails.Description.Tags.Add(
                    tag.Name
                    );
            }

            return(imageDetails);
        }
コード例 #11
0
        /// <summary>
        /// Sends a URL to Cognitive Services and performs analysis.
        /// </summary>
        /// <param name="imageUrl">The URL of the image to analyze.</param>
        /// <returns>Awaitable image analysis result.</returns>
        private async Task <ImageAnalysis> AnalyzeUrlAsync(string imageUrl)
        {
            // -----------------------------------------------------------------------
            // 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 for all visual features.
                //
                Log("Calling ComputerVisionClient.AnalyzeImageAsync()...");
                VisualFeatureTypes[] visualFeatures = GetSelectedVisualFeatures();
                string        language       = (_language.SelectedItem as RecognizeLanguage).ShortCode;
                ImageAnalysis analysisResult = await client.AnalyzeImageAsync(imageUrl, visualFeatures, null, language);

                return(analysisResult);
            }

            // -----------------------------------------------------------------------
            // KEY SAMPLE CODE ENDS HERE
            // -----------------------------------------------------------------------
        }
コード例 #12
0
        public static async Task AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
        {
            Console.WriteLine("----------------------------------------------------------");
            Console.WriteLine("ANALYZE IMAGE - URL");
            Console.WriteLine();

            // Creating a list that defines the features to be extracted from the image.

            List <VisualFeatureTypes?> features = new List <VisualFeatureTypes?>()
            {
                VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
                VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
                VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
                VisualFeatureTypes.Objects
            };
            ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, features);

            Console.WriteLine("Objects:");
            foreach (var obj in results.Objects)
            {
                Console.WriteLine($"{obj.ObjectProperty} with confidence {obj.Confidence} at location {obj.Rectangle.X}, " +
                                  $"{obj.Rectangle.X + obj.Rectangle.W}, {obj.Rectangle.Y}, {obj.Rectangle.Y + obj.Rectangle.H}");
            }
            Console.WriteLine();
        }
コード例 #13
0
        private async void imgPhoto_ImageOpened(object sender, RoutedEventArgs e)
        {
            size_image = new Size((imgPhoto.Source as BitmapImage).PixelWidth, (imgPhoto.Source as BitmapImage).PixelHeight);

            var client = new ComputerVisionClient(
                new ApiKeyServiceClientCredentials(key),
                new System.Net.Http.DelegatingHandler[] { });  // need to provide and endpoint and a delegate.

            client.Endpoint = apiroot;

            var feature = new VisualFeatureTypes []
            {
                VisualFeatureTypes.Tags,
                VisualFeatureTypes.Faces,
                VisualFeatureTypes.Description,
                VisualFeatureTypes.Adult,
                VisualFeatureTypes.Categories
            };

            var result = await client.AnalyzeImageAsync(txtLocation.Text, feature);

            thisresult = result;
            if (result != null)
            {
                DisplayData(result);
            }
            ringLoading.IsActive = false;
        }
コード例 #14
0
        /// <summary>
        /// Sends a URL to Cognitive Services and performs analysis.
        /// </summary>
        /// <param name="imageUrl">The URL of the image to analyze.</param>
        /// <returns>Awaitable image analysis result.</returns>
        private async Task <string> AnalyzeUrlAsync(string imageUrl, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
        {
            string key  = "<SERVICE CLIENT KEY>";
            var    test = new ApiKeyServiceClientCredentials(key);

            using (var client = new ComputerVisionClient(test)
            {
                Endpoint = "https://colourfind.cognitiveservices.azure.com/"
            })
            {
                VisualFeatureTypes[] visualFeatures = new List <VisualFeatureTypes>()
                {
                    VisualFeatureTypes.Color, VisualFeatureTypes.Description, VisualFeatureTypes.Tags
                }.ToArray();

                string        language = "en";
                ImageAnalysis analysisResult;

                analysisResult = await client.AnalyzeImageAsync(imageUrl, visualFeatures, null, language);

                string mainColour = analysisResult.Color.DominantColorForeground;

                return(mainColour);
            }
        }
コード例 #15
0
        public async Task <ImageAnalysis> Analizer(string urlAnalize)
        {
            string subscriptionKey   = "eeaf71b7af4b424f8784608593261774";
            string subscriptionKey2  = "90fa26632f7c49b8ae8723ae5a46ee40";
            string endpoint          = "https://computervisionsrg.cognitiveservices.azure.com/";
            string ANALYZE_URL_IMAGE = urlAnalize;

            ComputerVisionClient client = new ComputerVisionClient(new ApiKeyServiceClientCredentials(subscriptionKey))
            {
                Endpoint = endpoint
            };

            List <VisualFeatureTypes?> features = new List <VisualFeatureTypes?>()
            {
                VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
                VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
                VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
                VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
                VisualFeatureTypes.Objects
            };

            ImageAnalysis results = await client.AnalyzeImageAsync(ANALYZE_URL_IMAGE, visualFeatures : features);

            return(results);
        }
コード例 #16
0
        private async Task <ImageAnalysis> AnalyzeUrl(string imageUrl)
        {
            Log("Calling VisionServiceClient.AnalyzeImageAsync()...");
            VisualFeatureTypes?[] visualFeatures = new VisualFeatureTypes?[] { VisualFeatureTypes.Adult, VisualFeatureTypes.Categories, VisualFeatureTypes.Color, VisualFeatureTypes.Description, VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType, VisualFeatureTypes.Tags };
            var analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures);

            return(analysisResult);
        }
コード例 #17
0
 public static Task <ImageAnalysis> cvResult(string imgurl)
 {
     return(cv.AnalyzeImageAsync(imgurl, new List <VisualFeatureTypes?>()
     {
         VisualFeatureTypes.Description,
         VisualFeatureTypes.Objects
     }));
 }
コード例 #18
0
        public static async Task <ImageAnalysis> AnalyzeImage([ActivityTrigger] string name, ILogger log)
        {
            log.LogInformation($"Analyzing {name}.");
            ComputerVisionClient computerVision = new ComputerVisionClient(new ApiKeyServiceClientCredentials(Environment.GetEnvironmentVariable("CognitiveApiKey")), new System.Net.Http.DelegatingHandler[] { });

            computerVision.Endpoint = Environment.GetEnvironmentVariable("CognitiveApiUrl");

            return(await computerVision.AnalyzeImageAsync(await GetBlobAccessUrl("uploaded", name, TimeSpan.FromSeconds(60)), analysisFeatures));
        }
コード例 #19
0
        // Analyze a remote image
        public Task <ImageAnalysis> AnalyzeRemoteAsync(IComputerVisionClient computerVision, string imageUrl)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                throw new Exception($"Invalid Remote Image Url: {imageUrl}");
            }

            return(_computerVision.AnalyzeImageAsync(imageUrl, _features));
        }
コード例 #20
0
        // Analyze a remote image
        private async Task analyzeFromUrlAsync(ComputerVisionClient computerVision, string imageUrl, List <VisualFeatureTypes> features)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                throw new Exception($"Invalid remote image url:{imageUrl}");
            }

            ImageAnalysis analysis = await computerVision.AnalyzeImageAsync(imageUrl, features);
        }
コード例 #21
0
        public async Task <ActionResult> Upload(HttpPostedFileBase file)
        {
            //确认用户选择了图像文件
            if (!file.ContentType.StartsWith("image"))
            {
                TempData["Message"] = "只有图像文件可以上传";
            }
            else
            {
                try
                {
                    //保存原文件在photos容器中
                    CloudStorageAccount account   = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
                    CloudBlobClient     client    = account.CreateCloudBlobClient();
                    CloudBlobContainer  container = client.GetContainerReference("photos");
                    CloudBlockBlob      photo     = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
                    await photo.UploadFromStreamAsync(file.InputStream);

                    //生成缩略图并保存在 "thumbnails" 容器中
                    using (var outputStream = new MemoryStream())
                    {
                        file.InputStream.Seek(0L, SeekOrigin.Begin);
                        var settings = new ResizeSettings {
                            MaxWidth = 192
                        };
                        ImageBuilder.Current.Build(file.InputStream, outputStream, settings);
                        outputStream.Seek(0L, SeekOrigin.Begin);
                        container = client.GetContainerReference("thumbnails");
                        CloudBlockBlob thumbnail = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
                        await thumbnail.UploadFromStreamAsync(outputStream);

                        //提交图像到azure 视觉服务api接口去分析
                        ComputerVisionClient vision = new ComputerVisionClient(
                            new ApiKeyServiceClientCredentials(ConfigurationManager.AppSettings["SubscriptionKey"]),
                            new System.Net.Http.DelegatingHandler[] { });
                        vision.Endpoint = ConfigurationManager.AppSettings["VisionEndpoint"];
                        VisualFeatureTypes[] features = new VisualFeatureTypes[] { VisualFeatureTypes.Description };
                        var result = await vision.AnalyzeImageAsync(photo.Uri.ToString(), features);

                        //在blob元数据中记录图像描述和标记
                        photo.Metadata.Add("Caption", result.Description.Captions[0].Text);
                        for (int i = 0; i < result.Description.Tags.Count; i++)
                        {
                            string key = string.Format("Tag{0}", i);
                            photo.Metadata.Add(key, result.Description.Tags[i]);
                        }
                        await photo.SetMetadataAsync();
                    }
                }
                catch (Exception ex)
                {
                    TempData["Message"] = ex.Message;
                }
            }
            return(RedirectToAction("Index"));
        }
コード例 #22
0
        public Task <ImageAnalysis> AnalyzeAsync(string imageUrl)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                throw new Exception($"Invalid remoteImageUrl: {imageUrl}");
            }
            var analysisResults = _computerVision.AnalyzeImageAsync(imageUrl, Features);

            return(analysisResults);
        }
コード例 #23
0
 private static async Task <ImageAnalysis> AnalyzeRemoteAsync(
     ComputerVisionClient computerVision, string imageUrl, ILogger log)
 {
     if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
     {
         log.LogInformation("\nInvalid remoteImageUrl:\n{0} \n", imageUrl);
         return(null);
     }
     return(await computerVision.AnalyzeImageAsync(imageUrl, features));
 }
コード例 #24
0
        private static async Task <ImageAnalysis> AnalyseRemoteImage(string imageUrl)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                Console.WriteLine(
                    "\nInvalid remoteImageUrl:\n{0} \n", imageUrl);
                return(null);
            }

            return(await _computerVision.AnalyzeImageAsync(imageUrl, _features));
        }
コード例 #25
0
        public async Task <ImageAnalysis> AnalyzeImageUrl(string imageUrl)
        {
            ComputerVisionClient client = await GetClient();

            List <VisualFeatureTypes> features = Enum.GetValues(typeof(VisualFeatureTypes)).Cast <VisualFeatureTypes>().ToList();
            List <Details>            details  = Enum.GetValues(typeof(Details)).Cast <Details>().ToList();

            ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, features, details);

            return(results);
        }
コード例 #26
0
        private static async Task AnalyzeRemoteAsync(ComputerVisionClient computerVision, string imageUrl)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                Console.WriteLine("\nInvalid file:\n{0} \n", imageUrl);
                return;
            }
            ImageAnalysis analysis = await computerVision.AnalyzeImageAsync(imageUrl, features);

            DisplayResults(analysis, imageUrl);
        }
        // Analyze a remote image
        public static async Task <ImageAnalysis> AnalyzeRemoteAsync(
            ComputerVisionClient computerVision, string imageUrl, IList <VisualFeatureTypes> features)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                Console.WriteLine(
                    "\nInvalid remoteImageUrl:\n{0} \n", imageUrl);
                throw new FileNotFoundException(imageUrl);
            }

            return(await computerVision.AnalyzeImageAsync(imageUrl, features));
        }
コード例 #28
0
        static async Task CheckForAdultContentAsync(ComputerVisionClient visionClient, string url)
        {
            List <VisualFeatureTypes> features = Enum.GetValues(typeof(VisualFeatureTypes)).OfType <VisualFeatureTypes>().ToList();

            Console.WriteLine($"Анализируемое изображение {Path.GetFileName(url)}");
            Console.WriteLine("---------------");
            ImageAnalysis analysis = await visionClient.AnalyzeImageAsync(url, features);

            Console.WriteLine("--------Запрещенное содержимое-----------");
            Console.WriteLine($"Изображение содержит контент для взрослых: {analysis.Adult.IsAdultContent} с достоверностью  {analysis.Adult.AdultScore}");
            Console.WriteLine($"Изображение содержит расистский контент: {analysis.Adult.IsRacyContent} с достоверностью {analysis.Adult.RacyScore}");
        }
コード例 #29
0
        // Analyze a remote image
        private async Task AnalyzeRemoteAsync(string imageUrl)
        {
            if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
            {
                MessageBox.Show("Invalid remoteImageUrl:\n{0}", imageUrl);
                return;
            }

            ImageAnalysis analysis = await computerVision.AnalyzeImageAsync(imageUrl, features);

            DisplayResults(analysis, imageUrl);
        }
コード例 #30
0
        static async Task GetTagsAsync(ComputerVisionClient visionClient, string url)
        {
            List <VisualFeatureTypes> features = Enum.GetValues(typeof(VisualFeatureTypes)).OfType <VisualFeatureTypes>().ToList();

            Console.WriteLine($"Анализируемое изображение {Path.GetFileName(url)}");
            Console.WriteLine("---------------");
            ImageAnalysis analysis = await visionClient.AnalyzeImageAsync(url, features);

            foreach (var tag in analysis.Tags)
            {
                Console.WriteLine($"{tag.Name} с достоверностью {tag.Confidence}");
            }
        }