/// <summary>
/// Analyzes the image to see if we have
/// something we're interested in.
/// </summary>
/// <param name="endPoint">The endpoint of our CustomVision project</param>
/// <param name="projectId">The <see cref="Guid"/>of the project</param>
/// <param name="publishedModelName">The name of the published model</param>
/// <param name="fileName">The raw image name we're analyzing</param>
public void DetectImageCharacteristics(
CustomVisionPredictionClient endPoint,
Guid projectId,
string publishedModelName,
string fileName)
{
Console.WriteLine("Making a prediction:");
// Generate the full path
var imageFile = Path.Combine("/home/pi/images/", $"{fileName}.jpg");
// Open the image stream for uploading
using (FileStream stream = File.OpenRead(imageFile))
{
// Call the API with the image stream
ImagePrediction result = endPoint.DetectImage(
projectId,
publishedModelName,
File.OpenRead(imageFile));
// Loop over each prediction and write out the results
foreach (PredictionModel c in result.Predictions)
{
Console.WriteLine(
$"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
}
static void Predict(string imageFile)
{
var settings = RetrieveSettings();
// Now there is a trained endpoint, it can be used to make a prediction
// Create a prediction endpoint, passing in the obtained prediction key
CustomVisionPredictionClient endpoint = new CustomVisionPredictionClient()
{
ApiKey = PredictionKey,
Endpoint = Endpoint
};
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
using (var stream = File.OpenRead(imageFile))
{
var result = endpoint.DetectImage(new Guid(settings["projectId"]), settings["modelName"], File.OpenRead(imageFile));
//Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
Console.ReadKey();
}
private Boolean DetectionTest(CustomVisionPredictionClient predictionApi)
{
Console.WriteLine("Making a prediction:");
String filename = "C:\\Users\\User\\Desktop\\TestRec\\Pic\\KinectCapture";
filename = filename + this.skeletonDetectedCount.ToString();
filename = filename + ".png";
using (var stream = File.OpenRead(filename))
{
System.Guid projectID = new Guid("22a12a4d-2c2d-49f7-a6c3-4ff7bee6b15b"); //เอาจากlinkของ Project ใน customvision.ai/projects/<ProjectID>#/manage
var result = predictionApi.DetectImage(projectID, "ObjDetection", stream);
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ Left:{c.BoundingBox.Left}, Top:{c.BoundingBox.Top}, Width:{c.BoundingBox.Width}, Height:{c.BoundingBox.Height} ]");
if (c.Probability > 0.5)
{
if (c.BoundingBox.Left < 0.35 || c.BoundingBox.Top < 0.1 || c.BoundingBox.Left > 0.61 || c.BoundingBox.Top > 0.4)
{
return(true);
}
}
}
return(false);
}
}
public Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.Models.ImagePrediction TestIteration(Guid guid, string content)
{
var imageDataByteArray = Convert.FromBase64String(content);
var imageDataStream = new MemoryStream(imageDataByteArray);
var result = predictionApi.DetectImage(guid, "PRY2020237-DEV", imageDataStream);
return(result);
}
// </snippet_publish>
// <snippet_prediction>
private void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
var imageFile = Path.Combine("Images", "test", "test_image.jpg");
using (var stream = File.OpenRead(imageFile))
{
var result = predictionApi.DetectImage(project.Id, publishedModelName, stream);
// Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
Console.ReadKey();
}
public static void MakePrediction(CustomVisionPredictionClient endpoint, Guid projectId, string publishedModelName)
{
Console.WriteLine("Making a prediction:");
var imageFile = "c:\\temp\\image.jpg";
//Path.Combine("Images", "test", "test_image.jpg");
using (var stream = File.OpenRead(imageFile))
{
var result = endpoint.DetectImage(projectId, publishedModelName, File.OpenRead(imageFile));
// Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine(
$"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
}
public Dictionary <string, double> Predict(string imageFile)
{
// This is published Iteration name
var publishedName = Settings.Default.PublishedPredictionName;
// Create a prediction endpoint, passing in the obtained prediction key
var endpoint = new CustomVisionPredictionClient()
{
ApiKey = PredictionKey,
Endpoint = CustomVisionEndpoint
};
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
var result = endpoint.DetectImage(CustomVisionProjectId, publishedName, File.OpenRead(imageFile));
return(CalculateRating(result.Predictions.ToList()));
//return result.Predictions.OrderByDescending(a => a.Probability).FirstOrDefault();
}
static void Main(string[] args)
{
// Add your training & prediction key from the settings page of the portal
string trainingKey = "<your training key here>";
string predictionKey = "<your prediction key here>";
// Create the Api, passing in the training key
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = SouthCentralUsEndpoint
};
// Find the object detection domain
var domains = trainingApi.GetDomains();
var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");
// Create a new project
Console.WriteLine("Creating new project:");
var project = trainingApi.CreateProject("My New Project", null, objDetectionDomain.Id);
// Make two tags in the new project
var forkTag = trainingApi.CreateTag(project.Id, "fork");
var scissorsTag = trainingApi.CreateTag(project.Id, "scissors");
Dictionary <string, double[]> fileToRegionMap = new Dictionary <string, double[]>()
{
// FileName, Left, Top, Width, Height
{ "scissors_1", new double[] { 0.4007353, 0.194068655, 0.259803921, 0.6617647 } },
{ "scissors_2", new double[] { 0.426470578, 0.185898721, 0.172794119, 0.5539216 } },
{ "scissors_3", new double[] { 0.289215684, 0.259428144, 0.403186262, 0.421568632 } },
{ "scissors_4", new double[] { 0.343137264, 0.105833367, 0.332107842, 0.8055556 } },
{ "scissors_5", new double[] { 0.3125, 0.09766343, 0.435049027, 0.71405226 } },
{ "scissors_6", new double[] { 0.379901975, 0.24308826, 0.32107842, 0.5718954 } },
{ "scissors_7", new double[] { 0.341911763, 0.20714055, 0.3137255, 0.6356209 } },
{ "scissors_8", new double[] { 0.231617644, 0.08459154, 0.504901946, 0.8480392 } },
{ "scissors_9", new double[] { 0.170343131, 0.332957536, 0.767156839, 0.403594762 } },
{ "scissors_10", new double[] { 0.204656869, 0.120539248, 0.5245098, 0.743464053 } },
{ "scissors_11", new double[] { 0.05514706, 0.159754932, 0.799019635, 0.730392158 } },
{ "scissors_12", new double[] { 0.265931368, 0.169558853, 0.5061275, 0.606209159 } },
{ "scissors_13", new double[] { 0.241421565, 0.184264734, 0.448529422, 0.6830065 } },
{ "scissors_14", new double[] { 0.05759804, 0.05027781, 0.75, 0.882352948 } },
{ "scissors_15", new double[] { 0.191176474, 0.169558853, 0.6936275, 0.6748366 } },
{ "scissors_16", new double[] { 0.1004902, 0.279036, 0.6911765, 0.477124184 } },
{ "scissors_17", new double[] { 0.2720588, 0.131977156, 0.4987745, 0.6911765 } },
{ "scissors_18", new double[] { 0.180147052, 0.112369314, 0.6262255, 0.6666667 } },
{ "scissors_19", new double[] { 0.333333343, 0.0274019931, 0.443627447, 0.852941155 } },
{ "scissors_20", new double[] { 0.158088237, 0.04047389, 0.6691176, 0.843137264 } },
{ "fork_1", new double[] { 0.145833328, 0.3509314, 0.5894608, 0.238562092 } },
{ "fork_2", new double[] { 0.294117659, 0.216944471, 0.534313738, 0.5980392 } },
{ "fork_3", new double[] { 0.09191177, 0.0682516545, 0.757352948, 0.6143791 } },
{ "fork_4", new double[] { 0.254901975, 0.185898721, 0.5232843, 0.594771266 } },
{ "fork_5", new double[] { 0.2365196, 0.128709182, 0.5845588, 0.71405226 } },
{ "fork_6", new double[] { 0.115196079, 0.133611143, 0.676470637, 0.6993464 } },
{ "fork_7", new double[] { 0.164215669, 0.31008172, 0.767156839, 0.410130739 } },
{ "fork_8", new double[] { 0.118872553, 0.318251669, 0.817401946, 0.225490168 } },
{ "fork_9", new double[] { 0.18259804, 0.2136765, 0.6335784, 0.643790841 } },
{ "fork_10", new double[] { 0.05269608, 0.282303959, 0.8088235, 0.452614367 } },
{ "fork_11", new double[] { 0.05759804, 0.0894935, 0.9007353, 0.3251634 } },
{ "fork_12", new double[] { 0.3345588, 0.07315363, 0.375, 0.9150327 } },
{ "fork_13", new double[] { 0.269607842, 0.194068655, 0.4093137, 0.6732026 } },
{ "fork_14", new double[] { 0.143382356, 0.218578458, 0.7977941, 0.295751631 } },
{ "fork_15", new double[] { 0.19240196, 0.0633497, 0.5710784, 0.8398692 } },
{ "fork_16", new double[] { 0.140931368, 0.480016381, 0.6838235, 0.240196079 } },
{ "fork_17", new double[] { 0.305147052, 0.2512582, 0.4791667, 0.5408496 } },
{ "fork_18", new double[] { 0.234068632, 0.445702642, 0.6127451, 0.344771236 } },
{ "fork_19", new double[] { 0.219362751, 0.141781077, 0.5919118, 0.6683006 } },
{ "fork_20", new double[] { 0.180147052, 0.239820287, 0.6887255, 0.235294119 } }
};
// Add all images for fork
var imagePath = Path.Combine("Images", "fork");
var imageFileEntries = new List <ImageFileCreateEntry>();
foreach (var fileName in Directory.EnumerateFiles(imagePath))
{
var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List <Region>(new Region[] { new Region(forkTag.Id, region[0], region[1], region[2], region[3]) })));
}
trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));
// Add all images for scissors
imagePath = Path.Combine("Images", "scissors");
imageFileEntries = new List <ImageFileCreateEntry>();
foreach (var fileName in Directory.EnumerateFiles(imagePath))
{
var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List <Region>(new Region[] { new Region(scissorsTag.Id, region[0], region[1], region[2], region[3]) })));
}
trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));
// Now there are images with tags start training the project
Console.WriteLine("\tTraining");
var iteration = trainingApi.TrainProject(project.Id);
// The returned iteration will be in progress, and can be queried periodically to see when it has completed
while (iteration.Status == "Training")
{
Thread.Sleep(1000);
// Re-query the iteration to get its updated status
iteration = trainingApi.GetIteration(project.Id, iteration.Id);
}
// The iteration is now trained. Publish it to the prediction end point.
var publishedModelName = "toolModel";
var predictionResourceId = "<target prediction resource ID>";
trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
Console.WriteLine("Done!\n");
// Now there is a trained endpoint, it can be used to make a prediction
// Create a prediction endpoint, passing in the obtained prediction key
CustomVisionPredictionClient endpoint = new CustomVisionPredictionClient()
{
ApiKey = predictionKey,
Endpoint = SouthCentralUsEndpoint
};
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
var imageFile = Path.Combine("Images", "test", "test_image.jpg");
using (var stream = File.OpenRead(imageFile))
{
var result = endpoint.DetectImage(project.Id, publishedModelName, File.OpenRead(imageFile));
// Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
// Get Configuration Settings
IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
IConfigurationRoot configuration = builder.Build();
string prediction_endpoint = configuration["PredictionEndpoint"];
string prediction_key = configuration["PredictionKey"];
Guid project_id = Guid.Parse(configuration["ProjectID"]);
string model_name = configuration["ModelName"];
// Authenticate a client for the prediction API
prediction_client = new CustomVisionPredictionClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials(prediction_key))
{
Endpoint = prediction_endpoint
};
// Load the image and prepare for drawing
String image_file = "produce.jpg";
Image image = Image.FromFile(image_file);
int h = image.Height;
int w = image.Width;
Graphics graphics = Graphics.FromImage(image);
Pen pen = new Pen(Color.Magenta, 3);
Font font = new Font("Arial", 16);
SolidBrush brush = new SolidBrush(Color.Black);
using (var image_data = File.OpenRead(image_file))
{
// Make a prediction against the new project
Console.WriteLine("Detecting objects in " + image_file);
var result = prediction_client.DetectImage(project_id, model_name, image_data);
// Loop over each prediction
foreach (var prediction in result.Predictions)
{
// Get each prediction with a probability > 50%
if (prediction.Probability > 0.5)
{
// The bounding box sizes are proportional - convert to absolute
int left = Convert.ToInt32(prediction.BoundingBox.Left * w);
int top = Convert.ToInt32(prediction.BoundingBox.Top * h);
int height = Convert.ToInt32(prediction.BoundingBox.Height * h);
int width = Convert.ToInt32(prediction.BoundingBox.Width * w);
// Draw the bounding box
Rectangle rect = new Rectangle(left, top, width, height);
graphics.DrawRectangle(pen, rect);
// Annotate with the predicted label
graphics.DrawString(prediction.TagName, font, brush, left, top);
}
}
}
// Save the annotated image
String output_file = "output.jpg";
image.Save(output_file);
Console.WriteLine("Results saved in " + output_file);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
private async void Button_Clicked(object sender, EventArgs e)
{
imageView.Source = "loading.gif";
scanButton.IsEnabled = false;
galleryButton.IsEnabled = false;
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await DisplayAlert("No Camera", ":( No camera available.", "OK");
imageView.Source = "image.jpg";
scanButton.IsEnabled = true;
galleryButton.IsEnabled = true;
return;
}
try
{
PredictionModel predictionModel = null;
ImagePrediction result = null;
var image = await CrossMedia.Current.TakePhotoAsync(new StoreCameraMediaOptions { PhotoSize = PhotoSize.Medium });
var imageStream = image.GetStream();
byte[] imageArray;
using (var memoryStream = new MemoryStream())
{
imageStream.CopyTo(memoryStream);
imageArray = memoryStream.ToArray();
}
await Task.Run(() =>
{
CustomVisionPredictionClient endpoint = new CustomVisionPredictionClient(new ApiKeyServiceClientCredentials(PredictionKey))
{
Endpoint = EndPoint
};
using (var mStream = new MemoryStream(imageArray))
result = endpoint.DetectImage(Guid.Parse(ProjectId), PublishedModelName, mStream);
double maxProb = result.Predictions.Select(x => x.Probability).Max();
if (maxProb < 0.45)
{
throw new Exception("No food detected");
}
predictionModel = result.Predictions.First(x => x.Probability == maxProb);
});
var model = GetViewModel(predictionModel.TagName);
model.DetectionProbability = predictionModel.Probability;
var boundedImageArray = await _objectDetector.DrawBoundingBox(imageArray, predictionModel.BoundingBox);
var imageSource = ImageSource.FromStream(() => new MemoryStream(boundedImageArray));
model.ImageSource = imageSource;
scanButton.IsEnabled = true;
galleryButton.IsEnabled = true;
imageView.Source = "image.jpg";
await Navigation.PushAsync(new FoodContent(model));
}
catch (Exception ex)
{
imageView.Source = "image.jpg";
await DisplayAlert("Error", ex.Message, "Done");
scanButton.IsEnabled = true;
galleryButton.IsEnabled = true;
}
}