Мажирин Александр

cs/TagsCloudVisualization/Layouter/CircularCloudLayouter.cs

@@ -0,0 +1,44 @@
+using SkiaSharp;
+using TagsCloudVisualization.PositionGenerator;
+
+namespace TagsCloudVisualization.Layouter;
+
+public class CircularCloudLayouter : ICircularCloudLayouter
+{
+    private readonly IPositionGenerator positionGenerator;
+    private readonly List<SKRect> rectangles;
+
+    public CircularCloudLayouter(SKPoint center)
+    {
+        rectangles = [];
+        positionGenerator = new SpiralLayoutPositionGenerator(center);
+    }
+
+    public SKRect PutNextRectangle(SKSize rectangleSize)
+    {
+        if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+            throw new ArgumentException("Rectangle size must be positive", nameof(rectangleSize));
+
+        SKRect rectangle;
+
+        do
+        {
+            var centerOfRectangle = positionGenerator.GetNextPosition();
+            var rectanglePosition = new SKPoint(centerOfRectangle.X - rectangleSize.Width / 2,
+                centerOfRectangle.Y - rectangleSize.Height / 2);
+            rectangle = new SKRect(
+                rectanglePosition.X,
+                rectanglePosition.Y,
+                rectanglePosition.X + rectangleSize.Width,
+                rectanglePosition.Y + rectangleSize.Height);
+        } while (rectangles.Any(r => r.IntersectsWith(rectangle)));
+
+        rectangles.Add(rectangle);
+        return rectangle;
+    }
+
+    public SKRect[] GetRectangles()
+    {
+        return rectangles.ToArray();
+    }
+}

cs/TagsCloudVisualization/Layouter/ICircularCloudLayouter.cs

@@ -0,0 +1,9 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization.Layouter;
+
+public interface ICircularCloudLayouter
+{
+    SKRect PutNextRectangle(SKSize rectangleSize);
+    SKRect[] GetRectangles();
+}

cs/TagsCloudVisualization/PositionGenerator/IPositionGenerator.cs

@@ -0,0 +1,8 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization.PositionGenerator;
+
+public interface IPositionGenerator
+{
+    public SKPoint GetNextPosition();
+}

cs/TagsCloudVisualization/PositionGenerator/SpiralLayoutPositionGenerator.cs

@@ -0,0 +1,19 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization.PositionGenerator;
+
+public class SpiralLayoutPositionGenerator(SKPoint center, double step = 0.01) : IPositionGenerator
+{
+    private double angle;
+
+    public SKPoint GetNextPosition()
+    {
+        var radius = step * angle;
+        var x = (float)(center.X + radius * Math.Cos(angle));
+        var y = (float)(center.Y + radius * Math.Sin(angle));
+
+        angle += step;
+
+        return new SKPoint(x, y);
+    }
+}

cs/TagsCloudVisualization/Program.cs

@@ -0,0 +1,31 @@
+using SkiaSharp;
+using TagsCloudVisualization.Layouter;
+using TagsCloudVisualization.Renderer;
+
+internal class Program
+{
+    private static void Main()
+    {
+        if (!Directory.Exists("results"))
+            Directory.CreateDirectory("results");
+
+        RenderCloud(GenerateRandomCloud(10), "results/cloud_10.png");
+        RenderCloud(GenerateRandomCloud(50), "results/cloud_50.png");
+        RenderCloud(GenerateRandomCloud(100), "results/cloud_100.png");
+    }
+
+    private static SKRect[] GenerateRandomCloud(int count)
+    {
+        var layouter = new CircularCloudLayouter(new SKPoint(500, 500));
+        var rectangleSizes = Enumerable.Range(0, count)
+            .Select(_ => new SKSize(new Random().Next(10, 100), new Random().Next(10, 100)));
+        return rectangleSizes.Select(layouter.PutNextRectangle).ToArray();
+    }
+
+    private static void RenderCloud(SKRect[] rectangles, string path)
+    {
+        var renderer = new Renderer(new SKSize(1000, 1000));
+        renderer.CreateRectangles(rectangles);
+        renderer.CreateImage(path);
+    }
+}

cs/TagsCloudVisualization/Renderer/IRenderer.cs

