Алешев Руслан

TagsCloudContainer/CLI/CommandLineOptions.cs

@@ -0,0 +1,138 @@
+using CommandLine;
+using System.Drawing;
+using TagsCloudContainer.SettingsClasses;
+using TagsCloudContainer.TagCloudBuilder;
+using TagsCloudVisualization;
+
+namespace TagsCloudContainer.CLI
+{
+    class CommandLineOptions
+    {
+        [Option('f', "filename", Required = true, HelpText = "Input file name.")]
+        public string Filename { get; set; }
+
+        [Option('o', "output", Required = true, HelpText = "Output file name.")]
+        public string Output { get; set; }
+
+        [Option("font", Required = false, HelpText = "Set the font family name.")]
+        public string FontFamily { get; set; }
+
+        [Option("fontsize", Required = false, HelpText = "Set the font size. Must be a positive integer.")]
+        public int FontSize { get; set; }
+
+        [Option("colors", Required = false, HelpText = "List of color names. Separated by commas.")]
+        public string Colors { get; set; }
+
+        [Option("size", Required = false, HelpText = "Set the image size. Must be two positive integer.")]
+        public Size Size { get; set; }
+
+        [Option("exclude", Required = false, HelpText = "File with words to exclude.")]
+        public string Filter { get; set; }
+
+        [Option("layout", Required = false, HelpText = "Set cloud layouter - Spiral, Random or Normal.")]
+        public string Layout { get; set; }
+
+        public static AppSettings ParseArgs(CommandLineOptions options)
+        {
+            var appSettings = new AppSettings();
+            appSettings.DrawingSettings = new();
+
+            appSettings.TextFile = options.Filename;
+            appSettings.OutImagePath = options.Output;
+            appSettings.FilterFile = options.Filter;
+
+            appSettings.DrawingSettings.FontFamily = GetFontFamily(options.FontFamily);
+            appSettings.DrawingSettings.FontSize = GetFontSize(options.FontSize);
+            appSettings.DrawingSettings.Size = GetSize(options.Size);
+            appSettings.DrawingSettings.Colors = GetColors(options.Colors);
+            appSettings.DrawingSettings.PointsProvider = GetPointsProvider(
+                options.Layout,
+                appSettings.DrawingSettings.Size);
+
+            return appSettings;
+        }
+
+        private static int GetFontSize(int fontSize)
+        {
+            if (fontSize > 0)
+            {
+                return fontSize;
+            }
+            return 12;
+        }
+
+        private static Size GetSize(Size size)
+        {
+            if (size.IsEmpty)
+            {
+                return new Size(800, 600);
+            }
+            return size;
+        }
+
+        private static IPointsProvider GetPointsProvider(string layout, Size size)
+        {
+            var center = new Point(size.Width / 2, size.Height / 2);
+            IPointsProvider pointProvider = new SpiralPointsProvider();
+
+            if (string.IsNullOrEmpty(layout))
+            {
+                pointProvider.Initialize(center);
+                return pointProvider;
+            }
+
+            switch (layout.ToLowerInvariant())
+            {
+                case "random":
+                    pointProvider = new RandomPointsProvider();
+                    break;
+
+                case "normal":
+                    pointProvider = new NormalPointsProvider();
+                    break;
+
+                case "Spiral":
+                    pointProvider = new NormalPointsProvider();
+                    break;
+
+                default:
+                    pointProvider = new SpiralPointsProvider();
+                    break;
+            }
+
+            pointProvider.Initialize(center);
+            return pointProvider;
+        }
+
+        private static FontFamily GetFontFamily(string fontName)
+        {
+            try
+            {
+                var fontFamily = new FontFamily(fontName);
+                return fontFamily;
+            }
+            catch (ArgumentException)
+            {
+                Console.WriteLine("Font {0} not found. Using default font.", fontName);
+                return new FontFamily("Arial");
+            }
+        }
+
+        private static IList<Color> GetColors(string colors)
+        {
+            if (string.IsNullOrEmpty(colors))
+            {
+                return new List<Color>() { Color.White };
+            }
+
+            var c = colors.Split(',').Select(x => Color.FromName(x)).ToList();
+
+            if (c.Count > 0)
+            {
+                return c.ToList();
+            }
+
+            return new List<Color>() { Color.White };
+        }
+    }
+}

