Голубев Владимир

cs/TagsCloudVisualization/Geometry/Axis.cs

@@ -0,0 +1,7 @@
+namespace TagsCloudVisualization.Geometry;
+
+public enum Axis
+{
+    X,
+    Y
+}

cs/TagsCloudVisualization/Geometry/Extensions/PointExtensions.cs

@@ -0,0 +1,19 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Geometry.Extensions;
+
+public static class PointExtensions
+{
+    public static double DistanceTo(this Point point, Point other)
+    {
+        var dx = point.X - other.X;
+        var dy = point.Y - other.Y;
+
+        return Math.Sqrt(dx * dx + dy * dy);
+    }
+
+    public static bool IsZero(this Point point)
+    {
+        return Math.Abs(point.X) < double.Epsilon && Math.Abs(point.Y) < double.Epsilon;
+    }
+}

cs/TagsCloudVisualization/Geometry/Extensions/RectangleExtensions.cs

@@ -0,0 +1,30 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Geometry.Extensions;
+
+public static class RectangleExtensions
+{
+    public static IEnumerable<Point> GetVertices(this Rectangle rectangle)
+    {
+        yield return new Point(rectangle.Left, rectangle.Top);
+        yield return new Point(rectangle.Left, rectangle.Bottom);
+        yield return new Point(rectangle.Right, rectangle.Top);
+        yield return new Point(rectangle.Right, rectangle.Bottom);
+    }
+
+    public static double GetArea(this Rectangle rectangle)
+    {
+        return rectangle.Height * rectangle.Width;
+    }
+
+    public static Point GetCenter(this Rectangle rectangle)
+    {
+        return new Point(rectangle.Left + rectangle.Width / 2, rectangle.Top + rectangle.Height / 2);
+    }
+
+    public static Rectangle MoveInDirection(this Rectangle rectangle, Point direction, int distance)
+    {
+        var newLocation = new Point(rectangle.Left + direction.X * distance, rectangle.Top + direction.Y * distance);
+        return new Rectangle(newLocation, rectangle.Size);
+    }
+}

cs/TagsCloudVisualization/Geometry/ISpiral.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Geometry;
+
+public interface ISpiral
+{
+    Point Center { get; }
+    Point GetNextPoint();
+}

cs/TagsCloudVisualization/Geometry/Spiral.cs

@@ -0,0 +1,30 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Geometry;
+
+public class ArchimedeanSpiral : ISpiral
+{
+    private double currentAngle;
+    private readonly double angleStep;
+    private readonly int spiralStep;
+
+    public Point Center { get; }
+
+    public ArchimedeanSpiral(Point center, double angleStep = 0.1, int spiralStep = 1)
+    {
+        Center = center;
+        this.angleStep = angleStep;
+        this.spiralStep = spiralStep;
+    }
+
+    public Point GetNextPoint()
+    {
+        var radius = spiralStep / (2 * Math.PI) * currentAngle;
+        var x = (int)(Center.X + radius * Math.Cos(currentAngle));
+        var y = (int)(Center.Y + radius * Math.Sin(currentAngle));
+
+        currentAngle += angleStep;
+
+        return new Point(x, y);
+    }
+}

cs/TagsCloudVisualization/Helpers/BitmapCloudSaver.cs

@@ -0,0 +1,12 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace TagsCloudVisualization.Helpers;
+
+public class BitmapCloudSaver
+{
+    public void SaveToFile(Image bitmap, string fileName, ImageFormat format)
+    {
+        bitmap.Save(fileName, format);
+    }
+}

cs/TagsCloudVisualization/Layouters/ICircularCloudLayouter.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Layouters;
+
+public interface ICircularCloudLayouter
+{
+    IReadOnlyList<Rectangle> Rectangles { get; }
+    Rectangle PutNextRectangle(Size rectangleSize);
+}

cs/TagsCloudVisualization/Layouters/QuadTree.cs

