Юдин Павел

cs/TagsCloudTests/ CircularCloudLayouterTests.cs

@@ -0,0 +1,90 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using FluentAssertions;
+using NUnit.Framework.Interfaces;
+using tagsCloud;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class CircularCloudLayouterTests
+{
+    private Point _start;
+    private CircularCloudLayouter circularCloudLayouter;
+
+    [SetUp]
+    public void Setup()
+    {
+        _start = new Point(10, 10);
+        circularCloudLayouter = new CircularCloudLayouter(_start);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (TestContext.CurrentContext.Result.Outcome == ResultState.Failure)
+        {
+            var visualizer = new RectanglesVisualizer(circularCloudLayouter.Rectangles);
+            var workingDirectory = Environment.CurrentDirectory;
+            var projectDirectory = Directory.GetParent(workingDirectory).Parent.Parent.FullName;
+            var path = projectDirectory + @"\Images\";
+            var imageName = TestContext.CurrentContext.Test.Name;
+            var image = visualizer.DrawTagCloud();
+            image.Save($"{path}{imageName}.png", ImageFormat.Png);
+            Console.WriteLine($"Tag cloud visualization saved to file {path}{imageName}");
+        }
+    }
+
+
+    private readonly Func<List<Rectangle>, bool> isRectanglesIntersect = rectangles =>
+        rectangles.Any(rectangle => rectangles.Any(nextRectangle =>
+            nextRectangle.IntersectsWith(rectangle) && !rectangle.Equals(nextRectangle)));
+
+
+    [Test]
+    public void CircularCloudLayouter_GetLocationAfterInitialization_ShouldBeEmpty()
+    {
+        var location = circularCloudLayouter.GetRectanglesLocation();
+        location.Should().BeEmpty();
+    }
+
+    [TestCase(-1, 10, TestName = "width is negative")]
+    [TestCase(1, -10, TestName = "height is negative")]
+    [TestCase(1, 0, TestName = "Zero height, correct width")]
+    [TestCase(0, 10, TestName = "Zero width, correct height")]
+    public void CircularCloudLayouter_PutRectangleWithNegativeParams_ShouldBeThrowException(int width, int height)
+    {
+        var size = new Size(width, height);
+        Action action = () => circularCloudLayouter?.PutNextRectangle(size);
+        action.Should().Throw<ArgumentException>()
+            .WithMessage("Sides of the rectangle should not be non-positive");
+    }
+
+    [Test]
+    public void CircularCloudLayouter_PutOneRectangle_IsNotEmpty()
+    {
+        var rect = circularCloudLayouter.PutNextRectangle(new Size(10, 10));
+        var location = circularCloudLayouter.GetRectanglesLocation();
+        location.Should().NotBeEmpty();
+    }
+
+    [Test]
+    public void CircularCloudLayouter_CreateSecondLayouterAfterAddingRectangle_IsNotEmpty()
+    {
+        var rect = circularCloudLayouter.PutNextRectangle(new Size(10, 10));
+        var circularCloudLayouter2 = new CircularCloudLayouter(new Point(12, 12));
+        circularCloudLayouter.Rectangles.Should().NotBeEmpty();
+    }
+
+    [TestCase(1000, TestName = "check intersection of 1000 rectangles")]
+    public void CircularCloudLayouter_PutNextRectangle_RectanglesShouldNotIntersect(int count)
+    {
+        for (var i = 0; i < count; i++)
+        {
+            var size = Utils.GetRandomSize();
+            var rect = circularCloudLayouter.PutNextRectangle(size);
+        }
+
+        isRectanglesIntersect(circularCloudLayouter.Rectangles).Should().BeFalse();
+    }
+}

cs/TagsCloudTests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

cs/TagsCloudTests/RectanglesVisualizerTests.cs

@@ -0,0 +1,46 @@
+using System.Drawing;
+using FluentAssertions;
+using tagsCloud;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class RectanglesVisualizerTests
+{
+    [Test]
+    public void RectanglesVisualizer_ShouldNotBeException()
+    {
+        var rectangles = new List<Rectangle>();
+        var action = () =>
+        {
+            var visualizer = new RectanglesVisualizer(rectangles);
+            visualizer.DrawTagCloud();
+        };
+        action.Should().NotThrow();
+    }
+
+
+    [Test]
+    public void RectanglesVisualizer_DrawSomeRectangles_AllRectanglesInImage()
+    {
+        var count = 10;
+        var rectangles = new List<Rectangle>();
+        for (var i = 0; i < count; i++)
+        {
+            var locate = Utils.GetRandomLocation();
+            var size = Utils.GetRandomSize();
+            var rect = new Rectangle(locate, size);
+            rectangles.Add(rect);
+        }
+
+        var visualizer = new RectanglesVisualizer(rectangles);
+        var image = visualizer.DrawTagCloud();
+        CheckImageBorders(rectangles, image).Should().BeTrue();
+    }
+
+    private bool CheckImageBorders(List<Rectangle> rectangles, Bitmap image)
+    {
+        return rectangles.Max(rectangle => rectangle.Bottom) < image.Height &&
+               rectangles.Max(rectangle => rectangle.Right) < image.Width;
+    }
+}

