Попов Захар

cs/TagsCloudVisualization/CircularCloudLayouter.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization
+{
+    internal class CircularCloudLayouter
+    {
+        public readonly Point Center;
+        private float _radius = 2.0f;
+        private Random _random = new Random();
+        private readonly List<Rectangle> _rectangles = new List<Rectangle>();
+        public IReadOnlyList<Rectangle> Rectangles => _rectangles.AsReadOnly();
+
+        public CircularCloudLayouter(Point center)
+        {
+            if (center.X < 0 || center.Y < 0)
+            {
+                throw new ArgumentException("Координаты центра не могут быть меньше нуля.");
+            }
+            Center = center;
+        }
+
+        public Rectangle PutNextRectangle(Size rectangleSize)
+        {
+            if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+            {
+                throw new ArgumentException("Размеры прямоугольника не могут быть меньше либо равны нуля.");
+            }
+
+            var result = new Rectangle();
+            _radius -= 1.0f;
+            var isPlaced = false;
+            while (!isPlaced)
+            {
+                var points = GetCoordinatesOnEllipse(Center, _radius);
+                var pointsStartIndex = _random.Next(points.Length);
+
+                for (int j = 0; j < points.Length; j++)
+                {
+                    var index = (pointsStartIndex + j) % points.Length;
+
+                    int x = points[index].X - rectangleSize.Width / 2;
+                    int y = points[index].Y - rectangleSize.Height / 2;
+                    var location = new Point(x, y);
+
+                    var nextRectangle = new Rectangle(location, rectangleSize);
+
+                    var isIntersects = false;
+                    foreach (var rect in _rectangles)
+                    {
+                        if (rect.IntersectsWith(nextRectangle))
+                        {
+                            isIntersects = true;
+                            break;
+                        }
+                    }
+
+                    if (!isIntersects)
+                    {
+                        _rectangles.Add(nextRectangle);
+                        isPlaced = true;
+                        result = nextRectangle;
+                        break;
+                    }
+                }
+                _radius += 1.0f;
+            }
+            return result;
+        }
+
+        private Point[] GetCoordinatesOnEllipse(Point rectangleCenter, float radius)
+        {
+            var result = new Point[360];
+            var step = 1;
+
+            for (int angle = 0; angle < 360; angle += step)
+            {
+                double angleInRadians = angle * Math.PI / 180;
+
+                var x = (int)(rectangleCenter.X + radius * Math.Cos(angleInRadians));
+                var y = (int)(rectangleCenter.Y + radius * Math.Sin(angleInRadians));
+
+                result[angle] = new Point(x, y);
+            }
+            return result;
+        }
+    }
+}

cs/TagsCloudVisualization/CircularCloudLayouterPainter.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization
+{
+    internal class CircularCloudLayouterPainter
+    {
+        private string _fileName;
+        public CircularCloudLayouterPainter(string fileName)
+        {
+            _fileName = fileName;
+        }
+
+        public void Save(List<Rectangle> rectangles, int? paddingPerSide = null)
+        {
+            if (rectangles.Count == 0)
+            {
+                return;
+            }
+
+            var correctPaddingPerSide = paddingPerSide ?? 10;
+
+            var minimums = new Point(rectangles.Min(r => r.Left), rectangles.Min(r => r.Top));
+            var maximums = new Point(rectangles.Max(r => r.Right), rectangles.Max(r => r.Bottom));
+
+            var imageSize = GetImageSize(minimums, maximums, correctPaddingPerSide);
+            using (var bitmap = new Bitmap(imageSize.Width, imageSize.Height))
+            {
+                using (var graphics = Graphics.FromImage(bitmap))
+                {
+                    graphics.Clear(Color.White);
+                    using (var pen = new Pen(Color.Black, 1))
+                    {
+                        for (int i = 0; i < rectangles.Count; i++)
+                        {
+                            var currentRectangle = rectangles[i];
+                            var positionOnCanvas = GetPositionOnCanvas(currentRectangle, minimums, correctPaddingPerSide);
+                            graphics.DrawRectangle(pen, positionOnCanvas.X, positionOnCanvas.Y, currentRectangle.Width, currentRectangle.Height);
+                        }
+                    }
+                    bitmap.Save(_fileName, System.Drawing.Imaging.ImageFormat.Png);
+                }
+            }
+            Console.WriteLine($"Изображение сохранено как {_fileName}");
+        }
+
+        private Point GetPositionOnCanvas(Rectangle rectangle, Point minimums, int padding)
+            => new Point(rectangle.X - minimums.X + padding, rectangle.Y - minimums.Y + padding);
+
+        private Size GetImageSize(Point minimums, Point maximums, int paddingPerSide)
+            => new Size(maximums.X - minimums.X + 2 * paddingPerSide, maximums.Y - minimums.Y + 2 * paddingPerSide);
+    }
+}

cs/TagsCloudVisualization/CircularCloudLayouterTests.cs