@@ -0,0 +1,9 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization.Renderer;
+
+public interface IRenderer
+{
+    void CreateRectangles(SKRect[] rectangles);
+    void CreateImage(string path);
+}

cs/TagsCloudVisualization/Renderer/Renderer.cs

@@ -0,0 +1,48 @@
+using SkiaSharp;
+
+namespace TagsCloudVisualization.Renderer;
+
+public class Renderer : IRenderer
+{
+    private readonly SKBitmap bitmap;
+    private readonly SKPaint paint;
+
+    public Renderer(SKSize size)
+    {
+        bitmap = new SKBitmap((int)size.Width, (int)size.Height);
+        paint = new SKPaint
+        {
+            Color = SKColors.Black,
+            IsStroke = true,
+            TextSize = 24
+        };
+        using var canvas = new SKCanvas(bitmap);
+        {
+            canvas.Clear(SKColors.LightGray);
+        }
+    }
+
+    public void CreateRectangles(SKRect[] rectangles)
+    {
+        using var canvas = new SKCanvas(bitmap);
+        foreach (var rectangle in rectangles)
+        {
+            if (rectangle.Left < 0 || rectangle.Top < 0 || rectangle.Right > bitmap.Width ||
+                rectangle.Bottom > bitmap.Height)
+                throw new ArgumentException("Rectangle is out of bounds");
+            if (rectangle.Left >= rectangle.Right || rectangle.Top >= rectangle.Bottom)
+                throw new ArgumentException("Rectangle is invalid");
+            canvas.DrawRect(rectangle, paint);
+            paint.Color = new SKColor((byte)(paint.Color.Red + 21), (byte)(paint.Color.Green + 43),
+                (byte)(paint.Color.Blue + 67));
+        }
+    }
+
+    public void CreateImage(string path)
+    {
+        using var image = SKImage.FromBitmap(bitmap);
+        using var data = image.Encode(SKEncodedImageFormat.Png, 100);
+        using var stream = File.OpenWrite(path);
+        data.SaveTo(stream);
+    }
+}

cs/TagsCloudVisualization/TagsCloudVisualization.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <GenerateProgramFile>false</GenerateProgramFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="FluentAssertions" Version="6.12.2"/>
+        <PackageReference Include="SkiaSharp" Version="2.88.9"/>
+        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.9"/>
+    </ItemGroup>
+
+</Project>

cs/TagsCloudVisualizationTests/CircularCloudLayouterTests.cs

