*Box

// The image to be displayed. If nil, the widget will be empty.

image image.Image

// The size of the image. If a value is 0, the corresponding size is chosen

// automatically based on the other size while preserving the image's aspect

// ratio. If both are 0, the image uses as much space as possible. A

// negative value represents a percentage, e.g. -50 means 50% of the

// available space.

width, height int

// The number of colors to use. If 0, the number of colors is chosen based

// on the terminal's capabilities.

colors int

// The dithering algorithm to use, one of the constants starting with

// "ImageDithering".

dithering int

// The width of a terminal's cell divided by its height.

aspectRatio float64

// Horizontal and vertical alignment, one of the "Align" constants.

alignHorizontal, alignVertical int

// The text to be displayed before the image.

label string

// The label style.

labelStyle tcell.Style

// The screen width of the label area. A value of 0 means use the width of

// the label text.

labelWidth int

// The actual image size (in cells) when it was drawn the last time.

lastWidth, lastHeight int

// The actual image (in cells) when it was drawn the last time. The size of

// this slice is lastWidth * lastHeight, indexed by y*lastWidth + x.

pixels []pixel

// A callback function set by the Form class and called when the user leaves

// this form item.

finished func(tcell.Key)

return &Image{

Box: NewBox(),

dithering: DitheringFloydSteinberg,

aspectRatio: 0.5,

alignHorizontal: AlignCenter,

alignVertical: AlignCenter,

}

i.image = image

i.lastWidth, i.lastHeight = 0, 0

return i

i.width = columns

i.height = rows

return i

i.colors = colors

i.lastWidth, i.lastHeight = 0, 0

return i

switch {

case i.colors == 0:

return availableColors

case i.colors <= 2:

return 2

case i.colors <= 8:

return 8

case i.colors <= 256:

return 256

}

return TrueColor

i.dithering = dithering

i.lastWidth, i.lastHeight = 0, 0

return i

if aspectRatio <= 0 {

panic("aspect ratio must be greater than 0")

}

i.aspectRatio = aspectRatio

i.lastWidth, i.lastHeight = 0, 0

return i

i.alignHorizontal = horizontal

i.alignVertical = vertical

return i

if i.width <= 0 {

if i.image == nil {

return 0

}

bounds := i.image.Bounds()

height := i.GetFieldHeight()

return bounds.Dx() * height / bounds.Dy()

}

return i.width

if i.height <= 0 {

return 8

}

return i.height

i.labelWidth = labelWidth

i.backgroundColor = bgColor

i.SetLabelStyle(tcell.StyleDefault.Foreground(labelColor).Background(bgColor))

i.lastWidth, i.lastHeight = 0, 0

return i

// If we're part of a form, there's nothing the user can do here so we're

// finished.

if i.finished != nil {

i.finished(-1)

return

}

i.Box.Focus(delegate)

// If there is no image, there are no pixels.

if i.image == nil {

i.pixels = nil

return

}

// Calculate the new (terminal-space) image size.

bounds := i.image.Bounds()

imageWidth, imageHeight := bounds.Dx(), bounds.Dy()

if i.aspectRatio != 1.0 {

imageWidth = int(float64(imageWidth) / i.aspectRatio)

}

width, height := i.width, i.height

_, _, innerWidth, innerHeight := i.GetInnerRect()

if i.labelWidth > 0 {

innerWidth -= i.labelWidth

} else {

innerWidth -= TaggedStringWidth(i.label)

}

if innerWidth <= 0 {

i.pixels = nil

return

}

if width == 0 && height == 0 {

// Use all available space.

width, height = innerWidth, innerHeight

if adjustedWidth := imageWidth * height / imageHeight; adjustedWidth < width {

width = adjustedWidth

} else {

height = imageHeight * width / imageWidth

}

} else {

// Turn percentages into absolute values.

if width < 0 {

width = innerWidth * -width / 100

}

if height < 0 {

height = innerHeight * -height / 100

}

if width == 0 {

// Adjust the width.

width = imageWidth * height / imageHeight

} else if height == 0 {

// Adjust the height.

height = imageHeight * width / imageWidth

}

}

if width <= 0 || height <= 0 {

i.pixels = nil

return

}

// If nothing has changed, we're done.

if i.lastWidth == width && i.lastHeight == height {

return

}

i.lastWidth, i.lastHeight = width, height // This could still be larger than the available space but that's ok for now.

// Generate the initial pixels by resizing the image (8x8 per cell).

