Козлов Двнил

TagsCloudPainter/CloudDrawer/CloudDrawer.cs

@@ -0,0 +1,57 @@
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using TagsCloudPainter.Settings.Cloud;
+using TagsCloudPainter.Settings.Tag;
+
+namespace TagsCloudPainter.Drawer;
+
+public class CloudDrawer : ICloudDrawer
+{
+    private readonly ICloudSettings cloudSettings;
+    private readonly ITagSettings tagSettings;
+
+    public CloudDrawer(ITagSettings tagSettings, ICloudSettings 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.Item1.FontSize);
+                graphics.DrawString(tag.Item1.Value, font, pen.Brush, tag.Item2.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/CloudDrawer/ICloudDrawer.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudPainter.Drawer;
+
+public interface ICloudDrawer
+{
+    public Bitmap DrawCloud(TagsCloud cloud, int imageWidth, int imageHeight);
+}

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,65 @@
+using System.Drawing;
+using TagsCloudPainter.Extensions;
+using TagsCloudPainter.FormPointer;
+using TagsCloudPainter.Settings.Cloud;
+using TagsCloudPainter.Settings.Tag;
+using TagsCloudPainter.Sizer;
+using TagsCloudPainter.Tags;
+
+namespace TagsCloudPainter.CloudLayouter;
+
+public class TagsCloudLayouter : ICloudLayouter
+{
+    private readonly ICloudSettings cloudSettings;
+    private readonly IFormPointer formPointer;
+    private readonly IStringSizer stringSizer;
+    private readonly ITagSettings tagSettings;
+    private TagsCloud cloud;
+
+    public TagsCloudLayouter(
+        ICloudSettings cloudSettings,
+        IFormPointer formPointer,
+        ITagSettings 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();
+        cloud = new TagsCloud(cloudSettings.CloudCenter, []);
+    }
+
+    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.Any(pair => pair.Item2.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.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,17 @@
+using Spire.Doc;
+
+namespace TagsCloudPainter.FileReader;
+
+public class DocFileReader : IFileReader
+{
+    public HashSet<string> SupportedExtensions => new() { ".doc", ".docx" };
+
+    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,7 @@
+namespace TagsCloudPainter.FileReader;
+
+public interface IFileReader
+{
+    public HashSet<string> SupportedExtensions { get; }
+    public string ReadFile(string path);
+}

TagsCloudPainter/FileReader/IFormatFileReader.cs

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

TagsCloudPainter/FileReader/TextFileReader.cs

@@ -0,0 +1,26 @@
+namespace TagsCloudPainter.FileReader;
+
+public class TextFileReader : IFormatFileReader<string>
+{
+    private readonly IEnumerable<IFileReader> fileReaders;
+
+    public TextFileReader(IEnumerable<IFileReader> fileReaders)
+    {
+        this.fileReaders = fileReaders;
+    }
+
+    public string ReadFile(string path)
+    {
+        if (!File.Exists(path))
+            throw new FileNotFoundException();
+
+        var fileExtension = Path.GetExtension(path);
+        var fileReader =
+            fileReaders.FirstOrDefault(fileReader => fileReader.SupportedExtensions.Contains(fileExtension));
+
+        return fileReader is not null
+            ? fileReader.ReadFile(path)
+            : throw new ArgumentException($"Incorrect file extension {fileExtension}. " +
+                                          $"Supported file extensions: txt, doc, docx");
+    }
+}

TagsCloudPainter/FileReader/TxtFileReader.cs

@@ -0,0 +1,11 @@
+namespace TagsCloudPainter.FileReader;
+
+public class TxtFileReader : IFileReader
+{
+    public HashSet<string> SupportedExtensions => new() { ".txt" };
+
+    public string ReadFile(string path)
+    {
+        return File.ReadAllText(path).Trim();
+    }
+}

TagsCloudPainter/FormPointer/ArchimedeanSpiralPointer.cs

@@ -0,0 +1,41 @@
+using System.Drawing;
+using TagsCloudPainter.Settings.Cloud;
+using TagsCloudPainter.Settings.FormPointer;
+
+namespace TagsCloudPainter.FormPointer;
+
+public class ArchimedeanSpiralPointer : IFormPointer
+{
+    private readonly ICloudSettings cloudSettings;
+    private readonly ISpiralPointerSettings spiralPointerSettings;
+    private double сurrentDifference;
+
+    public ArchimedeanSpiralPointer(ICloudSettings cloudSettings, ISpiralPointerSettings 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 ITextSettings textSettings;
+
+    public BoringTextParser(ITextSettings 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/Cloud/CloudSettings.cs

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

TagsCloudPainter/Settings/Cloud/ICloudSettings.cs

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

TagsCloudPainter/Settings/FormPointer/ISpiralPointerSettings.cs

@@ -0,0 +1,8 @@
+namespace TagsCloudPainter.Settings.FormPointer;
+
+public interface ISpiralPointerSettings
+{
+    public double Step { get; set; }
+    public double RadiusConst { get; set; }
+    public double AngleConst { get; set; }
+}