What is the best way to render a pixel-perfect pixel-art image?

[NNBnh]

Hello, i have this image that i want to render on my terminal:

So i download and try to render it:

curl -sL 'https://veekun.com/dex/media/pokemon/icons/492-sky.png' > shaymin-sky.png
chafa --symbols vhalf shaymin-sky.png

But the result seem blurry:

I want the output to be pixel-perfect, am i missing something? you guy have any suggestion?

[hpjansson]

Which terminal are you running? Try one with sixel support, or Kitty, which is supported through its own protocol. Chafa should detect your terminal and use the correct mode automatically, but if it doesn't, there's always the -f flag (the parameter can be sixel, kitty, iterm, or symbol.

There may still be some blurriness due to scaling. Currently, the only was around that is to prescale the image using nearest-neighbor interpolation. I.e. make the pixels 16x bigger or 32x bigger. Then run chafa on that.

You can do the prescaling using something like convert in.png -filter point -resize 800% out.png.

[acxz]

I spent some time trying to tackle this issue as I think I got a reasonable solution:
I found that -filter did some blurring so I wanted to avoid that option and just use -scale for exact pixel replication.

For the following image:

Running just chafa:

Running:

convert in.png -scale 800% out.png
chafa --scale 1 out.png

We get the pixel perfect:

Note for some small images this doesn't work so well, but for most sprites the above will serve you well.

Here is an example of another image with the prescaling done for chafa and comparing it with timg's output:

Chafa w/ prescaling:

Timg's output with original file:

I would love if there was a mode for pixel perfect display in chafa that somehow bypasses the scaling of the dimension into cells. Note looking at the pipeline end to end, the prescaling does cause that pipeline to be slower than timg's pipeline, while also not being as accurate.

[hpjansson]

Great answer. You might get a little bit closer and skip ImageMagick by doing this:

chafa --symbols vhalf -w 1 --color-extractor median -s 15x10 --stretch pika.png

Quick explanation of the switches follows:

• --symbols vhalf: Use U+2584 only, which I think is what timg is doing.
• -w 1: Work as quickly as possible. This is a hack to disable smooth scaling.
• --color-extractor median: When colorizing the symbols, pick the median of the underlying pixels instead of the average.
• -s 15x10: Scale to a cell size corresponding to 1x2 pixels per cell. The dimensions come from e.g. file pika.png, with vertical size divided by two, rounding up.
• --stretch: Ignore aspect so we get the exact size specified by -s.

The result is almost perfect, but there's one more hurdle we can't overcome yet: the input image is 15x19 pixels, and 19 isn't evenly divisible by two. What we really want is to specify the scale in half-cells (and just pad the first or last row), but Chafa only allows integer cells. That can be fixed, though.

I think this shows there's a pixel-perfect mode in Chafa struggling to get out :-) I'll try to release it as time allows.

[acxz]

@hpjansson trying to get back into some terminal shenanigans and I remember this was a small lingering nit I had.

I was wondering if half-cell support has been added to Chafa or if there is a plan to add pixel-perfect/half cell support? If there is a plan should an issue be made?

[hpjansson]

There is pixel perfect processing since version 1.14, but only for pixel-based protocols like sixels and iterm2. I still need to make a few adjustments for it to work effortlessly with symbols. You should get the best possible half-cell output this way now:

chafa --scale 8 --symbols vhalf -w 1

The --scale option was added in version 1.12. This respects the view size, so if you want results that can be bigger than the terminal, you should use --view-size 9999x9999 or some other suitably large extent (1.14 onwards).