Бочаров Александр

cs/TagsCloudVisualization/CloudLayouters/CircularCloudLayouter.cs

@@ -0,0 +1,37 @@
+using System.Drawing;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.PointsGenerators;
+
+namespace TagsCloudVisualization.CloudLayouters;
+
+public class CircularCloudLayouter(Point layoutCenter, IPointsGenerator pointsGenerator) : ICircularCloudLayouter
+{
+    private const string FiniteGeneratorExceptionMessage =
+        "В конструктор CircularCloudLayouter был передан конечный генератор точек";
+    private readonly IEnumerator<Point> pointEnumerator = pointsGenerator
+        .GeneratePoints(layoutCenter)
+        .GetEnumerator();
+    private readonly List<Rectangle> layoutRectangles = [];
+
+    public CircularCloudLayouter(Point layoutCenter, double radius, double angleOffset) :
+        this(layoutCenter, new FermatSpiralPointsGenerator(radius, angleOffset))
+    {
+
+    }
+
+    public Rectangle PutNextRectangle(Size rectangleSize)
+    {
+        var rectangle = pointEnumerator
+            .ToIEnumerable()
+            .Select(point => new Rectangle()
+                .CreateRectangleWithCenter(point, rectangleSize))
+            .FirstOrDefault(rectangle => !layoutRectangles.Any(rectangle.IntersectsWith));
+
+        if (rectangle.IsEmpty)
+            throw new InvalidOperationException(FiniteGeneratorExceptionMessage);
+
+        layoutRectangles.Add(rectangle);
+        return rectangle;
+    }
+
+}

cs/TagsCloudVisualization/CloudLayouters/ICircularCloudLayouter.cs

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

cs/TagsCloudVisualization/Extensions/EnumeratorExtension.cs

@@ -0,0 +1,10 @@
+namespace TagsCloudVisualization.Extensions;
+
+public static class EnumeratorExtension
+{
+    public static IEnumerable<T> ToIEnumerable<T>(this IEnumerator<T> enumerator) {
+        while ( enumerator.MoveNext() ) {
+            yield return enumerator.Current;
+        }
+    }
+}

cs/TagsCloudVisualization/Extensions/RandomExtension.cs

@@ -0,0 +1,21 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Extensions;
+
+public static class RandomExtension
+{
+    public static Size RandomSize(this Random random, int minValue=1, int maxValue=int.MaxValue)
+    {
+        if (minValue <= 0)
+            throw new ArgumentOutOfRangeException(nameof(minValue), "minValue must be positive");
+        if (minValue > maxValue)
+            throw new ArgumentOutOfRangeException(nameof(minValue), "minValue must be less than maxValue");
+
+        return new Size(random.Next(minValue, maxValue), random.Next(minValue, maxValue));
+    }
+
+    public static Point RandomPoint(this Random random, int minValue=int.MinValue, int maxValue=int.MaxValue)
+    {
+        return new Point(random.Next(minValue, maxValue), random.Next(minValue, maxValue));
+    }
+}

cs/TagsCloudVisualization/Extensions/RectangleExtension.cs

@@ -0,0 +1,25 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Extensions;
+
+public static class RectangleExtension
+{
+    public static Rectangle CreateRectangleWithCenter(this Rectangle rectangle, Point center, Size rectangleSize)
+    {
+        var x = center.X - rectangleSize.Width / 2;
+        var y = center.Y - rectangleSize.Height / 2;
+        return new Rectangle(x, y, rectangleSize.Width, rectangleSize.Height);
+    }
+
+    public static double GetDistanceToMostRemoteCorner(this Rectangle rectangle, Point startingPoint)
+    {
+        Point[] corners = [
+            new(rectangle.X, rectangle.Y),
+            new(rectangle.X + rectangle.Width, rectangle.Y),
+            new(rectangle.X, rectangle.Y + rectangle.Height),
+            new(rectangle.X + rectangle.Width, rectangle.Y + rectangle.Height)];
+        return corners.Max(corner =>
+            Math.Sqrt((startingPoint.X - corner.X) * (startingPoint.X - corner.X) +
+                      (startingPoint.Y - corner.Y) * (startingPoint.Y - corner.Y)));
+    }
+}

cs/TagsCloudVisualization/PointsGenerators/FermatSpiralPointsGenerator.cs

@@ -0,0 +1,45 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.PointsGenerators;
+
+public class FermatSpiralPointsGenerator : IPointsGenerator
+{
+    private readonly double angleOffset;
+    private readonly double radius;
+
+    private double OffsetPerRadian => radius / (2 * Math.PI);
+
+    public FermatSpiralPointsGenerator(double radius, double angleOffset)
+    {
+        if (radius <= 0)
+            throw new ArgumentException("radius must be greater than 0", nameof(radius));
+        if (angleOffset <= 0)
+            throw new ArgumentException("angleOffset must be greater than 0", nameof(angleOffset));
+
+        this.angleOffset = angleOffset * Math.PI / 180;
+        this.radius = radius;
+    }
+
+    public IEnumerable<Point> GeneratePoints(Point spiralCenter)
+    {
+        double angle = 0;
+
+        while (true)
+        {
+            yield return GetPointByPolarCoordinates(spiralCenter, angle);
+            angle += angleOffset;
+        }
+    }
+
+    private Point GetPointByPolarCoordinates(Point spiralCenter, double angle)
+    {
+        var radiusVector = OffsetPerRadian * angle;
+
+        var x = (int)Math.Round(
+            radiusVector * Math.Cos(angle) + spiralCenter.X);
+        var y = (int)Math.Round(
+            radiusVector * Math.Sin(angle) + spiralCenter.Y);
+
+        return new Point(x, y);
+    }
+}

