Зубков Андрей

cs/TagCloud/CircularCloudLayouter.cs

@@ -0,0 +1,38 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class CircularCloudLayouter : ICircularCloudLayouter
+{
+    private readonly IPointGenerator pointGenerator;
+    public IList<Rectangle> Rectangles { get; }
+
+    public CircularCloudLayouter(IPointGenerator pointGenerator)
+    {
+        Rectangles = new List<Rectangle>();
+        this.pointGenerator = pointGenerator;
+    }
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        if (rectangleSize.Height <= 0 || rectangleSize.Width <= 0)
+        {
+            throw new ArgumentException("Rectangle size parameters should be positive");
+        }
+
+        var rectangle = new Rectangle(pointGenerator.GetNextPoint(), rectangleSize);
+        while (!CanPlaceRectangle(rectangle))
+        {
+            rectangle = new Rectangle(pointGenerator.GetNextPoint() - rectangleSize / 2, rectangleSize);
+        }
+
+        Rectangles.Add(rectangle);
+
+        return rectangle;
+    }
+
+    private bool CanPlaceRectangle(Rectangle newRectangle)
+    {
+        return !Rectangles.Any(rectangle => rectangle.IntersectsWith(newRectangle));
+    }
+}

cs/TagCloud/CloudDrawer.cs

@@ -0,0 +1,46 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public static class CloudDrawer
+{
+    public static Bitmap DrawTagCloud(IList<Rectangle> rectangles, int border = 10)
+    {
+        var imageSize = GetImageSize(rectangles, border);
+        var shift = GetImageShift(rectangles, border);
+        var image = new Bitmap(imageSize.Width, imageSize.Height);
+        using var graphics = Graphics.FromImage(image);
+        foreach (var rectangle in rectangles)
+        {
+            var shiftedCoordinates = new Point(rectangle.X - shift.Width, rectangle.Y - shift.Height);
+            using var brush = new SolidBrush(GetRandomColor());
+            graphics.FillRectangle(brush, new Rectangle(shiftedCoordinates, rectangle.Size));
+        }
+
+        return image;
+    }
+
+    private static Size GetImageShift(IList<Rectangle> rectangles, int border)
+    {
+        var minX = rectangles.Min(rectangle => rectangle.Left);
+        var minY = rectangles.Min(rectangle => rectangle.Top);
+
+        return new Size(minX - border, minY - border);
+    }
+
+    private static Size GetImageSize(IList<Rectangle> rectangles, int border)
+    {
+        var minX = rectangles.Min(rectangle => rectangle.Left);
+        var maxX = rectangles.Max(rectangle => rectangle.Right);
+        var minY = rectangles.Min(rectangle => rectangle.Top);
+        var maxY = rectangles.Max(rectangle => rectangle.Bottom);
+
+        return new Size(maxX - minX + 2 * border, maxY - minY + 2 * border);
+    }
+
+    private static Color GetRandomColor()
+    {
+        var random = new Random();
+        return Color.FromArgb(random.Next(0, 255), random.Next(0, 255), random.Next(0, 255));
+    }
+}

cs/TagCloud/ICircularCloudLayouter.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public interface ICircularCloudLayouter
+{
+    Rectangle PutNextRectangle(Size rectangleSize);
+}

cs/TagCloud/IPointGenerator.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public interface IPointGenerator
+{
+    Point GetNextPoint();
+}

cs/TagCloud/Program.cs

