Брозовский Максим

cs/TagsCloudVisualization/CircularCloudLayouter.cs

@@ -0,0 +1,47 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public class CircularCloudLayouter(Point center, IPointsGenerator pointsGenerator) : ICloudLayouter
+{
+    private readonly List<Rectangle> rectangles = new();
+
+    public Point Center => center;
+    public IEnumerable<Rectangle> Rectangles => rectangles;
+
+    public CircularCloudLayouter(Point center) : 
+        this(center, new SpiralPointsGenerator(center, 1d, 0.5d))
+    {
+
+    }
+
+    public CircularCloudLayouter(Point center, double radius, double angleOffset) :
+        this(center, new SpiralPointsGenerator(center, radius, angleOffset))
+    { 
+
+    }
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        while (true)
+        {
+            var rectanglePosition = pointsGenerator.GetNextPoint();
+            var rectangle = CreateRectangle(rectanglePosition, rectangleSize);
+
+            if (rectangles.Any(rectangle.IntersectsWith)) continue;
+
+            rectangles.Add(rectangle);
+
+            return rectangle;
+        }
+    }
+
+    public static Rectangle CreateRectangle(Point center, Size rectangleSize) =>
+        new(
+            center.X - rectangleSize.Width / 2,
+            center.Y - rectangleSize.Height / 2,
+            rectangleSize.Width,
+            rectangleSize.Height
+        );
+}
+

cs/TagsCloudVisualization/ICloudLayouter.cs

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

cs/TagsCloudVisualization/IPointsGenerator.cs

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

cs/TagsCloudVisualization/Program.cs

@@ -0,0 +1,32 @@
+using System.Drawing;
+using SkiaSharp;
+
+namespace TagsCloudVisualization;
+
+class Program
+{
+    private const int ImageWidth = 2560;
+    private const int ImageHeight = 1440;
+
+    private const int NumberOfRectangles = 50;
+    private const int MinRectangleSize = 10;
+    private const int MaxRectangleSize = 50;
+
+    private const string ImageDirectory = "../../../imgs";
+    public static void Main(string[] args)
+    {
+        var center = new Point(ImageWidth / 2, ImageHeight / 2);
+        var cloudLayouter = new CircularCloudLayouter(center);
+        var randomizer = new Random();
+        var rectangles = Enumerable
+            .Range(0, NumberOfRectangles)
+            .Select(_ => 
+                cloudLayouter.PutNextRectangle(randomizer.NextSize(MinRectangleSize, MaxRectangleSize)));
+
+        var visualizer = new Visualizer(ImageWidth, ImageHeight);
+        var bitmap = visualizer.VisualizeTagCloud(rectangles);
+
+        var saver = new Saver(ImageDirectory);
+        saver.SaveAsPng(bitmap, $"{NumberOfRectangles}_TagCloud.png");
+    }
+}

cs/TagsCloudVisualization/README.md

@@ -0,0 +1,8 @@
+### 50 прямоугольников
+<img src="imgs/50_TagCloud.png">
+
+### 100 прямоугольников
+<img src="imgs/100_TagCloud.png">
+
+### 1000 прямоугольников
+<img src="imgs/1000_TagCloud.png">

cs/TagsCloudVisualization/RandomExtension.cs

@@ -0,0 +1,19 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public static class RandomExtension
+{
+    public static Size NextSize(this Random random, int minValue, int maxValue)
+    {
+        if (minValue <= 0)
+            throw new ArgumentOutOfRangeException(nameof(minValue), "minValue must be greater than 0");
+        if (maxValue < minValue)
+            throw new ArgumentOutOfRangeException(nameof(maxValue), "maxValue must be greater than minValue");
+
+        return new Size(random.Next(minValue, maxValue), random.Next(minValue, maxValue));
+    }
+
+    public static Point NextPoint(this Random random, int minValue, int maxValue) =>
+        new (random.Next(minValue, maxValue), random.Next(minValue, maxValue));
+}

cs/TagsCloudVisualization/Saver.cs

