Ослина Анастасия

TagsCloudVisualization/App/ConsoleApp.cs

@@ -0,0 +1,35 @@
+using TagsCloudVisualization.ConsoleCommands;
+using TagsCloudVisualization.FileReaders;
+using TagsCloudVisualization.Layouters;
+using TagsCloudVisualization.Renderers;
+using TagsCloudVisualization.WordPreprocessors;
+
+namespace TagsCloudVisualization.App;
+
+public class ConsoleApp : IApp
+{
+    private readonly IWordPreprocessor wordPreprocessor;
+    private readonly IFileReader fileReader;
+    private readonly ICloudLayouter cloudLayouter;
+    private readonly ICloudRenderer cloudRenderer;
+    private readonly string inputFilePath;
+
+    public ConsoleApp(IWordPreprocessor wordPreprocessor,
+        IFileReader fileReader,
+        ICloudLayouter cloudLayouter,
+        ICloudRenderer cloudRenderer,
+        Options options)
+    {
+        this.wordPreprocessor = wordPreprocessor;
+        this.fileReader = fileReader;
+        this.cloudLayouter = cloudLayouter;
+        this.cloudRenderer = cloudRenderer;
+        inputFilePath = options.InputFilePath;
+    }
+
+    public void Run()
+    {
+        var words = wordPreprocessor.ProcessWords(fileReader.Read(inputFilePath));
+        cloudRenderer.Render(cloudLayouter.CreateTagsCloud(words));
+    }
+}

TagsCloudVisualization/App/IApp.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudVisualization.App;
+
+public interface IApp
+{
+    public void Run();
+}

TagsCloudVisualization/ConsoleCommands/Options.cs

@@ -0,0 +1,25 @@
+using CommandLine;
+
+namespace TagsCloudVisualization.ConsoleCommands;
+
+public class Options
+{
+    [Option('i', "inputFilePath", Required = true, HelpText = "Set input file path.")]
+    public string InputFilePath { get; set; }
+
+    [Option('o', "outputFilePath", Required = true, HelpText = "Set output file path.")]
+    public string OutputFilePath { get; set; }
+
+    [Option('f', "font", Default = "Arial", HelpText = "Set font for tags cloud words.")]
+    public string TagsFont { get; set; }
+
+    [Option('h', "imageHeight", Default = 1080, HelpText = "Set output image height.")]
+    public int ImageHeight { get; set; }
+
+    [Option('w', "imageWidth", Default = 1920, HelpText = "Set output image width.")]
+    public int ImageWidth { get; set; }
+
+    [Option('b', "backgroundColor", Default = "Empty", 
+        HelpText = "Set background color for tags cloud.")]
+    public string BackgroundColor { get; set; }
+}

TagsCloudVisualization/ContainerConfig.cs

@@ -0,0 +1,41 @@
+using Autofac;
+using MyStemWrapper;
+using TagsCloudVisualization.App;
+using TagsCloudVisualization.ConsoleCommands;
+using TagsCloudVisualization.Distributors;
+using TagsCloudVisualization.FileReaders;
+using TagsCloudVisualization.Layouters;
+using TagsCloudVisualization.Renderers;
+using TagsCloudVisualization.Renderers.ColorGenerators;
+using TagsCloudVisualization.WordPreprocessors;
+using TagsCloudVisualization.WordPreprocessors.FontCreators;
+using TagsCloudVisualization.WordPreprocessors.WordValidators;
+
+namespace TagsCloudVisualization;
+
+public static class ContainerConfig
+{
+    public static IContainer Configure(Options options)
+    {
+        var builder = new ContainerBuilder();
+        builder.RegisterInstance(options).AsSelf().SingleInstance();
+        builder.RegisterType<DefaultColorGenerator>().As<IColorGenerator>().SingleInstance();
+        builder.RegisterType<SpiralDistribution>().As<ICloudDistribution>();
+        builder.RegisterType<DefaultRenderer>().As<ICloudRenderer>();
+        builder.RegisterType<DelegateFileReader>().As<IFileReader>();
+        builder.RegisterType<DefaultFontCreator>().As<IFontCreator>();
+        builder.RegisterType<DefaultWordValidator>().As<IWordValidator>();
+        builder.RegisterType<DefaultWordPreprocessor>().As<IWordPreprocessor>();
+        builder.RegisterType<CircularCloudLayouter>().As<ICloudLayouter>();
+        builder.RegisterType<ConsoleApp>().As<IApp>();
+
+        var myStem = new MyStem
+        {
+            PathToMyStem = Path.GetFullPath("Utilities\\mystem.exe"),
+            Parameters = "-ni"
+        };
+        builder.RegisterInstance(myStem).AsSelf().SingleInstance();
+
+        return builder.Build();
+    }
+}

