Calculate resize before doing it and do not crash if the image is smaller than the terminal

Author: hilli

cmd/icat/icat.go

@@ -15,7 +15,7 @@ func main() {
 		os.Exit(0)
 	}
 
-	for _, arg := range args {
+	for i, arg := range args {
 		var err error
 
 		url, err := url.Parse(arg)
@@ -27,5 +27,8 @@ func main() {
 		if err != nil {
 			os.Stderr.WriteString(err.Error())
 		}
+		if i < len(args)-1 {
+			os.Stdout.WriteString("\n")
+		}
 	}
 }

print_image.go

@@ -35,16 +35,11 @@ func PrintImageFile(imageFileName string) error {
 		return err
 	}
 
-	imageConfig, err := DecodeImageConfig(imageData)
-	if err != nil {
-		return err
-	}
-
 	img, err := DecodeImage(imageData)
 	if err != nil {
 		return err
 	}
-	return PrintImage(img, &imageConfig, imageFileName, imageSize)
+	return PrintImage(img, imageFileName, imageSize)
 }
 
 func PrintImageURL(imageURL string) error {
@@ -63,43 +58,31 @@ func PrintImageURL(imageURL string) error {
 		return err
 	}
 
-	imageConfig, err := DecodeImageConfig(imageData)
-	if err != nil {
-		fmt.Println("Error decoding image config:", err)
-		return err
-	}
-
 	img, err := DecodeImage(imageData)
 	if err != nil {
 		return err
 	}
-	return PrintImage(img, &imageConfig, imageURL, resp.ContentLength)
+	return PrintImage(img, imageURL, resp.ContentLength)
 }
 
-func PrintImage(img *image.Image, imageConfig *image.Config, filename string, imageSize int64) error {
-	var img2 image.Image
+func PrintImage(img *image.Image, filename string, imageSize int64) error {
+	var img2 image.Image = *img
 	sixelCapable, _ := rasterm.IsSixelCapable()
 
 	_, _, pw, ph := TermSize() // Get terminal height and width in pixels
+	size, resizeOption := resizeConstraints(img2.Bounds(), int(pw), int(ph))
 
-	kittyOpts := rasterm.KittyImgOpts{SrcWidth: uint32(pw), SrcHeight: uint32(ph)}
-
-	if pw < uint16(imageConfig.Width) {
-		kittyOpts.SrcWidth = uint32(pw)
-	}
-	if ph < uint16(imageConfig.Height) {
-		kittyOpts.SrcHeight = uint32(ph)
+	switch resizeOption {
+	case 'x':
+		img2 = resize.Resize(uint(size), 0, img2, resize.NearestNeighbor)
+	case 'y':
+		img2 = resize.Resize(0, uint(size), img2, resize.NearestNeighbor)
 	}
 
-	if pw < uint16(imageConfig.Width) {
-		img2 = resize.Resize(uint(pw), 0, *img, resize.NearestNeighbor)
-	}
+	newWidth := img2.Bounds().Max.X
+	newHeight := img2.Bounds().Max.Y
 
-	img2Height := img2.Bounds().Max.Y
-
-	if ph < uint16(img2Height) {
-		img2 = resize.Resize(0, uint(ph), img2, resize.NearestNeighbor)
-	}
+	kittyOpts := rasterm.KittyImgOpts{SrcWidth: uint32(newWidth), SrcHeight: uint32(newHeight)}
 
 	switch {
 	case rasterm.IsKittyCapable():
@@ -126,15 +109,6 @@ func PrintImage(img *image.Image, imageConfig *image.Config, filename string, im
 	return nil
 }
 
-func DecodeImageConfig(imageData []byte) (imageConfig image.Config, err error) {
-	imageDataReader := bytes.NewReader(imageData)
-	imageConfig, _, err = image.DecodeConfig(imageDataReader)
-	if err != nil {
-		return image.Config{}, err
-	}
-	return imageConfig, nil
-}
-
 func DecodeImage(imageData []byte) (*image.Image, error) {
 	imageDataReader := bytes.NewReader(imageData)
 	image, _, err := image.Decode(imageDataReader)

resize_constraints.go

@@ -0,0 +1,32 @@
+package icat
+
+import (
+	"image"
+)
+
+func resizeConstraints(imageBounds image.Rectangle, maxHeight, maxWidth int) (size int, option rune) {
+	imgHeight := imageBounds.Dy()
+	imgWidth := imageBounds.Dx()
+
+	if imgHeight <= maxHeight && imgWidth <= maxWidth {
+		return 0, '0' // Don't resize
+	}
+
+	if imgHeight <= maxHeight && imgWidth > maxWidth {
+		return maxWidth, 'x'
+	}
+
+	if imgWidth <= maxWidth && imgHeight > maxHeight {
+		return maxHeight, 'y'
+	}
+
+	// OK, both x and y are too big. Let's figure out which one is the biggest
+	// and use that to calculate the resize factor.
+	hRatio := float32(imgHeight) / float32(maxHeight)
+	wRatio := float32(imgWidth) / float32(maxWidth)
+	if hRatio > wRatio {
+		return maxHeight, 'y'
+	} else {
+		return maxWidth, 'x'
+	}
+}

resize_constraints_test.go

@@ -0,0 +1,70 @@
+package icat
+
+import (
+	"image"
+	"testing"
+)
+
+func Test_resizeFactor(t *testing.T) {
+	type args struct {
+		imageBounds image.Rectangle
+		height      int
+		width       int
+	}
+	tests := []struct {
+		name        string
+		args        args
+		want_size   int
+		want_option rune
+	}{
+		{
+			name: "no resize",
+			args: args{
+				imageBounds: image.Rect(0, 0, 100, 100),
+				height:      200,
+				width:       200,
+			},
+			want_size:   0,
+			want_option: '0',
+		},
+		{
+			name: "resize height",
+			args: args{
+				imageBounds: image.Rect(0, 0, 100, 100),
+				height:      50,
+				width:       200,
+			},
+			want_size:   50,
+			want_option: 'y',
+		},
+		{
+			name: "resize width",
+			args: args{
+				imageBounds: image.Rect(0, 0, 100, 100),
+				height:      200,
+				width:       50,
+			},
+			want_size:   50,
+			want_option: 'x',
+		},
+		{
+			name: "resize both x and y",
+			args: args{
+				imageBounds: image.Rect(0, 0, 100, 100),
+				height:      50,
+				width:       50,
+			},
+			want_size:   50,
+			want_option: 'x',
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got_size, got_option := resizeConstraints(tt.args.imageBounds, tt.args.height, tt.args.width)
+			if got_size != int(tt.want_size) || got_option != tt.want_option {
+				t.Errorf("resizeConstraints() = %v, %s, want %v, %s", got_size, string(got_option), tt.want_size, string(tt.want_option))
+			}
+		})
+	}
+}