Козлов Двнил

TagsCloudPainter/CloudDrawer/CloudDrawer.cs

@@ -0,0 +1,56 @@
+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);
+        using var graphics = Graphics.FromImage(bitmap);
+        using 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,69 @@
+using System.Drawing;
+using TagsCloudPainter.Extensions;
+using TagsCloudPainter.FormPointer;
+using TagsCloudPainter.Settings;
+using TagsCloudPainter.Sizer;
+using TagsCloudPainter.Tags;
+
+namespace TagsCloudPainter.CloudLayouter;
+
+public class TagsCloudLayouter : ICloudLayouter
+{
+    private readonly Lazy<CloudSettings> cloudSettings;
+    private readonly IFormPointer formPointer;
+    private readonly IStringSizer stringSizer;
+    private readonly TagSettings tagSettings;
+    private TagsCloud cloud;
+
+    public TagsCloudLayouter(
+        Lazy<CloudSettings> cloudSettings,
+        IFormPointer formPointer,
+        TagSettings tagSettings,
+        IStringSizer stringSizer)
+    {
+        this.cloudSettings = cloudSettings ?? throw new ArgumentNullException(nameof(cloudSettings));
+        this.formPointer = formPointer ?? throw new ArgumentNullException(nameof(formPointer));
+        this.tagSettings = tagSettings ?? throw new ArgumentNullException(nameof(tagSettings));
+        this.stringSizer = stringSizer ?? throw new ArgumentNullException();
+    }
+
+    private TagsCloud Cloud
+    {
+        get => cloud ??= new TagsCloud(cloudSettings.Value.CloudCenter, []);
+        set => cloud = value;
+    }
+
+    public Rectangle PutNextTag(Tag tag)
+    {
+        var tagSize = stringSizer.GetStringSize(tag.Value, tagSettings.TagFontName, tag.FontSize);
+        if (tagSize.Height <= 0 || tagSize.Width <= 0)
+            throw new ArgumentException("either width or height of rectangle size is not possitive");
+
+        var nextRectangle = formPointer.GetNextPoint().GetRectangle(tagSize);
+        while (Cloud.Tags.Values.Any(rectangle => rectangle.IntersectsWith(nextRectangle)))
+            nextRectangle = formPointer.GetNextPoint().GetRectangle(tagSize);
+
+        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/Extensions/PointExtension.cs

@@ -0,0 +1,14 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Extensions;
+
+public static class PointExtension
+{
+    public static Rectangle GetRectangle(this Point center, Size size)
+    {
+        var x = center.X - size.Width / 2;
+        var y = center.Y - size.Height / 2;
+
+        return new Rectangle(new Point(x, y), size);
+    }
+}

TagsCloudPainter/Extensions/RectangleExtensions.cs

@@ -0,0 +1,13 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Extensions;
+
+public static class RectangleExtensions
+{
+    public static Point GetCenter(this Rectangle rectangle)
+    {
+        var x = rectangle.X;
+        var y = rectangle.Y;
+        return new Point(x + rectangle.Width / 2, y + rectangle.Height / 2);
+    }
+}

TagsCloudPainter/FileReader/DocFileReader.cs

@@ -0,0 +1,15 @@
+using Spire.Doc;
+
+namespace TagsCloudPainter.FileReader;
+
+internal class DocFileReader : IFileReader
+{
+    public string ReadFile(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/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,21 @@
+namespace TagsCloudPainter.FileReader;
+
+public class TextFileReader : IFileReader
+{
+    private readonly DocFileReader docFileReader = new();
+    private readonly TxtFileReader txtFileReader = new();
+
+    public string ReadFile(string path)
+    {
+        if (!File.Exists(path))
+            throw new FileNotFoundException();
+
+        return Path.GetExtension(path) switch
+        {
+            ".txt" => txtFileReader.ReadFile(path),
+            ".doc" => docFileReader.ReadFile(path),
+            ".docx" => docFileReader.ReadFile(path),
+            _ => throw new ArgumentException("Incorrect file extension. Supported file extensions: txt, doc, docx")
+        };
+    }
+}

TagsCloudPainter/FileReader/TxtFileReader.cs

@@ -0,0 +1,9 @@
+namespace TagsCloudPainter.FileReader;
+
+internal class TxtFileReader : IFileReader
+{
+    public string ReadFile(string path)
+    {
+        return File.ReadAllText(path).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,11 @@
+using System.Drawing;
+using System.Drawing.Text;
+
+namespace TagsCloudPainter.Settings;
+
+public class TagSettings
+{
+    public int TagFontSize { get; set; }
+    public string TagFontName { get; set; } = new InstalledFontCollection().Families.FirstOrDefault().Name;
+    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/Sizer/IStringSizer.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Sizer;
+
+public interface IStringSizer
+{
+    Size GetStringSize(string value, string fontName, float fontSize);
+}