Смышляев Дмитрий

cs/TagsCloudVisualization/BitmapGenerator.cs

@@ -0,0 +1,28 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public static class BitmapGenerator
+{
+    public static Bitmap GenerateWindowsBitmap(ICloudLayouter cloudLayouter, Size bitmapSize, in Size[] rectSizes)
+    {
+        var rects = rectSizes.Select(cloudLayouter.PutNextRectangle);
+        return GenerateWindowsBitmap(rects.ToList(), bitmapSize);
+    }
+
+    public static Bitmap GenerateWindowsBitmap(List<Rectangle> rects, Size bitmapSize)
+    {
+        var bitmap = new Bitmap(bitmapSize.Width, bitmapSize.Height);
+        using var graphics = Graphics.FromImage(bitmap);
+
+        var xOffset = bitmap.Width / 2 - rects.First().X;
+        var yOffset = bitmap.Height / 2 - rects.First().Y;
+
+        foreach (var rect in rects)
+        {
+            var offsetPos = new Point(rect.X + xOffset, rect.Y + yOffset);
+            graphics.DrawRectangle(Pens.MediumPurple, new Rectangle(offsetPos, rect.Size));
+        }
+        return bitmap;
+    }
+}

cs/TagsCloudVisualization/BitmapSaver.cs

@@ -0,0 +1,18 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace TagsCloudVisualization;
+
+public class BitmapSaver(string saveDirectory)
+{
+    private string saveDirectory = saveDirectory;
+
+    public string SaveBitmap(Bitmap bitmap, string fileName)
+    {
+        Directory.CreateDirectory(saveDirectory);
+        var filepath = Path.Combine(saveDirectory, fileName);
+        bitmap.Save(filepath, ImageFormat.Jpeg);
+
+        return Path.Combine(Directory.GetCurrentDirectory(), filepath);
+    }
+}

cs/TagsCloudVisualization/ICloudLayouter.cs

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

cs/TagsCloudVisualization/Program.cs

@@ -0,0 +1,36 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using TagsCloudVisualization.SpiralLayouter;
+using TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+namespace TagsCloudVisualization;
+
+internal class Program
+{
+    private const int IMAGE_WIDTH = 1920;
+    private const int IMAGE_HEIGHT = 1080;
+
+    private const int RECTANGLE_COUNT = 100;
+    private const int MAX_RECT_WIDTH = 75;
+    private const int MAX_RECT_HEIGHT = 75;
+
+    private const string MEDIA_ROOT = "images";
+
+    public static void Main(string[] args)
+    {
+        var random = new Random();
+
+        var center = new Point(IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2);
+        var spiralLayouter = new SpiralCloudLayouter(center, new PolarArchimedesSpiral(1, 1));
+
+        var rectangleSizes = new Size[RECTANGLE_COUNT]
+                .Select(_ => (random.Next(5, MAX_RECT_WIDTH), random.Next(5, MAX_RECT_HEIGHT)))
+                .Select(rawSize => new Size(rawSize.Item1, rawSize.Item2))
+                .ToArray();
+        var imageSize = new Size(IMAGE_WIDTH, IMAGE_HEIGHT);
+
+        var bitmap = BitmapGenerator.GenerateWindowsBitmap(spiralLayouter, imageSize, rectangleSizes);
+        var saver = new BitmapSaver(MEDIA_ROOT);
+        saver.SaveBitmap(bitmap, $"{RECTANGLE_COUNT}.jpeg");
+    }
+}

cs/TagsCloudVisualization/SpiralLayouter/PointGenerator/Direction.cs

@@ -0,0 +1,24 @@
+namespace TagsCloudVisualization.SpiralLayouter;
+
+public enum Direction
+{
+    Up,
+    Right,
+    Down,
+    Left,
+}
+
+internal static class DirectionExtensions
+{
+    public static Direction AntiClockwiseRotate(this Direction direction)
+    {
+        return direction switch
+        {
+            Direction.Up => Direction.Left,
+            Direction.Left => Direction.Down,
+            Direction.Down => Direction.Right,
+            Direction.Right => Direction.Up,
+            _ => throw new ArgumentOutOfRangeException(nameof(direction), direction, null)
+        };
+    }
+}

cs/TagsCloudVisualization/SpiralLayouter/PointGenerator/IPointGenerator.cs

