.gitignore

@@ -4,4 +4,5 @@
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
-
+bin/
+obj/

.vscode/launch.json

@@ -0,0 +1,28 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/netcoreapp2.1/agbidx.dll",
+            "args": ["-v", "-i", "/home/karathan/Downloads/Sprites aus der ROM/Pokemon Sprites/kanto", "-o", "/home/karathan/Downloads/Sprites aus der ROM/Pokemon Sprites/kanto/rendered"],
+            "cwd": "${workspaceFolder}",
+            // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "internalConsoleOptions": "openOnSessionStart"
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ,]
+}

.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/agbidx.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

ImageLib/BitmapProcessor.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Linq;
+
+namespace agbidx.ImageLib
+{
+    public static class BitmapProcessor
+    {
+        public static async Task ProcessPokemonImage(string outDirectory, string inPath, bool verbose, bool scanDirectories, bool recursive)
+        {
+            //Create the original bitmap
+            if(Directory.Exists(inPath))
+            {
+                if(scanDirectories)
+                {
+                    List<Task> subTasks = new List<Task>();
+                    foreach(string s in Directory.GetFiles(inPath))
+                    {
+                        subTasks.Add(ProcessPokemonImage(outDirectory, s, verbose, recursive, recursive));
+                    }
+                    foreach(string s in Directory.GetDirectories(inPath))
+                    {
+                        subTasks.Add(ProcessPokemonImage(outDirectory, s, verbose, recursive, recursive));
+                    }
+                    await Task.WhenAll(subTasks);
+                }
+
+            }
+            else
+            {
+                await Task.Run(() => {
+                    Bitmap input = new Bitmap(inPath);
+                    ProcessPokemonImageFront(input, outDirectory, Path.GetFileNameWithoutExtension(inPath), verbose);
+                });
+            }
+
+        }
+
+        private static Color[] Quantize4bppColors(Bitmap bmp)
+        {
+            List<Color> colors = new List<Color>(16);
+            BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);
+            int bytesPerPixel = System.Drawing.Bitmap.GetPixelFormatSize(bmp.PixelFormat) / 8;
+            int heightInPixels = bitmapData.Height;
+            int widthInBytes = bitmapData.Width * bytesPerPixel;
+            int palCount = 0;
+            unsafe
+            {
+                byte* ptrFirstPixel = (byte*)bitmapData.Scan0;
+                for (int y = 0; y < heightInPixels; y++)
+                {
+                    byte* currentLine = ptrFirstPixel + (y * bitmapData.Stride);
+                    for (int x = 0; x < widthInBytes; x = x + bytesPerPixel)
+                    {
+                        int blue = currentLine[x];
+                        int green = currentLine[x + 1];
+                        int red = currentLine[x + 2];
+                        if (!colors.Any(c => c.R == red && c.G == green && c.B == blue))
+                        {
+                            colors.Add(Color.FromArgb(red,green,blue));
+                            palCount++;
+                            if(palCount > 16)
+                                throw new ArgumentException("The image has too many colors", "bmp");
+                        }
+                            
+                    }
+                }
+            }
+            bmp.UnlockBits(bitmapData);
+            return colors.ToArray();
+        }
+
+        private static Bitmap RenderBitmapFromPalette(Bitmap original, Color[] palette)
+        {
+            Bitmap output = new Bitmap(original.Width,original.Height, PixelFormat.Format4bppIndexed);
+            BitmapData targetData = output.LockBits(new Rectangle(0, 0, original.Width,original.Height),
+                ImageLockMode.ReadWrite, PixelFormat.Format4bppIndexed);
+            BitmapData sourceData = original.LockBits(new Rectangle(0, 0, original.Width,original.Height),
+                ImageLockMode.ReadOnly, original.PixelFormat);
+
+            int bytesPerPixel = System.Drawing.Bitmap.GetPixelFormatSize(original.PixelFormat) / 8;
+            int heightInPixels = sourceData.Height;
+            int widthInBytes = sourceData.Width * bytesPerPixel;
+            unsafe
+            {
+                byte* ptrFirstPixel = (byte*)sourceData.Scan0;
+                for (int y = 0; y < heightInPixels; y++)
+                {
+                    byte* currentLine = ptrFirstPixel + (y * sourceData.Stride);
+                    byte* pTarget = (byte*) (targetData.Scan0 + y*targetData.Stride);
+                    byte prevValue = 0;
+                    for (int x = 0; x < widthInBytes; x = x + bytesPerPixel)
+                    {
+                        int blue = currentLine[x];
+                        int green = currentLine[x + 1];
+                        int red = currentLine[x + 2];
+                        if (!palette.Any(c => c.R == red && c.G == green && c.B == blue))
+                            throw new ArgumentException($"The color palette does not contain the required entry {red}:{green}:{blue}.","palette");
+                        else
+                        {
+                            byte colorIndex = (byte)Array.IndexOf(palette, Color.FromArgb(red,green,blue));
+                            if((x/bytesPerPixel) % 2 == 0)
+                                prevValue = colorIndex;
+                            else
+                            {
+                                *pTarget = (byte)((prevValue<<4) | (colorIndex));
+                                pTarget++;
+                            }
+
+                        }
+                    }
+                }
+            }
+
+            output.UnlockBits(targetData);
+            original.UnlockBits(sourceData);
+
+            ColorPalette pal = output.Palette;
+            for(int i = 0; i < ((palette.Length > 16) ? 16 : palette.Length); ++i)
+            {
+                pal.Entries[i] = palette[i];
+            }
+            output.Palette = pal;
+            return output;
+        }
+        private static void ProcessPokemonImageFront(Bitmap inFile, string outDirectory, string name, bool verbose)
+        {
+            Bitmap normal = new Bitmap(128,64, PixelFormat.Format32bppRgb);
+            Bitmap shiny = new Bitmap(128,64, PixelFormat.Format32bppRgb);
+            using(Graphics g = Graphics.FromImage(normal))
+            {
+                g.DrawImage(inFile,new Rectangle(0,0,64,64),new Rectangle(0,0,64,64), GraphicsUnit.Pixel);
+                g.DrawImage(inFile,new Rectangle(64,0,64,64),new Rectangle(2*64,0,64,64), GraphicsUnit.Pixel);
+            }
+            using(Graphics g = Graphics.FromImage(shiny))
+            {
+                g.DrawImage(inFile ,new Rectangle(0,0,64,64),new Rectangle(1*64,0,64,64), GraphicsUnit.Pixel);
+                g.DrawImage(inFile ,new Rectangle(64,0,64,64),new Rectangle(3*64,0,64,64), GraphicsUnit.Pixel);
+            }
+
+            Color[] normalPalette = Quantize4bppColors(normal);
+            Color[] shinyPalette = Quantize4bppColors(shiny);
+
+            Bitmap normalIndexed = RenderBitmapFromPalette(normal, normalPalette);
+            Bitmap shinyIndexed = RenderBitmapFromPalette(shiny, shinyPalette);
+
+            Bitmap frontNormalIndexed = normalIndexed.Clone(new Rectangle(0,0,64,64), PixelFormat.Format4bppIndexed);
+            Bitmap backShinyIndexed = shinyIndexed.Clone(new Rectangle(64,0,64,64), PixelFormat.Format4bppIndexed);
+
+            frontNormalIndexed.Save(Path.Combine(outDirectory, name+"_frontnormal.png"),ImageFormat.Png);
+            backShinyIndexed.Save(Path.Combine(outDirectory,name+"_backshiny.png"),ImageFormat.Png);
+
+            if(verbose)
+            {
+                Console.WriteLine("Processed " + Path.Combine(outDirectory, name+"_frontnormal.png"));
+                Console.WriteLine("Processed " + Path.Combine(outDirectory,name+"_backshiny.png"));
+            }
+        }
+    }
+}

