// encodePNG encodes an image to PNG format
func encodePNG(img image.Image, w io.Writer) error {
	// Use custom PNG encoder to avoid import cycles
	return encodeGrayscalePNG(img, w)
}

		}
	}
	return img
}
// CreateRGBImage creates an image.Image from a 2D RGBPixel array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateRGBImage(data [][]RGBPixel) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			img.SetRGBA(x, y, color.RGBA{
				R: data[y][x].R,
				G: data[y][x].G,
				B: data[y][x].B,
				A: 255,
			})

	result := image.NewGray(image.Rect(0, 0, newWidth, newHeight))

	// Detect if image is grayscale or RGB
	_, isGray := img.(*image.Gray)

	if isGray {
		result := image.NewGray(image.Rect(0, 0, newWidth, newHeight))
		for y := 0; y < newHeight; y++ {
			for x := 0; x < newWidth; x++ {
				srcX := int(float64(x) * scaleX)
				srcY := int(float64(y) * scaleY)
				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				if srcY >= srcHeight {
					srcY = srcHeight - 1
				}
				c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
				gray := color.GrayModel.Convert(c).(color.Gray)
				result.SetGray(x, y, gray)
			}
		}
		return result
	}

	result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))

			// Get pixel color

			gray := color.GrayModel.Convert(c).(color.Gray)
			result.SetGray(x, y, gray)

			r, g, b, _ := c.RGBA()
			result.SetRGBA(x, y, color.RGBA{
				R: uint8(r >> 8),
				G: uint8(g >> 8),
				B: uint8(b >> 8),
				A: 255,
			})

	return result
}

	return result

