Шмаков Данил

.gitignore

@@ -20,6 +20,7 @@ x64/
 x86/
 bld/
 [Bb]in/
+![Bbin]/**/mystem.exe
 [Oo]bj/
 
 # Visual Studio 2015 cache/options directory

TagCloud/CircularCloudLayouter.cs

@@ -0,0 +1,38 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class CircularCloudLayouter
+{
+    private List<Rectangle> rectangles;
+    private Point center;
+    private ICloudShaper shaper;
+
+    public IEnumerable<Rectangle> Rectangles => rectangles;
+
+    public CircularCloudLayouter(Point center, ICloudShaper shaper)
+    {
+        this.center = center;
+        rectangles = new List<Rectangle>();
+        this.shaper = shaper;
+    }
+
+    public Rectangle PutNextRectangle(Size size)
+    {
+        if (size.Width <= 0)
+            throw new ArgumentException("Size width must be positive number");
+        if (size.Height <= 0)
+            throw new ArgumentException("Size height must be positive number");
+
+        Rectangle rectangle = Rectangle.Empty;
+        foreach (var point in shaper.GetPossiblePoints())
+        {
+            rectangle = new Rectangle(point, size);
+            if (!Rectangles.Any(rect => rect.IntersectsWith(rectangle)))
+                break;
+        }
+
+        rectangles.Add(rectangle);
+        return rectangle;
+    }
+}

TagCloud/CloudDrawers/CloudDrawer.cs

@@ -0,0 +1,11 @@
+using System.Drawing;
+using TagCloud;
+
+namespace TagCloudTests;
+
+public interface ICloudDrawer
+{
+    int FontSize { get; }
+    void Draw(IEnumerable<TextRectangle> rectangle);
+    Size GetTextRectangleSize(string text, int size);
+}

TagCloud/CloudDrawers/TagCloudDrawer.cs

@@ -0,0 +1,72 @@
+using System.Drawing;
+using TagCloudTests;
+
+namespace TagCloud;
+
+public class TagCloudDrawer : ICloudDrawer
+{
+    private readonly string path;
+    private readonly IColorSelector selector;
+    private readonly string name;
+    private readonly int fontSize;
+
+    private TagCloudDrawer(string path, string name, IColorSelector selector, int fontSize)
+    {
+        this.path = path;
+        this.selector = selector;
+        this.fontSize = fontSize;
+        this.name = name;
+    }
+
+    public int FontSize => fontSize;
+
+    public void Draw(IEnumerable<TextRectangle> rectangles)
+    {
+        if (rectangles.Count() == 0)
+            throw new ArgumentException("Empty rectangles list");
+
+        var minX = rectangles.Min(rect => rect.X);
+        var maxX = rectangles.Max(rect => rect.Right);
+        var minY = rectangles.Min(rect => rect.Top);
+        var maxY = rectangles.Max(rect => rect.Bottom);
+
+        using var bitmap = new Bitmap(maxX - minX + 2, maxY - minY + 2);
+        using var graphics = Graphics.FromImage(bitmap);
+        graphics.DrawRectangles(
+            selector, 
+            rectangles
+                .Select(rect => rect with { X = -minX + rect.X, Y = -minY + rect.Y })
+                .Select(rect => new Rectangle(rect.X, rect.Y, rect.Width, rect.Height))
+                .ToArray()
+        );
+        graphics.DrawStrings(
+            selector, 
+            rectangles
+                .Select(rect => rect with { X = -minX + rect.X, Y = -minY + rect.Y })
+                .ToArray()
+        );
+
+        SaveToFile(bitmap);
+    }
+
+    public Size GetTextRectangleSize(string text, int size)
+    {
+        var graphics = Graphics.FromImage(new Bitmap(1,1));
+        var sizeF = graphics.MeasureString(text, new Font(FontFamily.GenericSerif, size));
+        return new Size((int)sizeF.Width, (int)sizeF.Height);
+    }
+
+    private void SaveToFile(Bitmap bitmap)
+    {
+        var pathToFile = @$"{path}\{name}.jpg";
+        bitmap.Save(pathToFile);
+        Console.WriteLine($"Tag cloud visualization saved to file {path}");
+    }
+
+    public static TagCloudDrawer Create(string path, string name, int size, IColorSelector selector)
+    {
+        if (!Directory.Exists(path))
+            throw new ArgumentException("Directory does not exist");
+        return new TagCloudDrawer(path, name, selector, size);
+    }
+}

TagCloud/ColorSelectors/ConstantColorSelector.cs

@@ -0,0 +1,15 @@
+using System.Drawing;
+using TagCloudTests;
+
+namespace TagCloud;
+
+public class ConstantColorSelector : IColorSelector
+{
+    private Color color;
+    public ConstantColorSelector(Color color)
+    {
+        this.color = color;
+    }
+
+    public Color PickColor() => color;
+}

TagCloud/ColorSelectors/IColorSelector.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagCloudTests;
+
+public interface IColorSelector
+{
+    Color PickColor();
+}

TagCloud/ColorSelectors/RandomColorSelector.cs