@@ -0,0 +1,114 @@
+using NUnit.Framework.Interfaces;
+using TagsCloudVisualization.Layouter;
+using TagsCloudVisualization.Renderer;
+
+namespace TagsCloudVisualizationTests;
+
+[TestFixture]
+public class CircularCloudLayouterTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        layouter = new CircularCloudLayouter(new SKPoint(500, 500));
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (TestContext.CurrentContext.Result.Outcome.Status != TestStatus.Failed) return;
+
+        if (!Directory.Exists("tests"))
+            Directory.CreateDirectory("tests");
+        var filename = "tests/layouter_" + TestContext.CurrentContext.Test.ID + ".png";
+        var renderer = new Renderer(new SKSize(1000, 1000));
+        renderer.CreateRectangles(layouter.GetRectangles());
+        renderer.CreateImage(filename);
+
+        var path = Path.Combine(Directory.GetCurrentDirectory(), filename);
+        Console.WriteLine($"Tag cloud visualization saved to file {path}");
+    }
+
+    private CircularCloudLayouter layouter;
+
+    [Test]
+    public void Constructor_ShouldCreateLayouter()
+    {
+        layouter.Should().NotBeNull();
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldThrowArgumentException_WhenSizeNotPositive()
+    {
+        Action action = () => layouter.PutNextRectangle(new SKSize(0, 100));
+        action.Should().Throw<ArgumentException>();
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldReturnRectangles()
+    {
+        var rectangles = new List<SKRect>();
+        for (var i = 0; i < 10; i++) rectangles.Add(layouter.PutNextRectangle(new SKSize(10, 10)));
+
+        rectangles.Should().HaveCount(10);
+    }
+
+    [Test]
+    public void PutNextRectangle_ShouldNotIntersectRectangles()
+    {
+        var rectangles = new List<SKRect>();
+        for (var i = 0; i < 10; i++) rectangles.Add(layouter.PutNextRectangle(new SKSize(10, 10)));
+
+        for (var i = 0; i < rectangles.Count; i++)
+        for (var j = i + 1; j < rectangles.Count; j++)
+            rectangles[i].IntersectsWith(rectangles[j]).Should().BeFalse();
+    }
+
+    [Test]
+    [Repeat(3)]
+    public void PutNextRectangle_ShouldGenerateDenseLayout()
+    {
+        var rectangles = new List<SKRect>();
+        float totalRectArea = 0;
+        var random = new Random();
+        for (var i = 0; i < 100; i++)
+        {
+            var size = new SKSize(random.Next(10, 100), random.Next(10, 100));
+            var rect = layouter.PutNextRectangle(size);
+            rectangles.Add(rect);
+            totalRectArea += size.Width * size.Height;
+        }
+
+        var boundingCircleRadius = rectangles.Max(DistanceToCenter);
+        var boundingCircleArea = Math.PI * Math.Pow(boundingCircleRadius, 2);
+
+        var density = totalRectArea / boundingCircleArea;
+        density.Should().BeGreaterOrEqualTo(0.7f);
+    }
+
+    [Test]
+    [Repeat(3)]
+    public void PutNextRectangle_ShouldPlaceRectanglesInCircle()
+    {
+        var rectangles = new List<SKRect>();
+        var random = new Random();
+        for (var i = 0; i < 100; i++)
+        {
+            var size = new SKSize(random.Next(10, 100), random.Next(10, 100));
+            var rect = layouter.PutNextRectangle(size);
+            rectangles.Add(rect);
+        }
+
+        var maxDistanceFromCenter = rectangles.Max(DistanceToCenter);
+        const int expectedMaxDistance = 500;
+
+        maxDistanceFromCenter.Should().BeLessOrEqualTo(expectedMaxDistance);
+    }
+
+    private static float DistanceToCenter(SKRect rect)
+    {
+        var center = new SKPoint(500, 500);
+        var rectCenter = new SKPoint(rect.MidX, rect.MidY);
+        return SKPoint.Distance(center, rectCenter);
+    }
+}

cs/TagsCloudVisualizationTests/GlobalUsings.cs

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

cs/TagsCloudVisualizationTests/RendererTests.cs

@@ -0,0 +1,58 @@
+using NUnit.Framework.Interfaces;
+using TagsCloudVisualization.Renderer;
+
+namespace TagsCloudVisualizationTests;
+
+[TestFixture]
+public class RendererTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        render = new Renderer(new SKSize(100, 100));
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (TestContext.CurrentContext.Result.Outcome.Status != TestStatus.Failed) return;
+
+        if (!Directory.Exists("tests"))
+            Directory.CreateDirectory("tests");
+        var filename = "tests/renderer_" + TestContext.CurrentContext.Test.ID + ".png";
+        render.CreateImage(filename);
+        var path = Path.Combine(Directory.GetCurrentDirectory(), filename);
+        Console.WriteLine($"Attempted to save result to file {path}");
+
+
+        if (File.Exists("image.png"))
+            File.Delete("image.png");
+    }
+
+    private Renderer render;
+
+    [Test]
+    public void CreateImage_ShouldCreateImage()
+    {
+        render.CreateImage("image.png");
+        Assert.That(File.Exists("image.png"));
+    }
+
+    [TestCase(0, 200)]
+    [TestCase(-1, 50)]
+    public void CreateRectangles_ShouldThrowException_WhenRectanglesAreOutOfBounds(int topLeft, int bottomRight)
+    {
+        Assert.Throws<ArgumentException>(() =>
+            render.CreateRectangles([new SKRect(topLeft, topLeft, bottomRight, bottomRight)]));
+    }
+
+    [TestCase(0, 0, 0, 0)]
+    [TestCase(50, 50, 0, 0)]
+    [TestCase(50, 0, 50, 0)]
+    public void CreateRectangles_ShouldThrowException_WhenRectanglesAreInvalid(int topLeft, int topRight,
+        int bottomLeft, int bottomRight)
+    {
+        Assert.Throws<ArgumentException>(() =>
+            render.CreateRectangles([new SKRect(topLeft, topRight, bottomLeft, bottomRight)]));
+    }
+}