Malin/ZPLify
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor and gh-actions

Browse Source
This commit is contained in:
Simon Waldherr
2024-06-16 15:35:26 +02:00
committed by GitHub
parent c0d018ffa9
commit 755efa31c4
8 changed files with 317 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
.github/workflows/go.yml vendored Normal file
View File

@@ -0,0 +1,28 @@
# This workflow will build a golang project
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
name: Go
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Go
uses: actions/setup-go@v4
with:
go-version: '1.22'
- name: Build
run: go build -v ./cmd/zplgfa
- name: Test
run: go test -v ./...

236
cmd/zplgfa/main.go
View File

@@ -19,154 +19,146 @@ import (
"simonwaldherr.de/go/zplgfa" "simonwaldherr.de/go/zplgfa"
) )
func specialCmds(zebraCmdFlag, networkIpFlag, networkPortFlag string) bool { func handleZebraCommands(cmd, ip, port string) bool {
var cmdSent bool if ip == "" {
if networkIpFlag == "" { return false
return cmdSent
} }
if strings.Contains(zebraCmdFlag, "cancel") {
if err := sendCancelCmdToZebra(networkIpFlag, networkPortFlag); err == nil { // Define a map of command strings to functions that return error only
cmdSent = true cmdActionsErr := map[string]func(string, string) error{
"cancel": sendCancelCmdToZebra,
"calib": sendCalibCmdToZebra,
"feed": sendFeedCmdToZebra,
}
// Define a map of command strings to functions that return (string, error)
cmdActionsStr := map[string]func(string, string) (string, error){
"info": getInfoFromZebra,
"config": getConfigFromZebra,
"diag": getDiagFromZebra,
}
for key, action := range cmdActionsErr {
if strings.Contains(cmd, key) {
if err := action(ip, port); err == nil {
return true
}
} }
} }
if strings.Contains(zebraCmdFlag, "calib") {
if err := sendCalibCmdToZebra(networkIpFlag, networkPortFlag); err == nil { for key, action := range cmdActionsStr {
cmdSent = true if strings.Contains(cmd, key) {
result, err := action(ip, port)
if err == nil {
fmt.Println(result)
return true
}
} }
} }
if strings.Contains(zebraCmdFlag, "feed") {
if err := sendFeedCmdToZebra(networkIpFlag, networkPortFlag); err == nil { return false
cmdSent = true }
}
func parseFlags() (string, string, string, string, string, string, float64) {
var filename, zebraCmd, graphicType, imageEdit, ip, port string
var resizeFactor float64
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")
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.Float64Var(&resizeFactor, "resize", 1.0, "zoom/resize the image")
flag.Parse()
return filename, zebraCmd, graphicType, imageEdit, ip, port, resizeFactor
}
func openImageFile(filename string) (image.Image, image.Config, error) {
file, err := os.Open(filename)
if err != nil {
return nil, image.Config{}, fmt.Errorf("could not open the file \"%s\": %s", filename, err)
} }
if strings.Contains(zebraCmdFlag, "info") { defer file.Close()
info, err := getInfoFromZebra(networkIpFlag, networkPortFlag)
if err == nil { config, format, err := image.DecodeConfig(file)
fmt.Println(info) if err != nil {
cmdSent = true return nil, config, fmt.Errorf("image not compatible, format: %s, config: %v, error: %s", format, config, err)
}
} }
if strings.Contains(zebraCmdFlag, "config") {
info, err := getConfigFromZebra(networkIpFlag, networkPortFlag) file.Seek(0, 0)
if err == nil { img, _, err := image.Decode(file)
fmt.Println(info) if err != nil {
cmdSent = true return nil, config, fmt.Errorf("could not decode the file, %s", err)
}
} }
if strings.Contains(zebraCmdFlag, "diag") {
info, err := getDiagFromZebra(networkIpFlag, networkPortFlag) return img, config, nil
if err == nil { }
fmt.Println(info)
cmdSent = true func processImage(img image.Image, editFlag string, resizeFactor float64, config image.Config) image.Image {
} if strings.Contains(editFlag, "monochrome") {
img = editImageMonochrome(img)
}
if strings.Contains(editFlag, "blur") {
img = blur.Gaussian(img, float64(config.Width)/300)
}
if strings.Contains(editFlag, "edge") {
img = effect.Sobel(img)
}
if strings.Contains(editFlag, "segment") {
img = segment.Threshold(img, 128)
}
if strings.Contains(editFlag, "invert") {
img = editImageInvert(img)
}
if resizeFactor != 1.0 {
img = resize.Resize(uint(float64(config.Width)*resizeFactor), uint(float64(config.Height)*resizeFactor), img, resize.MitchellNetravali)
}
return img
}
func getGraphicType(typeFlag string) zplgfa.GraphicType {
switch strings.ToUpper(typeFlag) {
case "ASCII":
return zplgfa.ASCII
case "BINARY":
return zplgfa.Binary
case "COMPRESSEDASCII":
return zplgfa.CompressedASCII
default:
return zplgfa.CompressedASCII
} }
return cmdSent
} }
func main() { func main() {
var filenameFlag string filename, zebraCmd, graphicTypeFlag, imageEdit, ip, port, resizeFactor := parseFlags()
var zebraCmdFlag string
var graphicTypeFlag string
var imageEditFlag string
var networkIpFlag string
var networkPortFlag string
var imageResizeFlag float64
var graphicType zplgfa.GraphicType
flag.StringVar(&filenameFlag, "file", "", "filename to convert to zpl") if handleZebraCommands(zebraCmd, ip, port) && filename == "" {
flag.StringVar(&zebraCmdFlag, "cmd", "", "send special command to printer [cancel,calib,feed,info,config,diag]") return
flag.StringVar(&graphicTypeFlag, "type", "CompressedASCII", "type of graphic field encoding") }
flag.StringVar(&imageEditFlag, "edit", "", "manipulate the image [invert,monochrome]")
flag.StringVar(&networkIpFlag, "ip", "", "send zpl to printer")
flag.StringVar(&networkPortFlag, "port", "9100", "network port of printer")
flag.Float64Var(&imageResizeFlag, "resize", 1.0, "zoom/resize the image")
// load flag input arguments if filename == "" {
flag.Parse()
// send special commands to printer
cmdSent := specialCmds(zebraCmdFlag, networkIpFlag, networkPortFlag)
// check input parameter
if filenameFlag == "" {
if cmdSent {
return
}
log.Printf("Warning: no input file specified\n") log.Printf("Warning: no input file specified\n")
return return
} }
// open file img, config, err := openImageFile(filename)
file, err := os.Open(filenameFlag)
if err != nil { if err != nil {
log.Printf("Warning: could not open the file \"%s\": %s\n", filenameFlag, err) log.Printf("Warning: %s\n", err)
return return
} }
// close file when complete img = processImage(img, imageEdit, resizeFactor, config)
defer file.Close()
// load image head information
config, format, err := image.DecodeConfig(file)
if err != nil {
log.Printf("Warning: image not compatible, format: %s, config: %v, error: %s\n", format, config, err)
}
// reset file pointer to the beginning of the file
file.Seek(0, 0)
// load and decode image
img, _, err := image.Decode(file)
if err != nil {
log.Printf("Warning: could not decode the file, %s\n", err)
return
}
// select graphic field type
switch strings.ToUpper(graphicTypeFlag) {
case "ASCII":
graphicType = zplgfa.ASCII
case "BINARY":
graphicType = zplgfa.Binary
case "COMPRESSEDASCII":
graphicType = zplgfa.CompressedASCII
default:
graphicType = zplgfa.CompressedASCII
}
// apply image manipulation functions
if strings.Contains(imageEditFlag, "monochrome") {
img = editImageMonochrome(img)
}
if strings.Contains(imageEditFlag, "blur") {
img = blur.Gaussian(img, float64(config.Width)/300)
}
if strings.Contains(imageEditFlag, "edge") {
img = effect.Sobel(img)
}
if strings.Contains(imageEditFlag, "segment") {
img = segment.Threshold(img, 128)
}
if strings.Contains(imageEditFlag, "invert") {
img = editImageInvert(img)
}
// resize image
if imageResizeFlag != 1.0 {
img = resize.Resize(uint(float64(config.Width)*imageResizeFlag), uint(float64(config.Height)*imageResizeFlag), img, resize.MitchellNetravali)
}
// flatten image
flat := zplgfa.FlattenImage(img) flat := zplgfa.FlattenImage(img)
gfimg := zplgfa.ConvertToZPL(flat, getGraphicType(graphicTypeFlag))
// convert image to zpl compatible type if ip != "" {
gfimg := zplgfa.ConvertToZPL(flat, graphicType) sendDataToZebra(ip, port, gfimg)
if networkIpFlag != "" {
// send zpl to printer
sendDataToZebra(networkIpFlag, networkPortFlag, gfimg)
} else { } else {
// output zpl with graphic field data to stdout
fmt.Println(gfimg) fmt.Println(gfimg)
} }
} }