TagsCloudContainer/ColorMapper.cs

@@ -0,0 +1,36 @@
+using System.Drawing;
+
+namespace TagsCloudContainer
+{
+    public class ColorMapper
+    {
+        public static Dictionary<int, Color> MapColors(IEnumerable<int> numbers, IList<Color> colors)
+        {
+            var distinctNumbers = numbers.Distinct().OrderByDescending(x => x);
+            var colorMapping = new Dictionary<int, Color>();
+
+            if (!distinctNumbers.Any() || !colors.Any())
+            {
+                return colorMapping;
+            }
+
+            int partitionSize = distinctNumbers.Count() / colors.Count;
+
+            int i = 0;
+            int j = 0;
+
+            foreach (var number in distinctNumbers)
+            {
+                colorMapping[number] = colors[j];
+                if (i >= partitionSize)
+                {
+                    i = 0;
+                    j = Math.Min(colors.Count - 1, j + 1);
+                }
+                i++;
+            }
+
+            return colorMapping;
+        }
+    }
+}

TagsCloudContainer/DependencyInjectionConfig.cs

@@ -0,0 +1,25 @@
+using Microsoft.Extensions.DependencyInjection;
+using TagsCloudContainer.FrequencyAnalyzers;
+using TagsCloudContainer.SettingsClasses;
+using TagsCloudContainer.TagCloudBuilder;
+using TagsCloudContainer.TextTools;
+using TagsCloudVisualization;
+
+namespace TagsCloudContainer
+{
+    public class DependencyInjectionConfig
+    {
+        public static IServiceCollection AddCustomServices(IServiceCollection services)
+        {
+            services.AddSingleton<ITextReader, TextFileReader>();
+            services.AddSingleton<IAnalyzer, FrequencyAnalyzer>();
+            services.AddTransient<IPointsProvider, SpiralPointsProvider>();
+            services.AddTransient<IPointsProvider, RandomPointsProvider>();
+            services.AddTransient<IPointsProvider, NormalPointsProvider>();
+            services.AddTransient<TagsCloudLayouter>();
+            services.AddTransient<CloudDrawingSettings>();
+
+            return services;
+        }
+    }
+}

TagsCloudContainer/FrequencyAnalyzers/FrequencyAnalyzer.cs

@@ -0,0 +1,35 @@
+namespace TagsCloudContainer.FrequencyAnalyzers
+{
+    public class FrequencyAnalyzer : IAnalyzer
+    {
+        //private readonly TextPreprocessing preprocessor;
+        private readonly Dictionary<string, int> wordFrequency;
+
+        public FrequencyAnalyzer()
+        {
+            wordFrequency = new Dictionary<string, int>();
+        }
+
+        public void Analyze(string text, string exclude = "")
+        {
+            var preprocessor = new TextPreprocessing(exclude);
+
+            foreach (var word in preprocessor.Preprocess(text))
+            {
+                if (wordFrequency.ContainsKey(word.ToLower()))
+                {
+                    wordFrequency[word]++;
+                }
+                else
+                {
+                    wordFrequency.Add(word, 1);
+                }
+            }
+        }
+
+        public IEnumerable<(string, int)> GetAnalyzedText()
+        {
+            return wordFrequency.Select(p => (p.Key, p.Value));
+        }
+    }
+}

TagsCloudContainer/FrequencyAnalyzers/IAnalyzer.cs

@@ -0,0 +1,8 @@
+namespace TagsCloudContainer.FrequencyAnalyzers
+{
+    public interface IAnalyzer
+    {
+        public void Analyze(string text, string exclude = "");
+        public IEnumerable<(string, int)> GetAnalyzedText();
+    }
+}

TagsCloudContainer/FrequencyAnalyzers/TextPreprocessing.cs

