comments

Author: rumkit

Pixie/CommandLineOptions.cs

@@ -5,6 +5,7 @@ namespace Pixie
 {
     /// <summary>
     /// Options for CommandLine parser
+    /// each field represent a key in console args
     /// </summary>
     class CommandLineOptions
     {
@@ -29,6 +30,10 @@ class CommandLineOptions
         [Option('h', "height", HelpText = "grid pattern height in symbols", MutuallyExclusiveSet = "Generation")]
         public int PatternHeight { get; set; }
 
+        /// <summary>
+        /// Gets help message from assebly attributes
+        /// </summary>
+        /// <returns>string representation of help message</returns>
         [HelpOption]
         public string GetUsage()
         {

Pixie/Extensions.cs

@@ -8,7 +8,7 @@ namespace Pixie
     internal static class Extensions
     {
         /// <summary>
-        /// Converts BitArray to byte[]
+        /// Converts <see cref="BitArray"/> to <see cref="byte[]"/>
         /// </summary>
         /// <param name="bits"></param>
         /// <returns></returns>

Pixie/OutputFileFormatter.cs

@@ -7,15 +7,25 @@ namespace Pixie
 {
     static class OutputFileFormatter
     {
+        /// <summary>
+        /// How many elements of array will be displayed in one line
+        /// </summary>
         private const int ElementsPerLine = 10;
 
+        /// <summary>
+        /// Writes formatted output of symbols parser's result
+        /// </summary>
+        /// <param name="symbols">byte[] representation of symbols</param>
+        /// <param name="fileName">path to the file to create</param>
+        /// <param name="singleArray">shall output be written to single array or one array per symbol</param>
         public static void WriteOutput(List<byte[]> symbols, string fileName, bool singleArray = false)
         {
             try
             {
                 using (var stream = File.Open(fileName, FileMode.Create))
                 using (var writer = new StreamWriter(stream))
                 {
+                    // Make header
                     writer.WriteLine("//");
                     writer.WriteLine("//");
                     writer.WriteLine("// Generated with PixelPixie (c) 2016");
@@ -24,6 +34,7 @@ public static void WriteOutput(List<byte[]> symbols, string fileName, bool singl
                     writer.WriteLine();
                     writer.WriteLine();
 
+                    // Write array(s)
                     if (singleArray)
                     {
                         var totalLength = (from s in symbols

Pixie/PatternGenerator.cs

@@ -2,17 +2,27 @@
 
 namespace Pixie
 {
+    /// <summary>
+    /// Generates empty grid pattern bitmap
+    /// </summary>
     internal class PatternGenerator
     {
         private PixelSettings _settings;
         private Color _delimeterColor;
         private static readonly Color BackGround = Color.Gray;
+
         public PatternGenerator(PixelSettings settings)
         {
             _settings = settings;
             _delimeterColor = ColorTranslator.FromHtml(_settings.DelimeterColor);
         }
-       
+
+        /// <summary>
+        /// Fills bitmap with solid color and draws a grid on it
+        /// </summary>
+        /// <param name="patternWidthCount">width of grid in symbols (cells)</param>
+        /// <param name="patternHeightCount">height of grid in symbols (cells)</param>
+        /// <returns>production ready bitmap</returns>
         public Bitmap GeneratePattern(int patternWidthCount, int patternHeightCount)
         {
             var pattentWidth = patternWidthCount*_settings.SymbolWidth +
@@ -28,6 +38,10 @@ public Bitmap GeneratePattern(int patternWidthCount, int patternHeightCount)
             return pattern;
         }
 
+        /// <summary>
+        /// Fills background with a solid color
+        /// </summary>
+        /// <param name="pattern">bitmap to fill</param>
         private void FillBackground(Bitmap pattern)
         {
             for (int j = 0; j < pattern.Height; j++)
@@ -39,6 +53,10 @@ private void FillBackground(Bitmap pattern)
             }
         }
 
+        /// <summary>
+        /// Draws horizontal lines, wich will devide grid cells
+        /// </summary>
+        /// <param name="pattern">bitmap to draw in</param>
         private void DrawHorizontalLines(Bitmap pattern)
         {
             for (int i = 0; i < pattern.Width; i++)
@@ -56,6 +74,10 @@ private void DrawHorizontalLines(Bitmap pattern)
             }
         }
 
+        /// <summary>
+        /// Draws vertical lines, wich will devide grid cells
+        /// </summary>
+        /// <param name="pattern">bitmap to draw in</param>
         private void DrawVerticalLines(Bitmap pattern)
         {
             for (int j = 0; j < pattern.Height; j++)

Pixie/PixelMapper.cs

@@ -26,6 +26,10 @@ public PixelMapper(Bitmap bitmap, PixelSettings settings)
         }
 
 
+        /// <summary>
+        /// map all cells in grid to byte arrays
+        /// </summary>
+        /// <returns>list of mapped arrays</returns>
         public List<byte[]> MapPixels()
         {
             var symbols = new List<byte[]>();
@@ -41,6 +45,14 @@ public List<byte[]> MapPixels()
             return symbols;
         }
 
+        /// <summary>
+        /// processes one symbol (one grid cell)
+        /// </summary>
+        /// <param name="symbolXStart">upper left corner of cell X coord</param>
+        /// <param name="symbolXEnd">bottom right corner of cell X coord</param>
+        /// <param name="symbolYStart">upper left corner of cell Y coord</param>
+        /// <param name="symbolYEnd">bottom right corner of cell Y coord</param>
+        /// <returns>byte representation of symbol</returns>
         private byte[] ProcessSymbol(int symbolXStart, int symbolXEnd, int symbolYStart, int symbolYEnd)
         {
             var bitsCount = (symbolXEnd - symbolXStart)*(symbolYEnd - symbolYStart)*_settings.BitsPerPixel;
@@ -68,6 +80,13 @@ private byte[] ProcessSymbol(int symbolXStart, int symbolXEnd, int symbolYStart,
             return bitArray.ToByteArray();
         }
 
+        /// <summary>
+        /// Processes one pixel of image and writes corresponding bits in output array
+        /// </summary>
+        /// <param name="color">color of pixel</param>
+        /// <param name="bitsPerPixel">bpp in output array</param>
+        /// <param name="outputArray">output array</param>
+        /// <param name="outputArrayPosition">current element in array</param>
         private void ProcessPixel(Color color, int bitsPerPixel, BitArray outputArray, ref int outputArrayPosition)
         {
             if (!ColorMapping.ContainsKey(color))

Pixie/PixelSettings.cs

@@ -12,6 +12,7 @@ namespace Pixie
     [DataContract]
     internal class PixelSettings
     {
+#pragma warning disable 0649
         [DataMember]
         public int BitsPerPixel;
 
@@ -29,6 +30,7 @@ internal class PixelSettings
 
         [DataMember]
         public string DelimeterColor;
+#pragma warning restore 0649
 
         [DataMember]
         public Dictionary<string, int> ColorMapping;

Pixie/Program.cs

@@ -22,6 +22,11 @@ static int Main(string[] args)
             return (int) ErrorCode.ArgumentsMismatch;
         }
 
+        /// <summary>
+        /// parses image and write arrays to output file
+        /// </summary>
+        /// <param name="options">parsed command line args</param>
+        /// <returns>error code</returns>
         static int ParseFontImage(CommandLineOptions options)
         {
             try
@@ -44,6 +49,11 @@ static int ParseFontImage(CommandLineOptions options)
             return (int) ErrorCode.NoError;
         }
 
+        /// <summary>
+        /// Grid pattern generation and writing to file
+        /// </summary>
+        /// <param name="options">parsed command line args</param>
+        /// <returns>error code</returns>
         static int GeneratePattern(CommandLineOptions options)
         {
             try