pixels := i.resize()

// Turn them into block elements with background/foreground colors.

i.stamp(pixels)

// Because most of the time, we will be downsizing the image, we don't even

// attempt to do any fancy interpolation. For each target pixel, we

// calculate a weighted average of the source pixels using their coverage

// area.

bounds := i.image.Bounds()

srcWidth, srcHeight := bounds.Dx(), bounds.Dy()

tgtWidth, tgtHeight := i.lastWidth*8, i.lastHeight*8

coverageWidth, coverageHeight := float64(tgtWidth)/float64(srcWidth), float64(tgtHeight)/float64(srcHeight)

pixels := make([][3]float64, tgtWidth*tgtHeight)

weights := make([]float64, tgtWidth*tgtHeight)

for srcY := bounds.Min.Y; srcY < bounds.Max.Y; srcY++ {

for srcX := bounds.Min.X; srcX < bounds.Max.X; srcX++ {

r32, g32, b32, _ := i.image.At(srcX, srcY).RGBA()

r, g, b := float64(r32)/0xffff, float64(g32)/0xffff, float64(b32)/0xffff

// Iterate over all target pixels. Outer loop is Y.

startY := float64(srcY-bounds.Min.Y) * coverageHeight

endY := startY + coverageHeight

fromY, toY := int(startY), int(endY)

for tgtY := fromY; tgtY <= toY && tgtY < tgtHeight; tgtY++ {

coverageY := 1.0

if tgtY == fromY {

coverageY -= math.Mod(startY, 1.0)

}

if tgtY == toY {

coverageY -= 1.0 - math.Mod(endY, 1.0)

}

// Inner loop is X.

startX := float64(srcX-bounds.Min.X) * coverageWidth

endX := startX + coverageWidth

fromX, toX := int(startX), int(endX)

for tgtX := fromX; tgtX <= toX && tgtX < tgtWidth; tgtX++ {

coverageX := 1.0

if tgtX == fromX {

coverageX -= math.Mod(startX, 1.0)

}

if tgtX == toX {

coverageX -= 1.0 - math.Mod(endX, 1.0)

}

// Add a weighted contribution to the target pixel.

index := tgtY*tgtWidth + tgtX

coverage := coverageX * coverageY

pixels[index][0] += r * coverage

pixels[index][1] += g * coverage

pixels[index][2] += b * coverage

weights[index] += coverage

}

}

}

}

// Normalize the pixels.

for index, weight := range weights {

if weight > 0 {

pixels[index][0] /= weight

pixels[index][1] /= weight

pixels[index][2] /= weight

}

}

return pixels

// For each 8x8 pixel block, we find the best block element to represent it,

// given the available colors.

i.pixels = make([]pixel, i.lastWidth*i.lastHeight)

colors := i.GetColors()

