Сибогатов Ринат

TagsCloudContainer/Interfaces/ICircularCloudLayouter.cs

@@ -0,0 +1,11 @@
+using System.Drawing;
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface ICircularCloudLayouter
+    {
+        public Point CloudCenter { get; }
+        public IList<Rectangle> Rectangles { get; }
+        Rectangle PutNextRectangle(string word, Font font);
+    }
+}

TagsCloudContainer/Interfaces/IFileReader.cs

@@ -0,0 +1,8 @@
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface IFileReader
+    {
+        IEnumerable<string> ReadWords(string filePath);
+    }
+}

TagsCloudContainer/Interfaces/IImageSettings.cs

@@ -0,0 +1,15 @@
+using System.Drawing;
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface IImageSettings
+    {
+        Color BackgroundColor { get; }
+        Color FontColor { get; }
+        Font GetFont();
+        int ImageWidth { get; set; }
+        int ImageHeight { get; set; }
+
+        void UpdateImageSettings(int width, int height);
+    }
+}

TagsCloudContainer/Interfaces/INextPointProvider.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface INextPointProvider
+    {
+        Point GetNextPoint();
+    }
+}

TagsCloudContainer/Interfaces/IPreprocessor.cs

@@ -0,0 +1,8 @@
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface IPreprocessor
+    {
+        IEnumerable<string> Process(IEnumerable<string> words, string boringWordsFilePath);
+    }
+}

TagsCloudContainer/Interfaces/ITagCloudClient.cs

@@ -0,0 +1,8 @@
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface ITagCloudClient
+    {
+        void Run();
+    }
+}

TagsCloudContainer/Interfaces/ITagCloudGenerator.cs

@@ -0,0 +1,9 @@
+using System.Drawing;
+
+namespace TagsCloudContainer.Interfaces
+{
+    public interface ITagCloudGenerator
+    {
+        Bitmap GenerateTagCloud(IEnumerable<string> words, IImageSettings imageSettings);
+    }
+}

TagsCloudContainer/Program.cs

@@ -0,0 +1,23 @@
+using CommandLine;
+using Microsoft.Extensions.DependencyInjection;
+using TagsCloudContainer.TagsCloud;
+using TagsCloudContainer.Utility;
+
+namespace TagsCloudContainer
+{
+    public class Program
+    {
+        static void Main(string[] args)
+        {
+            Parser.Default.ParseArguments<CommandLineOptions>(args)
+                    .WithParsed<CommandLineOptions>(o =>
+                    {
+                        using (var serviceProvider = Startup.ConfigureServices())
+                        {
+                            var tagCloudApp = serviceProvider.GetRequiredService<TagCloudApp>();
+                            tagCloudApp.Run(o);
+                        }
+                    });
+        }                
+    }
+}

TagsCloudContainer/Readers/DocReader.cs

