Шипицын Павел

cs/TagCloud/TagsCloudVisualization/CircularCloudLayouter.cs

@@ -0,0 +1,98 @@
+using System.Drawing;
+using TagsCloudVisualization;
+
+public class CircularCloudLayouter : ILayouter
+{
+    private readonly Point _center;
+    private readonly List<Rectangle> _placedRectangles;
+    private readonly ISpiralPointsProvider _pointsProvider;
+    private int _minDimension;
+
+    public CircularCloudLayouter(Point center, ISpiralPointsProvider pointsProvider)
+    {
+        _center = center;
+        _placedRectangles = [];
+        _pointsProvider = pointsProvider;
+        _minDimension = int.MaxValue;
+    }
+
+    public IReadOnlyList<Rectangle> PlacedRectangles => _placedRectangles.AsReadOnly();
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+            throw new ArgumentException("Rectangle size must have positive dimensions");
+
+        UpdateMinDimension(rectangleSize);
+
+        foreach (var point in _pointsProvider.GetSpiralPoints(_center, _minDimension))
+        {
+            var candidateRectangle = CreateRectangleAtPoint(rectangleSize, point);
+
+            if (IntersectsWithAny(candidateRectangle)) 
+                continue;
+
+            CompactRectangle(ref candidateRectangle);
+            _placedRectangles.Add(candidateRectangle);
+            return candidateRectangle;
+        }
+
+        throw new InvalidOperationException("Failed to find position for rectangle");
+    }
+
+    private void UpdateMinDimension(Size size)
+    {
+        _minDimension = Math.Min(_minDimension, Math.Min(size.Width, size.Height));
+    }
+
+    private Rectangle CreateRectangleAtPoint(Size size, Point point)
+    {
+        return new Rectangle(
+            point.X - size.Width / 2,
+            point.Y - size.Height / 2,
+            size.Width,
+            size.Height);
+    }
+
+    private void CompactRectangle(ref Rectangle rectangle)
+    {
+        var canMove = true;
+
+        while (canMove && !IntersectsWithAny(rectangle))
+        {
+            var movedX = TryMoveTowardsCenter(ref rectangle, Axis.X);
+            var movedY = TryMoveTowardsCenter(ref rectangle, Axis.Y);
+            canMove = movedX || movedY;
+        }
+    }
+
+    private bool TryMoveTowardsCenter(ref Rectangle rectangle, Axis axis)
+    {
+        var centerCoord = axis == Axis.X ? rectangle.X + rectangle.Width / 2 : rectangle.Y + rectangle.Height / 2;
+
+        var targetCoord = axis == Axis.X ? _center.X : _center.Y;
+        var direction = Math.Sign(targetCoord - centerCoord);
+
+        if (direction == 0)
+            return false;
+
+        var movedRectangle = rectangle;
+        if (axis == Axis.X)
+            movedRectangle.X += direction;
+        else
+            movedRectangle.Y += direction;
+
+        if (IntersectsWithAny(movedRectangle)) 
+            return false;
+
+        rectangle = movedRectangle;
+        return true;
+    }
+
+    private bool IntersectsWithAny(Rectangle rectangle)
+    {
+        return _placedRectangles.Any(rect => rect.IntersectsWith(rectangle));
+    }
+
+    private enum Axis { X, Y }
+}

cs/TagCloud/TagsCloudVisualization/IImageSaver.cs

@@ -0,0 +1,10 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace TagsCloudVisualization;
+
+public interface IImageSaver
+{
+    string GenerateFileName(string baseName);
+    string SaveBitmap(Bitmap bitmap, string fileName, ImageFormat format = null);
+}

cs/TagCloud/TagsCloudVisualization/ILayouter.cs

@@ -0,0 +1,10 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface ILayouter
+{
+    Rectangle PutNextRectangle(Size rectangleSize);
+    IReadOnlyList<Rectangle> PlacedRectangles { get; }
+
+}