cs/TagsCloudVisualization/PointsGenerators/IPointsGenerator.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.PointsGenerators;
+
+public interface IPointsGenerator
+{
+    public IEnumerable<Point> GeneratePoints(Point startPoint);
+}

cs/TagsCloudVisualization/Program.cs

@@ -0,0 +1,45 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Globalization;
+using TagsCloudVisualization.CloudLayouters;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.Savers;
+using TagsCloudVisualization.Visualizers;
+
+namespace TagsCloudVisualization;
+
+public static class Program
+{
+    private const int ImageWidth = 1920;
+    private const int ImageHeight = 1080;
+
+    private const int RectanglesNumber = 1000;
+    private const int MinRectangleSize = 10;
+    private const int MaxRectangleSize = 50;
+
+    private const double LayoutRadius = 1;
+    private const double LayoutAngleOffset = 0.5;
+
+    private const string ImagesDirectory = "images";
+
+    public static void Main()
+    {
+        CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
+        var center = new Point(ImageWidth / 2, ImageHeight / 2);
+        var cloudLayouter = new CircularCloudLayouter(center, LayoutRadius, LayoutAngleOffset);
+        var random = new Random();
+        var rectangles = Enumerable
+            .Range(0, RectanglesNumber)
+            .Select(_ => cloudLayouter.PutNextRectangle(random.RandomSize
+                (MinRectangleSize, MaxRectangleSize)))
+            .ToArray();
+
+        var visualizer = new DefaultVisualizer(new Size(ImageWidth, ImageHeight));
+        var bitmap = visualizer.CreateBitmap(rectangles);
+        var saver = new DefaultBitmapSaver(ImagesDirectory);
+
+        saver.SaveBitmap(bitmap,
+            $"{RectanglesNumber}_{LayoutRadius}_{LayoutAngleOffset}_TagCloud.jpg");
+    }
+}

cs/TagsCloudVisualization/README.MD

@@ -0,0 +1,6 @@
+1000 4-угольников, радиус=1, шаг спирали равен 0.5
+<img src="images/1000_1_0,5_TagCloud.jpg">
+1000 4-угольников, радиус=1, шаг спирали равен 5
+<img src="images/1000_1_5_TagCloud.jpg">
+1000 4-угольников, радиус=100, шаг спирали равен 0.5
+<img src="images/1000_100_0,5_TagCloud.jpg">

cs/TagsCloudVisualization/Savers/DefaultBitmapSaver.cs

@@ -0,0 +1,13 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace TagsCloudVisualization.Savers;
+
+public class DefaultBitmapSaver(string bitmapDirectory="images") : IBitmapSaver
+{
+    public void SaveBitmap(Bitmap bitmap, string filename)
+    {
+        Directory.CreateDirectory(bitmapDirectory);
+        bitmap.Save(Path.Combine(bitmapDirectory, filename), ImageFormat.Jpeg);
+    }
+}

cs/TagsCloudVisualization/Savers/IBitmapSaver.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Savers;
+
+public interface IBitmapSaver
+{
+    public void SaveBitmap(Bitmap bitmap,  string filename);
+}

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/TagsCloudVisualization/Visualizers/DefaultVisualizer.cs

@@ -0,0 +1,33 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Visualizers;
+
+public class DefaultVisualizer(Size bitmapSize) : IVisualizer
+{
+    private Point bitmapCenter = new(bitmapSize.Width / 2, bitmapSize.Height / 2);
+
+    public Bitmap CreateBitmap(IEnumerable<Rectangle> rectangles)
+    {
+        var bitmap = new Bitmap(bitmapSize.Width, bitmapSize.Height);
+
+        var deltaWidth = bitmapCenter.X - rectangles.First().X;
+        var deltaHeight = bitmapCenter.Y - rectangles.First().Y;
+
+        using var graphics = Graphics.FromImage(bitmap);
+        foreach (var rectangle in rectangles)
+        {
+            var pen = new Pen(Color.DeepPink);
+            graphics.DrawRectangle(pen, 
+                CenterRectangle(rectangle, deltaWidth, deltaHeight));
+        }
+
+        return bitmap;
+    }
+
+    private Rectangle CenterRectangle(Rectangle rectangle, int deltaWidth, int deltaHeight)
+    {
+        var centeredRectanglePos = new Point(rectangle.Location.X + deltaWidth, 
+            rectangle.Location.Y + deltaHeight);
+        return new Rectangle(centeredRectanglePos, rectangle.Size);
+    }
+}

cs/TagsCloudVisualization/Visualizers/IVisualizer.cs

@@ -0,0 +1,7 @@
+namespace TagsCloudVisualization.Visualizers;
+using System.Drawing;
+
+public interface IVisualizer
+{
+    public Bitmap CreateBitmap(IEnumerable<Rectangle> rectangles);
+}