Ejemplo n.º 1
0
 /// <summary>
 /// Two cells overlap if their bounding rectangle overlap by more than 50% of their area.
 /// </summary>
 /// <param name="rectangle1">The bounding rectangle of the first cell</param>
 /// <param name="rectangle2">The bounding rectangle of the second cell</param>
 /// <returns>Returns true if either rectangle overlaps the other by more than 50% of its surface.</returns>
 protected override bool Overlap(Rectangle rectangle1, Rectangle rectangle2)
 {
     // The rationale is that we want to provide a rectangular view over
     // cells of various shape, that might be embedded in a same square.
     Decimal overlapArea = rectangle1.Overlap(rectangle2);
     return Math.Max((overlapArea / rectangle1.Area()), (overlapArea / rectangle2.Area())) >= (decimal)0.5;
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Determines the area change from the first rectangle to the second.
        /// </summary>
        /// <param name="r1">The first rectangle.</param>
        /// <param name="r2">The second rectangle.</param>
        /// <returns>A percentage indicating area change.</returns>
        public static decimal AreaChangeAsPercent(Rectangle r1, Rectangle r2)
        {
            var minWidth = Math.Min(r1.Width, r2.Width);
            var minHeight = Math.Min(r1.Height, r2.Height);
            var maxWidth = Math.Max(r1.Width, r2.Width);
            var maxHeight = Math.Max(r1.Height, r2.Height);
            var startingArea = r1.Area();

            long areaDelta = 0;
            if (r1.Width != r2.Width) areaDelta += ((maxWidth - minWidth) * minHeight);
            if (r1.Height != r2.Height) areaDelta += ((maxHeight - minHeight) * minWidth);
            if ((r1.Height > r2.Height && r1.Width > r2.Width) ||
                (r2.Height > r1.Height && r2.Width > r1.Width)) areaDelta += ((maxHeight - minHeight) * (maxWidth - minWidth));

            return areaDelta == 0 ? 0 : ((decimal)areaDelta / startingArea) * 100;
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Check whether a region in an image matches an expected color.
        /// Does a simplistic average on each color channel and includes and inbuilt tolerance parameter.
        /// A repeating pattern can fool this test.
        /// </summary>
        /// <example>
        /// ImageAssert.ImageRegionIsColor(new Rectangle(10, 20, 100, 200), Color.FromArgb(41, 42, 31), actualImage, 1.0);
        /// </example>
        /// <param name="region">The rectangle within the image to test.</param>
        /// <param name="expectedColor">The single color you expect the region to have</param>
        /// <param name="actualImage">The image to test</param>
        /// <param name="tolerance">The tolerance allowed for each color channel</param>
        public static void ImageRegionIsColor(this Assert assert, System.Drawing.Rectangle region, System.Drawing.Color expectedColor, Bitmap actualImage, double tolerance = 0.0)
        {
            var width = region.Width;
            var area  = region.Area();

            var red     = new int[area];
            var green   = new int[area];
            var blue    = new int[area];
            var indices = new HashSet <int>();

            for (var x = region.Left; x < region.Right; x++)
            {
                for (var y = region.Top; y < region.Bottom; y++)
                {
                    var color = actualImage.GetPixel(x, y);

                    var i      = x - region.Left;
                    var j      = y - region.Top;
                    var index0 = (i * region.Height) + j;
                    if (indices.Contains(index0))
                    {
                        Debugger.Break();
                    }

                    indices.Add(index0);
                    red  [index0] = color.R;
                    green[index0] = color.G;
                    blue [index0] = color.B;
                }
            }

            var averageRed   = red.Average();
            var averageBlue  = blue.Average();
            var averageGreen = green.Average();

            Assert.IsTrue(
                Math.Abs(averageRed - expectedColor.R) <= tolerance &&
                Math.Abs(averageGreen - expectedColor.G) <= tolerance &&
                Math.Abs(averageBlue - expectedColor.B) <= tolerance,
                $"Region {region} is not expected color {expectedColor} - actual averages: R={averageRed:F20}, G={averageGreen:F20}, B={averageBlue:F20}");
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Returns the difference between two rectangles as a string description.
        /// </summary>
        /// <param name="r1">The first rectangle.</param>
        /// <param name="r2">The second rectangle.</param>
        /// <param name="percentageChange">The change as a percentage.</param>
        /// <returns>A string description.</returns>
        private static string GetLocationChanges(Rectangle r1, Rectangle r2, out decimal percentageChange)
        {
            var sb = new System.Text.StringBuilder();

            if (r1.Width != r2.Width)
            {
                sb.AppendLine(string.Format("Element width {0} by {1} pixels", r1.Width > r2.Width ? "decreased" : "increased", Math.Abs(r1.Width - r2.Width)));
            }

            if (r1.Height != r2.Height)
            {
                sb.AppendLine(string.Format("Element height {0} by {1} pixels", r1.Height > r2.Height ? "decreased" : "increased", Math.Abs(r1.Height - r2.Height)));
            }

            if (r1.X != r2.X)
            {
                sb.AppendLine(string.Format("Element moved {0} {1} pixels", r1.X > r2.X ? "left" : "right", Math.Abs(r1.X - r2.X)));
            }

            if (r1.Y != r2.Y)
            {
                sb.AppendLine(string.Format("Element moved {0} {1} pixels", r1.Y > r2.Y ? "up" : "down", Math.Abs(r1.Y - r2.Y)));
            }

            var commonArea = Rectangle.Intersect(r1, r2).Area();
            percentageChange = commonArea > 0 ? (commonArea / (decimal)r1.Area()) * 100 : 100;

            return sb.ToString();
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Calculates the area difference between two rectangles.
 /// </summary>
 /// <param name="r1">The first rectangle.</param>
 /// <param name="r2">The second rectangle.</param>
 /// <returns>A long value.</returns>
 public static long AreaDifferenceBetweenRectangles(Rectangle r1, Rectangle r2)
 {
     return Math.Abs(r1.Area() - r2.Area());
 }