@@ -0,0 +1,11 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+public interface IPointGenerator
+{
+    /*
+     * Infinite point generator
+     */
+    public IEnumerable<Point> StartFrom(Point startPoint);
+}

cs/TagsCloudVisualization/SpiralLayouter/PointGenerator/PolarArchimedesSpiral.cs

@@ -0,0 +1,39 @@
+using System.Collections;
+using System.Drawing;
+
+namespace TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+public class PolarArchimedesSpiral : IPointGenerator
+{
+    public double Radius { get; }
+    public double AngleOffset { get; }
+
+
+    public PolarArchimedesSpiral(double radius, double angleOffset)
+    {
+        if (radius <= 0 || angleOffset <= 0)
+        {
+            var argName = radius <= 0 ? nameof(radius) : nameof(angleOffset);
+            throw new ArgumentException("Spiral params should be positive.", argName);
+        }
+
+        Radius = radius;
+        AngleOffset = angleOffset * Math.PI / 180;
+    }
+
+    public IEnumerable<Point> StartFrom(Point startPoint)
+    {
+        var currentAngle = 0.0;
+        while (true)
+        {
+            var polarCoordinate = Radius / (2 * Math.PI) * currentAngle;
+
+            var xOffset = (int)Math.Round(polarCoordinate * Math.Cos(currentAngle));
+            var yOffset = (int)Math.Round(polarCoordinate * Math.Sin(currentAngle));
+
+            yield return startPoint + new Size(xOffset, yOffset);
+
+            currentAngle += AngleOffset;
+        }
+    }
+}

cs/TagsCloudVisualization/SpiralLayouter/PointGenerator/SquareArchimedesSpiral.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Drawing;
+
+namespace TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+public class SquareArchimedesSpiral : IPointGenerator
+{
+    public int Step { get; }
+
+    public SquareArchimedesSpiral(int step)
+    {
+        if (step <= 0)
+            throw new ArgumentException("Step should be positive number");
+
+        Step = step;
+    }
+
+    public IEnumerable<Point> StartFrom(Point startPoint)
+    {
+        var neededPoints = 1;
+        var pointsToPlace = 1;
+        var direction = Direction.Up;
+        var currentPoint = Point.Empty;
+
+        while (true)
+        {
+            yield return currentPoint;
+
+            pointsToPlace--;
+            currentPoint += GetOffsetSize(direction);
+
+            if (pointsToPlace == 0)
+            {
+                direction = direction.AntiClockwiseRotate();
+                if (direction is Direction.Up or Direction.Down) neededPoints++;
+                pointsToPlace = neededPoints;
+            }
+        }
+    }
+
+    private Size GetOffsetSize(Direction direction) => direction switch
+    {
+        Direction.Up => new Size(0, Step),
+        Direction.Right => new Size(Step, 0),
+        Direction.Down => new Size(0, -Step),
+        Direction.Left => new Size(-Step, 0),
+        _ => throw new ArgumentOutOfRangeException(nameof(direction))
+    };
+}

cs/TagsCloudVisualization/SpiralLayouter/SpiralCloudLayouter.cs

@@ -0,0 +1,48 @@
+using System.Drawing;
+using TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+namespace TagsCloudVisualization.SpiralLayouter;
+
+public class SpiralCloudLayouter : ICloudLayouter
+{
+    private List<Point> placedPoints;
+    private IPointGenerator pointGenerator;
+    private List<Rectangle> placedRectangles;
+
+    public Point Center { get; }
+
+    public SpiralCloudLayouter(Point center, IPointGenerator pointGenerator)
+    {
+        Center = center;
+        placedPoints = [];
+        placedRectangles = [];
+        this.pointGenerator = pointGenerator;
+    }
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        Rectangle placedRect;
+        try
+        {
+            placedRect = pointGenerator.StartFrom(Center)
+                .Except(placedPoints)
+                .Select(p => CreateRectangle(p, rectangleSize))
+                .First(r => !placedRectangles.Any(r.IntersectsWith));
+        }
+        catch (InvalidOperationException)
+        {
+            throw new ArgumentException("There are no more points in generator");
+        }
+
+        placedRectangles.Add(placedRect);
+        placedPoints.Add(placedRect.Location - placedRect.Size / 2);
+
+        return placedRect;
+    }
+
+    private Rectangle CreateRectangle(Point center, Size rectangleSize)
+    {
+        var rectangleUpperLeft = center - rectangleSize / 2;
+        return new Rectangle(rectangleUpperLeft, rectangleSize);
+    }
+}

