From a882cd61584f7cf2babda1888f2726eb5c8418de Mon Sep 17 00:00:00 2001 From: Stefan Haustein Date: Sat, 9 Apr 2016 00:39:53 +0200 Subject: [PATCH] Initial checkin --- src/main/java/TerminalImageViewer.java | 301 +++++++++++++++++++++++++ 1 file changed, 301 insertions(+) create mode 100644 src/main/java/TerminalImageViewer.java diff --git a/src/main/java/TerminalImageViewer.java b/src/main/java/TerminalImageViewer.java new file mode 100644 index 0000000..918ed00 --- /dev/null +++ b/src/main/java/TerminalImageViewer.java @@ -0,0 +1,301 @@ +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.util.Arrays; + +import javax.imageio.ImageIO; + +public class TerminalImageViewer { + + /** + * Main method, handles command line arguments and loads and scales images. + */ + public static void main(String[] args) throws IOException { + if (args.length == 0) { + System.out.println("Image file name required. Use -w to set the width in characters (default: 80)."); + return; + } + + int w = 80 * 4; + + for (int i = 0; i < args.length; i++) { + String name = args[i]; + if (name.equals("-w")) { + w = 4 * Integer.parseInt(args[++i]); + continue; + } + + BufferedImage original; + if (name.startsWith("http://") || name.startsWith("https://")) { + URL url = new URL(name); + original = ImageIO.read(url); + } else { + original = ImageIO.read(new File(args[0])); + } + + int ow = original.getWidth(); + int oh = original.getHeight(); + int h = oh * w / ow; + + BufferedImage image = original; + if (w != ow) { + image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); + Graphics2D graphics = image.createGraphics(); + graphics.drawImage(original, 0, 0, w, h, null); + } + + ImageData imageData = new ImageData(w, h); + byte[] data = imageData.data; + int[] rgbArray = new int[w]; + for (int y = 0; y < image.getHeight(); y++) { + image.getRGB(0, y, image.getWidth(), 1, rgbArray, 0, w); + int pos = y * w * 4; + for (int x = 0; x < w; x++) { + int rgb = rgbArray[x]; + data[pos++] = (byte) (rgb >> 16); + data[pos++] = (byte) (rgb >> 8); + data[pos++] = (byte) rgb; + pos++; + } + } + System.out.println(imageData.dump()); + } + } + + /** + * ANSI control code helpers + */ + static class Ansi { + public static final String RESET = "\u001b[0m"; + + public static String fgColor(int r, int g, int b) { + return "\u001b[38;2;" + (r & 255) + ";" + (g & 255) + ";" + (b & 255) + "m"; + } + + public static String bgColor(int r, int g, int b) { + return "\u001b[48;2;" + (r & 255) + ";" + (g & 255) + ";" + (b & 255) + "m"; + } + } + + /** + * Converts 4x8 RGB pixel to a unicode character and a foreground and background character. + * Uses a variation of the median cut algorithm to determine a two-color palette for the + * character, then creates a corresponding bitmap for the partial image covered by the + * character and finds the best match in the character bitmap table. + */ + static class BlockChar { + + /** + * Assumed bitmaps of the supported characters + */ + static int[] BITMAPS = new int[] { + 0x00000000, ' ', + + 0x000ff000, '\u2501', + 0x000cc000, '\u2578', + 0x00033000, '\u257a', + + 0xffff0000, '\u2580', // upper 1/2 + + 0x0000000f, '\u2581', // lower 1/8 + 0x000000ff, '\u2582', // lower 1/4 + 0x00000fff, '\u2583', + 0x0000ffff, '\u2584', // lower 1/2 + 0x000fffff, '\u2585', + 0x00ffffff, '\u2586', // lower 3/4 + 0x0fffffff, '\u2587', + 0xffffffff, '\u2588', // full + + 0xeeeeeeee, '\u258a', // left 3/4 + 0xcccccccc, '\u258c', // left 1/2 + 0x88888888, '\u258e', // left 1/4 + + 0x0000cccc, '\u2596', // quadrant lower left + 0x00003333, '\u2597', // quadrant lower right + 0xcccc0000, '\u2598', // quadrant upper left + 0xccccffff, '\u2599', // ... + 0xcccc3333, '\u259a', + 0xffffcccc, '\u259b', + 0xffff3333, '\u259c', + 0x33330000, '\u259d', + 0x3333cccc, '\u259e', + 0x3333ffff, '\u259f', + + 0x0006ff60, '\u25cf', // Black circle + + 0x000137f0, '\u25e2', // Triangles + 0x0008cef0, '\u25e3', + 0x000fec80, '\u25e4', + 0x000f7310, '\u25e5' + }; + + /** Minimum value for each color channel. */ + int[] min = new int[3]; + + /** Maximum value for each color channel. */ + int[] max = new int[3]; + + /** Red, green and blue components of the selected background color. */ + int[] bgColor = new int[3]; + + /** Red, green and blue components of the selected background color. */ + int[] fgColor = new int[3]; + + /** The selected character. */ + char character; + + /** + * Converts a set of pixels to a unicode character and a background and foreground color. + * data contains the rgba values, p0 is the start point in data and scanWidth the number + * of bytes in each row of data. + */ + void load(byte[] data, int p0, int scanWidth) { + Arrays.fill(min, 255); + Arrays.fill(max, 0); + Arrays.fill(bgColor, 0); + Arrays.fill(fgColor, 0); + + // Determine the minimum and maximum value for each color channel + int pos = p0; + for (int y = 0; y < 8; y++) { + for (int x = 0; x < 4; x++) { + for (int i = 0; i < 3; i++) { + int d = data[pos++] & 255; + min[i] = Math.min(min[i], d); + max[i] = Math.max(max[i], d); + } + pos++; // Alpha + } + pos += scanWidth - 16; + } + + // Determine the color channel with the greatest range. + int splitIndex = 0; + int bestSplit = 0; + for (int i = 0; i < 3; i++) { + if (max[i] - min[i] > bestSplit) { + bestSplit = max[i] - min[i]; + splitIndex = i; + } + } + // We just split at the middle of the interval instead of computing the median. + int splitValue = min[splitIndex] + bestSplit / 2; + + // Compute a bitmap using the given split and sum the color values for both buckets. + int bits = 0; + int fgCount = 0; + int bgCount = 0; + + pos = p0; + for (int y = 0; y < 8; y++) { + for (int x = 0; x < 4; x++) { + bits = bits << 1; + int[] avg; + if ((data[pos + splitIndex] & 255) > splitValue) { + avg = fgColor; + bits |= 1; + fgCount++; + } else { + avg = bgColor; + bgCount++; + } + for (int i = 0; i < 3; i++) { + avg[i] += data[pos++] & 255; + } + pos++; // Alpha + } + pos += scanWidth - 16; + } + + // Calculate the average color value for each bucket + for (int i = 0; i < 3; i++) { + if (bgCount != 0) { + bgColor[i] /= bgCount; + } + if (fgCount != 0) { + fgColor[i] /= fgCount; + } + } + + // Find the best bitmap match by counting the bits that don't match, including + // the inverted bitmaps. + int bestDiff = Integer.MAX_VALUE; + boolean invert = false; + for (int i = 0; i < BITMAPS.length; i += 2) { + int diff = Integer.bitCount(BITMAPS[i] ^ bits); + if (diff < bestDiff) { + character = (char) BITMAPS[i + 1]; + bestDiff = diff; + invert = false; + } + diff = Integer.bitCount((~BITMAPS[i]) ^ bits); + if (diff < bestDiff) { + character = (char) BITMAPS[i + 1]; + bestDiff = diff; + invert = true; + } + } + + // If the match is quite bad, use a shade image instead. + if (bestDiff > 12) { + invert = false; + character = " \u2591\u2592\u2593\u2588".charAt(Math.min(4, fgCount * 5 / 32)); + } + + // If we use an inverted character, we need to swap the colors. + if (invert) { + int[] tmp = bgColor; + bgColor = fgColor; + fgColor = tmp; + } + } + } + + /** + * Roughly modeled after the corresponding HTML 5 class. + */ + static class ImageData { + public final int width; + public final int height; + public final byte[] data; + + public ImageData(int width, int height) { + this.width = width; + this.height = height; + this.data = new byte[width * height * 4]; + } + + /** + * Convert the image to an Ansi control character string setting the colors + */ + public String dump() { + StringBuilder sb = new StringBuilder(); + BlockChar blockChar = new BlockChar(); + + for (int y = 0; y < height - 7; y += 8) { + int pos = y * width * 4; + String lastFg = ""; + String lastBg = ""; + for (int x = 0; x < width - 3; x += 4) { + blockChar.load(data, pos, width * 4); + String fg = Ansi.fgColor(blockChar.fgColor[0], blockChar.fgColor[1], blockChar.fgColor[2]); + String bg = Ansi.bgColor(blockChar.bgColor[0], blockChar.bgColor[1], blockChar.bgColor[2]); + if (!fg.equals(lastFg)) { + sb.append(fg); + lastFg = fg; + } + if (!bg.equals(lastBg)) { + sb.append(bg); + lastBg = bg; + } + sb.append(blockChar.character); + pos += 16; + } + sb.append(Ansi.RESET).append("\n"); + } + return sb.toString(); + } + } +}