@@ -0,0 +1,30 @@
+namespace TagsCloudContainer.FrequencyAnalyzers
+{
+    public class TextPreprocessing
+    {
+        private readonly HashSet<string> excludedWords = new();
+
+        public TextPreprocessing(string excludedWordsPath)
+        {
+            if (!File.Exists(excludedWordsPath))
+            {
+                return;
+            }
+
+            var reader = new StreamReader(excludedWordsPath);
+            excludedWords = reader.ReadToEnd()
+                .Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries).ToHashSet();
+        }
+
+        public IEnumerable<string> Preprocess(string text)
+        {
+            var words = text.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(x => x.ToLower());
+            foreach (var word in words)
+            {
+                if (!excludedWords.Contains(word))
+                    yield return word;
+            }
+        }
+    }
+}

TagsCloudContainer/Program.cs

@@ -0,0 +1,39 @@
+using CommandLine;
+using Microsoft.Extensions.DependencyInjection;
+using TagsCloudContainer.CLI;
+using TagsCloudContainer.Drawer;
+using TagsCloudContainer.FrequencyAnalyzers;
+using TagsCloudContainer.SettingsClasses;
+using TagsCloudContainer.TextTools;
+using TagsCloudVisualization;
+
+namespace TagsCloudContainer
+{
+    public static class Program
+    {
+        public static void Main(string[] args)
+        {
+            var services = DependencyInjectionConfig.AddCustomServices(new ServiceCollection());
+            var serviceProvider = services.BuildServiceProvider();
+
+            var reader = serviceProvider.GetService<ITextReader>();
+            var analyzer = serviceProvider.GetService<IAnalyzer>();
+
+            var appSettings = new AppSettings();
+
+            Parser.Default.ParseArguments<CommandLineOptions>(args)
+                .WithParsed(o => appSettings = CommandLineOptions.ParseArgs(o));
+
+            var text = reader.ReadText(appSettings.TextFile);
+            var layouter = serviceProvider.GetService<TagsCloudLayouter>();
+
+            analyzer.Analyze(text, appSettings.FilterFile);
+
+            layouter.Initialize(appSettings.DrawingSettings, analyzer.GetAnalyzedText());
+
+            Visualizer.Draw(appSettings.DrawingSettings.Size,
+                            layouter.GetTextImages()).Save(appSettings.OutImagePath);
+            Console.WriteLine("Resulting image saved to " + appSettings.OutImagePath);
+        }
+    }
+}

TagsCloudContainer/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "TagsCloudContainer": {
+      "commandName": "Project",
+      "commandLineArgs": "-f sample.txt -o testout.png --exclude excludedWords.txt --font Calibri --colors Gold,Pink,LightGoldenrodYellow --layout SpiralPointsProvider --fontsize 12 --size 500,500"
+    }
+  }
+}

TagsCloudContainer/SettingsClasses/AppSettings.cs

@@ -0,0 +1,10 @@
+namespace TagsCloudContainer.SettingsClasses
+{
+    public class AppSettings
+    {
+        public string TextFile;
+        public string OutImagePath;
+        public string FilterFile;
+        public CloudDrawingSettings DrawingSettings;
+    }
+}

TagsCloudContainer/SettingsClasses/CloudDrawingSettings.cs

@@ -0,0 +1,14 @@
+using System.Drawing;
+using TagsCloudVisualization;
+
+namespace TagsCloudContainer.SettingsClasses
+{
+    public class CloudDrawingSettings
+    {
+        public FontFamily FontFamily = new("Arial");
+        public float FontSize = 12;
+        public IList<Color> Colors = new List<Color>() { Color.AliceBlue };
+        public Size Size = new(600, 600);
+        public IPointsProvider PointsProvider = new SpiralPointsProvider();
+    }
+}

TagsCloudContainer/TagCloudBuilder/IPointsProvider.cs

@@ -0,0 +1,10 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization
+{
+    public interface IPointsProvider
+    {
+        public IEnumerable<Point> Points();
+        public void Initialize(Point center);
+    }
+}