@@ -0,0 +1,13 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization;
+
+public class Saver(string imageDirectory)
+{
+    public void SaveAsPng(SKBitmap bitmap, string filename)
+    {
+        Directory.CreateDirectory(imageDirectory);
+        using var file = File.OpenWrite(Path.Combine(imageDirectory, filename));
+        bitmap.Encode(SKEncodedImageFormat.Png, 80).SaveTo(file);
+    }
+}

cs/TagsCloudVisualization/SpiralPointsGenerator.cs

@@ -0,0 +1,41 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public class SpiralPointsGenerator : IPointsGenerator
+{
+    private readonly double angleOffset;
+    private readonly double radius;
+    private readonly Point start;
+    private double angle;
+
+    public SpiralPointsGenerator(Point start, double radius, double angleOffset)
+    {
+        if (radius <= 0)
+            throw new ArgumentException("radius must be greater than 0");
+        if (angleOffset <= 0)
+            throw new ArgumentException("angleOffset must be greater than 0");
+
+        this.angleOffset = angleOffset * Math.PI / 180;
+        this.radius = radius;
+        this.start = start;
+    }
+
+    public Point GetNextPoint()
+    {
+        var nextPoint = GetPointByPolarCords();
+        angle += angleOffset;
+        return nextPoint;
+    }
+
+    private Point GetPointByPolarCords()
+    {
+        var offsetPerRadian = radius / (2 * Math.PI);
+        var radiusVector =  offsetPerRadian * angle;
+
+        var x = (int)Math.Round(radiusVector * Math.Cos(angle) + start.X);
+        var y = (int)Math.Round(radiusVector * Math.Sin(angle) + start.Y);
+
+        return new Point(x, y);
+    }
+}

cs/TagsCloudVisualization/TagsCloudVisualization.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="SkiaSharp" Version="3.118.0-preview.1.2" />
+      <PackageReference Include="SkiaSharp.Views.WindowsForms" Version="3.118.0-preview.1.2" />
+    </ItemGroup>
+
+</Project>

cs/TagsCloudVisualization/Visualizer.cs

@@ -0,0 +1,32 @@
+using System.Drawing;
+using SkiaSharp;
+using SkiaSharp.Views.Desktop;
+
+
+namespace TagsCloudVisualization;
+
+public class Visualizer
+{
+    private readonly SKBitmap bitmap;
+    private readonly SKCanvas canvas;
+
+    public Visualizer(int width, int height)
+    {
+        bitmap = new SKBitmap(width, height);
+        canvas = new SKCanvas(bitmap);
+    }
+
+    public SKBitmap VisualizeTagCloud(IEnumerable<Rectangle> rectangles)
+    {
+        var paint = new SKPaint 
+        { 
+            Color = SKColors.White,
+            Style = SKPaintStyle.Stroke
+        };
+
+        foreach (var rectangle in rectangles)
+            canvas.DrawRect(rectangle.ToSKRect(), paint);
+
+        return bitmap;
+    }
+}

cs/TagsCloudVisualizationTests/CircularCloudLayouterTest.cs