2
example_test.go
View File

@@ -52,5 +52,5 @@ func ExampleConvertToZPL() {
fmt.Println(zplstr) fmt.Println(zplstr)
// Output: ^XA,^FS^FO0,0^GFA,52,51,3,FFFF00::FE3F00::FFFF00FFE300::FFFF00E22300::FFFF00::^FS,^XZ // Output: ^XA,^FS^FO0,0^GFA,52,51,3,FFFF80::FE3F80::FFFF80FFE380::FFFF80E22380::FFFF80::^FS,^XZ
} }

8
go.mod Normal file
View File

@@ -0,0 +1,8 @@
module simonwaldherr.de/go/zplgfa
go 1.22
require (
github.com/anthonynsimon/bild v0.13.0
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
)

35
go.sum Normal file
View File

@@ -0,0 +1,35 @@
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/anthonynsimon/bild v0.13.0 h1:mN3tMaNds1wBWi1BrJq0ipDBhpkooYfu7ZFSMhXt1C8=
github.com/anthonynsimon/bild v0.13.0/go.mod h1:tpzzp0aYkAsMi1zmfhimaDyX1xjn2OUc1AJZK/TF0AE=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/image v0.0.0-20190703141733-d6a02ce849c9/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

22
tests/tests.json
View File

File diff suppressed because one or more lines are too long