cs/TagCloud/TagsCloudVisualization/IRectangleSizeProvider.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface IRectangleSizeProvider
+{
+    IEnumerable<Size> GetSizes(int count, Size minSize, Size maxSize);
+}

cs/TagCloud/TagsCloudVisualization/ISpiralPointsProvider.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface ISpiralPointsProvider
+{
+    IEnumerable<Point> GetSpiralPoints(Point center, int minDimension);
+}

cs/TagCloud/TagsCloudVisualization/IVisualizer.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface IVisualizer
+{
+    Bitmap CreateVisualization(IEnumerable<Rectangle> rectangles, Point center, TagCloudVisualizationConfig config);
+    string SaveVisualization(IEnumerable<Rectangle> rectangles, Point center, TagCloudVisualizationConfig config);
+}

cs/TagCloud/TagsCloudVisualization/ImageSaver.cs

@@ -0,0 +1,52 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace TagsCloudVisualization;
+
+public class ImageSaver : IImageSaver
+{
+    private readonly string _relativeOutputDirectory;
+
+    public ImageSaver(string relativeOutputDirectory = "out")
+    {
+        _relativeOutputDirectory = relativeOutputDirectory;
+    }
+
+    public string GenerateFileName(string baseName)
+    {
+        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
+        return $"{baseName}_{timestamp}.png";
+    }
+
+    public string SaveBitmap(Bitmap bitmap, string fileName, ImageFormat format = null)
+    {
+        ArgumentNullException.ThrowIfNull(bitmap);
+
+        if (string.IsNullOrWhiteSpace(fileName))
+            throw new ArgumentException("File name cannot be empty", nameof(fileName));
+
+        var projectDir = GetProjectDirectory();
+        var outputDir = Path.Combine(projectDir, _relativeOutputDirectory);
+        Directory.CreateDirectory(outputDir);
+
+        var filePath = Path.Combine(outputDir, fileName);
+        bitmap.Save(filePath, format ?? ImageFormat.Png);
+
+        return Path.GetFullPath(filePath);
+    }
+
+    private string GetProjectDirectory()
+    {
+        var baseDir = AppDomain.CurrentDomain.BaseDirectory;
+        var currentDir = baseDir;
+        while (currentDir != null)
+        {
+            if (Directory.GetFiles(currentDir, "*.csproj").Any())
+                return currentDir;
+            var parent = Directory.GetParent(currentDir);
+            currentDir = parent?.FullName;
+        }
+
+        return baseDir;
+    }
+}

cs/TagCloud/TagsCloudVisualization/PolarMath.cs

@@ -0,0 +1,13 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public static class PolarMath
+{
+    public static Point PolarToCartesian(double radius, double angle, Point center)
+    {
+        var x = center.X + (int)(radius * Math.Cos(angle));
+        var y = center.Y + (int)(radius * Math.Sin(angle));
+        return new Point(x, y);
+    }
+}

cs/TagCloud/TagsCloudVisualization/Program.cs