TagsCloudVisualization/Distributors/ICloudDistribution.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Distributors;
+
+public interface ICloudDistribution
+{
+    public Point GetNextPoint();
+}

TagsCloudVisualization/Distributors/SpiralDistribution.cs

@@ -0,0 +1,35 @@
+using System.Drawing;
+using TagsCloudVisualization.ConsoleCommands;
+
+namespace TagsCloudVisualization.Distributors;
+
+public class SpiralDistribution : ICloudDistribution
+{
+    private const double AngleStep = 0.02;
+    private const double RadiusStep = 0.01;
+    private double angle;
+    private double radius;
+    private readonly Point cloudCenter;
+
+    public SpiralDistribution(Options options)
+    {
+        cloudCenter = new Point(options.ImageWidth / 2, options.ImageHeight / 2);
+    }
+
+    public Point GetNextPoint()
+    {
+        var nextPoint = ConvertPolarToCartesian();
+        angle += AngleStep;
+        radius += RadiusStep;
+        return nextPoint;
+    }
+
+    public Point GetCenter() => cloudCenter;
+
+    private Point ConvertPolarToCartesian()
+    {
+        var cartesian = new Point((int)(radius * Math.Cos(angle)), (int)(radius * Math.Sin(angle)));
+        cartesian.Offset(cloudCenter);
+        return cartesian;
+    }
+}

TagsCloudVisualization/Domain/Tag.cs

@@ -0,0 +1,17 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Domain;
+
+public class Tag
+{
+    public readonly Rectangle Rectangle;
+    public readonly Font Font;
+    public readonly string Content;
+
+    public Tag(Rectangle rectangle, Font font, string content)
+    {
+        Rectangle = rectangle;
+        Font = font;
+        Content = content;
+    }
+}

TagsCloudVisualization/FileReaders/DelegateFileReader.cs

@@ -0,0 +1,33 @@
+namespace TagsCloudVisualization.FileReaders;
+
+//Хочу попробовать переписать на visitor, чтобы избежать свича
+public class DelegateFileReader : IFileReader
+{
+    public IEnumerable<string> Read(string filePath)
+    {
+        try
+        {
+            var reader = CreateReader(filePath);
+            return reader.Read(filePath);
+        }
+        catch (Exception e)
+        {
+            throw new Exception(e.Message);
+        }
+    }
+
+    private static IFileReader CreateReader(string filePath)
+    {
+        if (!File.Exists(filePath))
+            throw new FileNotFoundException("File not found", filePath);
+
+        var extension = Path.GetExtension(filePath).Trim('.');
+        Enum.TryParse(extension, true, out FileType fileType);
+
+        return fileType switch
+        {
+            FileType.Txt => new TextFileReader(),
+            _ => throw new NotSupportedException($"File type {fileType} is not supported.")
+        };
+    }
+}

TagsCloudVisualization/FileReaders/FileType.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudVisualization.FileReaders;
+
+public enum FileType
+{
+    Txt
+}

TagsCloudVisualization/FileReaders/IFileReader.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudVisualization.FileReaders;
+
+public interface IFileReader
+{
+    public IEnumerable<string> Read(string filePath);
+}

TagsCloudVisualization/FileReaders/TextFileReader.cs

