async void AnalyzeImage(string imagePathOrUrl)
{
// this.ShowInfo ("Analyzing");
AnalysisResult analysisResult = null;
string resultStr = string.Empty;
try
{
if (File.Exists(imagePathOrUrl))
{
using (FileStream stream = File.Open(imagePathOrUrl, FileMode.Open))
{
analysisResult = this.visionClient.AnalyzeImageAsync(stream).Result;
Console.Write(analysisResult);
}
}
else if (Uri.IsWellFormedUriString(imagePathOrUrl, UriKind.Absolute))
{
analysisResult = visionClient.AnalyzeImageAsync(imagePathOrUrl, null).Result;
Console.Write(analysisResult);
}
else
{
// this.ShowError ("Invalid image path or Url");
}
}
catch (ClientException e)
{
if (e.Error != null)
{
Console.Write(e.Error.Message);
// this.ShowError (e.Error.Message);
}
else
{
Console.Write(e.Error.Message);
// this.ShowError (e.Message);
}
return;
}
catch (Exception)
{
// this.ShowError ("Some error happened.");
return;
}
Console.Write(analysisResult);
// this.ShowAnalysisResult (analysisResult);
}
protected async Task AnalyzeVisionAsync(Stream imageStream)
{
var visualFeatures = new List <VisualFeature>()
{
VisualFeature.Adult,
VisualFeature.Categories,
VisualFeature.Description,
VisualFeature.Tags,
VisualFeature.Color,
VisualFeature.ImageType,
};
var analysisResult = await visionServiceClient.AnalyzeImageAsync(imageStream, visualFeatures);
}
public async Task <Microsoft.ProjectOxford.Vision.Contract.AnalysisResult> AnalyzeVisionUsingHelper(Stream fileStream)
{
Microsoft.ProjectOxford.Vision.Contract.AnalysisResult adultResult = null;
try
{
adultResult = await visionDetector.AnalyzeImageAsync(fileStream, new VisualFeature[] { VisualFeature.Adult });
}
catch (Exception ex)
{
Debug.Write(ex.Message);
}
return(adultResult);
}
private async Task <AnalysisResult> identify_image_async(string path)
{
Debug.WriteLine("Start visio");
// The list of Visual Features to return
VisualFeature[] features = new VisualFeature[] { VisualFeature.Tags, VisualFeature.Description, VisualFeature.Adult, VisualFeature.Categories, VisualFeature.Color, VisualFeature.ImageType };
AnalysisResult ar = new AnalysisResult();
try {
// Read file
using (Stream stream = File.OpenRead(path)) {
ar = await vision_client.AnalyzeImageAsync(stream, features);
}
} catch { ar = null; }
return(ar);
}
/// <summary>
/// Function to get an image description based on a content URL for an image
/// </summary>
/// <param name="contentUrl">The URL for the image</param>
/// <returns>A string with image description, or "none" if it couldn't be found</returns>
private async Task <string> GetImageDescription(string contentUrl)
{
try
{
AnalysisResult imageAnalysisResult = await _visionClient.AnalyzeImageAsync(contentUrl, new List <VisualFeature>() { VisualFeature.Description });
if (imageAnalysisResult == null || imageAnalysisResult.Description?.Captions?.Length == 0)
{
return("none");
}
return(imageAnalysisResult.Description.Captions.First().Text);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return("none");
}
}
/// <summary>
/// Command to browse for an image, and analyze it
/// </summary>
/// <param name="obj"></param>
private async void BrowseAndAnalyze(object obj)
{
var openDialog = new Microsoft.Win32.OpenFileDialog();
openDialog.Filter = "JPEG Image(*.jpg)|*.jpg";
bool?result = openDialog.ShowDialog();
if (!(bool)result)
{
return;
}
string filePath = openDialog.FileName;
Uri fileUri = new Uri(filePath);
BitmapImage image = new BitmapImage(fileUri);
image.CacheOption = BitmapCacheOption.None;
image.UriSource = fileUri;
ImageSource = image;
try
{
using (Stream fileStream = File.OpenRead(filePath))
{
AnalysisResult analysisResult = await _visionClient.AnalyzeImageAsync(fileStream, SelectedFeatures);
if (analysisResult != null)
{
AnalysisResult = PrintAnalysisResult(analysisResult);
}
}
}
catch (ClientException ex)
{
Debug.WriteLine($"Failed to analyze image: {ex.Message}");
}
}
//upload and analyze picture
public async void uploadAndAnalyze(StorageFile picture)
{
ResultText.Text = "analysing.....";
try
{
IRandomAccessStream randomAccessStream = await picture.OpenReadAsync();
using (Stream stream = randomAccessStream.AsStreamForRead())
{
AnalysisResult analysisResult = await visionClient.AnalyzeImageAsync(stream,
new VisualFeature[] { VisualFeature.Faces, VisualFeature.Description });
setResultText(analysisResult);
faceDraw(analysisResult);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
ResultText.Text = "maybe no network connection";
}
}
public async Task <AnalysisResult> GetImageDescription(Stream stream)
{
VisualFeature[] features = { VisualFeature.Tags, VisualFeature.Categories, VisualFeature.Description };
return(await _visionClient.AnalyzeImageAsync(stream, features.ToList(), null));
}
private async Task <AnalysisResult> UploadAndGetTagsForUrl(string imageUrl)
{
return(await _visionServiceClient.AnalyzeImageAsync(imageUrl, null, null));
}
