Конина Анастасия

FractalPainter/fractalPainter.csproj

@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
     <PropertyGroup>
-        <OutputType>WinExe</OutputType>
         <TargetFramework>netcoreapp3.1</TargetFramework>
         <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
         <LangVersion>8</LangVersion>

TagCloud/IWordsForCloudGenerator.cs

@@ -0,0 +1,6 @@
+namespace TagCloud;
+
+public interface IWordsForCloudGenerator
+{
+    List<WordForCloud> Generate(List<string> words);
+}

TagCloud/IWordsNormalizer.cs

@@ -0,0 +1,6 @@
+namespace TagCloud;
+
+public interface IWordsNormalizer
+{
+    List<string> NormalizeWords(List<string> words);
+}

TagCloud/Program.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using TagsCloudVisualization;
+
+namespace TagCloud
+{
+    internal class Program
+    {
+        public static void Main(string[] args)
+        {
+            var inputFile = "1.txt";
+            var outputFile = "qwe.bmp";
+
+            var wordNormalizer = new WordsNormalizer();
+            var wordForCloudGenerator = new WordsForCloudGenerator("Arial", Color.Black, 60);
+            var pictureSize = new Size(1000, 1000);
+            var circularCloudLayouter =
+                new CircularCloudLayouter(new SpiralPoints(new Point(pictureSize.Height / 2, pictureSize.Width / 2)));
+
+
+            var words = GetWordsFromFile(inputFile);
+            var normalizeWords = wordNormalizer.NormalizeWords(words);
+            var wordsForCloud = wordForCloudGenerator.Generate(normalizeWords);
+
+
+            DrawAndSaveCloud(
+                wordsForCloud.Select(word => circularCloudLayouter.PutNextRectangle(word.WordSize)).ToList(),
+                wordsForCloud, outputFile, pictureSize);
+        }
+
+        private static List<string> GetWordsFromFile(string path)
+        {
+            using (var fileStream = new StreamReader(path))
+            {
+                return fileStream.ReadToEnd().Split('\n').ToList();
+            }
+        }
+
+        private static void DrawAndSaveCloud(List<Rectangle> rectangles, List<WordForCloud> wordsForCloud,
+            string fileName,
+            Size pictureSize)
+        {
+            var bitmap = new Bitmap(pictureSize.Width, pictureSize.Height);
+            var gr = Graphics.FromImage(bitmap);
+            gr.FillRectangle(Brushes.White, 0, 0, pictureSize.Width, pictureSize.Height);
+            for (var i = 0; i < rectangles.Count; i++)
+            {
+                gr.DrawString($"{wordsForCloud[i].Word}", wordsForCloud[i].Font,
+                    new SolidBrush(wordsForCloud[i].WordColor), rectangles[i]);
+            }
+
+            bitmap.Save(fileName);
+        }
+    }
+}

TagCloud/TagCloud.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <GenerateProgramFile>false</GenerateProgramFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\TagsCloudVisualization\TagsCloudVisualization.csproj" />
+    </ItemGroup>
+
+</Project>

TagCloud/WordForCloud.cs

@@ -0,0 +1,22 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class WordForCloud
+{
+    public Font Font { get; }
+    public int FontSize { get; }
+    public Size WordSize { get; }
+
+    public string Word { get; }
+    public Color WordColor { get; }
+
+    public WordForCloud(string font, int fontSize, string word, Size wordSize, Color wordColor)
+    {
+        Font = new Font(font, fontSize);
+        FontSize = fontSize;
+        WordSize = wordSize;
+        WordColor = wordColor;
+        Word = word;
+    }
+}

TagCloud/WordsForCloudGenerator.cs

@@ -0,0 +1,59 @@
+using System.Drawing;
+
+namespace TagCloud;
+
+public class WordsForCloudGenerator: IWordsForCloudGenerator
+{
+    private readonly string fontName;
+    private readonly Color fontColor;
+    private readonly int maxFontSize;
+
+
+    public WordsForCloudGenerator(string fontName, Color color, int maxFontSize)
+    {
+        this.fontName = fontName;
+        this.maxFontSize = maxFontSize;
+        fontColor = color;
+    }
+
+    public List<WordForCloud> Generate(List<string> words)
+    {
+        var wordFrequency = GetWordsFrequency(words)
+            .OrderBy(x => x.Value)
+            .Reverse()
+            .ToList();
+
+        var maxFrequency = wordFrequency.FirstOrDefault().Value;
+        return wordFrequency
+            .Select(x =>
+                GetWordForCloud(fontName,
+                    maxFontSize,
+                    fontColor,
+                    x.Key,
+                    x.Value,
+                    maxFrequency))
+            .ToList();
+    }
+
+    private static Dictionary<string, int> GetWordsFrequency(List<string> words)
+    {
+        var wordFrequency = new Dictionary<string, int>();
+        foreach (var word in words)
+        {
+            if (wordFrequency.ContainsKey(word))
+                wordFrequency[word] += 1;
+            else
+                wordFrequency[word] = 1;
+        }
+
+        return wordFrequency;
+    }
+
+    private static WordForCloud GetWordForCloud(string font, int maxWordSize, Color color, string word,
+        int wordFrequency, int maxFrequency)
+    {
+        var wordFontSize = (int) (maxWordSize * ((double) wordFrequency / maxFrequency) + 0.6);
+        var wordSize = new Size((int) (word.Length * (wordFontSize + 6) * 0.65), wordFontSize + 10);
+        return new WordForCloud(font, wordFontSize, word, wordSize, color);
+    }
+}

TagCloud/WordsNormalizer.cs