@@ -0,0 +1,85 @@
+using System;
+using NUnit.Framework;
+using FluentAssertions;
+using System.Drawing;
+
+namespace TagsCloudVisualization
+{
+    [TestFixture]
+    internal class CircularCloudLayouterTests
+    {
+        private CircularCloudLayouter _circularCloudLayouter;
+        private CircularCloudLayouterWorker _circularCloudLayouterWorker;
+        private CircularCloudLayouterPainter _circularCloudLayouterPainter;
+
+        public void SetUp(int x = 400,
+            int y = 400,
+            int minRectangleWidth = 30,
+            int minRectangleHeight = 20,
+            int maxRectangleWidth = 70,
+            int maxRectangleHeight = 50,
+            string imageFileName = "circularCloudLayouter.png")
+        {
+            var center = new Point(x, y);
+            var minRectangleSize = new Size(minRectangleWidth, minRectangleHeight);
+            var maxRectangleSize = new Size(maxRectangleWidth, maxRectangleHeight);
+
+            _circularCloudLayouter = new CircularCloudLayouter(center);
+            _circularCloudLayouterWorker = new CircularCloudLayouterWorker(minRectangleSize, maxRectangleSize);
+            _circularCloudLayouterPainter = new CircularCloudLayouterPainter(imageFileName);
+        }
+
+        [TestCase(-1, 0)]
+        [TestCase(0, -1)]
+        [TestCase(-1, -1)]
+        public void CircularCloudLayouter_ThrowsArgumentException_OnNegativeCenterPoint(int x, int y)
+        {
+            var center = new Point(x, y);
+            Assert.Throws<ArgumentException>(() => new CircularCloudLayouter(center));
+        }
+
+
+        [TestCase(0, 100, 1)]
+        [TestCase(-1, 100, 1)]
+        [TestCase(100, 0, 1)]
+        [TestCase(100, -1, 1)]
+
+        public void PutNextRectangle_ThrowsArgumentException_OnAnyNegativeOrZeroSize(int width, int height, int rectanglesCount)
+        {
+            SetUp();
+            for (int i = 0; i < rectanglesCount; i++)
+            {
+                var nextRectangleSize = _circularCloudLayouterWorker.GetNextRectangleSize();
+                Assert.Throws<ArgumentException>(() => _circularCloudLayouter.PutNextRectangle(new Size(width, height)));
+            }
+        }
+
+        [TestCase(1)]
+        public void PutNextRectangle_ReturnsRectangleType(int rectanglesCount)
+        {
+            SetUp();
+            for (int i = 0; i < rectanglesCount; i++)
+            {
+                var nextRectangleSize = _circularCloudLayouterWorker.GetNextRectangleSize();
+                Assert.That(_circularCloudLayouter.PutNextRectangle(nextRectangleSize), Is.TypeOf(typeof(Rectangle)));
+            }
+        }
+
+        [TestCase(1, "TestFile.png", ExpectedResult = true)]
+        [TestCase(0, "TestFile.png", ExpectedResult = false)]
+        public bool CircularCloudLayouterPainter_CreatesFile(int rectanglesCount, string fileName)
+        {
+            SetUp(imageFileName: fileName);
+            File.Delete(fileName);
+
+            for (int i = 0; i < rectanglesCount; i++)
+            {
+                var nextRectangleSize = _circularCloudLayouterWorker.GetNextRectangleSize();
+                _circularCloudLayouter.PutNextRectangle(nextRectangleSize);
+            }
+
+            _circularCloudLayouterPainter.Save(_circularCloudLayouter.Rectangles.ToList());
+            return File.Exists(fileName);
+        }
+    }
+}

cs/TagsCloudVisualization/CircularCloudLayouterWorker.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization
+{
+    internal class CircularCloudLayouterWorker
+    {
+        private Size _minRectangleSize;
+        private Size _maxRectangleSize;
+        private Random _random = new Random();
+
+        public CircularCloudLayouterWorker(Size minRectangleSize, Size maxRectangleSize)
+        {
+            _minRectangleSize = minRectangleSize;
+            _maxRectangleSize = maxRectangleSize;
+        }
+
+        public Size GetNextRectangleSize()
+        {
+            var width = _random.Next(_minRectangleSize.Width, _maxRectangleSize.Width);
+            var height = _random.Next(_minRectangleSize.Height, _maxRectangleSize.Height);
+            return new Size(width, height);
+        }
+    }
+}

cs/TagsCloudVisualization/Program.cs

@@ -0,0 +1,28 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization
+{
+    internal class Program
+    {
+        static void Main(string[] args)
+        {
+            var center = new Point(400, 400);
+            var minRectangleSize = new Size(30, 20);
+            var maxRectangleSize = new Size(70, 50);
+            var rectanglesCount = 100;
+            var imageFileName = "circularCloudLayouter.png";
+
+            var circularCloudLayouter = new CircularCloudLayouter(center);
+            var circularCloudLayouterWorker = new CircularCloudLayouterWorker(minRectangleSize, maxRectangleSize);
+            var circularCloudLayouterPainter = new CircularCloudLayouterPainter(imageFileName);
+
+            for (int i = 0; i < rectanglesCount; i++)
+            {
+                var nextRectangleSize = circularCloudLayouterWorker.GetNextRectangleSize();
+                circularCloudLayouter.PutNextRectangle(nextRectangleSize);
+            }
+
+            circularCloudLayouterPainter.Save(circularCloudLayouter.Rectangles.ToList());
+        }
+    }
+}

cs/TagsCloudVisualization/TagsCloudVisualization.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <StartupObject>TagsCloudVisualization.Program</StartupObject>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="6.12.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Console" Version="3.18.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="System.Drawing.Common" Version="8.0.10" />
+  </ItemGroup>
+
+</Project>