public async Task <DetectLabelsResponse> GetImageLabels(DetectLabelsRequest request)
{
DetectLabelsResponse response = await _Client.DetectLabelsAsync(request);
if (response.HttpStatusCode.Equals(HttpStatusCode.OK) && response.Labels.Count > 0)
{
return(response);
}
return(null);
}
static async Task <string> ReadTextFromStreamAWS(byte[] byteData)
{
try
{
using (var imageCient = new AmazonRekognitionClient())
{
var stream = new MemoryStream(byteData);
//if using .NET Core, make sure to use await keyword and async method
var detectResponses = await imageCient.DetectLabelsAsync(new DetectLabelsRequest
{
MinConfidence = 75,
Image = new Image
{
Bytes = stream
}
});
var contentString = new List <string>();
foreach (var item in detectResponses.Labels)
{
contentString.Add(item.Name);
}
var json = JsonConvert.SerializeObject(contentString);
return(json);
}
}
catch (Exception e)
{
return(e.Message);
}
}
/// <summary>
/// A simple function that takes an image name as an input and returns whether it's abc or not?
/// </summary>
/// <param name="input">name of the image we want to detect</param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> FunctionHandler(string input, ILambdaContext context)
{
var rekognitionClient = new AmazonRekognitionClient();
var response = await rekognitionClient.DetectLabelsAsync(
new DetectLabelsRequest
{
Image = new Image
{
S3Object = new S3Object
{
Bucket = "somebucket",
Name = input //the name of the image we are detecting
}
}
});
//iterate through all the labels for the real-world object detected
foreach (var label in response.Labels)
{
if (label.Confidence > 50) //here if confidence is more than 50, we make the call that it's the image we are looking for
{
if (label.Name == "Fried Chicken" || label.Name == "Nuggets")
{
return(true);
}
}
}
return(false);
}
public async Task <DetectLabelsResponse> RecognizeImage(string fileName)
{
Image image = new Image();
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
byte[] data = null;
data = new byte[fs.Length];
fs.Read(data, 0, (int)fs.Length);
image.Bytes = new MemoryStream(data);
}
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
{
Image = image,
MaxLabels = 10,
MinConfidence = 77F
};
DetectLabelsResponse detectLabelsResponse = await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
return(detectLabelsResponse);
}
public async Task <List <string> > LabelImage(byte[] imgBytes)
{
List <string> lstLabels = new List <string>();
try
{
MemoryStream memStream = new MemoryStream(imgBytes);
DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
{
Image = new Image {
Bytes = memStream
},
MaxLabels = _maxLabels,
MinConfidence = _minConfidence
};
DetectLabelsResponse response = await client.DetectLabelsAsync(detectlabelsRequest);
foreach (Label label in response.Labels)
{
lstLabels.Add(label.Name);
}
}
catch (Exception ex)
{
_logger.Error("Error getting info from AWS", ex);
return(null);
}
return(lstLabels);
}
private async Task <string> DetectObjects(MemoryStream memoryStream, AmazonRekognitionClient client, ILambdaContext context)
{
List <string> responseText = new List <string>();
string detectedResponse = "";
isDetectFace = false;
try
{
var detectResponses = await client.DetectLabelsAsync(new DetectLabelsRequest
{
MinConfidence = 80,
Image = new Image
{
Bytes = memoryStream
},
MaxLabels = 10
});
if (detectResponses != null && detectResponses.HttpStatusCode == HttpStatusCode.OK && detectResponses.Labels.Count > 0)
{
foreach (var item in detectResponses.Labels)
{
if (item.Name.Contains("Human") || item.Name.Contains("People") || item.Name.Contains("Person"))
{
isDetectFace = true;
}
else
{
responseText.Add(item.Name);
}
}
if (responseText.Count > 0)
{
detectedResponse = "you are seeing " + string.Join(", ", responseText.ToArray());
if (isDetectFace)
{
detectedResponse = detectedResponse + " you also have people around you.";
}
}
else if (responseText.Count == 0 && isDetectFace)
{
detectedResponse = " you have people around you.";
}
else
{
detectedResponse = "No objects Detected";
}
}
else
{
detectedResponse = "No objects Detected";
}
}
catch (Exception ex)
{
context.Logger.LogLine(ex.Message);
detectedResponse = "No objects Detected";
}
return(detectedResponse);
}
/// <summary>
/// A function for responding to S3 create events. It will determine if the object is an image and use Amazon Rekognition
/// to detect labels and add the labels as tags on the S3 object.
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <ObservableCollection <string> > FunctionHandler(string input, ILambdaContext context)
{
ObservableCollection <String> listTest = new ObservableCollection <String>();
var rekognitionClient = new AmazonRekognitionClient();
var detectResponse = await rekognitionClient.DetectLabelsAsync(
new DetectLabelsRequest
{
Image = new Image
{
S3Object = new Amazon.Rekognition.Model.S3Object
{
Bucket = "cloudgangbucket",
Name = input
}
}
}
);
foreach (var label in detectResponse.Labels)
{
listTest.Add(label.Name + ": " + label.Confidence + "%");
}
return(listTest);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> FunctionHandler(string fileName, ILambdaContext context)
{
var accesKey = "";
var secretKey = "";
var rekognitionClient = new AmazonRekognitionClient(accesKey, secretKey, Amazon.RegionEndpoint.USWest2);
var detectResponses = await rekognitionClient.DetectLabelsAsync(new DetectLabelsRequest
{
MinConfidence = 30,
Image = new Image
{
S3Object = new Amazon.Rekognition.Model.S3Object
{
Bucket = "schnitzelornot",
Name = fileName
}
}
});
foreach (var label in detectResponses.Labels)
{
if (label.Name == "Fried Chicken" || label.Name == "Nuggets")
{
return(true);
}
}
return(false);;
}
// For Image analysis
public List <Label> DetectLabels(MemoryStream stream, string target, out string message)
{
string outMessage = "";
var minConfidence = 70;//float.Parse(Console.ReadLine());
Stopwatch watch = new Stopwatch();
watch.Start();
var response = _client.DetectLabelsAsync(new DetectLabelsRequest
{
MinConfidence = minConfidence,
MaxLabels = 100,
Image = new Image
{
Bytes = stream
}
}).Result;
watch.Stop();
foreach (var label in response.Labels)
{
//Console.WriteLine($"{label.Name} {label.Confidence} %");
if (label.Name.ToLower() == target.ToLower())
{
outMessage = "The Object '" + target.ToUpper() + "' in your watchlist has been found in live stream with '" + Convert.ToInt32(label.Confidence) + "%' confidence.";
}
}
message = outMessage;
LogResponse(GetIndentedJson(response), "DetectLabels");
return(response.Labels);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> FunctionHandler(string input, ILambdaContext context)
{
var reckognitionClient = new AmazonRekognitionClient();
var detectResponse = await reckognitionClient.DetectLabelsAsync(
new DetectLabelsRequest
{
Image = new Image
{
S3Object = new S3Object
{
Bucket = "rekogniton1907154",
Name = input
}
}
}
);
foreach (var label in detectResponse.Labels)
{
if (label.Confidence > 50)
{
if (label.Name == "Fried Chicken" || label.Name == "Nuggets")
{
return(true);
}
}
}
return(false);
}
public async Task ExecuteAsync()
{
var keyName = "TestIMage.png";
var client = new AmazonRekognitionClient(RegionEndpoint.USEast1);
var labelsRequest = new DetectLabelsRequest
{
Image = new Image
{
S3Object = new S3Object()
{
Name = keyName,
Bucket = "rawimagestc1983"
}
},
MaxLabels = 10,
MinConfidence = 75f
};
var moderationRequest = new DetectModerationLabelsRequest
{
Image = new Image
{
S3Object = new S3Object()
{
Name = keyName,
Bucket = "rawimagestc1983"
}
},
MinConfidence = 60f
};
var labelsResponse = await client.DetectLabelsAsync(labelsRequest);
var inappropriateResponse = await client.DetectModerationLabelsAsync(moderationRequest);
Console.WriteLine("Detected Labels for Image");
Console.WriteLine();
foreach (Label label in labelsResponse.Labels)
{
Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
Console.WriteLine();
foreach (ModerationLabel label in inappropriateResponse.ModerationLabels)
{
Console.WriteLine("Label: {0}\n Confidence: {1}\n Parent: {2}",
label.Name, label.Confidence, label.ParentName);
}
}
public async Task Handler(S3Event s3Event)
{
// Level 1: Make this output when a file is uploaded to S3
LambdaLogger.Log("Hello from The AutoMaTweeter!");
// Level 2: Get the bucket name and key from event data and log to cloudwatch
var bucketName = s3Event.Records[0].S3.Bucket.Name;
var keyName = s3Event.Records[0].S3.Object.Key;
LambdaLogger.Log($"The AutoMaTweeter found a file path: {bucketName}/{keyName}");
var file1 = await RetrieveBinaryPayload(bucketName, keyName);
// Boss Level: Use Amazon Rekognition to get keywords about the image
IEnumerable <string> labels = Enumerable.Empty <string>();
using (var client = new AmazonRekognitionClient())
{
var request = new DetectLabelsRequest();
request.Image = new Image();
request.Image.Bytes = new MemoryStream(file1);
var response = await client.DetectLabelsAsync(request);
labels = response.Labels.Select(x => x.Name);
}
// Level 3: Post the image and message to twitter
var consumerKey = "GCNunS5DfXGwh8rvFAterxmXP";
var consumerSecret = "fq03tBiAIAM7pB6DjRI8S69scCFiR3FibCbjz3HWfjEOPMLSQD";
var accessToken = "842206967632338944-XMAH3FU86RSak57FVJmglXn4HAvNmpy";
var accessTokenSecret = "fiFvNoEASqyqWo3FuFr5JKBYyWlILihVLlGCTSxfqAtlv";
Auth.SetUserCredentials(consumerKey, consumerSecret, accessToken, accessTokenSecret);
var media = Upload.UploadImage(file1);
var message = "Team1: " + string.Join(" ", labels);
if (message.Length > 140)
{
message = message.Substring(0, 139);
}
var tweet = Tweet.PublishTweet(message, new PublishTweetOptionalParameters
{
Medias = new List <IMedia> {
media
}
});
}
private async Task <object> GetImageLabels(string fileName, AmazonRekognitionClient rekognitionClient)
{
var detectResponses = await rekognitionClient.DetectLabelsAsync(new DetectLabelsRequest
{
MinConfidence = 50,
Image = new Image
{
S3Object = new Amazon.Rekognition.Model.S3Object
{
Bucket = bucketName,
Name = fileName
}
}
});
return(detectResponses.Labels);
}
public async Task <IEnumerable <Rectangle> > ExtractCarsAsync()
{
if (_objectsResponse == null)
{
var objectsRequest = new DetectLabelsRequest()
{
Image = _rekognitionImage
};
_objectsResponse = await _client.DetectLabelsAsync(objectsRequest);
}
return(ExtractCars());
}
// snippet-start:[Rekognition.dotnetv3.DetectLabelsLocalFile]
public static async Task Main()
{
string photo = "input.jpg";
var image = new Amazon.Rekognition.Model.Image();
try
{
using var fs = new FileStream(photo, FileMode.Open, FileAccess.Read);
byte[] data = null;
data = new byte[fs.Length];
fs.Read(data, 0, (int)fs.Length);
image.Bytes = new MemoryStream(data);
}
catch (Exception)
{
Console.WriteLine("Failed to load file " + photo);
return;
}
var rekognitionClient = new AmazonRekognitionClient();
var detectlabelsRequest = new DetectLabelsRequest
{
Image = image,
MaxLabels = 10,
MinConfidence = 77F,
};
try
{
DetectLabelsResponse detectLabelsResponse = await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
Console.WriteLine($"Detected labels for {photo}");
foreach (Label label in detectLabelsResponse.Labels)
{
Console.WriteLine($"{label.Name}: {label.Confidence}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
// Uses the Amazon Rekognition service to detect labels within an image.
public async Task <List <WorkItem> > DetectLabels(string bucketName, string photo)
{
var rekognitionClient = new AmazonRekognitionClient(RegionEndpoint.USWest2);
var labelList = new List <WorkItem>();
var detectlabelsRequest = new DetectLabelsRequest
{
Image = new Image()
{
S3Object = new Amazon.Rekognition.Model.S3Object()
{
Name = photo,
Bucket = bucketName,
},
},
MaxLabels = 10,
MinConfidence = 75F,
};
try
{
DetectLabelsResponse detectLabelsResponse = await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
Console.WriteLine("Detected labels for " + photo);
WorkItem workItem;
foreach (Label label in detectLabelsResponse.Labels)
{
workItem = new WorkItem();
workItem.Key = photo;
workItem.Confidence = label.Confidence.ToString();
workItem.Name = label.Name;
labelList.Add(workItem);
}
return(labelList);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(null);
}
public async Task <DetectLabelsResponse> DetectLabels(DetectLabelParams dlp)
{
var detectlabelsRequest = new DetectLabelsRequest()
{
Image = new Image()
{
Bytes = new MemoryStream(),
S3Object = new S3Object()
{
Bucket = dlp.BucketName,
Name = dlp.PhotoName,
Version = dlp.PhotoVersion
}
},
MinConfidence = dlp.MinConfidence,
MaxLabels = dlp.MaxLabels
};
Task <DetectLabelsResponse> detectLabelsResponse = null;
try
{
using (AmazonRekognitionClient recognitionClient = new AmazonRekognitionClient())
{
detectLabelsResponse = recognitionClient.DetectLabelsAsync(detectlabelsRequest);
}
Console.WriteLine("Detected labels for " + dlp.PhotoName);
foreach (Label label in detectLabelsResponse.Result.Labels)
{
Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(await detectLabelsResponse ?? throw new Exception("response is null"));
}
public static async Task Detect()
{
//Get picture from local storage
var photo = "img/sheep.png";
var image = new Image();
try
{
await using var fs = new FileStream(photo, FileMode.Open, FileAccess.Read);
var data = new byte[fs.Length];
fs.Read(data, 0, (int)fs.Length);
image.Bytes = new MemoryStream(data);
}
catch (Exception)
{
Console.WriteLine("Failed to load file " + photo);
return;
}
var rekognitionClient = new AmazonRekognitionClient();
//Set settings for label detection
var detectlabelsRequest = new DetectLabelsRequest
{
Image = image,
MaxLabels = 3,
MinConfidence = 77F
};
var detectLabelsResponse = await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
Console.WriteLine("Detected labels for " + photo);
foreach (var label in detectLabelsResponse.Labels)
{
Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
}
// snippet-start:[Rekognition.dotnetv3.DetectLabelsExample]
public static async Task Main()
{
string photo = "del_river_02092020_01.jpg"; // "input.jpg";
string bucket = "igsmiths3photos"; // "bucket";
var rekognitionClient = new AmazonRekognitionClient();
var detectlabelsRequest = new DetectLabelsRequest
{
Image = new Image()
{
S3Object = new S3Object()
{
Name = photo,
Bucket = bucket,
},
},
MaxLabels = 10,
MinConfidence = 75F,
};
try
{
DetectLabelsResponse detectLabelsResponse = await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
Console.WriteLine("Detected labels for " + photo);
foreach (Label label in detectLabelsResponse.Labels)
{
Console.WriteLine($"Name: {label.Name} Confidence: {label.Confidence}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task <DetectLabelsResponse> DetectAsync(MemoryStream data)
{
try
{
var image = new Image()
{
Bytes = data
};
detectlabelsRequest = new DetectLabelsRequest()
{
Image = image,
MaxLabels = 10,
MinConfidence = 77F
};
return(await rekognitionClient.DetectLabelsAsync(detectlabelsRequest));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(new DetectLabelsResponse());
}
}
public static void Example()
{
const string photo = "recognition/BM.jpg";
const string bucket = "bhavesh-aws-bucket";
var rekognitionClient = new AmazonRekognitionClient(RegionEndpoint.APSouth1);
var detectlabelsRequest = new DetectLabelsRequest()
{
Image = new Image()
{
S3Object = new S3Object()
{
Name = photo,
Bucket = bucket
},
},
MaxLabels = 10,
MinConfidence = 75F
};
try
{
var detectLabels = rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
var detectLabelsResponse = detectLabels.Result;
Console.WriteLine("Detected labels for " + photo);
foreach (Label label in detectLabelsResponse.Labels)
{
Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
//[Route("[action]")]
//public async Task<ActionResult<FileVM>> PostImage(FileVM UploadedImage)
public async Task <IActionResult> PostImage(FileVM UploadedImage)
{
byte[] bytes = Convert.FromBase64String(UploadedImage.FileAsBase64);
var credentials = new BasicAWSCredentials("AKIAYFOXPUFXRIBLXF4O", "kt30oEKBt35RZRxXD6rLRd2uxITL0aYX24qFXnox");
var config = new AmazonS3Config
{
RegionEndpoint = Amazon.RegionEndpoint.USEast1
};
var image = new Image();
using (var client = new AmazonS3Client(credentials, config))
{
using (var newMemoryStream = new MemoryStream(bytes))
{
//file.CopyTo(newMemoryStream);
var uploadRequest = new TransferUtilityUploadRequest
{
InputStream = newMemoryStream,
Key = UploadedImage.FileName,
BucketName = "quickquoteitem",
CannedACL = S3CannedACL.PublicRead
};
var fileTransferUtility = new TransferUtility(client);
try
{
await fileTransferUtility.UploadAsync(uploadRequest);
}
catch (Exception err)
{
throw err;
}
}
}
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(credentials, Amazon.RegionEndpoint.USEast1);
DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
{
Image = new Image()
{
S3Object = new S3Object()
{
Name = UploadedImage.FileName,
Bucket = "quickquoteitem"
},
},
MaxLabels = 10,
MinConfidence = 75F
};
try
{
var Labels = new List <LabelVM>();
DetectLabelsResponse detectLabelsResponse =
await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
//Console.WriteLine("Detected labels for " + photo);
foreach (Label label in detectLabelsResponse.Labels)
{
var item = new LabelVM();
item.LabelName = label.Name;
item.LabelConfidence = label.Confidence.ToString();
Labels.Add(item);
}
return(Ok(Labels));
//Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//return CreatedAtAction("GetQuote", new { id = quote.QuoteID }, quote);
return(Ok());
}
private static async Task Main(string[] args)
{
const string AWS_ACCESS_KEY_ID = "AWS_ACCESS_KEY_ID";
const string AWS_SECRET_ACCESS_KEY = "AWS_SECRET_ACCESS_KEY";
Console.WriteLine("Hello World!");
var self = await File.ReadAllBytesAsync("assets\\self.jpg");
var front = await File.ReadAllBytesAsync("assets\\front.png");
var back = await File.ReadAllBytesAsync("assets\\back.png");
var command = new AnalizeDocumentCommand {
Self = self, Back = back, Front = front
};
var region = RegionEndpoint.USEast1;
var client = new AmazonRekognitionClient(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, region);
#region Analiza se é documento
using (var stream = new MemoryStream(command.Back))
{
var request = new DetectLabelsRequest {
Image = new Image {
Bytes = stream
}
};
var response = await client.DetectLabelsAsync(request);
var labels = response.Labels;
foreach (var label in labels)
{
var accuracy = Accuracy.GetAccuracy(label.Confidence);
if (DocumentTypes.IsValidDocument(label.Name))
{
if (accuracy.IsLow)
{
Console.WriteLine("Não é um documento");
}
if (accuracy.IsMedium)
{
Console.WriteLine("Pode ser que seja um documento");
}
if (accuracy.IsHigh)
{
Console.WriteLine("É muito provável que seja um documento");
}
break;
}
}
}
#endregion
#region Compara com a self
using (var source = new MemoryStream(command.Self))
using (var target = new MemoryStream(command.Front))
{
var request = new CompareFacesRequest {
SourceImage = new Image {
Bytes = source
}, TargetImage = new Image {
Bytes = target
}
};
var response = await client.CompareFacesAsync(request);
var faces = response.FaceMatches;
if (faces.Count != 1)
{
Console.WriteLine("Resultado inconsistente");
}
var accuracy = Accuracy.GetAccuracy(faces.First().Similarity);
if (accuracy.IsLow)
{
Console.WriteLine("Esse documento não da mesma pessoa");
}
if (accuracy.IsMedium)
{
Console.WriteLine("Pode ser que este documento seja da mesma pessoa");
}
if (accuracy.IsHigh)
{
Console.WriteLine("É muito provável que este documento seja da mesma pessoa");
}
}
#endregion
#region Verifica se é do portador válido
using (var stream = new MemoryStream(command.Back))
{
var request = new DetectTextRequest {
Image = new Image {
Bytes = stream
}
};
var response = await client.DetectTextAsync(request);
var texts = response.TextDetections;
foreach (var text in texts)
{
var accuracy = Accuracy.GetAccuracy(text.Confidence);
if ("CPF".Equals(text.DetectedText, StringComparison.InvariantCultureIgnoreCase))
{
if (accuracy.IsLow)
{
Console.WriteLine("não contém um número de CPF");
}
if (accuracy.IsMedium)
{
Console.WriteLine("Pode ser que contenha um número de CPF");
}
if (accuracy.IsHigh)
{
Console.WriteLine("É muito provável que contenha um número de CPF");
}
break;
}
}
}
#endregion
Console.WriteLine("That's all folks!");
}
public ClassificationResult GetResult(string inputImageLocation, string pictureName)
{
Amazon.Rekognition.Model.Image image = new Amazon.Rekognition.Model.Image();
// Load image
try
{
using (FileStream fs = new FileStream(inputImageLocation, FileMode.Open, FileAccess.Read))
{
byte[] data = null;
data = new byte[fs.Length];
fs.Read(data, 0, (int)fs.Length);
image.Bytes = new MemoryStream(data);
}
}
catch (Exception e)
{
throw new Exception("Error during loading image file AWS.", e);
}
// Create client
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
// Create detectLabelsRequest
DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
{
Image = image,
MaxLabels = Constants.maxLabelsReturned,
};
ClassificationResult classificationResult = new ClassificationResult()
{
APIName = "AWS"
};
try
{
var startTime = DateTime.Now;
var detectLabelsResponse = rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
detectLabelsResponse.Wait();
var endTime = DateTime.Now;
var labels = new List <string>();
var scores = new List <float>();
foreach (var label in detectLabelsResponse.Result.Labels)
{
if (!string.IsNullOrEmpty(label.Name) && label.Confidence != 0)
{
labels.Add(label.Name);
scores.Add(label.Confidence);
}
else
{
throw new Exception("Exception during AWS processing of image " + inputImageLocation);
}
}
classificationResult.ProcessingTimeMilliseconds = endTime.Subtract(startTime).TotalMilliseconds;
classificationResult.InputLabel = pictureName;
classificationResult.ReturnedLabel1 = labels[0];
classificationResult.ReturnedConfidence1 = scores[0];
classificationResult.ReturnedLabel2 = labels[1];
classificationResult.ReturnedConfidence2 = scores[1];
classificationResult.ReturnedLabel3 = labels[2];
classificationResult.ReturnedConfidence3 = scores[2];
classificationResult.FilePath = inputImageLocation;
}
catch (Exception e)
{
throw e;
}
return(classificationResult);
}