@@ -0,0 +1,75 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.ConsoleApp;
+
+class Program
+{
+    static void Main()
+    {
+        var imageSaver = new ImageSaver();
+        var visualizer = new TagCloudVisualizer(imageSaver);
+        var sizeProvider = new RandomRectangleSizeProvider();
+        var layouterFactory = (Point center) => new CircularCloudLayouter(center, new SpiralPointsProvider());
+
+        var tagCloudGenerator = new TagCloudGenerator(
+            visualizer,
+            layouterFactory,
+            sizeProvider);
+
+        Console.WriteLine("Generating tag cloud visualizations...");
+
+        List<TagCloudGenerationConfig> generationConfigs = 
+        [
+            new TagCloudGenerationConfig(
+                center: new Point(400, 300),
+                rectangleCount: 30,
+                minSize: new Size(20, 10),
+                maxSize: new Size(50, 30)
+            ),
+            new TagCloudGenerationConfig(
+                center: new Point(500, 400),
+                rectangleCount: 100,
+                minSize: new Size(30, 15),
+                maxSize: new Size(80, 40)
+            ),
+            new TagCloudGenerationConfig(
+                center: new Point(600, 450),
+                rectangleCount: 150,
+                minSize: new Size(25, 12),
+                maxSize: new Size(120, 60)
+            )
+        ];
+
+        List<TagCloudVisualizationConfig> visualizationConfigs = 
+        [
+            new TagCloudVisualizationConfig(
+                outputFileName: "cloud_small.png",
+                imageSize: new Size(800, 600),
+                backgroundColor: Color.White,
+                rectangleColor: Color.Blue,
+                centerColor: Color.Red
+            ),
+            new TagCloudVisualizationConfig(
+                outputFileName: "cloud_medium.png",
+                imageSize: new Size(1000, 800),
+                backgroundColor: Color.White,
+                rectangleColor: Color.Green,
+                centerColor: Color.Red
+            ),
+            new TagCloudVisualizationConfig(
+                outputFileName: "cloud_large.png",
+                imageSize: new Size(1200, 900),
+                backgroundColor: Color.Black,
+                rectangleColor: Color.Yellow,
+                centerColor: Color.Red
+            )
+        ];
+
+        var results = tagCloudGenerator.GenerateMultiple(generationConfigs, visualizationConfigs);
+
+        foreach (var result in results)
+        {
+            Console.WriteLine(result.StartsWith("ERROR") ? $"  - {result}" : $"- Created cloud at {result}");
+        }
+    }
+}

cs/TagCloud/TagsCloudVisualization/README.md

@@ -0,0 +1,10 @@
+# Примеры визуализации раскладки с прямоугольниками случайного размера и с разными настройками визуализации
+
+----
+![cloud_small.png](out/cloud_small.png)
+
+----
+![cloud_medium.png](out/cloud_medium.png)
+
+----
+![cloud_large.png](out/cloud_large.png)

cs/TagCloud/TagsCloudVisualization/RandomRectangleSizeProvider.cs

@@ -0,0 +1,32 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public class RandomRectangleSizeProvider : IRectangleSizeProvider
+{
+    private readonly Random _random;
+
+    public RandomRectangleSizeProvider(Random? random = null)
+    {
+        _random = random ?? new Random();
+    }
+
+    public IEnumerable<Size> GetSizes(int count, Size minSize, Size maxSize)
+    {
+        if (count <= 0)
+            throw new ArgumentException("Count must be positive", nameof(count));
+
+        if (minSize.Width <= 0 || minSize.Height <= 0)
+            throw new ArgumentException("Min size must have positive dimensions", nameof(minSize));
+
+        if (maxSize.Width < minSize.Width || maxSize.Height < minSize.Height)
+            throw new ArgumentException("Max size must be greater than or equal to min size", nameof(maxSize));
+
+        for (var i = 0; i < count; i++)
+        {
+            var width = _random.Next(minSize.Width, maxSize.Width + 1);
+            var height = _random.Next(minSize.Height, maxSize.Height + 1);
+            yield return new Size(width, height);
+        }
+    }
+}

cs/TagCloud/TagsCloudVisualization/SpiralPointsProvider.cs

@@ -0,0 +1,31 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public class SpiralPointsProvider : ISpiralPointsProvider
+{
+    private const double AngleStep = 0.05;
+    private const double RadiusStepFactor = 0.05;
+
+    private double _currentRadius;
+    private double _currentAngle;
+
+    public SpiralPointsProvider()
+    {
+        _currentRadius = 0;
+        _currentAngle = 0;
+    }
+
+    public IEnumerable<Point> GetSpiralPoints(Point center, int minDimension)
+    {
+        while (true)
+        {
+            var point = PolarMath.PolarToCartesian(_currentRadius, _currentAngle, center);
+
+            _currentAngle += AngleStep;
+            _currentRadius += minDimension * RadiusStepFactor;
+
+            yield return point;
+        }
+    }
+}