Козлов Двнил

TagsCloudPainter/CloudDrawer/CloudDrawer.cs

@@ -0,0 +1,55 @@
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using TagsCloudPainter.Settings;
+
+namespace TagsCloudPainter.Drawer;
+
+public class CloudDrawer
+{
+    private readonly CloudSettings cloudSettings;
+    private readonly TagSettings tagSettings;
+
+    public CloudDrawer(TagSettings tagSettings, CloudSettings cloudSettings)
+    {
+        this.tagSettings = tagSettings ?? throw new ArgumentNullException(nameof(tagSettings));
+        this.cloudSettings = cloudSettings ?? throw new ArgumentNullException(nameof(cloudSettings));
+    }
+
+    public Bitmap DrawCloud(TagsCloud cloud, int imageWidth, int imageHeight)
+    {
+        if (cloud.Tags.Count == 0)
+            throw new ArgumentException("rectangles are empty");
+        if (imageWidth <= 0 || imageHeight <= 0)
+            throw new ArgumentException("either width or height of rectangle size is not positive");
+
+        var drawingScale = CalculateObjectDrawingScale(cloud.GetWidth(), cloud.GetHeight(), imageWidth, imageHeight);
+        var bitmap = new Bitmap(imageWidth, imageHeight);
+        var graphics = Graphics.FromImage(bitmap);
+        var pen = new Pen(tagSettings.TagColor);
+
+        graphics.TranslateTransform(-cloud.Center.X, -cloud.Center.Y);
+        graphics.ScaleTransform(drawingScale, drawingScale, MatrixOrder.Append);
+        graphics.TranslateTransform(cloud.Center.X, cloud.Center.Y, MatrixOrder.Append);
+        graphics.Clear(cloudSettings.BackgroundColor);
+        foreach (var tag in cloud.Tags)
+        {
+            var font = new Font(tagSettings.TagFontName, tag.Key.FontSize);
+            graphics.DrawString(tag.Key.Value, font, pen.Brush, tag.Value.Location);
+        }
+
+        return bitmap;
+    }
+
+    public static float CalculateObjectDrawingScale(float width, float height, float imageWidth, float imageHeight)
+    {
+        var scale = 1f;
+        var scaleAccuracy = 0.05f;
+        var widthScale = scale;
+        var heightScale = scale;
+        if (width * scale > imageWidth)
+            widthScale = imageWidth / width - scaleAccuracy;
+        if (height * scale > imageHeight)
+            heightScale = imageHeight / height - scaleAccuracy;
+        return Math.Min(widthScale, heightScale);
+    }
+}

TagsCloudPainter/CloudLayouter/ICloudLayouter.cs

@@ -0,0 +1,11 @@
+using System.Drawing;
+using TagsCloudPainter.Tags;
+
+namespace TagsCloudPainter.CloudLayouter;
+
+public interface ICloudLayouter : IResetable
+{
+    Rectangle PutNextTag(Tag tag);
+    TagsCloud GetCloud();
+    void PutTags(List<Tag> tags);
+}

TagsCloudPainter/CloudLayouter/TagsCloudLayouter.cs

@@ -0,0 +1,61 @@
+using System.Drawing;
+using TagsCloudPainter.FormPointer;
+using TagsCloudPainter.Settings;
+using TagsCloudPainter.Tags;
+
+namespace TagsCloudPainter.CloudLayouter;
+
+public class TagsCloudLayouter : ICloudLayouter
+{
+    private readonly Lazy<CloudSettings> cloudSettings;
+    private readonly IFormPointer formPointer;
+    private readonly TagSettings tagSettings;
+    private TagsCloud cloud;
+
+    public TagsCloudLayouter(Lazy<CloudSettings> cloudSettings, IFormPointer formPointer, TagSettings tagSettings)
+    {
+        this.cloudSettings = cloudSettings ?? throw new ArgumentNullException(nameof(cloudSettings));
+        this.formPointer = formPointer ?? throw new ArgumentNullException(nameof(formPointer));
+        this.tagSettings = tagSettings ?? throw new ArgumentNullException(nameof(tagSettings));
+    }
+
+    private TagsCloud Cloud
+    {
+        get => cloud ??= new TagsCloud(cloudSettings.Value.CloudCenter, []);
+        set => cloud = value;
+    }
+
+    public Rectangle PutNextTag(Tag tag)
+    {
+        var rectangleSize = Utils.Utils.GetStringSize(tag.Value, tagSettings.TagFontName, tag.FontSize);
+        if (rectangleSize.Height <= 0 || rectangleSize.Width <= 0)
+            throw new ArgumentException("either width or height of rectangle size is not possitive");
+
+        var nextRectangle = Utils.Utils.GetRectangleFromCenter(formPointer.GetNextPoint(), rectangleSize);
+        while (Cloud.Tags.Values.Any(rectangle => rectangle.IntersectsWith(nextRectangle)))
+            nextRectangle = Utils.Utils.GetRectangleFromCenter(formPointer.GetNextPoint(), rectangleSize);
+
+        Cloud.AddTag(tag, nextRectangle);
+
+        return nextRectangle;
+    }
+
+    public void PutTags(List<Tag> tags)
+    {
+        if (tags.Count == 0)
+            throw new ArgumentException("пустые размеры");
+        foreach (var tag in tags)
+            PutNextTag(tag);
+    }
+
+    public TagsCloud GetCloud()
+    {
+        return new TagsCloud(Cloud.Center, Cloud.Tags);
+    }
+
+    public void Reset()
+    {
+        formPointer.Reset();
+        Cloud = new TagsCloud(cloudSettings.Value.CloudCenter, []);
+    }
+}