@@ -0,0 +1,14 @@
+namespace TagCloud;
+
+public class WordsNormalizer : IWordsNormalizer
+{
+    private readonly HashSet<string> boringWords;
+
+    public WordsNormalizer(HashSet<string> boringWords = null)
+    {
+        this.boringWords = boringWords ?? new HashSet<string>();
+    }
+
+    public List<string> NormalizeWords(List<string> words) =>
+        words.Where(x => !boringWords.Contains(x)).Select(x => x.ToLower()).ToList();
+}

TagCloudVisualization.Tests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

TagCloudVisualization.Tests/TagCloudVisualization.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="FluentAssertions" Version="7.0.0-alpha.3" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="NUnit" Version="3.12.0"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1"/>
+        <PackageReference Include="NUnit.Analyzers" Version="3.6.1"/>
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\TagsCloudVisualization\TagsCloudVisualization.csproj" />
+    </ItemGroup>
+
+</Project>

TagCloudVisualization.Tests/UnitTest1.cs

@@ -0,0 +1,54 @@
+namespace TagCloudVisualization.Tests;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using FluentAssertions;
+using System.Linq;
+using NUnit.Framework;
+using TagsCloudVisualization;
+
+[TestFixture]
+public class CircularCloudLayouter_Should
+{
+    private CircularCloudLayouter cloud;
+    private Point center;
+    private List<Rectangle> rectangles;
+
+    [SetUp]
+    public void Setup()
+    {
+        center = new Point(250, 250);
+        cloud = new CircularCloudLayouter(new SpiralPoints(center));
+        rectangles = new List<Rectangle>();
+    }
+
+    [Test]
+    public void PutNextRectangle_NoIntersects_AfterPutting()
+    {
+        var rectangleSize = new Size(10, 50);
+
+        rectangles = new List<Rectangle>();
+        for (var i = 0; i < 100; i++)
+        {
+            rectangles.Add(cloud.PutNextRectangle(rectangleSize));
+        }
+
+        foreach (var rectangle in rectangles)
+        {
+            foreach (var secondRectangle in rectangles.Where(x => x != rectangle))
+            {
+                rectangle.IntersectsWith(secondRectangle).Should().BeFalse();
+            }
+        }
+    }
+
+    [Test]
+    public void PutNextRectangle_OnCenter_AfterFirstPut()
+    {
+        var rectangleSize = new Size(100, 50);
+        var expectedRectangle = new Rectangle(center, rectangleSize);
+        var rectangle = cloud.PutNextRectangle(rectangleSize);
+        rectangles.Add(rectangle);
+        rectangle.Should().BeEquivalentTo(expectedRectangle);
+    }
+}

TagsCloudVisualization/CircularCloudLayouter.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+
+namespace TagsCloudVisualization
+{
+    public class CircularCloudLayouter : ITagCloudLayouter
+    {
+        private readonly List<Rectangle> rectangles = new List<Rectangle>();
+        private readonly IPoints Points;
+
+        public CircularCloudLayouter(IPoints points) =>
+            Points = points;
+
+        public Rectangle PutNextRectangle(Size rectangleSize)
+        {
+            var halfRectangleSize = new Size(rectangleSize.Width / 2, rectangleSize.Height / 2);
+            foreach (var point in Points.GetPoints())
+            {
+                var rectangle = new Rectangle(point - halfRectangleSize, rectangleSize);
+                if (rectangles.Any(x => x.IntersectsWith(rectangle)))
+                    continue;
+
+                rectangles.Add(rectangle);
+                return rectangle;
+            }
+
+            return new Rectangle();
+        }
+    }
+}

TagsCloudVisualization/IPoints.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface IPoints
+{
+    IEnumerable<Point> GetPoints();
+}

TagsCloudVisualization/ITagCloudLayouter.cs

@@ -0,0 +1,8 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public interface ITagCloudLayouter
+{
+    Rectangle PutNextRectangle(Size rectangleSize);
+}

TagsCloudVisualization/Program.cs

@@ -0,0 +1,6 @@
+namespace TagsCloudVisualization;
+
+public class Program
+{
+    public static void Main(string[] args){}
+}

TagsCloudVisualization/README.md

@@ -0,0 +1,8 @@
+100 квадратов со случайными размерами (максимальный размер - 70)
+![TagCloud](100(randomButLesser70)Rectangles.png )
+
+40 квадратов со случайными размерами (максимальный размер - 50)
+![TagCloud](40(randomButLesser50)Rectangles.png )
+
+100 квадратов со сторонами 10, 50
+![TagCloud](100(10,50)Rectangles.png )

TagsCloudVisualization/SpiralPoints.cs

@@ -0,0 +1,35 @@
+using System.Drawing;
+
+namespace TagsCloudVisualization;
+
+public sealed class SpiralPoints : IPoints
+{
+    private readonly Point center;
+    private readonly double radiusStep;
+
+    public SpiralPoints(Point center, double radiusStep = 1)
+    {
+        this.center = center;
+        this.radiusStep = radiusStep;
+    }
+
+    ///<exception cref="System.OverflowExeption">
+    /// Long point generation operation
+    /// </exception>
+    public IEnumerable<Point> GetPoints()
+    {
+        double radius = 0;
+        var term = radiusStep / 360;
+        while (true)
+        {
+            for (var pointNumber = 0; pointNumber < 360; pointNumber++)
+            {
+                var pointAngle = 2 * Math.PI * pointNumber / 360;
+                var currentPoint = new Point(center.X, center.Y);
+                currentPoint.Offset((int)(Math.Cos(pointAngle) * radius), (int)(Math.Sin(pointAngle) * radius));
+                yield return currentPoint;
+                radius += term;
+            }
+        }
+    }
+}