Овечкин Илья

TagsCloudContainer/Actions/AlgorithmSettingsAction.cs

@@ -0,0 +1,29 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class AlgorithmSettingsAction : IUiAction
+    {
+        private AlgorithmSettings algorithmSettings;
+        private ITagCloudClient tagCloudClient;
+
+        public AlgorithmSettingsAction(AlgorithmSettings settings, ITagCloudClient tagCloudClient)
+        { 
+            this.algorithmSettings = settings;  
+            this.tagCloudClient = tagCloudClient;
+        }
+
+        public string Category => "���������";
+
+        public string Name => "��������";
+
+        public string Description => "�������� ��������� ���������";
+
+        public void Perform()
+        {
+            tagCloudClient.SetSettings(algorithmSettings);
+        }
+    }
+}

TagsCloudContainer/Actions/DrawTagCloudAction.cs

@@ -0,0 +1,32 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class DrawTagCloudAction : IUiAction
+    {
+        private ImageSettings imageSettings;
+        private FileSettings fileSettings;
+        private ITagCloudClient tagCloudClient;
+
+        public DrawTagCloudAction(ImageSettings imageSettings, FileSettings fileSettings, ITagCloudClient tagCloudClient)
+        { 
+            this.tagCloudClient = tagCloudClient;
+            this.imageSettings = imageSettings;
+            this.fileSettings = fileSettings;
+        }
+
+        public string Category => "�����������";
+
+        public string Name => "���������� �����������";
+
+        public string Description => "���������� ����������� ������ �����";
+
+        public void Perform()
+        {
+            tagCloudClient.DrawImage(fileSettings.SourceFilePath,
+                fileSettings.BoringFilePath, imageSettings.Width, imageSettings.Height);
+        }
+    }
+}

TagsCloudContainer/Actions/ImageSettingsAction.cs

@@ -0,0 +1,29 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class ImageSettingsAction : IUiAction
+    {
+        private ImageSettings imageSettings;
+        private ITagCloudClient tagCloudClient;
+
+        public ImageSettingsAction(ImageSettings settings, ITagCloudClient tagCloudClient)
+        { 
+            this.imageSettings = settings;  
+            this.tagCloudClient = tagCloudClient;
+        }
+
+        public string Category => "���������";
+
+        public string Name => "�����������";
+
+        public string Description => "�������� ��������� �����������";
+
+        public void Perform()
+        {
+            tagCloudClient.SetSettings(imageSettings);
+        }
+    }
+}

TagsCloudContainer/Actions/SaveImageAction.cs

@@ -0,0 +1,29 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class SaveImageAction : IUiAction
+    {
+        private FileSettings fileSettings;
+        private ITagCloudClient tagCloudClient;
+
+        public SaveImageAction(FileSettings settings, ITagCloudClient tagCloudClient)
+        { 
+            this.fileSettings = settings;  
+            this.tagCloudClient = tagCloudClient;
+        }
+
+        public string Category => "�����������";
+
+        public string Name => "���������";
+
+        public string Description => "��������� �����������";
+
+        public void Perform()
+        {
+            tagCloudClient.SaveImage(fileSettings.ImagePath);
+        }
+    }
+}

TagsCloudContainer/Actions/SelectBoringWordsFileAction.cs

@@ -0,0 +1,29 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class SelectBoringWordsFileAction : IUiAction
+    {
+        private FileSettings fileSetting;
+        private ITagCloudClient tagCloudClient;
+
+        public SelectBoringWordsFileAction(FileSettings settings, ITagCloudClient tagCloudClient)
+        { 
+            this.fileSetting = settings;  
+            this.tagCloudClient = tagCloudClient;
+        }
+
+        public string Category => "�����";
+
+        public string Name => "���� �� �������� �������";
+
+        public string Description => "������� ���� �� ������� ������� ����";
+
+        public void Perform()
+        {
+            fileSetting.BoringFilePath = tagCloudClient.SetBoringFilePath(fileSetting.BoringFilePath);
+        }
+    }
+}

TagsCloudContainer/Actions/SelectSourceFileAction.cs