@@ -0,0 +1,22 @@
+using System.Drawing;
+
+namespace TagCloudTests;
+
+public class RandomColorSelector : IColorSelector
+{
+    private readonly Random random;
+
+    public RandomColorSelector()
+    {
+        random = new Random(DateTime.Now.Microsecond);
+    }
+
+    public Color PickColor()
+    {
+        return Color.FromArgb(255,
+            random.Next(0, 255),
+            random.Next(0, 255),
+            random.Next(0, 255)
+        );
+    }
+}

TagCloud/Extensions.cs

@@ -0,0 +1,27 @@
+using System.Drawing;
+using TagCloudTests;
+
+namespace TagCloud;
+
+public static class Extensions
+{
+    public static void DrawRectangles(this Graphics graphics, IColorSelector selector, Rectangle[] rectangles, int lineWidth = 1)
+    {
+        var pen = new Pen(selector.PickColor(), lineWidth);
+        foreach (var rectangle in rectangles)
+        {
+            graphics.DrawRectangle(pen, rectangle);
+            pen.Color = selector.PickColor();
+        }
+    }
+
+    public static void DrawStrings(this Graphics graphics, IColorSelector selector, TextRectangle[] rectangles)
+    {
+        var brush = new SolidBrush(selector.PickColor());
+        foreach (var rectangle in rectangles)
+        {
+            graphics.DrawString(rectangle.Text, rectangle.Font, brush, rectangle.X, rectangle.Y);
+            brush.Color = selector.PickColor();
+        }
+    }
+}

TagCloud/ICloudShaper.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public interface ICloudShaper
+{
+    IEnumerable<Point> GetPossiblePoints();
+}

TagCloud/Option.cs

@@ -0,0 +1,49 @@
+using CommandLine;
+
+namespace TagCloudApplication;
+
+public class Options
+{
+    [Option('d', "destination", HelpText = "Set destination path.", Default = @"..\..\..\Results")]
+    public string DestinationPath { get; set; }
+
+    [Option('s', "source", HelpText = "Set source path.", Default = @"..\..\..\Results\text.txt")]
+    public string SourcePath { get; set; }
+
+    [Option('n', "name", HelpText = "Set name.", Default = "default")]
+    public string Name { get; set; }
+
+    [Option('c', "color", HelpText = "Set color.", Default = "random")]
+    public string ColorScheme { get; set; }
+
+    [Option('f', "font", HelpText = "Set font.", Default = "Comic Sans")]
+    public string Font { get; set; }
+
+    [Option("size", HelpText = "Set font size.", Default = 20)]
+    public int FontSize { get; set; }
+
+    [Option("width", HelpText = "Set width.", Default = 100)]
+    public int Width { get; set; }
+
+    [Option("height", HelpText = "Set height.", Default = 100)]
+    public int Height { get; set; }
+
+    public static Options Default
+    {
+        get
+        {
+            var options = new Options();
+            foreach (var property in typeof(Options).GetProperties())
+            {
+                var option = property
+                    .GetCustomAttributes(typeof(OptionAttribute), false)
+                    .Cast<OptionAttribute>()
+                    .FirstOrDefault();
+                if (option != null && option.Default != null)
+                    property.SetValue(options, option.Default);
+            }
+
+            return options;
+        }
+    }
+}

TagCloud/SpiralCloudShaper.cs

@@ -0,0 +1,53 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class SpiralCloudShaper : ICloudShaper
+{
+    private Point center;
+    private double coefficient;
+    private double deltaAngle;
+
+    private SpiralCloudShaper(Point center, double coefficient, double deltaAngle)
+    {
+        this.center = center;
+        this.deltaAngle = deltaAngle;
+        this.coefficient = coefficient;
+    }
+
+    public IEnumerable<Point> GetPossiblePoints()
+    {
+        var currentAngle = 0D;
+        var position = center;
+        var previousPoint = position;
+        while(true)
+        {
+            while (position == previousPoint)
+            {
+                currentAngle += deltaAngle;
+                previousPoint = position;
+                position = CalculatePointByCurrentAngle(currentAngle);
+            }
+            yield return position;
+            previousPoint = position;
+            position = CalculatePointByCurrentAngle(currentAngle);
+        }
+    }
+
+    private Point CalculatePointByCurrentAngle(double angle)
+    {
+        return new Point(
+            center.X + (int)(coefficient * angle * Math.Cos(angle)), 
+            center.Y + (int)(coefficient * angle * Math.Sin(angle))
+        );
+    }
+
+    public static SpiralCloudShaper Create(Point center, double coefficient = 0.1, double deltaAngle = 0.1)
+    {
+        if (coefficient <= 0)
+            throw new ArgumentException("Spiral coefficient must be positive number");
+        if (deltaAngle <= 0)
+            throw new ArgumentException("Spiral delta angle must be positive number");
+        return new SpiralCloudShaper(center, coefficient, deltaAngle);
+    }
+}

TagCloud/TagCloud.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="CommandLineParser" Version="2.9.1" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+      <PackageReference Include="MyStemWrapper" Version="1.0.0" />
+      <PackageReference Include="System.Drawing.Common" Version="8.0.0" />
+    </ItemGroup>
+
+</Project>