public void TestAddAndRemoveMultipleImages()
        {
            var image1 = GraphicUtils.GetImageByDimensions(100, 100);
            var image2 = GraphicUtils.GetImageByDimensions(200, 200);

            var category1     = new CategoryManager().GetOrCreate(18, "Small Car");
            var observations1 = new Observation[]
            {
                new Observation(category1, 0.9, new SKRect(image1.Width / 5, image1.Height / 4, image1.Width / 3, image1.Height / 2)),
                new Observation(category1, 0.9, new SKRect(image1.Width / 6, image1.Height / 7, image1.Width * 2 / 3, image1.Height * 3 / 4))
            };

            var category2     = new CategoryManager().GetOrCreate(19, "Large Boat");
            var observations2 = new[]
            {
                new Observation(category2, 0.9, new SKRect(image2.Width / 5, image2.Height / 4, image2.Width / 3, image2.Height / 2))
            };

            const string name1         = "Image1.jpg";
            const string name2         = "Image2.jpg";
            var          creationTime1 = DateTime.UtcNow;
            var          creationTime2 = DateTime.UtcNow;

            var imageDao1 = DatabaseService.InsertOrUpdate(new ImageEntry(image1, name1, creationTime1, null, observations1));
            var imageDao2 = DatabaseService.InsertOrUpdate(new ImageEntry(image2, name2, creationTime2, null, observations2));

            DatabaseService.DeleteImage(imageDao1.Id);

            Assert.IsNull(DatabaseService.GetImage(imageDao1.Id));

            CollectionAssert.AreEqual(imageDao2.Observations, DatabaseUtils.GetAllObservations().ToList());
        }
Example #2
0
        public void TestFromImage_DimensionsNotDivisibleByDefault(int width, int height)
        {
            var image = GraphicUtils.GetImageByDimensions(width, height);
            var chips = Chip.FromImage(image).ToList();

            var numWidth  = width / SharedConstants.DefaultChipWidth + 1;
            var numHeight = height / SharedConstants.DefaultChipHeight + 1;

            for (var i = 0; i < numWidth; i++)
            {
                var subWidth = i + 1 < numWidth
                    ? SharedConstants.DefaultChipWidth
                    : width % SharedConstants.DefaultChipWidth;

                for (var j = 0; j < numHeight; j++)
                {
                    var subHeight = j + 1 < numHeight
                        ? SharedConstants.DefaultChipHeight
                        : height % SharedConstants.DefaultChipHeight;

                    var left           = i * SharedConstants.DefaultChipWidth;
                    var top            = j * SharedConstants.DefaultChipHeight;
                    var expectedRegion = new SKRectI(left, top, left + subWidth, top + subHeight);
                    var expectedPixels = GraphicUtils.GetPixelsByDimensions(subWidth, subHeight);
                    Assert.AreEqual(expectedRegion, chips[i * numHeight + j].Region);
                    Assert.AreEqual(expectedPixels, chips[i * numHeight + j].Pixels);
                }
            }
        }
Example #3
0
        public void TestFromImage_DimensionsLessThanDefault(int width, int height)
        {
            var image = GraphicUtils.GetImageByDimensions(width, height);
            var chips = Chip.FromImage(image).ToList();

            Assert.AreEqual(1, chips.Count);

            var expectedRegion = new SKRectI(0, 0, width, height);
            var expectedPixels = GraphicUtils.GetPixelsByDimensions(width, height);

            Assert.AreEqual(expectedRegion, chips[0].Region);
            Assert.AreEqual(expectedPixels, chips[0].Pixels);
        }
        public void TestAddImage()
        {
            var          image        = GraphicUtils.GetImageByDimensions(100, 100);
            var          category     = new CategoryManager().GetOrCreate(18, "Small Car");
            const string name         = "Image.jpg";
            var          creationTime = DateTime.UtcNow;
            var          observations = new Observation[]
            {
                new Observation(category, 0.9, new SKRect(image.Width / 5, image.Height / 4, image.Width / 3, image.Height / 2)),
                new Observation(category, 0.9, new SKRect(image.Width / 6, image.Height / 7, image.Width * 2 / 3, image.Height * 3 / 4))
            };

            var addedImageDao     = DatabaseService.InsertOrUpdate(new ImageEntry(image, name, creationTime, null, observations));
            var retrievedImageDao = DatabaseService.GetImage(addedImageDao.Id);

            Assert.AreEqual(addedImageDao, retrievedImageDao);
        }
        public void TestRemoveImage()
        {
            var          image        = GraphicUtils.GetImageByDimensions(100, 100);
            var          category     = new CategoryManager().GetOrCreate(18, "Small Car");
            const string name         = "Image.jpg";
            var          creationTime = DateTime.UtcNow;
            var          observations = new Observation[]
            {
                new Observation(category, 0.9, new SKRect(image.Width / 5, image.Height / 4, image.Width / 3, image.Height / 2)),
                new Observation(category, 0.9, new SKRect(image.Width / 6, image.Height / 7, image.Width * 2 / 3, image.Height * 3 / 4))
            };

            var imageDaoToDelete = DatabaseService.InsertOrUpdate(new ImageEntry(image, name, creationTime, null, observations));

            DatabaseService.DeleteImage(imageDaoToDelete.Id);

            Assert.IsNull(DatabaseService.GetImage(imageDaoToDelete.Id));
            Assert.IsEmpty(DatabaseUtils.GetAllObservations());
        }
        private (ImageDAO, string) GenerateJsonsExamples()
        {
            var observations = new List <Observation>()
            {
                new Observation(_manager.GetOrCreate(0, "Car"), 0.5, new SKRect(0.1f, 0.2f, 0.7f, 0.8f)),
                new Observation(_manager.GetOrCreate(1, "Bat Mobile"), 0.7, new SKRect(0.1f, 0.2f, 0.7f, 0.8f)),
            };

            const string name         = "Image.jpg";
            var          creationTime = DateTime.UtcNow;
            var          testImg      =
                GraphicUtils.GetImageByDimensions(SharedConstants.DefaultChipWidth, SharedConstants.DefaultChipHeight);
            var imageDao = new ImageDAO(testImg, name, creationTime);

            foreach (var ob in observations)
            {
                imageDao.Add(new ObservationDAO(imageDao, ob));
            }

            return(imageDao, JSONService.ConvertToJson(imageDao));
        }
Example #7
0
        public void TestFromImage_DimensionsDivisibleByDefault(int widthMultiplier, int heightMultiplier)
        {
            var image = GraphicUtils.GetImageByDimensions(widthMultiplier * SharedConstants.DefaultChipWidth,
                                                          heightMultiplier * SharedConstants.DefaultChipHeight);
            var chips = Chip.FromImage(image).ToList();

            Assert.AreEqual(widthMultiplier * heightMultiplier, chips.Count);

            for (var i = 0; i < widthMultiplier; i++)
            {
                for (var j = 0; j < heightMultiplier; j++)
                {
                    var left           = i * SharedConstants.DefaultChipWidth;
                    var top            = j * SharedConstants.DefaultChipHeight;
                    var expectedRegion = new SKRectI(left, top, left + SharedConstants.DefaultChipWidth,
                                                     top + SharedConstants.DefaultChipHeight);
                    var expectedPixels = GraphicUtils.GetPixelsByDimensions(SharedConstants.DefaultChipWidth,
                                                                            SharedConstants.DefaultChipHeight);
                    Assert.AreEqual(expectedRegion, chips[i * heightMultiplier + j].Region);
                    Assert.AreEqual(expectedPixels, chips[i * heightMultiplier + j].Pixels);
                }
            }
        }