for row := 0; row < i.lastHeight; row++ {

for col := 0; col < i.lastWidth; col++ {

// Calculate an error for each potential block element + color. Keep

// the one with the lowest error.

// Note that the values in "resize" may lie outside [0, 1] due to

// the error distribution during dithering.

minMSE := math.MaxFloat64 // Mean squared error.

var final [64][3]float64 // The final pixel values.

for element, bits := range blockElements {

// Calculate the average color for the pixels covered by the set

// bits and unset bits.

var (

bg, fg [3]float64

setBits float64

bit uint64 = 1

)

for y := 0; y < 8; y++ {

for x := 0; x < 8; x++ {

index := (row*8+y)*i.lastWidth*8 + (col*8 + x)

if bits&bit != 0 {

fg[0] += resized[index][0]

fg[1] += resized[index][1]

fg[2] += resized[index][2]

setBits++

} else {

bg[0] += resized[index][0]

bg[1] += resized[index][1]

bg[2] += resized[index][2]

}

bit <<= 1

}

}

for ch := 0; ch < 3; ch++ {

fg[ch] /= setBits

if fg[ch] < 0 {

fg[ch] = 0

} else if fg[ch] > 1 {

fg[ch] = 1

}

bg[ch] /= 64 - setBits

if bg[ch] < 0 {

bg[ch] = 0

}

if bg[ch] > 1 {

bg[ch] = 1

}

}

// Quantize to the nearest acceptable color.

for _, color := range []*[3]float64{&fg, &bg} {

if colors == 2 {

// Monochrome. The following weights correspond better

// to human perception than the arithmetic mean.

gray := 0.299*color[0] + 0.587*color[1] + 0.114*color[2]

if gray < 0.5 {

*color = [3]float64{0, 0, 0}

} else {

*color = [3]float64{1, 1, 1}

}

} else {

for index, ch := range color {

switch {

case colors == 8:

// Colors vary wildly for each terminal. Expect

// suboptimal results.

if ch < 0.5 {

color[index] = 0

} else {

color[index] = 1

}

case colors == 256:

color[index] = math.Round(ch*6) / 6

}

}

}

}

// Calculate the error (and the final pixel values).

var (

mse float64

values [64][3]float64

valuesIndex int

)

bit = 1

for y := 0; y < 8; y++ {

for x := 0; x < 8; x++ {

if bits&bit != 0 {

values[valuesIndex] = fg

} else {

values[valuesIndex] = bg

}

index := (row*8+y)*i.lastWidth*8 + (col*8 + x)

for ch := 0; ch < 3; ch++ {

err := resized[index][ch] - values[valuesIndex][ch]

mse += err * err

}

bit <<= 1

valuesIndex++

}

}

// Do we have a better match?

if mse < minMSE {

// Yes. Save it.

minMSE = mse

final = values

index := row*i.lastWidth + col

i.pixels[index].element = element

i.pixels[index].style = tcell.StyleDefault.

Foreground(tcell.NewRGBColor(int32(math.Min(255, fg[0]*255)), int32(math.Min(255, fg[1]*255)), int32(math.Min(255, fg[2]*255)))).

Background(tcell.NewRGBColor(int32(math.Min(255, bg[0]*255)), int32(math.Min(255, bg[1]*255)), int32(math.Min(255, bg[2]*255))))

}

}

// Check if there is a shade block which results in a smaller error.

// What's the overall average color?

var avg [3]float64

for y := 0; y < 8; y++ {

for x := 0; x < 8; x++ {

index := (row*8+y)*i.lastWidth*8 + (col*8 + x)

for ch := 0; ch < 3; ch++ {

avg[ch] += resized[index][ch] / 64

}

}

}

for ch := 0; ch < 3; ch++ {

if avg[ch] < 0 {

avg[ch] = 0

} else if avg[ch] > 1 {

avg[ch] = 1

}

}

// Quantize and choose shade element.

element := BlockFullBlock

var fg, bg tcell.Color

shades := []rune{' ', BlockLightShade, BlockMediumShade, BlockDarkShade, BlockFullBlock}

if colors == 2 {

// Monochrome.

gray := 0.299*avg[0] + 0.587*avg[1] + 0.114*avg[2] // See above for details.

shade := int(math.Round(gray * 4))

element = shades[shade]

for ch := 0; ch < 3; ch++ {

avg[ch] = float64(shade) / 4

}

bg = tcell.ColorBlack

fg = tcell.ColorWhite

} else if colors == TrueColor {

// True color.

fg = tcell.NewRGBColor(int32(math.Min(255, avg[0]*255)), int32(math.Min(255, avg[1]*255)), int32(math.Min(255, avg[2]*255)))

bg = fg

} else {

// 8 or 256 colors.

steps := 1.0

if colors == 256 {

steps = 6.0

}

var (

lo, hi, pos [3]float64

shade float64

)

for ch := 0; ch < 3; ch++ {

lo[ch] = math.Floor(avg[ch]*steps) / steps

hi[ch] = math.Ceil(avg[ch]*steps) / steps

if r := hi[ch] - lo[ch]; r > 0 {

pos[ch] = (avg[ch] - lo[ch]) / r

if math.Abs(pos[ch]-0.5) < math.Abs(shade-0.5) {

shade = pos[ch]

}

}

}

shade = math.Round(shade * 4)

element = shades[int(shade)]

shade /= 4

for ch := 0; ch < 3; ch++ { // Find the closest channel value.

best := math.Abs(avg[ch] - (lo[ch] + (hi[ch]-lo[ch])*shade)) // Start shade from lo to hi.

if value := math.Abs(avg[ch] - (hi[ch] - (hi[ch]-lo[ch])*shade)); value < best {

best = value // Swap lo and hi.

lo[ch], hi[ch] = hi[ch], lo[ch]

}

if value := math.Abs(avg[ch] - lo[ch]); value < best {

best = value // Use lo.

hi[ch] = lo[ch]

}

if value := math.Abs(avg[ch] - hi[ch]); value < best {

lo[ch] = hi[ch] // Use hi.

}

avg[ch] = lo[ch] + (hi[ch]-lo[ch])*shade // Quantize.

}

bg = tcell.NewRGBColor(int32(math.Min(255, lo[0]*255)), int32(math.Min(255, lo[1]*255)), int32(math.Min(255, lo[2]*255)))

fg = tcell.NewRGBColor(int32(math.Min(255, hi[0]*255)), int32(math.Min(255, hi[1]*255)), int32(math.Min(255, hi[2]*255)))

}

// Calculate the error (and the final pixel values).

var (

mse float64

values [64][3]float64

valuesIndex int

)

for y := 0; y < 8; y++ {

for x := 0; x < 8; x++ {

index := (row*8+y)*i.lastWidth*8 + (col*8 + x)

for ch := 0; ch < 3; ch++ {

err := resized[index][ch] - avg[ch]

mse += err * err

}

values[valuesIndex] = avg

valuesIndex++

}

}

// Is this shade element better than the block element?

if mse < minMSE {

// Yes. Save it.

final = values

index := row*i.lastWidth + col

i.pixels[index].element = element

i.pixels[index].style = tcell.StyleDefault.Foreground(fg).Background(bg)

}

// Apply dithering.

if colors < TrueColor && i.dithering == DitheringFloydSteinberg {

// The dithering mask determines how the error is distributed.

// Each element has three values: dx, dy, and weight (in 16th).

var mask = [4][3]int{

{1, 0, 7},

{-1, 1, 3},

{0, 1, 5},

{1, 1, 1},

}

// We dither the 8x8 block as a 2x2 block, transferring errors

// to its 2x2 neighbors.

for ch := 0; ch < 3; ch++ {

for y := 0; y < 2; y++ {

for x := 0; x < 2; x++ {

// What's the error for this 4x4 block?

var err float64

for dy := 0; dy < 4; dy++ {

for dx := 0; dx < 4; dx++ {

err += (final[(y*4+dy)*8+(x*4+dx)][ch] - resized[(row*8+(y*4+dy))*i.lastWidth*8+(col*8+(x*4+dx))][ch]) / 16

}

}

// Distribute it to the 2x2 neighbors.

for _, dist := range mask {

for dy := 0; dy < 4; dy++ {

for dx := 0; dx < 4; dx++ {

targetX, targetY := (x+dist[0])*4+dx, (y+dist[1])*4+dy

if targetX < 0 || col*8+targetX >= i.lastWidth*8 || targetY < 0 || row*8+targetY >= i.lastHeight*8 {

continue

}

resized[(row*8+targetY)*i.lastWidth*8+(col*8+targetX)][ch] -= err * float64(dist[2]) / 16

}

}

}

}

}

}

}

}

}