Program.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+using CSharpx;
+
+namespace agbidx
+{
+    [Verb("pokemon", HelpText = "Parse a combination of Pokémon front- and backsprite, and output two files respectively.")]
+    class PokespriteOptions {
+        [Option('i', "input-files", Required = true, HelpText = "Input images to be processed")]
+        public IEnumerable<string> Input {get;set;}
+
+        [Option('o', "output-directory", Default = ".", Required = false, HelpText = "Output directory for the processed images, defaults to current directory")]
+        public string OutputDirectory{get;set;}
+
+        [Option('v', "verbose", Default = false, Required = false, HelpText = "Show Verbose information")]
+        public bool Verbose{get;set;}
+
+        [Option('r', "recursive", Default = false, Required = false, HelpText = "Recursively scan directories for images, by default only one level is scanned, if an input argument is a directory")]
+        public bool Recursive{get;set;}
+    }
+    class Program
+    {
+        static async Task<int> Main(string[] args)
+        {
+            return await CommandLine.Parser.Default.ParseArguments<PokespriteOptions>(args)
+	            .MapResult(
+	                async (PokespriteOptions opts) => await RunPokespritesAndReturnExitCode(opts),
+	                async (IEnumerable<Error> errs) => await Task.Run<int>(() => 1));
+        }
+
+        static async Task<int> RunPokespritesAndReturnExitCode(PokespriteOptions opts)
+        {
+            try
+            {
+                if(!Directory.Exists(opts.OutputDirectory))
+                    Directory.CreateDirectory(opts.OutputDirectory);
+                    await Task.WhenAll(opts.Input.Select(s => ImageLib.BitmapProcessor.ProcessPokemonImage(opts.OutputDirectory, s, opts.Verbose, true, opts.Recursive)));
+                return 0;
+            }
+            catch(Exception ex)
+            {
+                Console.WriteLine("An error occured: " + ex.Message);
+                return 1;
+            }
+
+        }
+    }
+}

agbidx.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommandLineParser" Version="2.3.65" />
+    <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
+  </ItemGroup>
+
+</Project>