cs/TagsCloudTests/SpiralTests.cs

@@ -0,0 +1,57 @@
+using System.Drawing;
+using FluentAssertions;
+using tagsCloud;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class SpiralTests
+{
+    private Point center;
+
+    [SetUp]
+    public void Setup()
+    {
+        center = new Point(10, 10);
+    }
+
+    [Test]
+    public void Spiral_StepAngleEquals0_ShouldBeThrowException()
+    {
+        Action action = () => new Spiral(center, 0);
+        action.Should().Throw<ArgumentException>()
+            .WithMessage("angle step non be 0");
+    }
+
+    [Test]
+    public void Spiral_IsNotStaticParams_ShouldBeTrue()
+    {
+        var spiral = new Spiral(center);
+        var start = spiral.GetPoint();
+        var spiral2 = new Spiral(new Point(0, 0));
+        var start2 = spiral2.GetPoint();
+        start.Should().NotBe(start2);
+    }
+
+    [TestCase(0.5f,
+        new[] { 10, 10, 10, 10, 10, 9 },
+        new[] { 10, 10, 10, 11, 12, 13 },
+        TestName = "AngleStep is positive")]
+    [TestCase(-0.5f,
+        new[] { 10, 10, 10, 10, 10, 9 },
+        new[] { 10, 10, 10, 9, 8, 7 },
+        TestName = "AngleStep is negative")]
+    public void Spiral_GetNextPoint_CreatePointsWithCustomAngle_ReturnsCorrectPoints(float angleStep, int[] x, int[] y)
+    {
+        var spiral = new Spiral(new Point(10, 10), angleStep);
+        var expectedPoints = new Point[x.Length];
+        var resultPoints = new Point[x.Length];
+        for (var i = 0; i < x.Length; i++)
+        {
+            expectedPoints[i] = new Point(x[i], y[i]);
+            resultPoints[i] = spiral.GetPoint();
+        }
+
+        resultPoints.Should().BeEquivalentTo(expectedPoints);
+    }
+}

cs/TagsCloudTests/TagsCloudTests.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="FluentAssertions" Version="7.0.0-alpha.3" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="NUnit" Version="3.13.3"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1"/>
+        <PackageReference Include="NUnit.Analyzers" Version="3.6.1"/>
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\tagsCloud\tagsCloud.csproj" />
+    </ItemGroup>
+
+</Project>

cs/tagsCloud/CircularCloudLayouter.cs

@@ -0,0 +1,50 @@
+using System.Drawing;
+
+namespace tagsCloud;
+
+public class CircularCloudLayouter(Point center) : ICircularCloudLayouter
+{
+    public List<Rectangle> Rectangles { get; } = new();
+    private readonly Spiral _spiral = new(center);
+    private readonly Size _sizeZone = new(500, 500);
+    private Rectangle _zonePossibleIntersections;
+    private List<Rectangle> _nearestRectangles;
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        if (rectangleSize.Height <= 0 || rectangleSize.Width <= 0)
+            throw new ArgumentException("Sides of the rectangle should not be non-positive");
+        var rect = CreateNextRectangle(rectangleSize);
+        Rectangles.Add(rect);
+        return rect;
+    }
+
+    private Rectangle CreateNextRectangle(Size rectangleSize)
+    {
+        var point = _spiral.GetPoint();
+        var rect = new Rectangle(point, rectangleSize);
+        GetNearestRectangles(point);
+        while (_nearestRectangles.Any(x => x.IntersectsWith(rect)))
+        {
+            point = _spiral.GetPoint();
+            rect = new Rectangle(point, rectangleSize);
+            if (!Utils.IsInside(rect, _zonePossibleIntersections))
+                GetNearestRectangles(point);
+        }
+
+        return rect;
+    }
+
+    private void GetNearestRectangles(Point point)
+    {
+        _zonePossibleIntersections =
+            new Rectangle(new Point(point.X - _sizeZone.Width / 2, point.Y - _sizeZone.Height / 2), _sizeZone);
+        _nearestRectangles = Rectangles.Where(x =>
+            x.IntersectsWith(_zonePossibleIntersections) || Utils.IsInside(_zonePossibleIntersections, x)).ToList();
+    }
+
+    public List<Point> GetRectanglesLocation()
+    {
+        return Rectangles.Select(rectangle => rectangle.Location).ToList();
+    }
+}

