557 lines
16 KiB
C++
557 lines
16 KiB
C++
#include <iostream>
|
|
#include <bitset>
|
|
#include <cmath>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <sys/ioctl.h>
|
|
#include <experimental/filesystem>
|
|
|
|
#define cimg_display 0
|
|
#include "CImg.h"
|
|
|
|
//using namespace std;
|
|
|
|
const int FLAG_FG = 1;
|
|
const int FLAG_BG = 2;
|
|
const int FLAG_MODE_256 = 4;
|
|
const int FLAG_24BIT = 8;
|
|
const int FLAG_NOOPT = 16;
|
|
|
|
const int COLOR_STEP_COUNT = 6;
|
|
const int COLOR_STEPS[COLOR_STEP_COUNT] = {0, 0x5f, 0x87, 0xaf, 0xd7, 0xff};
|
|
|
|
const int GRAYSCALE_STEP_COUNT = 24;
|
|
const int GRAYSCALE_STEPS[GRAYSCALE_STEP_COUNT] = {
|
|
0x08, 0x12, 0x1c, 0x26, 0x30, 0x3a, 0x44, 0x4e, 0x58, 0x62, 0x6c, 0x76,
|
|
0x80, 0x8a, 0x94, 0x9e, 0xa8, 0xb2, 0xbc, 0xc6, 0xd0, 0xda, 0xe4, 0xee};
|
|
|
|
const unsigned int BITMAPS[] = {
|
|
0x00000000, 0x00a0,
|
|
|
|
// Block graphics
|
|
// 0xffff0000, 0x2580, // upper 1/2; redundant with inverse lower 1/2
|
|
|
|
0x0000000f, 0x2581, // lower 1/8
|
|
0x000000ff, 0x2582, // lower 1/4
|
|
0x00000fff, 0x2583,
|
|
0x0000ffff, 0x2584, // lower 1/2
|
|
0x000fffff, 0x2585,
|
|
0x00ffffff, 0x2586, // lower 3/4
|
|
0x0fffffff, 0x2587,
|
|
//0xffffffff, 0x2588, // full; redundant with inverse space
|
|
|
|
0xeeeeeeee, 0x258a, // left 3/4
|
|
0xcccccccc, 0x258c, // left 1/2
|
|
0x88888888, 0x258e, // left 1/4
|
|
|
|
0x0000cccc, 0x2596, // quadrant lower left
|
|
0x00003333, 0x2597, // quadrant lower right
|
|
0xcccc0000, 0x2598, // quadrant upper left
|
|
//0xccccffff, 0x2599, // 3/4 redundant with inverse 1/4
|
|
0xcccc3333, 0x259a, // diagonal 1/2
|
|
//0xffffcccc, 0x259b, // 3/4 redundant
|
|
//0xffff3333, 0x259c, // 3/4 redundant
|
|
0x33330000, 0x259d, // quadrant upper right
|
|
//0x3333cccc, 0x259e, // 3/4 redundant
|
|
//0x3333ffff, 0x259f, // 3/4 redundant
|
|
|
|
// Line drawing subset: no double lines, no complex light lines
|
|
// Simple light lines duplicated because there is no center pixel int the 4x8 matrix
|
|
|
|
0x000ff000, 0x2501, // Heavy horizontal
|
|
0x66666666, 0x2503, // Heavy vertical
|
|
|
|
0x00077666, 0x250f, // Heavy down and right
|
|
0x000ee666, 0x2513, // Heavy down and left
|
|
0x66677000, 0x2517, // Heavy up and right
|
|
0x666ee000, 0x251b, // Heavy up and left
|
|
|
|
0x66677666, 0x2523, // Heavy vertical and right
|
|
0x666ee666, 0x252b, // Heavy vertical and left
|
|
0x000ff666, 0x2533, // Heavy down and horizontal
|
|
0x666ff000, 0x253b, // Heavy up and horizontal
|
|
0x666ff666, 0x254b, // Heavy cross
|
|
|
|
0x000cc000, 0x2578, // Bold horizontal left
|
|
0x00066000, 0x2579, // Bold horizontal up
|
|
0x00033000, 0x257a, // Bold horizontal right
|
|
0x00066000, 0x257b, // Bold horizontal down
|
|
|
|
0x06600660, 0x254f, // Heavy double dash vertical
|
|
|
|
0x000f0000, 0x2500, // Light horizontal
|
|
0x0000f000, 0x2500, //
|
|
0x44444444, 0x2502, // Light vertical
|
|
0x22222222, 0x2502,
|
|
|
|
0x000e0000, 0x2574, // light left
|
|
0x0000e000, 0x2574, // light left
|
|
0x44440000, 0x2575, // light up
|
|
0x22220000, 0x2575, // light up
|
|
0x00030000, 0x2576, // light right
|
|
0x00003000, 0x2576, // light right
|
|
0x00004444, 0x2575, // light down
|
|
0x00002222, 0x2575, // light down
|
|
|
|
// Misc technical
|
|
|
|
0x44444444, 0x23a2, // [ extension
|
|
0x22222222, 0x23a5, // ] extension
|
|
|
|
0x0f000000, 0x23ba, // Horizontal scanline 1
|
|
0x00f00000, 0x23bb, // Horizontal scanline 3
|
|
0x00000f00, 0x23bc, // Horizontal scanline 7
|
|
0x000000f0, 0x23bd, // Horizontal scanline 9
|
|
|
|
// Geometrical shapes. Tricky because some of them are too wide.
|
|
|
|
//0x00ffff00, 0x25fe, // Black medium small square
|
|
0x00066000, 0x25aa, // Black small square
|
|
|
|
//0x11224488, 0x2571, // diagonals
|
|
//0x88442211, 0x2572,
|
|
//0x99666699, 0x2573,
|
|
//0x000137f0, 0x25e2, // Triangles
|
|
//0x0008cef0, 0x25e3,
|
|
//0x000fec80, 0x25e4,
|
|
//0x000f7310, 0x25e5,
|
|
|
|
0, 0 // End marker
|
|
};
|
|
|
|
|
|
struct CharData {
|
|
int fgColor[3] = {0};
|
|
int bgColor[3] = {0};
|
|
int codePoint;
|
|
};
|
|
|
|
|
|
// Return a CharData struct with the given code point and corresponding averag fg and bg colors.
|
|
CharData getCharData(const cimg_library::CImg<unsigned char> & image, int x0, int y0, int codepoint, int pattern) {
|
|
CharData result;
|
|
result.codePoint = codepoint;
|
|
int fg_count = 0;
|
|
int bg_count = 0;
|
|
unsigned int mask = 0x80000000;
|
|
|
|
for (int y = 0; y < 8; y++) {
|
|
for (int x = 0; x < 4; x++) {
|
|
int* avg;
|
|
if (pattern & mask) {
|
|
avg = result.fgColor;
|
|
fg_count++;
|
|
} else {
|
|
avg = result.bgColor;
|
|
bg_count++;
|
|
}
|
|
for (int i = 0; i < 3; i++) {
|
|
avg[i] += image(x0 + x, y0 + y, 0, i);
|
|
}
|
|
mask = mask >> 1;
|
|
}
|
|
}
|
|
|
|
// Calculate the average color value for each bucket
|
|
for (int i = 0; i < 3; i++) {
|
|
if (bg_count != 0) {
|
|
result.bgColor[i] /= bg_count;
|
|
}
|
|
if (fg_count != 0) {
|
|
result.fgColor[i] /= fg_count;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Find the best character and colors for a 4x8 part of the image at the given position
|
|
CharData getCharData(const cimg_library::CImg<unsigned char> & image, int x0, int y0) {
|
|
int min[3] = {255, 255, 255};
|
|
int max[3] = {0};
|
|
std::map<long,int> count_per_color;
|
|
|
|
// Determine the minimum and maximum value for each color channel
|
|
for (int y = 0; y < 8; y++) {
|
|
for (int x = 0; x < 4; x++) {
|
|
long color = 0;
|
|
for (int i = 0; i < 3; i++) {
|
|
int d = image(x0 + x, y0 + y, 0, i);
|
|
min[i] = std::min(min[i], d);
|
|
max[i] = std::max(max[i], d);
|
|
color = (color << 8) | d;
|
|
}
|
|
count_per_color[color]++;
|
|
}
|
|
}
|
|
|
|
std::multimap<int,long> color_per_count;
|
|
for (auto i = count_per_color.begin(); i != count_per_color.end(); ++i) {
|
|
color_per_count.insert(std::pair<int,long>(i->second, i->first));
|
|
}
|
|
|
|
auto iter = color_per_count.rbegin();
|
|
int count2 = iter->first;
|
|
long max_count_color_1 = iter->second;
|
|
long max_count_color_2 = max_count_color_1;
|
|
if ((++iter) != color_per_count.rend()) {
|
|
count2 += iter->first;
|
|
max_count_color_2 = iter->second;
|
|
}
|
|
|
|
unsigned int bits = 0;
|
|
bool direct = count2 > (8*4) / 2;
|
|
|
|
if (direct) {
|
|
for (int y = 0; y < 8; y++) {
|
|
for (int x = 0; x < 4; x++) {
|
|
bits = bits << 1;
|
|
int d1 = 0;
|
|
int d2 = 0;
|
|
for (int i = 0; i < 3; i++) {
|
|
int shift = 16 - 8 * i;
|
|
int c1 = (max_count_color_1 >> shift) & 255;
|
|
int c2 = (max_count_color_2 >> shift) & 255;
|
|
int c = image(x0 + x, y0 + y, 0, i);
|
|
d1 += (c1-c) * (c1-c);
|
|
d2 += (c2-c) * (c2-c);
|
|
}
|
|
if (d1 > d2) {
|
|
bits |= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// 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.
|
|
for (int y = 0; y < 8; y++) {
|
|
for (int x = 0; x < 4; x++) {
|
|
bits = bits << 1;
|
|
if (image(x0 + x, y0 + y, 0, splitIndex) > splitValue) {
|
|
bits |= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find the best bitmap match by counting the bits that don't match,
|
|
// including the inverted bitmaps.
|
|
int best_diff = 8;
|
|
unsigned int best_pattern = 0x0000ffff;
|
|
int codepoint = 0x2584;
|
|
bool inverted = false;
|
|
for (int i = 0; BITMAPS[i + 1] != 0; i += 2) {
|
|
unsigned int pattern = BITMAPS[i];
|
|
for (int j = 0; j < 2; j++) {
|
|
int diff = (std::bitset<32>(pattern ^ bits)).count();
|
|
if (diff < best_diff) {
|
|
best_pattern = BITMAPS[i]; // pattern might be inverted.
|
|
codepoint = BITMAPS[i + 1];
|
|
best_diff = diff;
|
|
inverted = best_pattern != pattern;
|
|
}
|
|
pattern = ~pattern;
|
|
}
|
|
}
|
|
|
|
if (direct) {
|
|
CharData result;
|
|
if (inverted) {
|
|
long tmp = max_count_color_1;
|
|
max_count_color_1 = max_count_color_2;
|
|
max_count_color_2 = tmp;
|
|
}
|
|
for (int i = 0; i < 3; i++) {
|
|
int shift = 16 - 8 * i;
|
|
result.fgColor[i] = (max_count_color_2 >> shift) & 255;
|
|
result.bgColor[i] = (max_count_color_1 >> shift) & 255;
|
|
result.codePoint = codepoint;
|
|
}
|
|
return result;
|
|
}
|
|
return getCharData(image, x0, y0, codepoint, best_pattern);
|
|
}
|
|
|
|
|
|
int clamp_byte(int value) {
|
|
return value < 0 ? 0 : (value > 255 ? 255 : value);
|
|
}
|
|
|
|
|
|
double sqr(double n) {
|
|
return n*n;
|
|
}
|
|
|
|
|
|
int best_index(int value, const int data[], int count) {
|
|
int best_diff = std::abs(data[0] - value);
|
|
int result = 0;
|
|
for (int i = 1; i < count; i++) {
|
|
if (std::abs(data[i] - value) < best_diff) {
|
|
result = i;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
void emit_color(int flags, int r, int g, int b) {
|
|
r = clamp_byte(r);
|
|
g = clamp_byte(g);
|
|
b = clamp_byte(b);
|
|
|
|
bool bg = (flags & FLAG_BG) != 0;
|
|
|
|
if ((flags & FLAG_MODE_256) == 0) {
|
|
std::cout << (bg ? "\x1b[48;2;" : "\x1b[38;2;") << r << ';' << g << ';' << b << 'm';
|
|
return;
|
|
}
|
|
|
|
int ri = best_index(r, COLOR_STEPS, COLOR_STEP_COUNT);
|
|
int gi = best_index(g, COLOR_STEPS, COLOR_STEP_COUNT);
|
|
int bi = best_index(b, COLOR_STEPS, COLOR_STEP_COUNT);
|
|
|
|
int rq = COLOR_STEPS[ri];
|
|
int gq = COLOR_STEPS[gi];
|
|
int bq = COLOR_STEPS[bi];
|
|
|
|
int gray = static_cast<int>(std::round(r * 0.2989f + g * 0.5870f + b * 0.1140f));
|
|
|
|
int gri = best_index(gray, GRAYSCALE_STEPS, GRAYSCALE_STEP_COUNT);
|
|
int grq = GRAYSCALE_STEPS[gri];
|
|
|
|
int color_index;
|
|
if (0.3 * sqr(rq-r) + 0.59 * sqr(gq-g) + 0.11 * sqr(bq-b) <
|
|
0.3 * sqr(grq-r) + 0.59 * sqr(grq-g) + 0.11 * sqr(grq-b)) {
|
|
color_index = 16 + 36 * ri + 6 * gi + bi;
|
|
} else {
|
|
color_index = 232 + gri; // 1..24 -> 232..255
|
|
}
|
|
std::cout << (bg ? "\x1B[48;5;" : "\u001B[38;5;") << color_index << "m";
|
|
}
|
|
|
|
|
|
void emitCodepoint(int codepoint) {
|
|
if (codepoint < 128) {
|
|
std::cout << (char) codepoint;
|
|
} else if (codepoint < 0x7ff) {
|
|
std::cout << (char) (0xc0 | (codepoint >> 6));
|
|
std::cout << (char) (0x80 | (codepoint & 0x3f));
|
|
} else if (codepoint < 0xffff) {
|
|
std::cout << (char) (0xe0 | (codepoint >> 12));
|
|
std::cout << (char) (0x80 | ((codepoint >> 6) & 0x3f));
|
|
std::cout << (char) (0x80 | (codepoint & 0x3f));
|
|
} else if (codepoint < 0x10ffff) {
|
|
std::cout << (char) (0xf0 | (codepoint >> 18));
|
|
std::cout << (char) (0x80 | ((codepoint >> 12) & 0x3f));
|
|
std::cout << (char) (0x80 | ((codepoint >> 6) & 0x3f));
|
|
std::cout << (char) (0x80 | (codepoint & 0x3f));
|
|
} else {
|
|
std::cerr << "ERROR";
|
|
}
|
|
}
|
|
|
|
|
|
void emit_image(const cimg_library::CImg<unsigned char> & image, int flags) {
|
|
for (int y = 0; y <= image.height() - 8; y += 8) {
|
|
for (int x = 0; x <= image.width() - 4; x += 4) {
|
|
CharData charData = flags & FLAG_NOOPT
|
|
? getCharData(image, x, y, 0x2584, 0x0000ffff)
|
|
: getCharData(image, x, y);
|
|
emit_color(flags | FLAG_BG, charData.bgColor[0], charData.bgColor[1], charData.bgColor[2]);
|
|
emit_color(flags | FLAG_FG, charData.fgColor[0], charData.fgColor[1], charData.fgColor[2]);
|
|
emitCodepoint(charData.codePoint);
|
|
}
|
|
std::cout << "\x1b[0m" << std::endl;
|
|
}
|
|
}
|
|
|
|
|
|
struct size {
|
|
size(unsigned int in_width, unsigned int in_height) :
|
|
width(in_width), height(in_height) {
|
|
}
|
|
size(cimg_library::CImg<unsigned int> img) :
|
|
width(img.width()), height(img.height()) {
|
|
}
|
|
unsigned int width;
|
|
unsigned int height;
|
|
size scaled(double scale) {
|
|
return size(width*scale, height*scale);
|
|
}
|
|
size fitted_within(size container) {
|
|
double scale = std::min(container.width / (double) width, container.height / (double) height);
|
|
return scaled(scale);
|
|
}
|
|
};
|
|
std::ostream& operator<<(std::ostream& stream, size sz) {
|
|
stream << sz.width << "x" << sz.height;
|
|
return stream;
|
|
}
|
|
|
|
|
|
|
|
|
|
void emit_usage() {
|
|
std::cerr << "Terminal Image Viewer" << std::endl << std::endl;
|
|
std::cerr << "usage: tiv [options] <image> [<image>...]" << std::endl << std::endl;
|
|
std::cerr << " -0 : No block character adjustment, always use top half block char." << std::endl;
|
|
std::cerr << " -256 : Use 256 color mode." << std::endl;
|
|
std::cerr << " -c <num> : Number of thumbnail columns in 'dir' mode (3)." << std::endl;
|
|
std::cerr << " -d : Force 'dir' mode. Automatially selected for more than one input." << std::endl;
|
|
std::cerr << " -f : Force 'full' mode. Automatically selected for one input." << std::endl;
|
|
std::cerr << " -help : Display this help text." << std::endl;
|
|
std::cerr << " -h <num> : Set the maximum height to <num> lines." << std::endl;
|
|
std::cerr << " -w <num> : Set the maximum width to <num> characters." << std::endl << std::endl;
|
|
}
|
|
|
|
enum Mode {AUTO, THUMBNAILS, FULL_SIZE};
|
|
|
|
|
|
/* Wrapper around CImg<T>(const char*) to ensure the result has 3 channels as RGB
|
|
*/
|
|
cimg_library::CImg<unsigned char> load_rgb_CImg(const char * const filename) {
|
|
cimg_library::CImg<unsigned char> image(filename);
|
|
if(image.spectrum() == 1) {
|
|
// Greyscale. Just copy greyscale data to all channels
|
|
cimg_library::CImg<unsigned char> rgb_image(image.width(), image.height(), image.depth(), 3);
|
|
for(unsigned int chn = 0; chn < 3; chn++) {
|
|
rgb_image.draw_image(0, 0, 0,chn, image);
|
|
}
|
|
return rgb_image;
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
int maxWidth = 80;
|
|
int maxHeight = 24;
|
|
bool sizeDetectionSuccessful = true;
|
|
struct winsize w;
|
|
int ioStatus = ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
|
|
// If redirecting STDOUT to one file ( col or row == 0, or the previous ioctl call's failed )
|
|
if (ioStatus != 0 || (w.ws_col | w.ws_row) == 0) {
|
|
ioStatus = ioctl(STDIN_FILENO, TIOCGWINSZ, &w);
|
|
if (ioStatus != 0 || (w.ws_col | w.ws_row) == 0) {
|
|
std::cerr << "Warning: failed to determine most reasonable size, defaulting to 80x24" << std::endl;
|
|
sizeDetectionSuccessful = false;
|
|
}
|
|
}
|
|
if (sizeDetectionSuccessful)
|
|
{
|
|
maxWidth = w.ws_col * 4;
|
|
maxHeight = w.ws_row * 8;
|
|
}
|
|
int flags = 0;
|
|
Mode mode = AUTO;
|
|
int columns = 3;
|
|
|
|
std::vector<std::string> file_names;
|
|
int error = 0;
|
|
|
|
if (argc <= 1) {
|
|
emit_usage();
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
std::string arg(argv[i]);
|
|
if (arg == "-0") {
|
|
flags |= FLAG_NOOPT;
|
|
} else if (arg == "-c") {
|
|
columns = std::stoi(argv[++i]);
|
|
} else if (arg == "-d") {
|
|
mode = THUMBNAILS;
|
|
} else if (arg == "-f") {
|
|
mode = FULL_SIZE;
|
|
} else if (arg == "-w") {
|
|
maxWidth = 4 * std::stoi(argv[++i]);
|
|
} else if (arg == "-h") {
|
|
maxHeight = 8 * std::stoi(argv[++i]);
|
|
} else if (arg == "-256") {
|
|
flags |= FLAG_MODE_256;
|
|
} else if (arg == "--help" || arg == "-help") {
|
|
emit_usage();
|
|
} else if (arg[0] == '-') {
|
|
std::cerr << "Unrecognized argument: " << arg << std::endl;
|
|
} else {
|
|
if (std::experimental::filesystem::is_directory(arg)) {
|
|
for (auto & p : std::experimental::filesystem::directory_iterator(arg)) {
|
|
if (std::experimental::filesystem::is_regular_file(p.path())) {
|
|
file_names.push_back(p.path().string());
|
|
}
|
|
}
|
|
} else {
|
|
file_names.push_back(arg);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (mode == FULL_SIZE || (mode == AUTO && file_names.size() == 1)) {
|
|
for (unsigned int i = 0; i < file_names.size(); i++) {
|
|
try {
|
|
cimg_library::CImg<unsigned char> image = load_rgb_CImg(file_names[i].c_str());
|
|
|
|
if (image.width() > maxWidth || image.height() > maxHeight) {
|
|
size new_size = size(image).fitted_within(size(maxWidth,maxHeight));
|
|
image.resize(new_size.width, new_size.height, -100, -100, 5);
|
|
}
|
|
emit_image(image, flags);
|
|
} catch(cimg_library::CImgIOException & e) {
|
|
error = 1;
|
|
std::cerr << "File format is not recognized for '" << file_names[i] << "'" << std::endl;
|
|
}
|
|
}
|
|
} else {
|
|
// Thumbnail mode
|
|
|
|
unsigned int index = 0;
|
|
int cw = (((maxWidth / 4) - 2 * (columns - 1)) / columns);
|
|
int tw = cw * 4;
|
|
cimg_library::CImg<unsigned char> image(tw * columns + 2 * 4 * (columns - 1), tw, 1, 3);
|
|
size maxThumbSize(tw, tw);
|
|
|
|
while (index < file_names.size()) {
|
|
image.fill(0);
|
|
int count = 0;
|
|
std::string sb;
|
|
while (index < file_names.size() && count < columns) {
|
|
std::string name = file_names[index++];
|
|
try {
|
|
cimg_library::CImg<unsigned char> original = load_rgb_CImg(name.c_str());
|
|
auto cut = name.find_last_of("/");
|
|
sb += cut == std::string::npos ? name : name.substr(cut + 1);
|
|
size newSize = size(original).fitted_within(maxThumbSize);
|
|
original.resize(newSize.width, newSize.height, 1, -100, 5);
|
|
image.draw_image(count * (tw + 8) + (tw - newSize.width) / 2, (tw - newSize.height) / 2, 0, 0, original);
|
|
count++;
|
|
unsigned int sl = count * (cw + 2);
|
|
sb.resize(sl - 2, ' ');
|
|
sb += " ";
|
|
} catch (std::exception & e) {
|
|
// Probably no image; ignore.
|
|
}
|
|
}
|
|
if (count) emit_image(image, flags);
|
|
std::cout << sb << std::endl << std::endl;
|
|
}
|
|
}
|
|
return error;
|
|
}
|