cs/TagsCloudVisualization/TagsCloudVisualization.csproj

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

cs/TagsCloudVisualizationTests/Extensions/RectangleExtensions.cs

@@ -0,0 +1,12 @@
+using System.Drawing;
+
+namespace TagsCloudVisualizationTests.Extensions;
+
+public static class RectangleExtensions
+{
+    public static double Area(this Rectangle rectangle)
+    {
+        return rectangle.Width * rectangle.Height;
+    }
+
+}

cs/TagsCloudVisualizationTests/SpiralLayouter/PointGenerator/PolarArchimedesSpiralTest.cs

@@ -0,0 +1,85 @@
+using System.Drawing;
+using FluentAssertions;
+using NUnit.Framework;
+using TagsCloudVisualization.SpiralLayouter.PointGenerator;
+
+namespace TagsCloudVisualizationTests.SpiralLayouter.PointGenerator;
+
+[TestFixture]
+public class PolarArchimedesSpiralTest
+{
+    private const string NOT_POSITIVE_ARGUMENT_ERROR = "Spiral params should be positive.";
+
+    [TestCase(2, 3)]
+    [TestCase(10.1, 15.6)]
+    [TestCase(200.1111111, 23)]
+    public void PolarArchimedesSpiral_InitAtGivenPointAngleAndRadius(double radius, double angleOffset)
+    {
+        var polarSpiral = new PolarArchimedesSpiral(radius, angleOffset);
+
+        polarSpiral.Radius.Should().Be(radius);
+        polarSpiral.AngleOffset.Should().Be(angleOffset * Math.PI / 180);
+    }
+
+    public static IEnumerable<TestCaseData> ThrowErrorOnNotPositiveNumberTestCases
+    {
+        get
+        {
+            yield return new TestCaseData(new Point(0, 0), 0.0000, 11);
+            yield return new TestCaseData(new Point(0, 0), -10, -100);
+            yield return new TestCaseData(new Point(0, 0), 52, double.MinValue);
+        }
+    }
+
+    [TestCase(0.0000, 11, Description = "Zero radius error")]
+    [TestCase(-10, -100, Description = "Negative error with respect to radius")]
+    [TestCase(52, double.MinValue, Description = "Negative angle offset error")]
+    public void PolarArchimedesSpiral_ThrowError_OnNotPositiveNumber(double radius, double angleOffset)
+    {
+        var negativeParameter = radius <= 0 ? nameof(radius) : nameof(angleOffset);
+        var polarSpiralCtor = () => new PolarArchimedesSpiral(radius, angleOffset);
+
+        polarSpiralCtor.Should()
+            .Throw<ArgumentException>()
+            .WithMessage($"{NOT_POSITIVE_ARGUMENT_ERROR} (Parameter '{negativeParameter}')");
+    }
+
+
+    [Test]
+    public void PolarArchimedesSpiral_CalculateSpecialPoints()
+    {
+        var polarSpiral = new PolarArchimedesSpiral(2, 360);
+        var expected = new[]
+        {
+            new Point(0, 0), new Point(2, 0), new Point(4, 0), 
+            new Point(6, 0), new Point(8, 0), new Point(10, 0)
+        };
+
+        var pointGenerator = polarSpiral.StartFrom(new Point(0, 0));
+        var expectedAndReceived = expected.Zip(pointGenerator);
+
+        foreach (var (expectedPoint, receivedPoint) in expectedAndReceived)
+        {
+            expectedPoint.Should().BeEquivalentTo(receivedPoint);
+        }
+    }
+
+    [TestCase(1)]
+    [TestCase(10)]
+    [TestCase(100)]
+    public void PolarArchimedesSpiral_GenerateCircleLikeShape(int radius)
+    {
+        var polarSpiral = new PolarArchimedesSpiral(radius, 5);
+        var pointGenerator = polarSpiral.StartFrom(new Point(0, 0));
+
+        for (var k = 1; k <= 10; k++)
+        {
+            var radiusSquare = k * radius * k * radius;
+            pointGenerator
+                .Skip((k - 1) * 10)
+                .Take(10)
+                .All(p => p.X * p.X + p.Y * p.Y < radiusSquare)
+                .Should().BeTrue("Circle like shape should be generated");
+        }
+    }
+}