Updated to dotnet 6.0, replacing resampling filter from bicubic to lanczos3 and added an option for custom filename formatting

Author: Derp

.gitignore

@@ -0,0 +1,9 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+/.vs
+/obj
+/Tiler.csproj.user
+/bin/Debug
+/bin/Release

BuildBinaries.bat

@@ -28,3 +28,6 @@ ren binaries\Tiler Tiler-Linux-arm64
 dotnet publish -c Release -r osx-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true /p:PublishTrimmed=true -p:PublishReadyToRun=false -o binaries
 del binaries\Tiler-OSX-x64
 ren binaries\Tiler Tiler-OSX-x64
+dotnet publish -c Release -r osx-arm64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true /p:PublishTrimmed=true -p:PublishReadyToRun=false -o binaries
+del binaries\Tiler-OSX-arm64
+ren binaries\Tiler Tiler-OSX-arm64

Program.cs

@@ -1,4 +1,7 @@
 using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
 using System.Linq;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,67 +15,84 @@ class Program
     {
         static void Main(string[] args)
         {
-            var commandline =
-                args.Select((x, i) => new { index = i, option = x })
-                .Where(x => x.option.StartsWith("-")).Select(x => new
+            var commandline = args.
+                Select((x, i) => new { index = i, option = x }).
+                Where(x => x.option.StartsWith("-")).
+                Select(x => new
                 {
-                    option = x.option.Substring(1),
-                    arguments = args.Skip(x.index + 1)
-                .TakeWhile(m => !m.StartsWith("-")).ToArray()
-                })
-                .ToDictionary(x => x.option.ToLower(), x => x.arguments);
+                    option = x.option[1..],
+                    arguments = args.
+                                Skip(x.index + 1).
+                                TakeWhile(m => !m.StartsWith("-")).ToArray()
+                }).
+                ToDictionary(x => x.option.ToLower(), x => x.arguments);
 
             if (args.Length == 0 || commandline.ContainsKey("h") || commandline.ContainsKey("help"))
             {
-                Console.WriteLine("Tiler XYZ tile maker v1.0");
-                Console.WriteLine("Usage:");
-                Console.WriteLine("Tiler.exe image.jpg");
-                Console.WriteLine(" or");
-                Console.WriteLine("Tiler.exe -input image.jpg -output output_folder -size 256 -zoom 6");
+                Console.Write("Tiler XYZ tile maker v1.0\n" +
+                                  "Usage:\n" +
+                                  "Tiler.exe image.jpg\n" +
+                                  " or\n" +
+                                  $"Tiler.exe -input image.jpg -size 256 -zoom 6 -filename \"image.jpg-tiles{Path.DirectorySeparatorChar}{{z}}_{{x}}_{{y}}.png\"\n");
                 return;
             }
 
             var sourceFile = commandline.Count == 0 && args.Length > 0 ? args[0] : commandline["input"].First();
             int tile_size = commandline.ContainsKey("size") ? int.Parse(commandline["size"].First()) : 256;
-            var Directory = commandline.ContainsKey("output") ? commandline["output"].First() : new System.IO.FileInfo(sourceFile).Directory.FullName + System.IO.Path.DirectorySeparatorChar + string.Format("{0}-tiles", commandline.ContainsKey("stdin") ? "STDIN" : new System.IO.FileInfo(sourceFile).Name);
-            System.IO.DirectoryInfo OutputDirectory = System.IO.Directory.CreateDirectory(Directory);
-            var OriginalSource = commandline.ContainsKey("stdin") ? Image<Rgba32>.Load(Console.OpenStandardInput()) : Image<Rgba32>.Load(sourceFile);
+            using var OriginalSource = commandline.ContainsKey("stdin") ? Image.Load(Console.OpenStandardInput()) : Image.Load(sourceFile);
+
             int maxzoom = commandline.ContainsKey("zoom") ? int.Parse(commandline["zoom"].First()) :
                 ((int)Math.Ceiling(Math.Log(Math.Max(OriginalSource.Width, OriginalSource.Height) / (double)tile_size)) + 1); // auto detect max level
 
-            var Sampler = new BicubicResampler();
-
             for (int zoom = 0; zoom <= maxzoom; zoom++)
             {
                 int tiles = (int)Math.Pow(2.0, zoom);
                 int size = tiles * tile_size;
-                using (var Scaled = new Image<Rgba32>(size, size))
+                using var Scaled = new Image<Rgba32>(size, size);
+                Scaled.Mutate(i => i.Clear(Color.Transparent)); // Clear the background to transparent
+
+                int width, height;
+
+                if (OriginalSource.Width > OriginalSource.Height) // Calculate the right scale ratio
+                    (width, height) = (Scaled.Width, Scaled.Width * OriginalSource.Height / OriginalSource.Width);
+                else
+                    (height, width) = (Scaled.Height, Scaled.Height * OriginalSource.Width / OriginalSource.Height);
+
+
+                var Sampler = // Use Lanczos3 for reducing, Bicubic for upscaling
+                    width < OriginalSource.Width || height < OriginalSource.Height
+                    ? (IResampler)new LanczosResampler(3.0f)
+                    : (IResampler)new BicubicResampler();
+
+                // Scale the entire image
+                using (Image<Rgba32> Rescaled = new(OriginalSource.Width, OriginalSource.Height))
                 {
-                    Scaled.Mutate(i => i.Clear(Color.Transparent));
-                    {
-
-                        if (OriginalSource.Width > OriginalSource.Height)
-                        {
-                            int width = Scaled.Width;
-                            int height = width * OriginalSource.Height / OriginalSource.Width;
-                            Scaled.Mutate(x => x.DrawImage(OriginalSource.Clone(x => x.Resize(width, height, Sampler)), new Point(0, (Scaled.Height - height) / 2), new GraphicsOptions()));
-                        }
-                        else
-                        {
-                            int height = Scaled.Height;
-                            int width = height * OriginalSource.Width / OriginalSource.Height;
-                            Scaled.Mutate(x => x.DrawImage(OriginalSource.Clone(x => x.Resize(width, height, Sampler)), new Point((Scaled.Width - width) / 2, 0), new GraphicsOptions()));
-                        }
-                    }
-                    Enumerable.Range(0, tiles).SelectMany(x => Enumerable.Range(0, tiles).Select(y => new { x, y })).AsParallel().ForAll((c) =>
-                    {
-                        using var Tile = new Image<Rgba32>(tile_size, tile_size);
-                        lock (Scaled)
-                            Tile.Mutate(x => x.DrawImage(Scaled.Clone(x => x.Crop(new Rectangle(c.x * tile_size, c.y * tile_size, tile_size, tile_size))), new Point(0, 0), new GraphicsOptions()));
-                        var l = OutputDirectory.FullName + System.IO.Path.DirectorySeparatorChar + zoom.ToString() + "_" + c.x.ToString() + "_" + c.y.ToString() + ".png";
-                        Tile.Save(l);
-                    });
+                    Rescaled.Mutate(x => x.DrawImage(OriginalSource, new Point(0, 0), 1.0f).Resize(width, height, Sampler));
+                    Scaled.Mutate(x => x.DrawImage(Rescaled, new Point((Scaled.Width - width) / 2, (Scaled.Height - height) / 2), new GraphicsOptions()));
                 }
+
+                // Take tiles from it
+                Enumerable.Range(0, tiles).SelectMany(x => Enumerable.Range(0, tiles).Select(y => new { x, y })).AsParallel().ForAll((c) =>
+                {
+                    using var Tile = new Image<Rgba32>(tile_size, tile_size);
+                    lock (Scaled)
+                        Tile.Mutate(x => x.DrawImage(Scaled.Clone(x => x.Crop(new Rectangle(c.x * tile_size, c.y * tile_size, tile_size, tile_size))), new Point(0, 0), new GraphicsOptions()));
+
+                    var Variables = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase) { { "z", zoom }, { "x", c.x }, { "y", c.y } };
+
+                    var Filename = Regex.Replace(
+                        commandline.ContainsKey("filename") && commandline["filename"].Length > 0
+                        ? commandline["filename"].First()
+                        : $"{sourceFile}-tiles{Path.DirectorySeparatorChar}{{z}}_{{x}}_{{y}}.png",
+                        @"{(?<var>[^}]+)}", new MatchEvaluator(m => $"{Variables[m.Groups["var"].Value]}"));
+
+                    var OutputDirectory = Path.GetDirectoryName(Filename);
+
+                    if (OutputDirectory != null && !Directory.Exists(OutputDirectory))
+                        Directory.CreateDirectory(OutputDirectory);
+
+                    Tile.Save(Filename);
+                });
             }
         }
     }