@@ -0,0 +1,29 @@
+using TagsCloudContainer.Client;
+using TagsCloudContainer.Infrastucture.Settings;
+using TagsCloudContainer.Infrastucture.UiActions;
+
+namespace TagsCloudContainer.Actions
+{
+    public class SelectSourceFileAction : IUiAction
+    {
+        private FileSettings fileSettings;
+        private ITagCloudClient tagCloudClient;
+
+        public SelectSourceFileAction(FileSettings settings, ITagCloudClient tagCloudClient)
+        { 
+            this.fileSettings = settings;  
+            this.tagCloudClient = tagCloudClient;
+        }
+
+        public string Category => "�����";
+
+        public string Name => "���� c� �������";
+
+        public string Description => "������� ���� �� ������� ��� ������ �����";
+
+        public void Perform()
+        {
+            fileSettings.SourceFilePath = tagCloudClient.SetSourceFilePath(fileSettings.SourceFilePath);
+        }
+    }
+}

TagsCloudContainer/Algorithm/CircularCloudLayouter.cs

@@ -0,0 +1,45 @@
+using TagsCloudContainer.Infrastucture;
+using TagsCloudContainer.Infrastucture.Settings;
+
+namespace TagsCloudContainer.Algorithm
+{
+    public class CircularCloudLayouter : ICloudLayouter
+    {
+        private readonly AlgorithmSettings algorithmSettings;
+        private readonly ImageSettings imageSettings;
+
+
+        public CircularCloudLayouter(AlgorithmSettings algorithmSettings, ImageSettings imageSettings)
+        {
+            this.algorithmSettings = algorithmSettings;
+            this.imageSettings = imageSettings;
+        }
+
+        public List<TextRectangle> GetRectangles(Dictionary<string, int> wordFrequencies)
+        {
+            var rectanglePlacer = new RectanglePlacer(
+                algorithmSettings, 
+                new Point(imageSettings.Width / 2, imageSettings.Height / 2));
+
+            var rectangles = new List<TextRectangle>();
+            var bitmap = new Bitmap(imageSettings.Width, imageSettings.Height);
+            var graphics = Graphics.FromImage(bitmap);
+
+            foreach (var word in wordFrequencies.Keys)
+            {
+                var fontSize = CalculateFontSize(wordFrequencies, word, imageSettings.Font.Size);
+                var font = new Font(imageSettings.Font.FontFamily, fontSize, imageSettings.Font.Style, imageSettings.Font.Unit);
+                var textSize = graphics.MeasureString(word, font);
+                var rectangle = rectanglePlacer.GetPossibleNextRectangle(rectangles, textSize);
+                rectangles.Add(new TextRectangle(rectangle, word, font));
+            }
+
+            return rectangles;
+        }
+
+        private float CalculateFontSize(Dictionary<string, int> wordFrequencies, string word, float fontSize)
+        {
+            return fontSize + (wordFrequencies[word] - wordFrequencies.Values.Min()) * 20 / (wordFrequencies.Values.Max());
+        }
+    }
+}

TagsCloudContainer/Algorithm/FileParser.cs

@@ -0,0 +1,24 @@
+namespace TagsCloudContainer.Algorithm
+{
+    public class FileParser : IFileParser
+    {
+        public List<string> ReadWordsInFile(string filePath)
+        {
+            var words = new List<string>();
+            var lines = File.ReadAllLines(filePath);
+
+            foreach (var line in lines)
+            {
+                var lineWords = line.ToLower().Trim().Split(' ');
+                if (lineWords.Length > 1)
+                {
+                    throw new Exception("There is more than one word in a line");
+                }
+                words.Add(lineWords[0]);
+            }
+
+            return words;
+        }
+
+    }
+}

TagsCloudContainer/Algorithm/ICloudLayouter.cs

@@ -0,0 +1,9 @@
+using TagsCloudContainer.Infrastucture;
+
+namespace TagsCloudContainer.Algorithm
+{
+    public interface ICloudLayouter
+    {
+        List<TextRectangle> GetRectangles(Dictionary<string, int> wordFrequencies);
+    }
+}

TagsCloudContainer/Algorithm/IFileParser.cs

@@ -0,0 +1,7 @@
+namespace TagsCloudContainer.Algorithm
+{
+    public interface IFileParser
+    {
+        List<string> ReadWordsInFile(string filePath);
+    }
+}

TagsCloudContainer/Algorithm/IRectanglePlacer.cs