TagsCloudPainter/FileReader/IFileReader.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudPainter.FileReader;
+
+public interface IFileReader
+{
+    public string ReadFile(string path);
+}

TagsCloudPainter/FileReader/TextFileReader.cs

@@ -0,0 +1,34 @@
+using Spire.Doc;
+
+namespace TagsCloudPainter.FileReader;
+
+public class TextFileReader : IFileReader
+{
+    public string ReadFile(string path)
+    {
+        if (!File.Exists(path))
+            throw new FileNotFoundException();
+
+        return Path.GetExtension(path) switch
+        {
+            ".txt" => ReadTxtFile(path),
+            ".doc" => ReadDocFile(path),
+            ".docx" => ReadDocFile(path),
+            _ => throw new ArgumentException("Incorrect file extension. Supported file extensions: txt, doc, docx")
+        };
+    }
+
+    private static string ReadTxtFile(string path)
+    {
+        return File.ReadAllText(path).Trim();
+    }
+
+    private static string ReadDocFile(string path)
+    {
+        var doc = new Document();
+        doc.LoadFromFile(path);
+        var text = doc.GetText();
+        var lastIndexOfSpirePart = text.IndexOf(Environment.NewLine);
+        return text.Substring(lastIndexOfSpirePart + 2).Trim();
+    }
+}

TagsCloudPainter/FormPointer/ArchimedeanSpiralPointer.cs

@@ -0,0 +1,40 @@
+using System.Drawing;
+using TagsCloudPainter.Settings;
+
+namespace TagsCloudPainter.FormPointer;
+
+public class ArchimedeanSpiralPointer : IFormPointer
+{
+    private readonly CloudSettings cloudSettings;
+    private readonly SpiralPointerSettings spiralPointerSettings;
+    private double сurrentDifference;
+
+    public ArchimedeanSpiralPointer(CloudSettings cloudSettings, SpiralPointerSettings spiralPointerSettings)
+    {
+        if (spiralPointerSettings.Step <= 0
+            || spiralPointerSettings.RadiusConst <= 0
+            || spiralPointerSettings.AngleConst <= 0)
+            throw new ArgumentException("either step or radius or angle is not possitive");
+        this.cloudSettings = cloudSettings ?? throw new ArgumentNullException(nameof(cloudSettings));
+        this.spiralPointerSettings =
+            spiralPointerSettings ?? throw new ArgumentNullException(nameof(spiralPointerSettings));
+        сurrentDifference = 0;
+    }
+
+    private double Angle => сurrentDifference * spiralPointerSettings.AngleConst;
+    private double Radius => сurrentDifference * spiralPointerSettings.RadiusConst;
+
+    public Point GetNextPoint()
+    {
+        сurrentDifference += spiralPointerSettings.Step;
+        var x = cloudSettings.CloudCenter.X + (int)(Radius * Math.Cos(Angle));
+        var y = cloudSettings.CloudCenter.Y + (int)(Radius * Math.Sin(Angle));
+
+        return new Point(x, y);
+    }
+
+    public void Reset()
+    {
+        сurrentDifference = 0;
+    }
+}

TagsCloudPainter/FormPointer/IFormPointer.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.FormPointer;
+
+public interface IFormPointer : IResetable
+{
+    Point GetNextPoint();
+}