i.DrawForSubclass(screen, i)

// Regenerate image if necessary.

i.render()

// Draw label.

viewX, viewY, viewWidth, viewHeight := i.GetInnerRect()

_, labelBg, _ := i.labelStyle.Decompose()

if i.labelWidth > 0 {

labelWidth := i.labelWidth

if labelWidth > viewWidth {

labelWidth = viewWidth

}

printWithStyle(screen, i.label, viewX, viewY, 0, labelWidth, AlignLeft, i.labelStyle, labelBg == tcell.ColorDefault)

viewX += labelWidth

viewWidth -= labelWidth

} else {

_, _, drawnWidth := printWithStyle(screen, i.label, viewX, viewY, 0, viewWidth, AlignLeft, i.labelStyle, labelBg == tcell.ColorDefault)

viewX += drawnWidth

viewWidth -= drawnWidth

}

// Determine image placement.

x, y, width, height := viewX, viewY, i.lastWidth, i.lastHeight

if i.alignHorizontal == AlignCenter {

x += (viewWidth - width) / 2

} else if i.alignHorizontal == AlignRight {

x += viewWidth - width

}

if i.alignVertical == AlignCenter {

y += (viewHeight - height) / 2

} else if i.alignVertical == AlignBottom {

y += viewHeight - height

}

// Draw the image.

for row := 0; row < height; row++ {

if y+row < viewY || y+row >= viewY+viewHeight {

continue

}

for col := 0; col < width; col++ {

if x+col < viewX || x+col >= viewX+viewWidth {

continue

}

index := row*width + col

screen.SetContent(x+col, y+row, i.pixels[index].element, nil, i.pixels[index].style)

}

}