@@ -0,0 +1,9 @@
+using TagsCloudContainer.Infrastucture;
+
+namespace TagsCloudContainer.Algorithm
+{
+    public interface IRectanglePlacer
+    {
+        RectangleF GetPossibleNextRectangle(List<TextRectangle> cloudRectangles, SizeF rectangleSize);
+    }
+}

TagsCloudContainer/Algorithm/IWordProcessor.cs

@@ -0,0 +1,7 @@
+namespace TagsCloudContainer.Algorithm
+{
+    public interface IWordProcessor
+    {
+        Dictionary<string, int> CalculateFrequencyInterestingWords(string sourceFilePath, string boringFilePath);
+    }
+}

TagsCloudContainer/Algorithm/RectanglePlacer.cs

@@ -0,0 +1,54 @@
+using TagsCloudContainer.Infrastucture;
+using TagsCloudContainer.Infrastucture.Settings;
+
+namespace TagsCloudContainer.Algorithm
+{
+    public sealed class RectanglePlacer: IRectanglePlacer
+    {
+        private Point center;
+        private double radius;
+        private double angle;
+        private double deltaRadius;
+        private double deltaAngle;
+
+        public RectanglePlacer(AlgorithmSettings algorithmSettings, Point center)
+        {
+            if (center.X < 0 || center.Y < 0)
+                throw new ArgumentException("the coordinates of the center must be positive numbers");
+            this.center = center;
+            this.deltaRadius = algorithmSettings.DeltaRadius;
+            this.deltaAngle = algorithmSettings.DeltaAngle;
+            this.radius = algorithmSettings.Radius;
+            this.angle = algorithmSettings.Angle;
+        }
+
+        public RectangleF GetPossibleNextRectangle(List<TextRectangle> cloudRectangles, SizeF rectangleSize)
+        {
+            if (rectangleSize.Width <= 0 || rectangleSize.Height <= 0)
+                throw new ArgumentException("the width and height of the rectangle must be positive numbers");
+
+            return FindPossibleNextRectangle(cloudRectangles, rectangleSize);
+        }
+
+        private RectangleF FindPossibleNextRectangle(List<TextRectangle> cloudRectangles, SizeF rectangleSize)
+        {
+            while (true)
+            {
+                var point = new Point(
+                    (int)(center.X + radius * Math.Cos(angle)),
+                    (int)(center.Y + radius * Math.Sin(angle))
+                    );
+                var possibleRectangle = new RectangleF(point, rectangleSize);
+
+                if (!cloudRectangles.Any(textRectangle => textRectangle.Rectangle.IntersectsWith(possibleRectangle)))
+                {
+                    return possibleRectangle;
+                }
+
+                angle += deltaAngle;
+                radius += deltaRadius;
+            }
+        }
+
+    }
+}

TagsCloudContainer/Algorithm/WordProcessor.cs

@@ -0,0 +1,41 @@
+using StopWord;
+
+namespace TagsCloudContainer.Algorithm
+{
+    public class WordProcessor : IWordProcessor
+    {
+
+        private readonly IFileParser parser;
+
+        public WordProcessor(IFileParser parser)
+        {
+            this.parser = parser;
+        }
+
+        public Dictionary<string, int> CalculateFrequencyInterestingWords(string sourceFilePath, string boringFilePath)
+        {
+            var wordFrequencies = new Dictionary<string, int>();
+            var interestingWords = GetInterestingWords(sourceFilePath, boringFilePath);
+
+            for (int i = 0; i < interestingWords.Count; i++)
+            {
+                if (!wordFrequencies.ContainsKey(interestingWords[i]))
+                    wordFrequencies.Add(interestingWords[i], 0);
+                wordFrequencies[interestingWords[i]]++;
+            }
+
+            return wordFrequencies.OrderByDescending(x => x.Value).ToDictionary();
+        }
+
+        public List<string> GetInterestingWords(string sourceFilePath, string boringFilePath)
+        {
+            var boringWords = parser.ReadWordsInFile(boringFilePath);
+            var sourceWords = parser.ReadWordsInFile(sourceFilePath);
+            var stopWords = StopWords.GetStopWords("ru");
+
+            var interestingWords = sourceWords.Where(word => !boringWords.Contains(word) && !stopWords.Contains(word)).ToList();
+
+            return interestingWords;
+        }
+    }
+}