cs/tagsCloud/ICircularCloudLayouter.cs

@@ -0,0 +1,10 @@
+using System.Drawing;
+
+namespace tagsCloud;
+
+public interface ICircularCloudLayouter
+{
+    List<Rectangle> Rectangles { get; }
+    Rectangle PutNextRectangle(Size rectangleSize);
+    List<Point> GetRectanglesLocation();
+}

cs/tagsCloud/MainProgram.cs

@@ -0,0 +1,24 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace tagsCloud;
+
+public class MainProgram
+{
+    public static void Main(string[] args)
+    {
+        var layout = new CircularCloudLayouter(new Point(100, 100));
+        for (var i = 0; i < 10; i++)
+        {
+            var rectangle = layout.PutNextRectangle(Utils.GetRandomSize());
+        }
+
+        var visualizer = new RectanglesVisualizer(layout.Rectangles);
+        var workingDirectory = Environment.CurrentDirectory;
+        var projectDirectory = Directory.GetParent(workingDirectory).Parent.Parent.FullName;
+        var path = projectDirectory + @"\images\";
+        var imageName = "10rect";
+        var image = visualizer.DrawTagCloud();
+        image.Save($"{path}{imageName}.png", ImageFormat.Png);
+    }
+}

cs/tagsCloud/README.md

@@ -0,0 +1,4 @@
+![10000 random rectangles](https://github.com/PavelUd/tdd/blob/master/cs/tagsCloud/images/10000rect.png)
+![1000 random rectangles](https://github.com/PavelUd/tdd/blob/master/cs/tagsCloud/images/1000rect.png)
+![100 random rectangles](https://github.com/PavelUd/tdd/blob/master/cs/tagsCloud/images/100rect.png)
+![10 random rectangles](https://github.com/PavelUd/tdd/blob/master/cs/tagsCloud/images/10rect.png)

cs/tagsCloud/RectanglesVisualizer.cs

@@ -0,0 +1,56 @@
+using System.Drawing;
+
+namespace tagsCloud;
+
+public class RectanglesVisualizer
+{
+    private readonly List<Rectangle> rectangles;
+    private readonly Bitmap image;
+    private readonly Graphics graphics;
+    private Point shift;
+    private static readonly Size DefaultSize = new(100, 100);
+    private const int Border = 50;
+
+
+    public RectanglesVisualizer(List<Rectangle> rectangles)
+    {
+        this.rectangles = rectangles;
+        var sizeImage = PrepareImage();
+        image = new Bitmap(sizeImage.Width, sizeImage.Height);
+        graphics = Graphics.FromImage(image);
+        var background = new SolidBrush(Color.Black);
+        graphics.FillRectangle(background, new Rectangle(0, 0, image.Width, image.Height));
+    }
+
+    private Size PrepareImage()
+    {
+        if (!rectangles.Any())
+            return DefaultSize;
+
+        var leftmost = rectangles.Min(rectangle => rectangle.Left);
+        var rightmost = rectangles.Max(rectangle => rectangle.Right);
+        var topmost = rectangles.Min(rectangle => rectangle.Top);
+        var bottommost = rectangles.Max(rectangle => rectangle.Bottom);
+
+        var startX = topmost >= 0 ? 0 : topmost;
+        var startY = leftmost >= 0 ? 0 : leftmost;
+        shift = new Point(Math.Abs(startX) + Border, Math.Abs(startY) + Border);
+
+        var height = Math.Abs(bottommost) + Math.Abs(topmost) + 2 * Border;
+        var width = Math.Abs(rightmost) + Math.Abs(topmost) + 2 * Border;
+
+        return new Size(width, height);
+    }
+
+    public Bitmap DrawTagCloud()
+    {
+        foreach (var rectangle in rectangles)
+        {
+            var vizRect = new Rectangle(new Point(rectangle.X + shift.X, rectangle.Y + shift.Y), rectangle.Size);
+            var pen = new Pen(Utils.GetRandomColor());
+            graphics.DrawRectangle(pen, vizRect);
+        }
+
+        return image;
+    }
+}