TagsCloudPainter/IResetable.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudPainter;
+
+public interface IResetable
+{
+    void Reset();
+}

TagsCloudPainter/Parser/BoringTextParser.cs

@@ -0,0 +1,32 @@
+using TagsCloudPainter.Settings;
+
+namespace TagsCloudPainter.Parser;
+
+public class BoringTextParser : ITextParser
+{
+    private static readonly string[] _separators = [" ", ". ", ", ", "; ", "-", "—", Environment.NewLine];
+    private readonly TextSettings textSettings;
+
+    public BoringTextParser(TextSettings textSettings)
+    {
+        this.textSettings = textSettings ?? throw new ArgumentNullException(nameof(textSettings));
+    }
+
+    public List<string> ParseText(string text)
+    {
+        var boringWords = GetBoringWords(textSettings.BoringText);
+        var words = text.Split(_separators, StringSplitOptions.RemoveEmptyEntries);
+        return words.Select(word => word.ToLower()).Where(word => !boringWords.Contains(word)).ToList();
+    }
+
+    public HashSet<string> GetBoringWords(string text)
+    {
+        var words = text.Split(Environment.NewLine);
+        var boringWords = new HashSet<string>();
+
+        foreach (var word in words)
+            boringWords.Add(word.ToLower());
+
+        return boringWords;
+    }
+}

TagsCloudPainter/Parser/ITextParser.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudPainter.Parser;
+
+public interface ITextParser
+{
+    List<string> ParseText(string text);
+}

TagsCloudPainter/Settings/CloudSettings.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Settings;
+
+public class CloudSettings
+{
+    public Point CloudCenter { get; set; }
+    public Color BackgroundColor { get; set; }
+}

TagsCloudPainter/Settings/SpiralPointerSettings.cs

@@ -0,0 +1,8 @@
+namespace TagsCloudPainter.Settings;
+
+public class SpiralPointerSettings
+{
+    public double Step { get; set; } = 1;
+    public double RadiusConst { get; set; } = 1;
+    public double AngleConst { get; set; } = 1;
+}

TagsCloudPainter/Settings/TagSettings.cs

@@ -0,0 +1,10 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Settings;
+
+public class TagSettings
+{
+    public int TagFontSize { get; set; }
+    public string TagFontName { get; set; } = "Arial";
+    public Color TagColor { get; set; }
+}

TagsCloudPainter/Settings/TextSettings.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudPainter.Settings;
+
+public class TextSettings
+{
+    public string BoringText { get; set; } = string.Empty;
+}

TagsCloudPainter/Tags/ITagsBuilder.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudPainter.Tags;
+
+public interface ITagsBuilder
+{
+    public List<Tag> GetTags(List<string> words);
+}

TagsCloudPainter/Tags/Tag.cs

@@ -0,0 +1,15 @@
+namespace TagsCloudPainter.Tags;
+
+public class Tag
+{
+    public Tag(string value, float fontSize, int count)
+    {
+        Value = value ?? "";
+        FontSize = fontSize;
+        Count = count;
+    }
+
+    public string Value { get; private set; }
+    public float FontSize { get; private set; }
+    public int Count { get; private set; }
+}

TagsCloudPainter/Tags/TagsBuilder.cs

@@ -0,0 +1,44 @@
+using TagsCloudPainter.Settings;
+
+namespace TagsCloudPainter.Tags;
+
+public class TagsBuilder : ITagsBuilder
+{
+    private readonly TagSettings _settings;
+
+    public TagsBuilder(TagSettings settings)
+    {
+        _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+    }
+
+    public List<Tag> GetTags(List<string> words)
+    {
+        var countedWords = CountWords(words);
+        var tags = new List<Tag>();
+
+        foreach (var wordWithCount in countedWords)
+        {
+            var tagFontSize = GetTagFontSize(_settings.TagFontSize, wordWithCount.Value, countedWords.Count);
+            var tag = new Tag(wordWithCount.Key, tagFontSize, wordWithCount.Value);
+            tags.Add(tag);
+        }
+
+        return tags;
+    }
+
+    private static Dictionary<string, int> CountWords(List<string> words)
+    {
+        var countedWords = new Dictionary<string, int>();
+
+        foreach (var word in words)
+            if (!countedWords.TryAdd(word, 1))
+                countedWords[word] += 1;
+
+        return countedWords;
+    }
+
+    private static float GetTagFontSize(int fontSize, int tagCount, int wordsAmount)
+    {
+        return (float)tagCount / wordsAmount * fontSize * 100;
+    }
+}