142
zplgfa.go
View File

@@ -21,19 +21,15 @@ const (
CompressedASCII CompressedASCII
) )
// ConvertToZPL is just a wrapper for ConvertToGraphicField which also includes the ZPL // ConvertToZPL is a wrapper for ConvertToGraphicField, adding ZPL start and end codes.
// starting code ^XA and ending code ^XZ, as well as a Field Separator and Field Origin.
func ConvertToZPL(img image.Image, graphicType GraphicType) string { func ConvertToZPL(img image.Image, graphicType GraphicType) string {
//Check before entering the ConvertToGraphicField function if img.Bounds().Size().X/8 == 0 {
//if the width is 0, the function can exit early
check := img.Bounds().Size().X / 8
if check == 0 {
return "" return ""
} }
return fmt.Sprintf("^XA,^FS\n^FO0,0\n%s^FS,^XZ\n", ConvertToGraphicField(img, graphicType)) return fmt.Sprintf("^XA,^FS\n^FO0,0\n%s^FS,^XZ\n", ConvertToGraphicField(img, graphicType))
} }
// FlattenImage optimizes an image for the converting process // FlattenImage optimizes an image for the converting process.
func FlattenImage(source image.Image) *image.NRGBA { func FlattenImage(source image.Image) *image.NRGBA {
size := source.Bounds().Size() size := source.Bounds().Size()
background := color.White background := color.White
@@ -41,37 +37,36 @@ func FlattenImage(source image.Image) *image.NRGBA {
for y := 0; y < size.Y; y++ { for y := 0; y < size.Y; y++ {
for x := 0; x < size.X; x++ { for x := 0; x < size.X; x++ {
p := source.At(x, y) p := source.At(x, y)
flat := flatten(p, background) target.Set(x, y, flatten(p, background))
target.Set(x, y, flat)
} }
} }
return target return target
} }
func flatten(input color.Color, background color.Color) color.Color { func flatten(input, background color.Color) color.Color {
source := color.NRGBA64Model.Convert(input).(color.NRGBA64) source := color.NRGBA64Model.Convert(input).(color.NRGBA64)
r, g, b, a := source.RGBA() r, g, b, a := source.RGBA()
bgR, bgG, bgB, _ := background.RGBA() bgR, bgG, bgB, _ := background.RGBA()
alpha := float32(a) / 0xffff alpha := float32(a) / 0xffff
conv := func(c uint32, bg uint32) uint8 {
val := 0xffff - uint32((float32(bg) * alpha)) conv := func(c, bg uint32) uint8 {
val = val | uint32(float32(c)*alpha) val := 0xffff - uint32(float32(bg)*alpha)
val |= uint32(float32(c) * alpha)
return uint8(val >> 8) return uint8(val >> 8)
} }
c := color.NRGBA{
conv(r, bgR), return color.NRGBA{
conv(g, bgG), R: conv(r, bgR),
conv(b, bgB), G: conv(g, bgG),
uint8(0xff), B: conv(b, bgB),
A: 0xff,
} }
return c
} }
func getRepeatCode(repeatCount int, char string) string { func getRepeatCode(repeatCount int, char string) string {
repeatStr := "" repeatStr := ""
if repeatCount > 419 { if repeatCount > 419 {
repeatCount -= 419 repeatStr += getRepeatCode(repeatCount-419, char)
repeatStr += getRepeatCode(repeatCount, char)
repeatCount = 419 repeatCount = 419
} }
@@ -88,118 +83,89 @@ func getRepeatCode(repeatCount int, char string) string {
repeatStr += string(lowString[low]) repeatStr += string(lowString[low])
} }
repeatStr += char return repeatStr + char
return repeatStr
} }
// CompressASCII compresses the ASCII data of a ZPL Graphic Field using RLE // CompressASCII compresses the ASCII data of a ZPL Graphic Field using RLE.
func CompressASCII(in string) string { func CompressASCII(input string) string {
var curChar string var output, lastChar, repCode string
var lastChar string lastCharSince := 0
var lastCharSince int
var output string
var repCode string
for i := 0; i < len(in)+1; i++ { for i := 0; i < len(input)+1; i++ {
if i == len(in) { curChar := ""
curChar = "" if i < len(input) {
if lastCharSince == 0 { curChar = string(input[i])
switch lastChar {
case "0":
output = ","
return output
case "F":
output = "!"
return output
}
}
} else {
curChar = string(in[i])
} }
if lastChar != curChar { if lastChar != curChar {
if i-lastCharSince > 4 { if i-lastCharSince > 4 {
repCode = getRepeatCode(i-lastCharSince, lastChar) repCode = getRepeatCode(i-lastCharSince, lastChar)
output += repCode output += repCode
} else { } else {
for j := 0; j < i-lastCharSince; j++ { output += strings.Repeat(lastChar, i-lastCharSince)
output += lastChar
}
} }
lastChar = curChar lastChar = curChar
lastCharSince = i lastCharSince = i
} }
if curChar == "" && lastCharSince == 0 {
switch lastChar {
case "0":
return ","
case "F":
return "!"
}
}
} }
if output == "" { if output == "" {
output += getRepeatCode(len(in), lastChar) output += getRepeatCode(len(input), lastChar)
} }
return output return output
} }
// ConvertToGraphicField converts an image.Image picture to a ZPL compatible Graphic Field. // ConvertToGraphicField converts an image.Image to a ZPL compatible Graphic Field.
// The ZPL ^GF (Graphic Field) supports various data formats, this package supports the
// normal ASCII encoded, as well as a RLE compressed ASCII format. It also supports the
// Binary Graphic Field format. The encoding can be chosen by the second argument.
func ConvertToGraphicField(source image.Image, graphicType GraphicType) string { func ConvertToGraphicField(source image.Image, graphicType GraphicType) string {
var gfType string var gfType, lastLine, graphicFieldData string
var lastLine string
size := source.Bounds().Size() size := source.Bounds().Size()
width := size.X / 8 width := (size.X + 7) / 8 // round up division
height := size.Y height := size.Y
if size.Y%8 != 0 {
width = width + 1
}
var GraphicFieldData string
for y := 0; y < size.Y; y++ { for y := 0; y < size.Y; y++ {
line := make([]uint8, width) line := make([]uint8, width)
lineIndex := 0
index := uint8(0)
currentByte := line[lineIndex]
for x := 0; x < size.X; x++ { for x := 0; x < size.X; x++ {
index = index + 1 if x%8 == 0 {
p := source.At(x, y) line[x/8] = 0
lum := color.Gray16Model.Convert(p).(color.Gray16)
if lum.Y < math.MaxUint16/2 {
currentByte = currentByte | (1 << (8 - index))
} }
if index >= 8 { if lum := color.Gray16Model.Convert(source.At(x, y)).(color.Gray16).Y; lum < math.MaxUint16/2 {
line[lineIndex] = currentByte line[x/8] |= 1 << (7 - uint(x)%8)
lineIndex++
if lineIndex < len(line) {
currentByte = line[lineIndex]
}
index = 0
} }
} }
hexstr := strings.ToUpper(hex.EncodeToString(line)) hexStr := strings.ToUpper(hex.EncodeToString(line))
switch graphicType { switch graphicType {
case ASCII: case ASCII:
GraphicFieldData += fmt.Sprintln(hexstr) graphicFieldData += fmt.Sprintln(hexStr)
case CompressedASCII: case CompressedASCII:
curLine := CompressASCII(hexstr) curLine := CompressASCII(hexStr)
if lastLine == curLine { if lastLine == curLine {
GraphicFieldData += ":" graphicFieldData += ":"
} else { } else {
GraphicFieldData += curLine graphicFieldData += curLine
} }
lastLine = curLine lastLine = curLine
case Binary: case Binary:
GraphicFieldData += fmt.Sprintf("%s", line) graphicFieldData += string(line)
} }
} }
if graphicType == ASCII || graphicType == CompressedASCII { switch graphicType {
case ASCII, CompressedASCII:
gfType = "A" gfType = "A"
} else if graphicType == Binary { case Binary:
gfType = "B" gfType = "B"
} }
return fmt.Sprintf("^GF%s,%d,%d,%d,\n%s", gfType, len(GraphicFieldData), width*height, width, GraphicFieldData) return fmt.Sprintf("^GF%s,%d,%d,%d,\n%s", gfType, len(graphicFieldData), width*height, width, graphicFieldData)
} }

