refactor: application is now have more coherent commands (#4)

changed the way application handles arguments, added help info

Author: krylphi

.idea/runConfigurations/go_build_github_com_krylphi_autotiler.xml

@@ -40,11 +40,14 @@ To tilesets like this:
 * [get yourself Go](https://go.dev/doc/install) 
 * clone this repository or download sources.
 * put simple tileset image (for example 2x3_packed.png) to source folder
-* run ```go run . <src image> <dst image> [padding]```
-  e.g. ```go run . ./examples/2x3_packed.png output.local.png```
-* you can optionally set padding for tiles in px. To do so you need to add desired padding as 3rd argument:
-  e.g. ```go run . ./examples/2x3_packed.png output.local.png 1``` - this will create tilesets with 1 px margin and 2px spacing.
-* grab complete tilesets from `out` directory
+* run ```go run . -in <file_in> [-o <file_out>] [-p <padding>] [-e <export_type(16,28,48,all)>]```
+
+  e.g. ```go run . -in ./examples/2x3_packed.png -o ./out/output.local.png -p 1 -e 16 -e 28 -e 48```
+* you can optionally set padding for tiles in px. To do so you need to add desired padding as argument:
+
+  e.g. ```go run . -in ./examples/2x3_packed.png -p 1``` - this will create tilesets with 1 px margin and 2px spacing.
+* grab complete tilesets from directory specified in `-o`. 
+* don't worry about filenames, as program will automatically prefix output files with necessary information. E.g. for options `-o ./out/output.local.png -e 16` output files will be `./out/16x1_terrain1_output.local.png` and `./out/16x1_terrain2_output.local.png`
 * enjoy
 * alternatively you can build an application using `make build` command to use it as a standalone application without Go
 

README.md

@@ -54,7 +54,7 @@ func rotateLeft90(img *image.NRGBA) *image.NRGBA {
 
 // scan copies pixel data from a source image to a destination slice.
 // It supports copying a rectangular region of the source image to the destination slice.
-// The function uses optimized copying for a single pixel (size == 4) and falls back to a generic copy for larger regions.
+// The function uses optimised copying for a single pixel (size == 4) and falls back to a generic copy for larger regions.
 //
 // Parameters:
 // - srcImg: The source image from which to copy pixel data.
@@ -63,7 +63,7 @@ func rotateLeft90(img *image.NRGBA) *image.NRGBA {
 // - x2, y2: The bottom-right coordinates of the rectangular region to copy from the source image.
 //
 // Returns:
-// - None
+// - None.
 func scan(srcImg *image.NRGBA, dstPx []uint8, x1, y1, x2, y2 int) {
 	size := (x2 - x1) * 4
 	srcStride := y1*srcImg.Stride + x1*4
@@ -99,7 +99,7 @@ func scan(srcImg *image.NRGBA, dstPx []uint8, x1, y1, x2, y2 int) {
 // - fn: The function to be executed in parallel. It should accept a channel of integers as its parameter.
 //
 // Returns:
-// - None
+// - None.
 func parallel(start, stop int, fn func(<-chan int)) {
 	count := stop - start
 	if count < 1 {

internal/unpack/util.go

@@ -28,26 +28,37 @@ import (
 	"fmt"
 	"image"
 	"image/png"
+	"log"
 	"os"
+	"path/filepath"
 	"strconv"
+	"strings"
 
 	"github.com/krylphi/autotiler/internal/unpack"
 )
 
-func main() {
+const (
+	inKey      = "in"
+	paddingKey = "p"
+	exportKey  = "e"
+	outKey     = "o"
+)
 
-	inputFile := os.Args[1]
+const (
+	export16  = "16"
+	export28  = "28"
+	export48  = "48"
+	exportAll = "all"
+)
 
-	outputFile := os.Args[2]
-	var err error
-	var padding = 0
-	if len(os.Args) > 3 {
-		padding, err = strconv.Atoi(os.Args[3])
-		if err != nil {
-			panic(err)
-		}
+func main() {
+	args := parseArgs()
+	inFiles, ok := args[inKey]
+	if !ok {
+		log.Print("Missing input file")
+		os.Exit(1)
 	}
-
+	inputFile := inFiles[0] // todo add handling for multiple inputs
 	imgFile, err := os.Open(inputFile)
 	if err != nil {
 		panic(err)
@@ -59,85 +70,122 @@ func main() {
 		panic(err)
 	}
 
-	g := unpack.NewUnpacker(img, 2, 3, padding)
-	if err := g.Init(2); err != nil {
-		panic(err)
-	}
-
-	// todo cleanup and parallel
-
-	canvas, err := g.From6to48Terrain1()
-	if err != nil {
-		panic(err)
-	}
-	file48t1, err := os.Create(fmt.Sprintf("out/12x4_terrain1_%s", outputFile))
-	if err != nil {
-		panic(err)
-	}
-	defer file48t1.Close()
-
-	err = png.Encode(file48t1, canvas)
+	padding, err := strconv.Atoi(args[paddingKey][0])
 	if err != nil {
 		panic(err)
 	}
 
-	canvas, err = g.From6to48Terrain2()
-	if err != nil {
+	unpacker := unpack.NewUnpacker(img, 2, 3, padding)
+	if err := unpacker.Init(2); err != nil {
 		panic(err)
 	}
-	file48t2, err := os.Create(fmt.Sprintf("out/12x4_terrain2_%s", outputFile))
-	if err != nil {
-		panic(err)
-	}
-	defer file48t2.Close()
 
-	err = png.Encode(file48t2, canvas)
-	if err != nil {
-		panic(err)
+	exports, ok := args[exportKey]
+	var exportTypes []string
+	if !ok || len(exports) == 0 || exports[0] == exportAll {
+		exportTypes = []string{export16, export28, export48}
+	} else {
+		exportTypes = exports
 	}
 
-	canvas, err = g.From6to16Terrain1()
-	if err != nil {
-		panic(err)
+	outputFile := "out.local.png"
+	outFiles, ok := args[outKey]
+	if ok {
+		outputFile = outFiles[0]
 	}
-	file15t1, err := os.Create(fmt.Sprintf("out/16x1_terrain1_%s", outputFile))
-	if err != nil {
-		panic(err)
-	}
-	defer file15t1.Close()
 
-	err = png.Encode(file15t1, canvas)
-	if err != nil {
-		panic(err)
+	for e := range exportTypes {
+		exportType := exportTypes[e]
+		switch exportType {
+		case export16:
+			err := produceTileset(unpacker.From6to16Terrain1, outputFile, "16x1_terrain1")
+			if err != nil {
+				panic(err)
+			}
+			err = produceTileset(unpacker.From6to16Terrain2, outputFile, "16x1_terrain2")
+			if err != nil {
+				panic(err)
+			}
+		case export28:
+			err := produceTileset(unpacker.From6to28, outputFile, "14x2")
+			if err != nil {
+				panic(err)
+			}
+		case export48:
+			err := produceTileset(unpacker.From6to48Terrain1, outputFile, "12x4_terrain1")
+			if err != nil {
+				panic(err)
+			}
+			err = produceTileset(unpacker.From6to48Terrain2, outputFile, "12x4_terrain2")
+			if err != nil {
+				panic(err)
+			}
+		}
 	}
+}
 
-	canvas, err = g.From6to16Terrain2()
-	if err != nil {
-		panic(err)
-	}
-	file15t2, err := os.Create(fmt.Sprintf("out/16x1_terrain2_%s", outputFile))
-	if err != nil {
-		panic(err)
+func parseArgs() map[string][]string {
+	if len(os.Args) < 2 {
+		log.Print(
+			"Usage: autotiler -in <file_in> [-o <file_out>] [-p <padding>] [-e <export_type(16,28,48,all)>]\n" +
+				"       -e can be repeated\n")
+		os.Exit(1)
+	}
+	res := make(map[string][]string)
+	allTilesets := false
+	for i := 1; i < len(os.Args); i += 2 {
+		key := strings.TrimPrefix(os.Args[i], "-")
+		v, ok := res[key]
+		value := os.Args[i+1]
+		if key == exportKey && allTilesets {
+			continue
+		}
+		if key == exportKey && strings.EqualFold(value, exportAll) {
+			allTilesets = true
+			v = []string{"all"}
+			res[key] = v
+			continue
+		}
+		if ok {
+			v = append(v, value)
+		} else {
+			v = []string{value}
+		}
+		res[key] = v
 	}
-	defer file15t2.Close()
+	return res
+}
 
-	err = png.Encode(file15t2, canvas)
+func produceTileset(unpackFunction func() (*image.NRGBA, error), outputPath, exportType string) error {
+	canvas, err := unpackFunction()
 	if err != nil {
-		panic(err)
+		return err
 	}
-
-	canvas, err = g.From6to28()
+	cleanPath := filepath.Clean(outputPath)
+	outputFile := fmt.Sprintf("%s_%s", exportType, filepath.Base(cleanPath))
+	outputFile = filepath.Join(filepath.Dir(cleanPath), outputFile)
+	file, err := os.Create(outputFile)
 	if err != nil {
-		panic(err)
+		return err
 	}
-	file1, err := os.Create(fmt.Sprintf("out/14x2_%s", outputFile))
+	defer func(file *os.File) {
+		err := file.Close()
+		if err != nil {
+			log.Println(err)
+		}
+	}(file)
+	err = png.Encode(file, canvas)
 	if err != nil {
-		panic(err)
+		return err
 	}
-	defer file1.Close()
+	return nil
+}
 
-	err = png.Encode(file1, canvas)
-	if err != nil {
-		panic(err)
+//nolint:unused //debug function
+func printArgs(args map[string][]string) {
+	for key, params := range args {
+		for _, param := range params {
+			log.Printf("%s: %s\n", key, param)
+		}
 	}
 }