@@ -0,0 +1,119 @@
+using System.Drawing;
+using FluentAssertions;
+using NUnit.Framework.Interfaces;
+using TagsCloudVisualization;
+
+namespace TagsCloudVisualizationTests;
+
+[TestFixture]
+[TestOf(typeof(CircularCloudLayouter))]
+public class CircularCloudLayouterTest
+{
+    private const string ImagesDirectory = "../../../failedTests";
+    private readonly Random randomizer = new();
+    private CircularCloudLayouter circularCloudLayouter;
+
+    [SetUp]
+    public void Setup()
+    {
+        circularCloudLayouter = TestContext.CurrentContext.Test.Name.Contains("Optimal") ? 
+            CreateCircularCloudLayouterWithOptimalParams() : CreateCircularCloudLayouterWithRandomParams();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        var currentContext = TestContext.CurrentContext;
+        if (currentContext.Result.Outcome.Status != TestStatus.Failed) return;
+
+        var layoutSize = GetLayoutSize(circularCloudLayouter.Rectangles.ToList());
+        var visualizer = new Visualizer(layoutSize.Width, layoutSize.Height);
+        var bitmap = visualizer.VisualizeTagCloud(circularCloudLayouter.Rectangles);
+
+        var saver = new Saver(ImagesDirectory);
+        var filename = $"{currentContext.Test.Name}.png";
+        saver.SaveAsPng(bitmap, filename);
+
+        TestContext.Out.WriteLine($"Tag cloud visualization saved to file {Path.Combine(ImagesDirectory, filename)}");
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldReturnRectangle()
+    {
+        var rectSize = randomizer.NextSize(1, int.MaxValue);
+
+        var rect = circularCloudLayouter.PutNextRectangle(rectSize);
+
+        rect.Should().BeOfType<Rectangle>();
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldReturnRectangleAtCenter_WhenFirstInvoked()
+    {
+        var rectSize = randomizer.NextSize(1, int.MaxValue);
+
+        var actualRect = circularCloudLayouter.PutNextRectangle(rectSize);
+        var expectedRect = CircularCloudLayouter.CreateRectangle(circularCloudLayouter.Center, rectSize);
+
+        actualRect.Should().BeEquivalentTo(expectedRect);
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldReturnRectangle_WithCorrectSize()
+    {
+        var recSize = randomizer.NextSize(1, int.MaxValue);
+
+        var actualRect = circularCloudLayouter.PutNextRectangle(recSize);
+
+        actualRect.Size.Should().Be(recSize);
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldReturnRectangles_WithoutIntersections()
+    {
+        var numberOfRectangles = randomizer.Next(100, 300);
+
+        var rectangles = Enumerable
+            .Range(0, numberOfRectangles)
+            .Select(_ => circularCloudLayouter.PutNextRectangle(randomizer.NextSize(10, 27)))
+            .ToList();
+
+        rectangles.Any(fr => rectangles.Any(sr => fr != sr && fr.IntersectsWith(sr)))
+            .Should().BeFalse();
+    }
+
+    [Test]
+    public void GeneratedLayout_ShouldHaveHighTightnessAndShapeOfCircularCloud_WithOptimalParams()
+    {
+        const double eps = 0.35;
+        var rectangles = PutRandomRectanglesInLayouter(randomizer.Next(500, 1000));
+        var layoutSize = GetLayoutSize(rectangles);
+
+        var diameterOfCircle = Math.Max(layoutSize.Width, layoutSize.Height);
+        var areaOfCircle = Math.PI * Math.Pow(diameterOfCircle, 2) / 4;
+        var areaOfRectangles = (double)rectangles
+            .Select(r => r.Height * r.Width)
+            .Sum();
+        var areaRatio = areaOfCircle / areaOfRectangles;
+
+        areaRatio.Should().BeApproximately(1, eps);
+    }
+
+    private CircularCloudLayouter CreateCircularCloudLayouterWithOptimalParams() => new(new Point(0, 0));
+    private CircularCloudLayouter CreateCircularCloudLayouterWithRandomParams() => 
+        new(randomizer.NextPoint(-10, 10), randomizer.Next(1, 10), randomizer.Next(1, 10));
+
+    private List<Rectangle> PutRandomRectanglesInLayouter(int numberOfRectangles) =>
+        Enumerable
+            .Range(0, numberOfRectangles)
+            .Select(_ => circularCloudLayouter.PutNextRectangle(randomizer.NextSize(10, 27)))
+            .ToList();
+
+    private Size GetLayoutSize(List<Rectangle> rectangles)
+    {
+        var layoutWidth = rectangles.Max(r => r.Right) - rectangles.Min(r => r.Left);
+        var layoutHeight = rectangles.Max(r => r.Top) - rectangles.Min(r => r.Bottom);
+
+        return new Size(layoutWidth, layoutHeight);
+    }
+}