125
zplgfa_test.go
View File

@@ -23,73 +23,80 @@ type zplTest struct {
var zplTests []zplTest var zplTests []zplTest
func init() { func init() {
jsonstr, _ := ioutil.ReadFile("./tests/tests.json") jsonstr, err := ioutil.ReadFile("./tests/tests.json")
json.Unmarshal(jsonstr, &zplTests) if err != nil {
log.Fatalf("Failed to read test cases: %s", err)
}
if err := json.Unmarshal(jsonstr, &zplTests); err != nil {
log.Fatalf("Failed to unmarshal test cases: %s", err)
}
} }
func Test_CompressASCII(t *testing.T) { func Test_CompressASCII(t *testing.T) {
if str := CompressASCII("FFFFFFFF000000"); str != "NFL0" { if str := CompressASCII("FFFFFFFF000000"); str != "NFL0" {
t.Fatalf("CompressASCII failed") t.Fatalf("CompressASCII failed: got %s, want NFL0", str)
} }
} }
func Test_ConvertToZPL(t *testing.T) { func Test_ConvertToZPL(t *testing.T) {
var graphicType GraphicType
for i, testcase := range zplTests { for i, testcase := range zplTests {
filename, zplstring, graphictype := testcase.Filename, testcase.Zplstring, testcase.Graphictype t.Run(testcase.Filename, func(t *testing.T) {
// open file testConvertToZPL(t, testcase, i)
file, err := os.Open(filename) })
if err != nil {
log.Printf("Warning: could not open the file \"%s\": %s\n", filename, err)
return
}
defer file.Close()
// load image head information
config, format, err := image.DecodeConfig(file)
if err != nil {
log.Printf("Warning: image not compatible, format: %s, config: %v, error: %s\n", format, config, err)
}
// reset file pointer to the beginning of the file
file.Seek(0, 0)
// load and decode image
img, _, err := image.Decode(file)
if err != nil {
log.Printf("Warning: could not decode the file, %s\n", err)
return
}
// flatten image
flat := FlattenImage(img)
// convert image to zpl compatible type
switch graphictype {
case "ASCII":
graphicType = ASCII
case "Binary":
graphicType = Binary
case "CompressedASCII":
graphicType = CompressedASCII
default:
graphicType = CompressedASCII
}
gfimg := ConvertToZPL(flat, graphicType)
if graphictype == "Binary" {
gfimg = base64.StdEncoding.EncodeToString([]byte(gfimg))
} else {
// remove whitespace - only for the test
gfimg = strings.Replace(gfimg, " ", "", -1)
gfimg = strings.Replace(gfimg, "\n", "", -1)
}
if gfimg != zplstring {
log.Printf("ConvertToZPL Test for file \"%s\" failed, wanted: \n%s\ngot: \n%s\n", filename, zplstring, gfimg)
t.Fatalf("Testcase %d ConvertToZPL failed", i)
}
} }
} }
func testConvertToZPL(t *testing.T, testcase zplTest, index int) {
file, err := os.Open(testcase.Filename)
if err != nil {
t.Fatalf("Failed to open file %s: %s", testcase.Filename, err)
}
defer file.Close()
_, _, err = image.DecodeConfig(file)
if err != nil {
t.Fatalf("Failed to decode config for file %s: %s", testcase.Filename, err)
}
if _, err := file.Seek(0, 0); err != nil {
t.Fatalf("Failed to reset file pointer for %s: %s", testcase.Filename, err)
}
img, _, err := image.Decode(file)
if err != nil {
t.Fatalf("Failed to decode image for file %s: %s", testcase.Filename, err)
}
flat := FlattenImage(img)
graphicType := parseGraphicType(testcase.Graphictype)
gfimg := ConvertToZPL(flat, graphicType)
if graphicType == Binary {
gfimg = base64.StdEncoding.EncodeToString([]byte(gfimg))
} else {
gfimg = cleanZPLString(gfimg)
}
if gfimg != testcase.Zplstring {
t.Fatalf("Testcase %d ConvertToZPL failed for file %s: \nExpected: \n%s\nGot: \n%s\n", index, testcase.Filename, testcase.Zplstring, gfimg)
}
}
func parseGraphicType(graphicTypeStr string) GraphicType {
switch graphicTypeStr {
case "ASCII":
return ASCII
case "Binary":
return Binary
case "CompressedASCII":
return CompressedASCII
default:
return CompressedASCII
}
}
func cleanZPLString(zpl string) string {
zpl = strings.ReplaceAll(zpl, " ", "")
zpl = strings.ReplaceAll(zpl, "\n", "")
return zpl
}