@@ -0,0 +1,34 @@
+using Spire.Doc;
+using Spire.Doc.Documents;
+using TagsCloudContainer.Interfaces;
+
+namespace TagsCloudContainer.Readers
+{
+    public class DocReader : IFileReader
+    {
+        public IEnumerable<string> ReadWords(string filePath)
+        {
+            var words = new List<string>();
+
+            try
+            {
+                var document = new Document();
+                document.LoadFromFile(filePath);
+
+                foreach (Section section in document.Sections)
+                {
+                    foreach (Paragraph paragraph in section.Paragraphs)
+                    {
+                        words.AddRange(paragraph.Text.Split(' ', StringSplitOptions.RemoveEmptyEntries));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error reading .doc file: {ex.Message}");
+            }
+
+            return words;
+        }
+    }
+}

TagsCloudContainer/Readers/DocxReader.cs

@@ -0,0 +1,30 @@
+using NPOI.XWPF.UserModel;
+using TagsCloudContainer.Interfaces;
+
+namespace TagsCloudContainer.Readers
+{
+    public class DocxReader : IFileReader
+    {
+        public IEnumerable<string> ReadWords(string filePath)
+        {
+            var words = new List<string>();
+
+            try
+            {
+                using (var doc = new XWPFDocument(File.OpenRead(filePath)))
+                {
+                    foreach (var paragraph in doc.Paragraphs)
+                    {
+                        words.AddRange(paragraph.Text.Split(' ', StringSplitOptions.RemoveEmptyEntries));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error reading .docx file: {ex.Message}");
+            }
+
+            return words;
+        }
+    }
+}

TagsCloudContainer/Readers/TxtReader.cs

@@ -0,0 +1,27 @@
+using TagsCloudContainer.Interfaces;
+
+namespace TagsCloudContainer.Readers
+{
+    public class TxtReader : IFileReader
+    {
+        public IEnumerable<string> ReadWords(string filePath)
+        {
+            try
+            {
+                string[] lines = File.ReadAllLines(filePath);
+
+                var words = lines.SelectMany(line => line.Split(' '));
+
+                var nonEmptyWords = words.Where(word => !string.IsNullOrEmpty(word));
+
+                return nonEmptyWords;
+            }
+            catch (Exception ex)
+            {
+
+                Console.WriteLine($"Error reading file: {ex.Message}");
+                return Enumerable.Empty<string>();
+            }
+        }
+    }
+}

TagsCloudContainer/Startup.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using TagsCloudContainer.Interfaces;
+using TagsCloudContainer.Readers;
+using TagsCloudContainer.TagsCloud;
+
+namespace TagsCloudContainer
+{
+    public class Startup
+    {
+        public static ServiceProvider ConfigureServices()
+        {
+            return new ServiceCollection()
+            .AddSingleton<IFileReader, TxtReader>()
+            .AddSingleton<IPreprocessor, WordPreprocessor>()
+            .AddSingleton<IImageSettings, ImageSettings>()
+            .AddSingleton<ITagCloudGenerator, TagCloudGenerator>()
+            .AddScoped(provider =>
+            {
+                var fileReader = provider.GetRequiredService<IFileReader>();
+                var preprocessor = provider.GetRequiredService<IPreprocessor>();
+                var tagCloudGenerator = provider.GetRequiredService<ITagCloudGenerator>();
+                var imageSettings = provider.GetRequiredService<IImageSettings>();
+
+
+                return new TagCloudApp(preprocessor, imageSettings);
+            })
+            .BuildServiceProvider();
+        }      
+    }
+}

TagsCloudContainer/TagsCloud/CircularCloudLayouter.cs

@@ -0,0 +1,82 @@
+using System.Drawing;
+using TagsCloudContainer.Interfaces;
+
+namespace TagsCloudContainer.TagsCloud
+{
+    public class CircularCloudLayouter : ICircularCloudLayouter
+    {
+        private readonly Point center;
+        private readonly List<Rectangle> rectangles;
+        private readonly INextPointProvider pointProvider;
+
+        public CircularCloudLayouter(Point center, INextPointProvider pointProvider)
+        {
+            this.center = center;
+            rectangles = new();
+            this.pointProvider = pointProvider;
+        }
+
+        public Point CloudCenter => center;
+        public IList<Rectangle> Rectangles => rectangles;
+
+        public Rectangle PutNextRectangle(Size rectangleSize)
+        {
+            ValidateRectangleSize(rectangleSize);
+
+            var currentRectangle = CreateNewRectangle(rectangleSize);
+            rectangles.Add(currentRectangle);
+
+            return currentRectangle;
+        }
+
+        public Rectangle PutNextRectangle(string word, Font font)
+        {
+            var textSize = MeasureTextSize(word, font);
+            return PutNextRectangle(textSize);
+        }
+
+        private Size MeasureTextSize(string text, Font font)
+        {
+            using (var temporaryBitmap = new Bitmap(1, 1))
+            using (var temporaryGraphics = Graphics.FromImage(temporaryBitmap))
+            {
+                return Size.Ceiling(temporaryGraphics.MeasureString(text, font));
+            }
+        }
+
+        private void ValidateRectangleSize(Size rectangleSize)
+        {
+            if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+            {
+                throw new ArgumentException("Width and height of the rectangle must be greater than zero");
+            }
+        }
+
+        private Rectangle CreateNewRectangle(Size rectangleSize)
+        {
+            while (true)
+            {
+                var nextPoint = pointProvider.GetNextPoint();
+                var rectangleLocation = GetUpperLeftCorner(nextPoint, rectangleSize);
+                var rectangle = new Rectangle(rectangleLocation, rectangleSize);
+
+                if (!RectanglesIntersect(rectangle))
+                {
+                    return rectangle;
+                }
+            }
+        }
+
+        private Point GetUpperLeftCorner(Point rectangleCenter, Size rectangleSize)
+        {
+            return new Point(rectangleCenter.X - rectangleSize.Width / 2, rectangleCenter.Y - rectangleSize.Height / 2);
+        }
+
+        private bool RectanglesIntersect(Rectangle newRectangle)
+        {
+            return rectangles.Any(rect => rect.IntersectsWith(newRectangle));
+        }
+
+
+    }
+}

TagsCloudContainer/TagsCloud/ImageSettings.cs

@@ -0,0 +1,25 @@
+using System.Drawing;
+using TagsCloudContainer.Interfaces;
+
+namespace TagsCloudContainer.TagsCloud
+{
+    public class ImageSettings : IImageSettings
+    {
+        public Color BackgroundColor { get; } = Color.White;
+        public Color FontColor { get; } = Color.Black;
+        public int ImageWidth { get; set; } = 1600;
+        public int ImageHeight { get; set; } = 1200;
+
+        public Font GetFont()
+        {
+            return new Font("Verdana", 20);
+        }
+
+        public void UpdateImageSettings(int width, int height)
+        {
+            ImageWidth = width;
+            ImageHeight = height;
+        }
+
+    }
+}