Readme.md

@@ -3,10 +3,10 @@ Tiler
 
 ## XYZ Tile creator
 
-Tiler is an XYZ tile creator written in C# (dotnet core 3.0 preview) that works on Windows, Linux, OSX.
+Tiler is an XYZ tile creator written in C# (dotnet 6.0) that works on Windows, Linux, OSX.
 It can quickly process large images into XYZ tiles that can be used with leaflet/slippy/etc.
 
-Because the output is PNG format, a transparent background is used to center the image into a square frame and subdivided. If you wish to use a different output format or naming convention create your own script to resave the format and name. The default naming format is *{zoom}\_{x}\_{y}.png*.
+A transparent background is used to center the image into a square frame and subdivided for any output format that supports transparency. Consider pre-sizing your input image to a square size (to your preferred alignment) if you do not want your image centered. If you wish to use a different (unsupported) output format or naming convention create your own script to resave the format and name. The default naming format is *{z}\_{x}\_{y}.png*.
 
 Tile size defaults to 256 pixels squared (matching the default of leaflet and slippy). 2<sup>*n*</sup> tiles squared are created for each zoom depth *n*.
 
@@ -27,11 +27,11 @@ Compiled binary (portable) versions are available in the **binaries/** directory
 
 This usage of Tiler requires only the file name for the command line arguments - This style looks different so it can handle drag-and-drop in an explorer context
 ```
-Tiler.exe <image file>
+Tiler.exe <input image file>
 ```
 **or explicit option overrides can be set**
 ```
-Tiler.exe -input <image file> [-size <tile pixel size>] [-zoom <max zoom level>] [-output <output directory no slash>]
+Tiler.exe -input <input image file> [-size <tile pixel size>] [-zoom <max zoom level>] [-filename "output/{z}_{x}_{y}.png"]
 ```
 * -zoom determines maximum zoom level/layers; if blank it will determine the correct maximum level
 * -size determines the tile size in pixels, defaults to 256 (square)