/// <summary> /// Uploads the image to Project Oxford and performs analysis /// </summary> /// <param name="imageFilePath">The image file path.</param> /// <returns></returns> private async Task <AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- // // Create Project Oxford Vision API Service client // VisionServiceClient VisionServiceClient = new VisionServiceClient(SubscriptionKey, "https://westcentralus.api.cognitive.microsoft.com/vision/v1.0"); Log("VisionServiceClient is created"); using (Stream imageFileStream = File.OpenRead(imageFilePath)) { // // Analyze the image for all visual features // Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); return(analysisResult); } // ----------------------------------------------------------------------- // KEY SAMPLE CODE ENDS HERE // ----------------------------------------------------------------------- }
public static async Task <(bool allowd, string message, string[] tags)> PassesImageModerationAsync(Stream image, KeyVault kvService, TraceWriter log) { try { log.Info("--- Creating VisionApi client and analyzing image"); var key = await GetSecret("MicrosoftVisionApiKey", kvService); var endpoint = await GetSecret("MicrosoftVisionApiEndpoint", kvService); var numTags = await GetSecret("MicrosoftVisionNumTags", kvService); var client = new VisionServiceClient(key, endpoint); var features = new VisualFeature[] { VisualFeature.Description }; var result = await client.AnalyzeImageAsync(image, features); log.Info($"--- Image analyzed with tags: {String.Join(",", result.Description.Tags)}"); if (!int.TryParse(numTags, out var tagsToFetch)) { tagsToFetch = 5; } var fetchedTags = result?.Description?.Tags.Take(tagsToFetch).ToArray() ?? new string[0]; bool isAllowed = fetchedTags.Contains("dog"); string message = result?.Description?.Captions.FirstOrDefault()?.Text; return(isAllowed, message, fetchedTags); } catch (Exception ex) { log.Info("Vision API error! " + ex.Message); return(false, "error " + ex.Message, new string[0]); } }
/// <summary> /// Sends a url to Project Oxford and performs analysis /// </summary> /// <param name="imageUrl">The url of the image to analyze</param> /// <returns></returns> private async Task <AnalysisResult> AnalyzeUrl(string imageUrl) { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- // // Create Project Oxford Vision API Service client // VisionServiceClient VisionServiceClient = new VisionServiceClient(SubscriptionKey); Log("VisionServiceClient is created"); // // Analyze the url for all visual features // Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures); return(analysisResult); // ----------------------------------------------------------------------- // KEY SAMPLE CODE ENDS HERE // ----------------------------------------------------------------------- }
private async Task AnalyzeImage(StorageFile imageFile) { resultText.Text = "Analyzing..."; try { VisionServiceClient visionServiceClient = new VisionServiceClient(""); using (var stream = await imageFile.OpenStreamForReadAsync()) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await visionServiceClient.AnalyzeImageAsync(stream, visualFeatures); resultText.Text = string.Join("\n", analysisResult.Tags.OrderByDescending(x => x.Confidence).Select(x => $"{x.Name} ({x.Confidence:F})")); } } catch (Exception ex) { resultText.Text = $"Failed: {ex.Message}"; } }
public async Task<string> AnalyzeUrl(string imageUrl) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await this.visionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures); return await TranslateText(analysisResult.Description.Captions.First().Text); }
public async Task <VisionResult> Analyze(Stream stream) { var client = new VisionServiceClient(Constants.VisionApiKey, Constants.VisionApiEndpoint); var attributes = new List <VisionAttribute>(); var rectangles = new List <Rectangle>(); using (stream) { var features = new VisualFeature[] { VisualFeature.Tags, VisualFeature.Faces }; var visionsResult = await client.AnalyzeImageAsync(stream, features, null); if (visionsResult != null && visionsResult?.Tags.Length > 0) { if (visionsResult.Faces != null) { foreach (var face in visionsResult.Faces) { rectangles.Add(face.FaceRectangle.ToRectangle()); } } foreach (var tag in visionsResult.Tags) { attributes.Add(new VisionAttribute(tag.Name, tag.Hint, tag.Confidence)); } } } return(new VisionResult { Attributes = attributes, Rectangles = rectangles }); }
private async Task <AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { // // Create Project Oxford Vision API Service client // Speak("Ok, I am analysing your photo!"); VisionServiceClient VisionServiceClient = new VisionServiceClient("---------"); Debug.WriteLine("VisionServiceClient is created"); StorageFile file = await StorageFile.GetFileFromPathAsync(imageFilePath); using (Stream imageFileStream = (await file.OpenReadAsync()).AsStreamForRead()) { // Analyze the image for all visual features Debug.WriteLine("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); Debug.WriteLine(analysisResult); return(analysisResult); } }
public static AnalysisResult AnalyzeImage(Bitmap sourceImage) { VisionServiceClient VisionServiceClient = ComputerVisionService.GetClient(); using (MemoryStream memoryStream = new MemoryStream()) { sourceImage.SaveAsPng(memoryStream); memoryStream.Position = 0; Console.WriteLine("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Color, VisualFeature.Description, VisualFeature.ImageType }; try { AnalysisResult analysisResult = VisionServiceClient.AnalyzeImageAsync(memoryStream, visualFeatures).GetAwaiter().GetResult(); return(analysisResult); } catch (Microsoft.ProjectOxford.Vision.ClientException exception) { Console.WriteLine(exception.Error.Message); Console.WriteLine(exception.Error.Code); throw exception; } } }
private void openFileDialog1_FileOk(object sender, CancelEventArgs e) { try { pictureBox1.ImageLocation = openFileDialog1.FileName; var file = System.IO.File.OpenRead(openFileDialog1.FileName); // Refer to this blog for all the preceding steps and more info: // https://devonblog.com/software-development/artificial-intelligence/censor-pictures-using-ai-from-computer-vision-api/ // TODO: you have to use your own KEY here. var client = new VisionServiceClient("ye2f5cb4ee15341ba8f7c4f0d90ff542c", "https://southeastasia.api.cognitive.microsoft.com/vision/v1.0"); var visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; var analysisResult = client.AnalyzeImageAsync(file, visualFeatures, new[] { "celebrities" }); analysisResult.Wait(); var result = analysisResult.Result; // check out these extension methods on AnalysisResultExtension class var resultText = $@"Adult/racy content: {result.IsAdultOrRacyContent()} Clear human face found: {result.HasAFace()} Is there a child: {!result.IsYoungerThan(14)}, Celebrity: {result.DetectCelebrity()}"; label1.Text = resultText; } catch (AggregateException ex) { MessageBox.Show(ex.InnerException.Message + " Make sure you are using a valid API KEY "); } }
private static async Task <AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- // // Create Project Oxford Computer Vision API Service client // VisionServiceClient VisionServiceClient = new VisionServiceClient(ComKey); Log("VisionServiceClient is created"); using (Stream imageFileStream = File.OpenRead(imageFilePath)) { // // Analyze the image for all visual features // Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); return(analysisResult); } // ----------------------------------------------------------------------- // KEY SAMPLE CODE ENDS HERE // ----------------------------------------------------------------------- }
/// <summary> /// Uploads the image to Project Oxford and performs analysis /// </summary> /// <param name="imageFilePath">The image file path.</param> /// <returns></returns> private async Task<AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- // // Create Project Oxford Vision API Service client // VisionServiceClient VisionServiceClient = new VisionServiceClient(SubscriptionKey); Log("VisionServiceClient is created"); using (Stream imageFileStream = File.OpenRead(imageFilePath)) { // // Analyze the image for all visual features // Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); return analysisResult; } // ----------------------------------------------------------------------- // KEY SAMPLE CODE ENDS HERE // ----------------------------------------------------------------------- }
private static void AnalyzeImage() { var apiKey = ConfigurationManager.AppSettings["VisionApiSubscriptionKey"]; var apiRoot = "https://eastus2.api.cognitive.microsoft.com/vision/v1.0"; var visionClient = new VisionServiceClient(apiKey, apiRoot); var visualFeats = new VisualFeature[] { VisualFeature.Description, VisualFeature.Faces }; Stream imageStream = File.OpenRead("satyaNadella.jpg"); try { AnalysisResult analysisResult = visionClient.AnalyzeImageAsync(imageStream, visualFeats).Result; foreach (var caption in analysisResult.Description.Captions) { Console.WriteLine("Description: " + caption.Text); } } catch (ClientException e) { Console.WriteLine("Vision client error: " + e.Error.Message); } catch (Exception e) { Console.WriteLine("Error: " + e.Message); } }
public async Task <ActionResult> Upload(HttpPostedFileBase file) { if (file != null && file.ContentLength > 0) { // Make sure the user selected an image file if (!file.ContentType.StartsWith("image")) { TempData["Message"] = "Only image files may be uploaded"; } else { // Save the original image in the "photos" container string photoContainer = CloudConfigurationManager.GetSetting("storage:photocontainer"); string thumbContainer = CloudConfigurationManager.GetSetting("storage:thumbnailcontainer"); CloudBlobClient client = _account.CreateCloudBlobClient(); CloudBlobContainer container = client.GetContainerReference(photoContainer); CloudBlockBlob photo = container.GetBlockBlobReference(Path.GetFileName(file.FileName)); photo.Properties.ContentType = file.ContentType; await photo.UploadFromStreamAsync(file.InputStream); await photo.SetPropertiesAsync(); file.InputStream.Seek(0L, SeekOrigin.Begin); // Generate a thumbnail and save it in the "thumbnails" container using (var outputStream = new MemoryStream()) { var settings = new ResizeSettings { MaxWidth = 192, Format = "png" }; ImageBuilder.Current.Build(file.InputStream, outputStream, settings); outputStream.Seek(0L, SeekOrigin.Begin); container = client.GetContainerReference(thumbContainer); CloudBlockBlob thumbnail = container.GetBlockBlobReference(Path.GetFileName(file.FileName)); await thumbnail.UploadFromStreamAsync(outputStream); } // Submit the image to Azure's Computer Vision API VisionServiceClient vision = new VisionServiceClient(CloudConfigurationManager.GetSetting("vision:key"), CloudConfigurationManager.GetSetting("vision:rootUrl")); VisualFeature[] features = new VisualFeature[] { VisualFeature.Description }; var result = await vision.AnalyzeImageAsync(photo.Uri.ToString(), features); // Record the image description and tags in blob metadata photo.Metadata.Add("Caption", result.Description.Captions[0].Text); for (int i = 0; i < result.Description.Tags.Length; i++) { string key = $"Tag{i}"; photo.Metadata.Add(key, result.Description.Tags[i]); } await photo.SetMetadataAsync(); } } // redirect back to the index action to show the form once again return(RedirectToAction("Details", "Pictures", new { name = file?.FileName })); }
public async Task <AnalysisResult> AnalyzeImageAsync(string imageString) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Categories, VisualFeature.Tags }; AnalysisResult response = await _visionServiceClient.AnalyzeImageAsync(imageString, visualFeatures); return(response); }
private async Task <AnalysisResult> AnalyzeUrl(string imageUrl) { Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures); return(analysisResult); }
public static async Task <string> AnalyzeAsync(byte[] image) { var visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; var vision = new Microsoft.ProjectOxford.Vision.VisionServiceClient(SubscriptionKeys.ComputerVisionId, "https://westeurope.api.cognitive.microsoft.com/vision/v1.0"); var result = await vision.AnalyzeImageAsync(new MemoryStream(image) { Position = 0 }, visualFeatures); return(result.Description.Captions.OrderBy(c => c.Confidence).Select(c => c.Text).FirstOrDefault()); }
public static async Task <AnalysisResult> DescribeImage(string url) { var client = new VisionServiceClient("<Project Oxford Subscription key here>"); var features = new VisualFeature[] { VisualFeature.Color, VisualFeature.Description }; var result = await client.AnalyzeImageAsync(url, features); return(result); }
public async Task <string> RecognizeImageFromStream(Stream stream) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult x = await VisionServiceClient.AnalyzeImageAsync(stream, visualFeatures); var result = LogAnalysisResult(x); return(result); }
private async Task <AnalysisResult> AnalyzeUrl(string imageUrl) { VisionServiceClient VisionServiceClient = new VisionServiceClient("SUA_CHAVE2_AQUI", "https://westcentralus.api.cognitive.microsoft.com/vision/v1.0"); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures); return(analysisResult); }
public static void CallCognitiveService(string imagePath) { var features = new VisualFeature[] { VisualFeature.Tags, VisualFeature.Description }; using (var fs = new FileStream(@"C:\Vision\Sample.jpg", FileMode.Open)) { //analysisResult = await visionClient.AnalyzeImageAsync(fs, features); // } }
private async void _TakePhoto() { Debug.WriteLine("Taking Photo"); try { photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync(PHOTO_FILE_NAME, CreationCollisionOption.ReplaceExisting); var imageProperties = ImageEncodingProperties.CreateJpeg(); await mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile); var photoStream = await photoFile.OpenReadAsync(); var bitmap = new BitmapImage(); bitmap.SetSource(photoStream); captureImage.Source = bitmap; using (Stream imageFileStream = (await photoFile.OpenReadAsync()).AsStreamForRead()) { // Analyze the image for all visual features Debug.WriteLine("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; // add your API key in here VisionServiceClient VisionServiceClient = new VisionServiceClient(""); analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); Debug.WriteLine("photo: " + analysisResult.Description.Captions[0].Text + " , " + analysisResult.Description.Captions[0].Confidence); if (analysisResult.Description.Captions[0].Confidence > 0.6d) { Speak("I see, " + analysisResult.Description.Captions[0].Text); } else { Speak("I'm not quite sure but it could be, " + analysisResult.Description.Captions[0].Text); } } } catch (Exception ex) { Debug.WriteLine(ex.Message); } finally { isProcessing = false; } }
public override void Run() { Trace.WriteLine("Starting processing of messages"); // Initiates the message pump and callback is invoked for each message that is received, calling close on the client will stop the pump. Client.OnMessage((receivedMessage) => { try { // Process the message Trace.WriteLine("Processing Service Bus message: " + receivedMessage.SequenceNumber.ToString()); var stream = receivedMessage.GetBody <Stream>(); var bytes = ReadFully(stream); var uri = Encoding.UTF8.GetString(bytes); AnalysisResult analysisResult; var features = new VisualFeature[] { VisualFeature.Tags, VisualFeature.Description }; var visionClient = new VisionServiceClient("<-- ADD API KEY -->", "https://southcentralus.api.cognitive.microsoft.com/vision/v1.0"); analysisResult = visionClient.AnalyzeImageAsync(uri, features).Result; // // Speak a string. bool isCat = false; foreach (var caption in analysisResult.Description.Captions) { if (caption.Text.Contains("cat")) { isCat = true; } } foreach (var tag in analysisResult.Description.Tags) { if (tag.Contains("cat")) { isCat = true; } } var tableStorageService = new TableStorageService(); tableStorageService.InsertResult(uri, isCat); Console.WriteLine("Is Cat: " + isCat.ToString()); Console.Read(); } catch { // Handle any message processing specific exceptions here } }); CompletedEvent.WaitOne(); }
private async Task <AnalysisResult> UploadAndAnalyzeImage(StorageFile imageFile) { var stream = await imageFile.OpenStreamForReadAsync(); Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(stream, visualFeatures); return(analysisResult); }
public async Task <IActionResult> Upload(IFormFile file) { if (file != null && file.Length > 0) { if (!file.ContentType.StartsWith("image")) { TempData["Message"] = "Only image files may be uploaded."; } else { var client = _account.CreateCloudBlobClient(); var container = client.GetContainerReference("photos"); var photo = container.GetBlockBlobReference(Path.GetFileName(file.FileName)); await photo.UploadFromStreamAsync(file.OpenReadStream()); file.OpenReadStream().Seek(0L, SeekOrigin.Begin); using (var outputStream = new MemoryStream()) { Configuration.Default.AddImageFormat(new PngFormat()); using (var image = Image.Load(file.OpenReadStream())) { image.Resize(new Size { Width = 252, Height = 252 }).SaveAsPng(outputStream); container = client.GetContainerReference("thumbnails"); var thumbnail = container.GetBlockBlobReference(Path.GetFileName(file.FileName)); outputStream.Seek(0L, SeekOrigin.Begin); await thumbnail.UploadFromStreamAsync(outputStream); } } var features = new VisualFeature[] { VisualFeature.Description }; var result = await _vision.AnalyzeImageAsync(photo.Uri.ToString(), features); photo.Metadata.Add("Caption", result.Description.Captions.First().Text); for (int i = 0; i < result.Description.Tags.Length; i++) { var key = $"tag{i}"; photo.Metadata.Add(key, result.Description.Tags[i]); } await photo.SetMetadataAsync(); } } else { TempData["Message"] = "Not uploaded! The file is empty :c"; } return(RedirectToAction(nameof(Index))); }
public async Task <string> getcaption(String url) { VisionServiceClient vision = new VisionServiceClient("****************************************"); VisualFeature[] visual = new VisualFeature[] { VisualFeature.Description }; AnalysisResult analysis = await vision.AnalyzeImageAsync(url, visual); string message = analysis?.Description?.Captions.FirstOrDefault()?.Text; return(message); }
private async Task MakeAnalysisRequest() { var features = new VisualFeature[] { VisualFeature.Description }; var details = new string[] { "Celebrities" }; var visionClient = new VisionServiceClient(subscriptionKey, uriBase); var analysisResult = await visionClient.AnalyzeImageAsync(ImageUrl, features, details); Detail = analysisResult.Categories[0].Detail.ToString(); Caption = analysisResult?.Description?.Captions[0]?.Text; Confidence = analysisResult?.Description?.Captions[0]?.Confidence; }
/// <summary> /// Get information from cognitive services /// </summary> /// //private Stream stream = new MemoryStream(); private async Task <AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { // // Create Project Oxford Vision API Service client // try { VisionServiceClient VisionServiceClient = new VisionServiceClient("5cd43034665d42bb912d04a946ac6512"); Debug.WriteLine("VisionServiceClient is created"); status.Text = "VisionServiceClient is created"; StorageFile file = await StorageFile.GetFileFromPathAsync(imageFilePath); using (Stream imageFileStream = (await file.OpenReadAsync()).AsStreamForRead()) { // Analyze the image for all visual features Debug.WriteLine("Calling VisionServiceClient.AnalyzeImageAsync()..."); status.Text = "Calling VisionServiceClient.AnalyzeImageAsync()..."; VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); Debug.WriteLine(analysisResult); status.Text = "Image analyzed!"; return(analysisResult); } } catch (Exception ex) { Debug.WriteLine(ex.Message); return(null); } }
private static async Task AnalyzeImage(string apiKey, string apiUrl, string imageUrl) { var vsc = new VisionServiceClient(apiKey, apiUrl); var visualFeatures = new VisualFeature[] { VisualFeature.Description, VisualFeature.Tags }; var analysisResult = await vsc.AnalyzeImageAsync(imageUrl, visualFeatures); ShowAnalysisResult(analysisResult); }
// Microsoft Vision API function public static async Task <AnalysisResult> UploadAndAnalyzeImage(string imageFilePath) { await Task.Delay(1000); VisionServiceClient VisionServiceClient = new VisionServiceClient("1b1fde153ba546dbbc6676d168854b1e", "https://westcentralus.api.cognitive.microsoft.com/vision/v1.0"); using (Stream imageFileStream = File.OpenRead(imageFilePath)) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); return(analysisResult); } }
private async Task <AnalysisResult> CheckImage(string photoUrl) { AnalysisResult analysisResult; VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; analysisResult = await visionClient.AnalyzeImageAsync(photoUrl, visualFeatures); if (analysisResult == null) { throw new Exception("Can't detect image"); } return(analysisResult); }
async void SelectFile() { Picker_Hide(); try { if (Picker_SelectedFile != null) { txtFileName.Text = Picker_SelectedFile.Path; var stream = await Picker_SelectedFile.OpenAsync(Windows.Storage.FileAccessMode.Read); var stream_send = stream.CloneStream(); var image = new BitmapImage(); image.SetSource(stream); imgPhoto.Source = image; size_image = new Size(image.PixelWidth, image.PixelHeight); ringLoading.IsActive = true; //Vision Service VisionServiceClient client = new VisionServiceClient(key); var feature = new VisualFeature[] { VisualFeature.Tags, VisualFeature.Faces, VisualFeature.Description, VisualFeature.Adult, VisualFeature.Categories }; var result = await client.AnalyzeImageAsync(stream_send.AsStream(), feature); thisresult = result; if (result != null) { DisplayData(result); } //hide preview if (stpPreview.Visibility == Visibility.Collapsed) { stpPreview.Visibility = Visibility.Visible; btnShow.Content = "Hide Preview"; } else { stpPreview.Visibility = Visibility.Collapsed; btnShow.Content = "Show Preview"; } ringLoading.IsActive = false; } } catch (Exception ex) { //lblError.Text = ex.Message; //lblError.Visibility = Visibility.Visible; } }
/// <summary> /// Sends a url to Project Oxford and performs analysis /// </summary> /// <param name="imageUrl">The url of the image to analyze</param> /// <returns></returns> private async Task<AnalysisResult> AnalyzeUrl(string imageUrl) { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- // // Create Project Oxford Vision API Service client // VisionServiceClient VisionServiceClient = new VisionServiceClient(SubscriptionKey); Log("VisionServiceClient is created"); // // Analyze the url for all visual features // Log("Calling VisionServiceClient.AnalyzeImageAsync()..."); VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await VisionServiceClient.AnalyzeImageAsync(imageUrl, visualFeatures); return analysisResult; // ----------------------------------------------------------------------- // KEY SAMPLE CODE ENDS HERE // ----------------------------------------------------------------------- }
private async Task<AnalysisResult> UploadAndAnalyzeImage(Stream imageStream) { var visionServiceClient = new VisionServiceClient(Constants.CuomputerVisionApiKey); var assembley = this.GetType().GetTypeInfo().Assembly; using (Stream imageFileStream = imageStream) { VisualFeature[] visualFeatures = new VisualFeature[] { VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.Description, VisualFeature.Faces, VisualFeature.ImageType, VisualFeature.Tags }; AnalysisResult analysisResult = await visionServiceClient.AnalyzeImageAsync(imageFileStream, visualFeatures); return analysisResult; } }