// encodePNG encodes an image to PNG format.
// Detects whether image is grayscale or RGB and uses appropriate encoder.
func encodePNG(img image.Image, w io.Writer) error {
	if _, ok := img.(*image.Gray); ok {
		return encodeGrayscalePNG(img, w)
	}
	return encodeRGBPNG(img, w)

// encodeRGBPNG encodes an RGB image to PNG format.
// This is a minimal implementation that works for 8-bit RGB images.
func encodeRGBPNG(img image.Image, w io.Writer) error {
	bounds := img.Bounds()
	width := bounds.Dx()
	height := bounds.Dy()

	// PNG signature
	signature := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
	if _, err := w.Write(signature); err != nil {
		return err
	}
	// IHDR chunk
	ihdr := make([]byte, 13)
	ihdr[0] = byte(width >> 24)
	ihdr[1] = byte(width >> 16)
	ihdr[2] = byte(width >> 8)
	ihdr[3] = byte(width)
	ihdr[4] = byte(height >> 24)
	ihdr[5] = byte(height >> 16)
	ihdr[6] = byte(height >> 8)
	ihdr[7] = byte(height)
	ihdr[8] = 8  // bit depth
	ihdr[9] = 2  // color type: RGB
	ihdr[10] = 0 // compression: deflate
	ihdr[11] = 0 // filter: adaptive
	ihdr[12] = 0 // interlace: none
	if err := writePNGChunk(w, "IHDR", ihdr); err != nil {
		return err
	}
	// IDAT chunk (image data)
	// RGB: 3 bytes per pixel + 1 filter byte per row
	rawData := make([]byte, 0, height*(width*3+1))
	for y := 0; y < height; y++ {
		rawData = append(rawData, 0) // filter byte (none)
		for x := 0; x < width; x++ {
			r, g, b, _ := img.At(x+bounds.Min.X, y+bounds.Min.Y).RGBA()
			rawData = append(rawData, byte(r>>8), byte(g>>8), byte(b>>8))
		}
	}
	compressed := deflateCompress(rawData)
	if err := writePNGChunk(w, "IDAT", compressed); err != nil {
		return err
	}
	// IEND chunk
	if err := writePNGChunk(w, "IEND", nil); err != nil {
		return err
	}
	return nil
}

package utils
// RGBPixel represents an RGB color value
type RGBPixel struct {
	R, G, B uint8
}
// L4Colormap is the Black-Red-Yellow heat colormap from PerceptualColourMaps.jl
// Control points:
//   Index 0:   Black      (0.0, 0.0, 0.0)
//   Index 85:  Dark Red   (0.85, 0.0, 0.0)
//   Index 170: Orange-Red (1.0, 0.15, 0.0)
//   Index 255: Yellow     (1.0, 1.0, 0.0)
var L4Colormap [256]RGBPixel
func init() {
	// Generate L4 colormap using piecewise linear interpolation
	// This avoids overshoot issues with cubic splines
	controlPoints := []struct {
		idx int
		r   float64
		g   float64
		b   float64
	}{
		{0, 0.0, 0.0, 0.0},
		{85, 0.85, 0.0, 0.0},
		{170, 1.0, 0.15, 0.0},
		{255, 1.0, 1.0, 0.0},
	}
	for i := 0; i < 256; i++ {
		// Find the segment we're in
		var seg int
		for seg = 0; seg < len(controlPoints)-1; seg++ {
			if i <= controlPoints[seg+1].idx {
				break
			}
		}
		if seg >= len(controlPoints)-1 {
			seg = len(controlPoints) - 2
		}
		// Linear interpolation within segment
		p0 := controlPoints[seg]
		p1 := controlPoints[seg+1]
		t := 0.0
		if p1.idx != p0.idx {
			t = float64(i-p0.idx) / float64(p1.idx-p0.idx)
		}
		L4Colormap[i] = RGBPixel{
			R: uint8((p0.r + t*(p1.r-p0.r)) * 255.0),
			G: uint8((p0.g + t*(p1.g-p0.g)) * 255.0),
			B: uint8((p0.b + t*(p1.b-p0.b)) * 255.0),
		}
	}
}
// ApplyL4Colormap converts a grayscale image to RGB using the L4 colormap
func ApplyL4Colormap(grayscale [][]uint8) [][]RGBPixel {
	if len(grayscale) == 0 || len(grayscale[0]) == 0 {
		return nil
	}
	rows := len(grayscale)
	cols := len(grayscale[0])
	result := make([][]RGBPixel, rows)
	for i := range result {
		result[i] = make([]RGBPixel, cols)
	}
	for y := 0; y < rows; y++ {
		for x := 0; x < cols; x++ {
			result[y][x] = L4Colormap[grayscale[y][x]]
		}
	}
	return result
}

	"image"

	Color        bool   `json:"color" jsonschema:"Apply L4 colormap to spectrogram"`

		// Print segment time info
		fmt.Fprintf(os.Stderr, "Segment %d: %.1fs - %.1fs (%.1fs)\n", i+1, segment.StartTime, segment.EndTime, segment.EndTime-segment.StartTime)

		// Create image
		img := utils.CreateGrayscaleImage(spectrogram)

		// Create image (grayscale or color)
		var img image.Image
		if input.Color {
			// Apply L4 colormap
			colorData := utils.ApplyL4Colormap(spectrogram)
			img = utils.CreateRGBImage(colorData)
		} else {
			img = utils.CreateGrayscaleImage(spectrogram)
		}

		// Print segment time info
		fmt.Fprintf(os.Stderr, "Segment %d: %.1fs - %.1fs (%.1fs)\n", i+1, segment.StartTime, segment.EndTime, segment.EndTime-segment.StartTime)
		fmt.Println() // Newline

	color := fs.Bool("color", false, "Apply L4 colormap (default: false, grayscale)")

		fmt.Fprintf(os.Stderr, "  skraak calls show-images --file recording.wav.data --color\n")

		Color:        *color,

	fmt.Println() // Newline

	fmt.Fprintf(os.Stderr, "Showing spectrogram images for: %s\n", *filePath)
	if *color {
		fmt.Fprintf(os.Stderr, "Color: L4 colormap (Black-Red-Yellow)\n")
	}