@@ -0,0 +1,9 @@
+namespace TagsCloudVisualization.FileReaders;
+
+public class TextFileReader : IFileReader
+{
+    public IEnumerable<string> Read(string filePath)
+    {
+        return File.ReadAllLines(filePath);
+    }
+}

TagsCloudVisualization/Layouters/CircularCloudLayouter.cs

@@ -0,0 +1,53 @@
+using System.Drawing;
+using TagsCloudVisualization.Distributors;
+using TagsCloudVisualization.Domain;
+using TagsCloudVisualization.WordPreprocessors.FontCreators;
+
+namespace TagsCloudVisualization.Layouters;
+
+public class CircularCloudLayouter : ICloudLayouter
+{
+    private readonly ICloudDistribution distribution;
+    private readonly IFontCreator fontCreator;
+
+    public CircularCloudLayouter(ICloudDistribution distribution, IFontCreator fontCreator)
+    {
+        this.distribution = distribution;
+        this.fontCreator = fontCreator;
+    }
+
+    public IEnumerable<Tag> CreateTagsCloud(Dictionary<string, int> wordsCollection)
+    {
+        List<Tag> tags = [];
+        using var graphic = Graphics.FromImage(new Bitmap(1, 1));
+        foreach (var word in wordsCollection)
+        {
+            var tagFont = fontCreator.CreateFont(word.Value);
+            var rectangleSize = ConvertWordToRectangleSize(graphic, word.Key, tagFont);
+            var rectangle = GetNextRectangle(tags, rectangleSize);
+
+            tags.Add(new Tag(rectangle, tagFont, word.Key));
+        }
+
+        return tags;
+    }
+
+    private Rectangle GetNextRectangle(List<Tag> tags, Size rectangleSize)
+    {
+        if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+            throw new ArgumentException("The rectangle size must be greater than zero.");
+
+        var newRectangle = new Rectangle(distribution.GetNextPoint(), rectangleSize);
+
+        while (tags.Any(r => r.Rectangle.IntersectsWith(newRectangle)))
+            newRectangle.Location = distribution.GetNextPoint();
+
+        return newRectangle;
+    }
+
+    private static Size ConvertWordToRectangleSize(Graphics graphic, string word, Font font)
+    {
+        var sizeF = graphic.MeasureString(word, font);
+        return new Size((int)Math.Ceiling(sizeF.Width), (int)Math.Ceiling(sizeF.Height));
+    }
+}

TagsCloudVisualization/Layouters/ICloudLayouter.cs

@@ -0,0 +1,8 @@
+using TagsCloudVisualization.Domain;
+
+namespace TagsCloudVisualization.Layouters;
+
+public interface ICloudLayouter
+{
+    public IEnumerable<Tag> CreateTagsCloud(Dictionary<string, int> wordsCollection);
+}

TagsCloudVisualization/Program.cs

@@ -0,0 +1,18 @@
+using Autofac;
+using CommandLine;
+using TagsCloudVisualization.App;
+using TagsCloudVisualization.ConsoleCommands;
+
+namespace TagsCloudVisualization;
+
+public class Program
+{
+    static void Main(string[] args)
+    {
+        var options = Parser.Default.ParseArguments<Options>(args).Value;
+        var container = ContainerConfig.Configure(options);
+
+        using var scope = container.BeginLifetimeScope();
+        scope.Resolve<IApp>().Run();
+    }
+}

TagsCloudVisualization/Renderers/ColorGenerators/DefaultColorGenerator.cs

@@ -0,0 +1,13 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Renderers.ColorGenerators;
+
+public class DefaultColorGenerator : IColorGenerator
+{
+    private static Random random = new();
+
+    public Color GetColor()
+    {
+        return Color.FromArgb(random.Next(0, 255), random.Next(0, 255), random.Next(0, 255));
+    }
+}

TagsCloudVisualization/Renderers/ColorGenerators/IColorGenerator.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization.Renderers.ColorGenerators;
+
+public interface IColorGenerator
+{
+    public Color GetColor();
+}