Add ZPL reverse conversion and line output (#14)

Author: Copilot

README.md

@@ -19,6 +19,8 @@ You can also try the package directly in your browser — the [WebAssembly b
 - convert `image.Image` values to complete ZPL labels with `ConvertToZPL`
 - generate raw `^GF` graphic fields with `ConvertToGraphicField`
 - choose between `ASCII`, `Binary`, `CompressedASCII` and `Z64` graphic field encodings
+- decode ZPL `^GF` graphic fields back to black and white images with `ConvertZPLToImage`
+- output black pixel runs as ZPL `^GB` line/box commands with `ConvertToZPLLines`
 - flatten images with alpha transparency against a white background with `FlattenImage`
 - compress ASCII graphic data with `CompressASCII`
 - position graphics on the label with `ConvertToZPLAt`
@@ -134,6 +136,18 @@ zplFromFile, err := zplgfa.ConvertFileToZPL("label.png", zplgfa.CompressedASCII)
 gf := zplgfa.ConvertToGraphicField(flat, zplgfa.ASCII)
 ```
 
+### Convert ZPL graphics back to an image
+
+```go
+img, err := zplgfa.ConvertZPLToImage(zpl)
+```
+
+### Output lines instead of a graphic field
+
+```go
+zpl := zplgfa.ConvertToZPLLines(flat)
+```
+
 ## test and benchmark
 
 Run the full test suite:

cmd/wasm/main.go

@@ -33,6 +33,10 @@ func graphicTypeFromString(s string) zplgfa.GraphicType {
 	}
 }
 
+func isLineOutput(s string) bool {
+	return strings.ToUpper(strings.TrimSpace(s)) == "LINES"
+}
+
 // jsUint8ArrayToBytes copies a JavaScript Uint8Array into a Go []byte.
 func jsUint8ArrayToBytes(arr js.Value) []byte {
 	length := arr.Get("length").Int()
@@ -50,8 +54,7 @@ func makeError(format string, a ...interface{}) map[string]interface{} {
 
 // convertImage is the main entry point exported to JavaScript.
 //
-// JS signature: zplgfaConvert(bytes: Uint8Array, graphicType?: string)
-//   => {zpl, width, height} | {error}
+// JS signature: zplgfaConvert(bytes: Uint8Array, graphicType?: string), returning {zpl, width, height} or {error}.
 func convertImage(this js.Value, args []js.Value) interface{} {
 	if len(args) < 1 {
 		return makeError("zplgfaConvert: expected at least one argument (Uint8Array)")
@@ -66,13 +69,28 @@ func convertImage(this js.Value, args []js.Value) interface{} {
 	}
 
 	gt := zplgfa.CompressedASCII
+	lines := false
 	if len(args) >= 2 && args[1].Type() == js.TypeString {
-		gt = graphicTypeFromString(args[1].String())
-	}
-
-	zpl, err := zplgfa.ConvertReaderToZPL(bytes.NewReader(data), gt)
-	if err != nil {
-		return makeError("zplgfaConvert: %s", err)
+		outputType := args[1].String()
+		lines = isLineOutput(outputType)
+		if !lines {
+			gt = graphicTypeFromString(outputType)
+		}
+	}
+
+	var zpl string
+	if lines {
+		img, _, err := image.Decode(bytes.NewReader(data))
+		if err != nil {
+			return makeError("zplgfaConvert: %s", err)
+		}
+		zpl = zplgfa.ConvertToZPLLines(zplgfa.FlattenImage(img))
+	} else {
+		var err error
+		zpl, err = zplgfa.ConvertReaderToZPL(bytes.NewReader(data), gt)
+		if err != nil {
+			return makeError("zplgfaConvert: %s", err)
+		}
 	}
 
 	// Decode the config again purely to expose width/height to the UI;
@@ -93,8 +111,7 @@ func convertImage(this js.Value, args []js.Value) interface{} {
 // plus width and height, allowing the in-browser editor to send canvas pixels
 // directly without re-encoding to PNG first.
 //
-// JS signature: zplgfaConvertRGBA(rgba: Uint8Array, width: number, height: number, graphicType?: string)
-//   => {zpl, width, height} | {error}
+// JS signature: zplgfaConvertRGBA(rgba: Uint8Array, width: number, height: number, graphicType?: string), returning {zpl, width, height} or {error}.
 func convertRGBA(this js.Value, args []js.Value) interface{} {
 	if len(args) < 3 {
 		return makeError("zplgfaConvertRGBA: expected (rgba, width, height[, graphicType])")
@@ -119,12 +136,22 @@ func convertRGBA(this js.Value, args []js.Value) interface{} {
 	}
 
 	gt := zplgfa.CompressedASCII
+	lines := false
 	if len(args) >= 4 && args[3].Type() == js.TypeString {
-		gt = graphicTypeFromString(args[3].String())
+		outputType := args[3].String()
+		lines = isLineOutput(outputType)
+		if !lines {
+			gt = graphicTypeFromString(outputType)
+		}
 	}
 
 	flat := zplgfa.FlattenImage(img)
-	zpl := zplgfa.ConvertToZPL(flat, gt)
+	var zpl string
+	if lines {
+		zpl = zplgfa.ConvertToZPLLines(flat)
+	} else {
+		zpl = zplgfa.ConvertToZPL(flat, gt)
+	}
 
 	return map[string]interface{}{
 		"zpl":    zpl,

cmd/zplgfa/README.md

@@ -23,6 +23,18 @@ or via the integrated network capability:
 zplgfa -file label.png -ip 192.168.178.42
 ```
 
+You can output black pixel runs as ZPL line/box commands instead of a `^GF` graphic field:
+
+```sh
+zplgfa -file label.png -lines
+```
+
+Or convert a ZPL file containing a `^GF` field back to PNG:
+
+```sh
+zplgfa -file label.zpl -decode -out label.png
+```
+
 You can also use some effects, e.g. blur:
 
 ```sh

cmd/zplgfa/main.go

@@ -6,7 +6,7 @@ import (
 	"image"
 	_ "image/gif"
 	_ "image/jpeg"
-	_ "image/png"
+	"image/png"
 	"log"
 	"os"
 	"strings"
@@ -59,20 +59,24 @@ func handleZebraCommands(cmd, ip, port string) bool {
 	return false
 }
 
-func parseFlags() (string, string, string, string, string, string, float64) {
-	var filename, zebraCmd, graphicType, imageEdit, ip, port string
+func parseFlags() (string, string, string, string, string, string, string, float64, bool, bool) {
+	var filename, zebraCmd, graphicType, imageEdit, ip, port, output string
 	var resizeFactor float64
+	var lines, decode bool
 
 	flag.StringVar(&filename, "file", "", "filename to convert to zpl")
 	flag.StringVar(&zebraCmd, "cmd", "", "send special command to printer [cancel,calib,feed,info,config,diag]")
 	flag.StringVar(&graphicType, "type", "CompressedASCII", "type of graphic field encoding [ASCII,Binary,CompressedASCII,Z64]")
 	flag.StringVar(&imageEdit, "edit", "", "manipulate the image [invert,monochrome]")
 	flag.StringVar(&ip, "ip", "", "send zpl to printer")
 	flag.StringVar(&port, "port", "9100", "network port of printer")
+	flag.StringVar(&output, "out", "", "output filename for decoded PNG")
 	flag.Float64Var(&resizeFactor, "resize", 1.0, "zoom/resize the image")
+	flag.BoolVar(&lines, "lines", false, "output black pixel runs as ZPL line commands instead of a graphic field")
+	flag.BoolVar(&decode, "decode", false, "convert a ZPL file containing a ^GF field to PNG")
 
 	flag.Parse()
-	return filename, zebraCmd, graphicType, imageEdit, ip, port, resizeFactor
+	return filename, zebraCmd, graphicType, imageEdit, ip, port, output, resizeFactor, lines, decode
 }
 
 func openImageFile(filename string) (image.Image, image.Config, error) {
@@ -135,8 +139,28 @@ func getGraphicType(typeFlag string) zplgfa.GraphicType {
 	}
 }
 
+func decodeZPLFile(filename, output string) error {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return fmt.Errorf("could not read the file \"%s\": %s", filename, err)
+	}
+	img, err := zplgfa.ConvertZPLToImage(string(data))
+	if err != nil {
+		return err
+	}
+	if output == "" {
+		return png.Encode(os.Stdout, img)
+	}
+	file, err := os.Create(output)
+	if err != nil {
+		return fmt.Errorf("could not create the file \"%s\": %s", output, err)
+	}
+	defer file.Close()
+	return png.Encode(file, img)
+}
+
 func main() {
-	filename, zebraCmd, graphicTypeFlag, imageEdit, ip, port, resizeFactor := parseFlags()
+	filename, zebraCmd, graphicTypeFlag, imageEdit, ip, port, output, resizeFactor, lines, decode := parseFlags()
 
 	if handleZebraCommands(zebraCmd, ip, port) && filename == "" {
 		return
@@ -147,6 +171,13 @@ func main() {
 		return
 	}
 
+	if decode {
+		if err := decodeZPLFile(filename, output); err != nil {
+			log.Printf("Warning: %s\n", err)
+		}
+		return
+	}
+
 	img, config, err := openImageFile(filename)
 	if err != nil {
 		log.Printf("Warning: %s\n", err)
@@ -157,6 +188,9 @@ func main() {
 
 	flat := zplgfa.FlattenImage(img)
 	gfimg := zplgfa.ConvertToZPL(flat, getGraphicType(graphicTypeFlag))
+	if lines {
+		gfimg = zplgfa.ConvertToZPLLines(flat)
+	}
 
 	if ip != "" {
 		sendDataToZebra(ip, port, gfimg)

docs/index.html

@@ -48,6 +48,7 @@ <h2>2. Options</h2>
             <option value="CompressedASCII" selected>CompressedASCII</option>
             <option value="ASCII">ASCII</option>
             <option value="Binary">Binary</option>
+            <option value="Lines">Lines (^GB)</option>
           </select>
         </div>
         <div class="row">
@@ -135,6 +136,7 @@ <h2>Export</h2>
             <option value="CompressedASCII" selected>CompressedASCII</option>
             <option value="ASCII">ASCII</option>
             <option value="Binary">Binary</option>
+            <option value="Lines">Lines (^GB)</option>
           </select>
         </div>
         <div class="row">