@@ -0,0 +1,36 @@
+using System.Drawing;
+
+namespace TagCloud
+{
+    public class Program
+    {
+        private const int Width = 1920;
+        private const int Height = 1080;
+
+        static void Main(string[] args)
+        {
+            var layouter = new CircularCloudLayouter(new SpiralGenerator(new Point(Width / 2, Height / 2), 1, 0.01));
+
+            var random = new Random();
+
+            for (var i = 0; i < 150; i++)
+            {
+                layouter.PutNextRectangle(new Size(50 + random.Next(0, 100), 50 + random.Next(0, 100)));
+            }
+
+            var filename = "Sample";
+            var path = @$"{Environment.CurrentDirectory}\..\..\..\Samples";
+            var absPath = Path.GetFullPath(path);
+
+            if (!Directory.Exists(absPath))
+            {
+                Directory.CreateDirectory(absPath);
+            }
+
+            absPath += @$"\{filename}.png";
+
+            using var bitmap = CloudDrawer.DrawTagCloud(layouter.Rectangles);
+            bitmap.Save(absPath);
+        }
+    }
+}

cs/TagCloud/Samples/README.md

@@ -0,0 +1,16 @@
+## Layout examples
+
+#### 150 Equal reactangles:
+![150_equal_rectangles](https://github.com/HardreaM/tdd/blob/master/cs/TagCloud/Samples/150%20Equal%20rectangles.png)
+
+#### 50 Random reactangles:
+![50_random_rectangles](https://github.com/HardreaM/tdd/blob/master/cs/TagCloud/Samples/50%20Random%20rectangles.png)
+
+#### 150 Random reactangles:
+![150_random_rectangles](https://github.com/HardreaM/tdd/blob/master/cs/TagCloud/Samples/150%20Random%20rectangles.png)
+
+#### 500 Random reactangles:
+![500_random_rectangles](https://github.com/HardreaM/tdd/blob/master/cs/TagCloud/Samples/500%20Random%20rectangles.png)
+
+#### 150 Squares:
+![150_squares](https://github.com/HardreaM/tdd/blob/master/cs/TagCloud/Samples/150%20Squares.png)

cs/TagCloud/SpiralGenerator.cs

@@ -0,0 +1,30 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class SpiralGenerator : IPointGenerator
+{
+    private readonly Point startPoint;
+    private readonly int spiralDensity;
+    private readonly double angleShift;
+    private double currentAngle;
+
+    public SpiralGenerator(Point startPoint, int spiralDensity = 1, double angleShift = 0.1)
+    {
+        if (startPoint.X < 0 || startPoint.Y < 0)
+            throw new ArgumentException("Spiral center point coordinates should be non-negative");
+        this.startPoint = startPoint;
+        this.spiralDensity = spiralDensity;
+        this.angleShift = angleShift;
+    }
+
+    public Point GetNextPoint()
+    {
+        var radius = spiralDensity * currentAngle;
+        var x = (int)(Math.Cos(currentAngle) * radius);
+        var y = (int)(Math.Sin(currentAngle) * radius);
+        currentAngle += angleShift;
+
+        return new Point(startPoint.X + x, startPoint.Y + y);
+    }
+}

cs/TagCloud/TagCloud.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Drawing.Common" Version="8.0.0" />
+  </ItemGroup>
+
+</Project>

cs/TagCloudTests/CircularCloudLayouter_Should.cs

@@ -0,0 +1,96 @@
+using NUnit.Framework.Interfaces;
+
+[TestFixture]
+public class CircularCloudLayouter_Should
+{
+    private const int Width = 1920;
+    private const int Height = 1080;
+    private CircularCloudLayouter sut;
+
+
+    [SetUp]
+    public void Setup()
+    {
+        sut = new CircularCloudLayouter(new SpiralGenerator(new Point(Width / 2, Height / 2)));
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (TestContext.CurrentContext.Result.Outcome == ResultState.Failure)
+        {
+            var bitmap = CloudDrawer.DrawTagCloud(sut.Rectangles);
+
+            var path = @$"{Environment.CurrentDirectory}\..\..\..\FailedTests\{this.GetType()}";
+            var absPath = Path.GetFullPath(path);
+
+            if (!Directory.Exists(absPath))
+            {
+                Directory.CreateDirectory(absPath);
+            }
+
+            var fileName = TestContext.CurrentContext.Test.Name;
+            absPath += @$"\{fileName}.png";
+
+            bitmap.Save(absPath);
+
+            TestContext.Out.WriteLine($"Tag cloud visualization saved to file <{absPath}>");
+        }
+    }
+
+    [Test]
+    public void HaveEmptyRectanglesList_WhenCreated()
+    {
+        sut.Rectangles.Count.Should().Be(0);
+    }
+
+    [TestCase(1, TestName = "One rectangle")]
+    [TestCase(10, TestName = "10 rectangles")]
+    public void HaveAllRectangles_WhichWerePut(int rectanglesCount)
+    {
+        for (var i = 0; i < rectanglesCount; i++)
+        {
+            sut.PutNextRectangle(new Size(2, 3));
+        }
+
+        sut.Rectangles.Count.Should().Be(rectanglesCount);
+    }
+
+    [TestCase(0, 5, TestName = "Width is zero")]
+    [TestCase(5, 0, TestName = "Height is zero")]
+    [TestCase(-5, 5, TestName = "Width is negative")]
+    [TestCase(5, -5, TestName = "Height is negative")]
+    public void ThrowException_OnInvalidSizeArguments(int width, int height)
+    {
+        Action action = () => { sut.PutNextRectangle(new Size(0, 0)); };
+
+        action.Should().Throw<ArgumentException>();
+    }
+
+    [Test]
+    public void ContainNonIntersectingRectangles()
+    {
+        var random = new Random();
+
+        for (var i = 0; i < 50; i++)
+        {
+            sut.PutNextRectangle(new Size(50 + random.Next(0, 100), 50 + random.Next(0, 100)));
+        }
+
+        HasIntersectedRectangles(sut.Rectangles).Should().Be(false);
+    }
+
+    private bool HasIntersectedRectangles(IList<Rectangle> rectangles)
+    {
+        for (var i = 0; i < rectangles.Count - 1; i++)
+        {
+            for (var j = i + 1; j < rectangles.Count; j++)
+            {
+                if (rectangles[i].IntersectsWith(rectangles[j]))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+}

cs/TagCloudTests/SpiralGenerator_Should.cs

@@ -0,0 +1,44 @@
+[TestFixture]
+public class SpiralGenerator_Should
+{
+    private const int Width = 1920;
+    private const int Height = 1080;
+    private SpiralGenerator sut;
+    private Point startPoint;
+
+    [SetUp]
+    public void Setup()
+    {
+        startPoint = new Point(Width / 2, Height / 2);
+        sut = new SpiralGenerator(startPoint);
+    }
+
+    [Test]
+    public void ReturnCenterPoint_OnFirstCall()
+    {
+        sut.GetNextPoint().Should().BeEquivalentTo(startPoint);
+    }
+
+    [Test]
+    public void ReturnDifferentPoints_AfterMultipleCalls()
+    {
+        var spiralPoints = new HashSet<Point>();
+
+        for (var i = 0; i < 50; i++)
+        {
+            spiralPoints.Add(sut.GetNextPoint());
+        }
+
+        spiralPoints.Count.Should().BeGreaterThan(1);
+    }
+
+    [TestCase(-1, 1, TestName = "X is negative")]
+    [TestCase(1, -1, TestName = "Y is negative")]
+    [TestCase(-1, -1, TestName = "X and Y are negative")]
+    public void ThrowException_OnInvalidCenterPoint(int x, int y)
+    {
+        Action action = () => { new SpiralGenerator(new Point(x, y)); };
+
+        action.Should().Throw<ArgumentException>();
+    }
+}

cs/TagCloudTests/TagCloudTests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="NUnit" Version="3.12.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\TagCloud\TagCloud.csproj" />
+  </ItemGroup>
+
+</Project>

cs/TagCloudTests/Usings.cs

@@ -0,0 +1,4 @@
+global using NUnit.Framework;
+global using FluentAssertions;
+global using TagCloud;
+global using System.Drawing;