@@ -0,0 +1,188 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Layouters;
+
+public class QuadTree
+{
+    private readonly List<Rectangle> elements = new();
+    private readonly int bucketCapacity;
+    private readonly int maxDepth;
+    private readonly int level;
+
+    private QuadTree? upperLeft;
+    private QuadTree? upperRight;
+    private QuadTree? bottomLeft;
+    private QuadTree? bottomRight;
+
+    private Rectangle bounds;
+
+    public bool IsLeaf => upperLeft == null;
+
+    public QuadTree(Rectangle bounds, int bucketCapacity = 32, int maxDepth = 5, int level = 0)
+    {
+        this.bounds = bounds;
+        this.bucketCapacity = bucketCapacity;
+        this.maxDepth = maxDepth;
+        this.level = level;
+    }
+
+    public void Insert(Rectangle element)
+    {
+        if (!bounds.Contains(element))
+            ExpandBounds(element);
+
+        if (elements.Count >= bucketCapacity)
+            Split();
+
+        var containingChild = GetContainingChild(element);
+
+        if (containingChild != null)
+            containingChild.Insert(element);
+        else
+            elements.Add(element);
+    }
+
+    public bool HasIntersection(Rectangle element)
+    {
+        var nodes = new Queue<QuadTree>();
+        nodes.Enqueue(this);
+
+        while (nodes.Count > 0)
+        {
+            var node = nodes.Dequeue();
+
+            if (!element.IntersectsWith(node.bounds))
+                continue;
+
+            foreach (var item in node.elements)
+                if (item != element && element.IntersectsWith(item))
+                    return true;
+
+            if (node.IsLeaf) continue;
+
+            if (node.upperLeft != null && element.IntersectsWith(node.upperLeft.bounds))
+                nodes.Enqueue(node.upperLeft);
+
+            if (node.upperRight != null && element.IntersectsWith(node.upperRight.bounds))
+                nodes.Enqueue(node.upperRight);
+
+            if (node.bottomLeft != null && element.IntersectsWith(node.bottomLeft.bounds))
+                nodes.Enqueue(node.bottomLeft);
+
+            if (node.bottomRight != null && element.IntersectsWith(node.bottomRight.bounds))
+                nodes.Enqueue(node.bottomRight);
+        }
+
+        return false;
+    }
+
+    private void Clear()
+    {
+        elements.Clear();
+        upperLeft = upperRight = bottomLeft = bottomRight = null;
+    }
+
+    private void ExpandBounds(Rectangle newElement)
+    {
+        var minX = Math.Min(bounds.X, newElement.X);
+        var minY = Math.Min(bounds.Y, newElement.Y);
+        var maxX = Math.Max(bounds.Right, newElement.Right);
+        var maxY = Math.Max(bounds.Bottom, newElement.Bottom);
+
+        var width = maxX - minX;
+        var height = maxY - minY;
+
+        var newWidth = width * 2;
+        var newHeight = height * 2;
+
+        var centerX = (minX + maxX) / 2;
+        var centerY = (minY + maxY) / 2;
+
+        var newBounds = new Rectangle(
+            centerX - newWidth / 2,
+            centerY - newHeight / 2,
+            newWidth,
+            newHeight);
+
+        RebuildWithNewBounds(newBounds);
+    }
+
+    private void RebuildWithNewBounds(Rectangle newBounds)
+    {
+        var allElements = GetAllElements();
+
+        Clear();
+
+        bounds = newBounds;
+
+        foreach (var element in allElements) Insert(element);
+    }
+
+    private List<Rectangle> GetAllElements()
+    {
+        var result = new List<Rectangle>(elements);
+
+        if (!IsLeaf)
+        {
+            result.AddRange(upperLeft.GetAllElements());
+            result.AddRange(upperRight.GetAllElements());
+            result.AddRange(bottomLeft.GetAllElements());
+            result.AddRange(bottomRight.GetAllElements());
+        }
+
+        return result;
+    }
+
+    private void Split()
+    {
+        if (!IsLeaf)
+            return;
+
+        if (level + 1 > maxDepth)
+            return;
+
+        var halfWidth = bounds.Width / 2;
+        var halfHeight = bounds.Height / 2;
+        var x = bounds.X;
+        var y = bounds.Y;
+
+        upperLeft = new QuadTree(
+            new Rectangle(x, y, halfWidth, halfHeight),
+            bucketCapacity, maxDepth, level + 1);
+
+        upperRight = new QuadTree(
+            new Rectangle(x + halfWidth, y, halfWidth, halfHeight),
+            bucketCapacity, maxDepth, level + 1);
+
+        bottomLeft = new QuadTree(
+            new Rectangle(x, y + halfHeight, halfWidth, halfHeight),
+            bucketCapacity, maxDepth, level + 1);
+
+        bottomRight = new QuadTree(
+            new Rectangle(x + halfWidth, y + halfHeight, halfWidth, halfHeight),
+            bucketCapacity, maxDepth, level + 1);
+
+        var elements = this.elements.ToList();
+
+        foreach (var element in elements)
+        {
+            var containingChild = GetContainingChild(element);
+            if (containingChild != null)
+            {
+                this.elements.Remove(element);
+                containingChild.Insert(element);
+            }
+        }
+    }
+
+    private QuadTree? GetContainingChild(Rectangle element)
+    {
+        if (IsLeaf) return null;
+
+        foreach (var child in new[] { upperLeft, upperRight, bottomLeft, bottomRight })
+            if (child != null && child.bounds.Contains(element))
+                return child;
+
+        return null;
+    }
+}