public async void RegionManipulation()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "RegionManipulation", RecorderMode);
using (var project = CreateTrainedObjDetectionProject())
using (ICustomVisionTrainingClient client = BaseTests.GetTrainingClient())
{
var existingImage = (await client.GetTaggedImagesAsync(project.ProjectId)).First();
Assert.NotNull(existingImage);
var testTag = await client.CreateTagAsync(project.ProjectId, tagName);
var proposal = await client.GetImageRegionProposalsAsync(project.ProjectId, existingImage.Id);
Assert.True(proposal.Proposals.Count > 0);
Assert.Equal(project.ProjectId, proposal.ProjectId);
Assert.Equal(existingImage.Id, proposal.ImageId);
Assert.InRange(proposal.Proposals[0].Confidence, 0, 1);
var bbox = proposal.Proposals[0].BoundingBox;
List <ImageRegionCreateEntry> newRegions = new List <ImageRegionCreateEntry>();
newRegions.Add(new ImageRegionCreateEntry(existingImage.Id, testTag.Id, bbox.Left, bbox.Top, bbox.Width, bbox.Height));
var regions = await client.CreateImageRegionsAsync(project.ProjectId, new ImageRegionCreateBatch(newRegions));
Assert.Equal(1, regions.Created.Count);
Assert.Equal(0, regions.Duplicated.Count);
Assert.Equal(0, regions.Exceeded.Count);
Assert.Equal(bbox.Top, regions.Created[0].Top);
Assert.Equal(bbox.Left, regions.Created[0].Left);
Assert.Equal(bbox.Width, regions.Created[0].Width);
Assert.Equal(bbox.Height, regions.Created[0].Height);
Assert.Equal(existingImage.Id, regions.Created[0].ImageId);
Assert.Equal(testTag.Id, regions.Created[0].TagId);
Assert.NotEqual(Guid.Empty, regions.Created[0].RegionId);
var image = await client.GetImagesByIdsAsync(project.ProjectId, new List <Guid>(new Guid[] { existingImage.Id }));
Assert.Equal(1, image.Count);
Assert.Equal(2, image[0].Regions.Count);
await client.DeleteImageRegionsAsync(project.ProjectId, new List <Guid>(new Guid[] { regions.Created[0].RegionId }));
image = await client.GetImagesByIdsAsync(project.ProjectId, new List <Guid>(new Guid[] { existingImage.Id }));
Assert.Equal(1, image.Count);
Assert.Equal(1, image[0].Regions.Count);
await client.DeleteTagAsync(project.ProjectId, testTag.Id);
}
}
}
public void Dispose()
{
#if RECORD_MODE
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient(false);
foreach (var iter in client.GetIterations(this.ProjectId))
{
if (!string.IsNullOrEmpty(iter.PublishName))
{
client.UnpublishIteration(this.ProjectId, iter.Id);
}
}
client.DeleteProject(this.ProjectId);
#endif
}
public async void GetUntaggedImages()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "GetUntaggedImages", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
var images = await client.GetUntaggedImagesAsync(project.ProjectId);
Assert.Equal(0, images.Count);
}
}
}
public async void TrainAndPublishProject()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "TrainAndPublishProject", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
// Remove the last trained iteration so we can retrain
var iterationToDelete = client.GetIteration(project.ProjectId, project.IterationId);
var originalPublishName = iterationToDelete.PublishName;
await client.UnpublishIterationAsync(project.ProjectId, iterationToDelete.Id);
await client.DeleteIterationAsync(project.ProjectId, iterationToDelete.Id);
// Need to ensure we wait 1 second between training calls from the previous project.Or
// We get 429s.
Thread.Sleep(1000);
var trainedIteration = await client.TrainProjectAsync(project.ProjectId);
Assert.NotEqual(iterationToDelete.Name, trainedIteration.Name);
Assert.NotEqual(iterationToDelete.Id, trainedIteration.Id);
Assert.NotEqual(Guid.Empty, trainedIteration.Id);
Assert.True("Staging" == trainedIteration.Status || "Training" == trainedIteration.Status);
Assert.False(trainedIteration.Exportable);
Assert.Null(trainedIteration.PublishName);
// Wait for training to complete.
while (trainedIteration.Status != "Completed")
{
Thread.Sleep(1000);
trainedIteration = client.GetIteration(project.ProjectId, trainedIteration.Id);
}
// Verify we can republish using same name
Assert.True(client.PublishIteration(project.ProjectId, trainedIteration.Id, originalPublishName, BaseTests.PredictionResourceId));
project.IterationId = trainedIteration.Id;
}
}
}
public async void QuerySuggestedImages()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "QuerySuggestedImages", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
using (ICustomVisionTrainingClient client = BaseTests.GetTrainingClient())
{
// Add an untagged image we expect to be classified as tag1
var images = new ImageFileCreateEntry[] {
new ImageFileCreateEntry("suggest_ic.jpg", File.ReadAllBytes(Path.Combine("TestImages", "suggest_ic.jpg")))
};
var imageResult = await client.CreateImagesFromFilesAsync(project.ProjectId, new ImageFileCreateBatch(images));
Assert.True(imageResult.IsBatchSuccessful);
Assert.Equal(1, imageResult.Images.Count);
// Ask for suggestions
var suggestions = client.SuggestTagsAndRegions(project.ProjectId, project.IterationId, new Guid[] { imageResult.Images[0].Image.Id });
// Validate result
Assert.Equal(1, suggestions.Count);
// Get tags and build a query
var tags = await client.GetTagsAsync(project.ProjectId, project.IterationId);
var query = new SuggestedTagAndRegionQueryToken()
{
MaxCount = 10,
TagIds = tags.Select(t => t.Id).ToList(),
Threshold = 0
};
// This will return all suggested images (1 in this case)
var suggestedImages = await client.QuerySuggestedImagesAsync(project.ProjectId, project.IterationId, query);
Assert.Equal(1, suggestedImages.Results.Count);
}
}
}
public async void SuggestTagAndRegions()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "SuggestTagAndRegions", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
using (ICustomVisionTrainingClient client = BaseTests.GetTrainingClient())
{
// Add an untagged image we expect to be classified as tag1
var images = new ImageFileCreateEntry[] {
new ImageFileCreateEntry("suggest_ic.jpg", File.ReadAllBytes(Path.Combine("TestImages", "suggest_ic.jpg")))
};
var imageResult = await client.CreateImagesFromFilesAsync(project.ProjectId, new ImageFileCreateBatch(images));
Assert.True(imageResult.IsBatchSuccessful);
Assert.Equal(1, imageResult.Images.Count);
// Ask for suggestions
var suggestions = client.SuggestTagsAndRegions(project.ProjectId, project.IterationId, new Guid[] { imageResult.Images[0].Image.Id });
// Validate result
Assert.Equal(1, suggestions.Count);
Assert.Equal(project.ProjectId, suggestions[0].Project);
Assert.Equal(project.IterationId, suggestions[0].Iteration);
Assert.NotEqual(0, suggestions[0].Predictions.Count);
foreach (var prediction in suggestions[0].Predictions)
{
var tag = await client.GetTagAsync(project.ProjectId, prediction.TagId, project.IterationId);
Assert.Equal(tag.Name, prediction.TagName);
Assert.Equal(tag.Id, prediction.TagId);
Assert.InRange(prediction.Probability, 0, 1);
}
// We expect Tag1 to have the highest probability
Assert.Equal("Tag1", suggestions[0].Predictions.OrderByDescending(p => p.Probability).First().TagName);
}
}
}
public async void GetIterations()
{
var updatedName = "New Iteration Name";
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "GetIterations", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
var iterations = await client.GetIterationsAsync(project.ProjectId);
Assert.Equal(1, iterations.Count);
Assert.NotEmpty(iterations[0].Name);
Assert.NotEqual(Guid.Empty, iterations[0].DomainId);
Assert.NotEqual(Guid.Empty, iterations[0].Id);
Assert.Equal(project.ProjectId, iterations[0].ProjectId);
Assert.Equal("Completed", iterations[0].Status);
Assert.False(iterations[0].Exportable);
var iteration = await client.GetIterationAsync(project.ProjectId, iterations[0].Id);
Assert.Equal(iteration.Name, iterations[0].Name);
Assert.Equal(iteration.Id, iterations[0].Id);
Assert.Equal(TrainingType.Regular, iteration.TrainingType);
Assert.Equal(0, iteration.ReservedBudgetInHours);
Assert.NotEmpty(iteration.PublishName);
Assert.Equal(1, iteration.TrainingTimeInMinutes);
Assert.Equal(BaseTests.PredictionResourceId, iteration.OriginalPublishResourceId);
var updatedIteration = await client.UpdateIterationAsync(project.ProjectId, iteration.Id, new Iteration()
{
Name = updatedName
});
Assert.Equal(updatedName, updatedIteration.Name);
}
}
}
public async void DeletePrediction()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "DeletePrediction", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
var token = new PredictionQueryToken()
{
OrderBy = "Newest",
};
var result = client.QueryPredictionsAsync(project.ProjectId, token).Result;
Assert.NotEqual(0, result.Results.Count);
await client.DeletePredictionAsync(project.ProjectId, new Guid[] { result.Results[result.Results.Count - 1].Id });
}
}
}
public async void CreateImagesFromPredictions()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "CreateImagesFromPredictions", RecorderMode);
using (var project = CreateTrainedImageClassificationProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
string imageUrl = "https://raw.githubusercontent.com/Microsoft/Cognitive-CustomVision-Windows/master/Samples/Images/Test/test_image.jpg";
var predictionResult = await client.QuickTestImageUrlAsync(project.ProjectId, new ImageUrl(imageUrl), project.IterationId);
var i = new ImageIdCreateEntry[] { new ImageIdCreateEntry(predictionResult.Id) };
var result = await client.CreateImagesFromPredictionsAsync(project.ProjectId, new ImageIdCreateBatch(i));
Assert.Equal(1, result.Images.Count);
Assert.NotEmpty(result.Images[0].SourceUrl);
}
}
}
public async void DeleteImages()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "DeleteImages", RecorderMode);
using (ICustomVisionTrainingClient client = BaseTests.GetTrainingClient())
{
var projectId = (await client.CreateProjectAsync(projName)).Id;
string imageUrl = "https://raw.githubusercontent.com/Microsoft/Cognitive-CustomVision-Windows/master/Samples/Images/Test/test_image.jpg";
var urlImages = new ImageUrlCreateEntry[] { new ImageUrlCreateEntry(imageUrl) };
var result = client.CreateImagesFromUrlsAsync(projectId, new ImageUrlCreateBatch(urlImages)).Result;
Assert.True(result.IsBatchSuccessful);
Assert.Equal(1, result.Images.Count);
await client.DeleteImagesAsync(projectId, new Guid[] { result.Images[0].Image.Id });
await client.DeleteProjectAsync(projectId);
}
}
}
public async void DownloadRegions()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "DownloadRegions", RecorderMode);
using (var project = CreateTrainedObjDetectionProject())
{
ICustomVisionTrainingClient client = BaseTests.GetTrainingClient();
var images = await client.GetTaggedImagesAsync(project.ProjectId);
foreach (var img in images)
{
Assert.NotNull(img.Regions);
Assert.Equal(1, img.Regions.Count);
Assert.InRange(img.Regions[0].Left, 0, 1);
Assert.InRange(img.Regions[0].Top, 0, 1);
Assert.InRange(img.Regions[0].Width, 0, 1);
Assert.InRange(img.Regions[0].Height, 0, 1);
}
}
}
}
