Отображение изображения в консольном приложении

У меня есть консольное приложение, которое управляет изображениями. Теперь мне нужно что-то вроде предварительного просмотра изображений в консольном приложении. Есть ли способ отобразить их в консоли?

Вот сравнение текущих ответов на основе персонажей:

Вход:

Выход:

Далее я поигрался с кодом от @DieterMeemken. Я уменьшил вдвое вертикальное разрешение и добавил дизеринг с помощью ░▒▓. Слева результат Дитера Мемкена, справа мой. Внизу оригинальное изображение, размер которого примерно соответствует выходному. Хотя функция конвертации Malwyns впечатляет, она не использует все серые цвета, к сожалению.

static int[] cColors = { 0x000000, 0x000080, 0x008000, 0x008080, 0x800000, 0x800080, 0x808000, 0xC0C0C0, 0x808080, 0x0000FF, 0x00FF00, 0x00FFFF, 0xFF0000, 0xFF00FF, 0xFFFF00, 0xFFFFFF };

public static void ConsoleWritePixel(Color cValue)
{
    Color[] cTable = cColors.Select(x => Color.FromArgb(x)).ToArray();
    char[] rList = new char[] { (char)9617, (char)9618, (char)9619, (char)9608 }; // 1/4, 2/4, 3/4, 4/4
    int[] bestHit = new int[] { 0, 0, 4, int.MaxValue }; //ForeColor, BackColor, Symbol, Score

    for (int rChar = rList.Length; rChar > 0; rChar--)
    {
        for (int cFore = 0; cFore < cTable.Length; cFore++)
        {
            for (int cBack = 0; cBack < cTable.Length; cBack++)
            {
                int R = (cTable[cFore].R * rChar + cTable[cBack].R * (rList.Length - rChar)) / rList.Length;
                int G = (cTable[cFore].G * rChar + cTable[cBack].G * (rList.Length - rChar)) / rList.Length;
                int B = (cTable[cFore].B * rChar + cTable[cBack].B * (rList.Length - rChar)) / rList.Length;
                int iScore = (cValue.R - R) * (cValue.R - R) + (cValue.G - G) * (cValue.G - G) + (cValue.B - B) * (cValue.B - B);
                if (!(rChar > 1 && rChar < 4 && iScore > 50000)) // rule out too weird combinations
                {
                    if (iScore < bestHit[3])
                    {
                        bestHit[3] = iScore; //Score
                        bestHit[0] = cFore;  //ForeColor
                        bestHit[1] = cBack;  //BackColor
                        bestHit[2] = rChar;  //Symbol
                    }
                }
            }
        }
    }
    Console.ForegroundColor = (ConsoleColor)bestHit[0];
    Console.BackgroundColor = (ConsoleColor)bestHit[1];
    Console.Write(rList[bestHit[2] - 1]);
}


public static void ConsoleWriteImage(Bitmap source)
{
    int sMax = 39;
    decimal percent = Math.Min(decimal.Divide(sMax, source.Width), decimal.Divide(sMax, source.Height));
    Size dSize = new Size((int)(source.Width * percent), (int)(source.Height * percent));   
    Bitmap bmpMax = new Bitmap(source, dSize.Width * 2, dSize.Height);
    for (int i = 0; i < dSize.Height; i++)
    {
        for (int j = 0; j < dSize.Width; j++)
        {
            ConsoleWritePixel(bmpMax.GetPixel(j * 2, i));
            ConsoleWritePixel(bmpMax.GetPixel(j * 2 + 1, i));
        }
        System.Console.WriteLine();
    }
    Console.ResetColor();
}

Применение:

Bitmap bmpSrc = new Bitmap(@"HuwnC.gif", true);    
ConsoleWriteImage(bmpSrc);

РЕДАКТИРОВАТЬ

Цветовое расстояние - сложная тема ( здесь , здесь и ссылки на этих страницах ...). Я попытался рассчитать расстояние в YUV, и результаты оказались хуже, чем в RGB. Они могли бы быть лучше с Lab и DeltaE, но я этого не пробовал. Расстояние в RGB кажется достаточно хорошим. На самом деле результаты очень похожи как для евклидова, так и для манхэттенского расстояния в цветовом пространстве RGB, поэтому я подозреваю, что на выбор слишком мало цветов.

Остальное - просто сравнение цвета методом грубой силы со всеми комбинациями цветов и узоров (= символов). Я заявил, что коэффициент заполнения для ░▒▓█ составляет 1/4, 2/4, 3/4 и 4/4. В этом случае третий символ фактически дублирует первый. Но если бы пропорции не были такими равномерными (зависит от шрифта), результаты могли бы измениться, поэтому я оставил это для будущих улучшений. Средний цвет символа рассчитывается как средневзвешенное значение foregroudColor и backgroundColor в соответствии с коэффициентом заполнения. Он предполагает линейные цвета, что также является большим упрощением. Так что есть возможности для улучшения.

Хотя отображение изображения в консоли не является предполагаемым использованием консоли, вы, безусловно, можете взломать вещи, поскольку окно консоли - это просто окно, как и любые другие окна.

Собственно, однажды я начал разрабатывать библиотеку текстовых элементов управления для консольных приложений с поддержкой графики. Я так и не закончил, хотя у меня есть работающая демонстрация концепции:

А если вы получите размер шрифта консоли, вы сможете очень точно разместить изображение.

Вот как это можно сделать:

static void Main(string[] args)
{
    Console.WriteLine("Graphics in console window!");

    Point location = new Point(10, 10);
    Size imageSize = new Size(20, 10); // desired image size in characters

    // draw some placeholders
    Console.SetCursorPosition(location.X - 1, location.Y);
    Console.Write(">");
    Console.SetCursorPosition(location.X + imageSize.Width, location.Y);
    Console.Write("<");
    Console.SetCursorPosition(location.X - 1, location.Y + imageSize.Height - 1);
    Console.Write(">");
    Console.SetCursorPosition(location.X + imageSize.Width, location.Y + imageSize.Height - 1);
    Console.WriteLine("<");

    string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonPictures), @"Sample Pictures\tulips.jpg");
    using (Graphics g = Graphics.FromHwnd(GetConsoleWindow()))
    {
        using (Image image = Image.FromFile(path))
        {
            Size fontSize = GetConsoleFontSize();

            // translating the character positions to pixels
            Rectangle imageRect = new Rectangle(
                location.X * fontSize.Width,
                location.Y * fontSize.Height,
                imageSize.Width * fontSize.Width,
                imageSize.Height * fontSize.Height);
            g.DrawImage(image, imageRect);
        }
    }
}

Вот как вы можете получить текущий размер шрифта консоли:

private static Size GetConsoleFontSize()
{
    // getting the console out buffer handle
    IntPtr outHandle = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE, 
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        IntPtr.Zero,
        OPEN_EXISTING,
        0,
        IntPtr.Zero);
    int errorCode = Marshal.GetLastWin32Error();
    if (outHandle.ToInt32() == INVALID_HANDLE_VALUE)
    {
        throw new IOException("Unable to open CONOUT$", errorCode);
    }

    ConsoleFontInfo cfi = new ConsoleFontInfo();
    if (!GetCurrentConsoleFont(outHandle, false, cfi))
    {
        throw new InvalidOperationException("Unable to get font information.");
    }

    return new Size(cfi.dwFontSize.X, cfi.dwFontSize.Y);            
}

И необходимые дополнительные вызовы, константы и типы WinApi:

[DllImport("kernel32.dll", SetLastError = true)]
private static extern IntPtr GetConsoleWindow();

[DllImport("kernel32.dll", SetLastError = true)]
private static extern IntPtr CreateFile(
    string lpFileName,
    int dwDesiredAccess,
    int dwShareMode,
    IntPtr lpSecurityAttributes,
    int dwCreationDisposition,
    int dwFlagsAndAttributes,
    IntPtr hTemplateFile);

[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool GetCurrentConsoleFont(
    IntPtr hConsoleOutput,
    bool bMaximumWindow,
    [Out][MarshalAs(UnmanagedType.LPStruct)]ConsoleFontInfo lpConsoleCurrentFont);

[StructLayout(LayoutKind.Sequential)]
internal class ConsoleFontInfo
{
    internal int nFont;
    internal Coord dwFontSize;
}

[StructLayout(LayoutKind.Explicit)]
internal struct Coord
{
    [FieldOffset(0)]
    internal short X;
    [FieldOffset(2)]
    internal short Y;
}

private const int GENERIC_READ = unchecked((int)0x80000000);
private const int GENERIC_WRITE = 0x40000000;
private const int FILE_SHARE_READ = 1;
private const int FILE_SHARE_WRITE = 2;
private const int INVALID_HANDLE_VALUE = -1;
private const int OPEN_EXISTING = 3;

И результат:

[

Если вы дважды используете ASCII 219 (█), у вас будет что-то вроде пикселя (██). Теперь вы ограничены количеством пикселей и количеством цветов в консольном приложении.

• если вы сохраните настройки по умолчанию, у вас будет около 39x39 пикселей, если вы хотите больше, вы можете изменить размер консоли с помощью Console.WindowHeight = resSize.Height + 1;иConsole.WindowWidth = resultSize.Width * 2;

• вы должны сохранить соотношение сторон изображения, насколько это возможно, поэтому в большинстве случаев у вас не будет 39x39

• Малвин опубликовал совершенно недооцененный метод преобразования System.Drawing.ColorвSystem.ConsoleColor

так что мой подход был бы

using System.Drawing;

public static int ToConsoleColor(System.Drawing.Color c)
{
    int index = (c.R > 128 | c.G > 128 | c.B > 128) ? 8 : 0;
    index |= (c.R > 64) ? 4 : 0;
    index |= (c.G > 64) ? 2 : 0;
    index |= (c.B > 64) ? 1 : 0;
    return index;
}

public static void ConsoleWriteImage(Bitmap src)
{
    int min = 39;
    decimal pct = Math.Min(decimal.Divide(min, src.Width), decimal.Divide(min, src.Height));
    Size res = new Size((int)(src.Width * pct), (int)(src.Height * pct));
    Bitmap bmpMin = new Bitmap(src, res);
    for (int i = 0; i < res.Height; i++)
    {
        for (int j = 0; j < res.Width; j++)
        {
            Console.ForegroundColor = (ConsoleColor)ToConsoleColor(bmpMin.GetPixel(j, i));
            Console.Write("██");
        }
        System.Console.WriteLine();
    }
}

так что вы можете

ConsoleWriteImage(new Bitmap(@"C:\image.gif"));

образец ввода:

образец вывода:

это было весело. Спасибо fubo , я попробовал ваше решение и смог увеличить разрешение превью на 4 (2x2).

Я обнаружил, что вы можете установить цвет фона для каждого отдельного символа. Итак, вместо использования двух символов ASCII 219 (█) я использовал ASCII 223 (▀) два раза с разными цветами переднего плана и фона. Это делит большой пиксель (██) на 4 субпикселя, как это (▀▄).

В этом примере я помещаю оба изображения рядом друг с другом, чтобы вы легко могли увидеть разницу:

Вот код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace ConsoleWithImage
{
  class Program
  {

    public static void ConsoleWriteImage(Bitmap bmpSrc)
    {
        int sMax = 39;
        decimal percent = Math.Min(decimal.Divide(sMax, bmpSrc.Width), decimal.Divide(sMax, bmpSrc.Height));
        Size resSize = new Size((int)(bmpSrc.Width * percent), (int)(bmpSrc.Height * percent));
        Func<System.Drawing.Color, int> ToConsoleColor = c =>
        {
            int index = (c.R > 128 | c.G > 128 | c.B > 128) ? 8 : 0;
            index |= (c.R > 64) ? 4 : 0;
            index |= (c.G > 64) ? 2 : 0;
            index |= (c.B > 64) ? 1 : 0;
            return index;
        };
        Bitmap bmpMin = new Bitmap(bmpSrc, resSize.Width, resSize.Height);
        Bitmap bmpMax = new Bitmap(bmpSrc, resSize.Width * 2, resSize.Height * 2);
        for (int i = 0; i < resSize.Height; i++)
        {
            for (int j = 0; j < resSize.Width; j++)
            {
                Console.ForegroundColor = (ConsoleColor)ToConsoleColor(bmpMin.GetPixel(j, i));
                Console.Write("██");
            }

            Console.BackgroundColor = ConsoleColor.Black;
            Console.Write("    ");

            for (int j = 0; j < resSize.Width; j++)
            {
                Console.ForegroundColor = (ConsoleColor)ToConsoleColor(bmpMax.GetPixel(j * 2, i * 2));
                Console.BackgroundColor = (ConsoleColor)ToConsoleColor(bmpMax.GetPixel(j * 2, i * 2 + 1));
                Console.Write("▀");

                Console.ForegroundColor = (ConsoleColor)ToConsoleColor(bmpMax.GetPixel(j * 2 + 1, i * 2));
                Console.BackgroundColor = (ConsoleColor)ToConsoleColor(bmpMax.GetPixel(j * 2 + 1, i * 2 + 1));
                Console.Write("▀");
            }
            System.Console.WriteLine();
        }
    }

    static void Main(string[] args)
    {
        System.Console.WindowWidth = 170;
        System.Console.WindowHeight = 40;

        Bitmap bmpSrc = new Bitmap(@"image.bmp", true);

        ConsoleWriteImage(bmpSrc);

        System.Console.ReadLine();
    }
  }
}

Для запуска примера растровое изображение «image.bmp» должно находиться в том же каталоге, что и исполняемый файл. Я увеличил размер консоли, размер превью по-прежнему 39 и его можно изменить на int sMax = 39;.

Раствор от taffer тоже очень крутой. Мой голос за вас двоих ...

Я читал о цветовых пространствах, и пространство LAB кажется вам хорошим вариантом (см. Следующие вопросы: Определение точного «расстояния» между цветами и алгоритм проверки схожести цветов )

Цитируя страницу Wikipedia CIELAB , преимущества этого цветового пространства:

В отличие от цветовых моделей RGB и CMYK, цвет Lab приближен к человеческому зрению. Он стремится к единообразию восприятия, и его L-компонент полностью соответствует человеческому восприятию легкости. Таким образом, его можно использовать для точной корректировки цветового баланса путем изменения выходных кривых в компонентах a и b.

Чтобы измерить расстояние между цветами, вы можете использовать расстояние Delta E.

С этим вы можете лучше приблизиться от Colorдо ConsoleColor:

Во-первых, вы можете определить CieLabкласс для представления цветов в этом пространстве:

public class CieLab
{
    public double L { get; set; }
    public double A { get; set; }
    public double B { get; set; }

    public static double DeltaE(CieLab l1, CieLab l2)
    {
        return Math.Pow(l1.L - l2.L, 2) + Math.Pow(l1.A - l2.A, 2) + Math.Pow(l1.B - l2.B, 2);
    }

    public static CieLab Combine(CieLab l1, CieLab l2, double amount)
    {
        var l = l1.L * amount + l2.L * (1 - amount);
        var a = l1.A * amount + l2.A * (1 - amount);
        var b = l1.B * amount + l2.B * (1 - amount);

        return new CieLab { L = l, A = a, B = b };
    }
}

Существует два статических метода: один для измерения расстояния с помощью Delta E ( DeltaE), а другой - для объединения двух цветов с указанием количества каждого цвета ( Combine).

А для преобразования из RGBв LABвы можете использовать следующий метод ( отсюда ):

public static CieLab RGBtoLab(int red, int green, int blue)
{
    var rLinear = red / 255.0;
    var gLinear = green / 255.0;
    var bLinear = blue / 255.0;

    double r = rLinear > 0.04045 ? Math.Pow((rLinear + 0.055) / (1 + 0.055), 2.2) : (rLinear / 12.92);
    double g = gLinear > 0.04045 ? Math.Pow((gLinear + 0.055) / (1 + 0.055), 2.2) : (gLinear / 12.92);
    double b = bLinear > 0.04045 ? Math.Pow((bLinear + 0.055) / (1 + 0.055), 2.2) : (bLinear / 12.92);

    var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
    var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
    var z = r * 0.0193 + g * 0.1192 + b * 0.9505;

    Func<double, double> Fxyz = t => ((t > 0.008856) ? Math.Pow(t, (1.0 / 3.0)) : (7.787 * t + 16.0 / 116.0));

    return new CieLab
    {
        L = 116.0 * Fxyz(y / 1.0) - 16,
        A = 500.0 * (Fxyz(x / 0.9505) - Fxyz(y / 1.0)),
        B = 200.0 * (Fxyz(y / 1.0) - Fxyz(z / 1.0890))
    };
}

Идея состоит в том, чтобы использовать символы оттенка, такие как @AntoninLejsek do ('█', '▓', '▒', '░'), это позволяет получить более 16 цветов, комбинируя цвета консоли (используя Combineметод).

Здесь мы можем сделать некоторые улучшения, предварительно вычислив используемые цвета:

class ConsolePixel
{
    public char Char { get; set; }

    public ConsoleColor Forecolor { get; set; }
    public ConsoleColor Backcolor { get; set; }
    public CieLab Lab { get; set; }
}

static List<ConsolePixel> pixels;
private static void ComputeColors()
{
    pixels = new List<ConsolePixel>();

    char[] chars = { '█', '▓', '▒', '░' };

    int[] rs = { 0, 0, 0, 0, 128, 128, 128, 192, 128, 0, 0, 0, 255, 255, 255, 255 };
    int[] gs = { 0, 0, 128, 128, 0, 0, 128, 192, 128, 0, 255, 255, 0, 0, 255, 255 };
    int[] bs = { 0, 128, 0, 128, 0, 128, 0, 192, 128, 255, 0, 255, 0, 255, 0, 255 };

    for (int i = 0; i < 16; i++)
        for (int j = i + 1; j < 16; j++)
        {
            var l1 = RGBtoLab(rs[i], gs[i], bs[i]);
            var l2 = RGBtoLab(rs[j], gs[j], bs[j]);

            for (int k = 0; k < 4; k++)
            {
                var l = CieLab.Combine(l1, l2, (4 - k) / 4.0);

                pixels.Add(new ConsolePixel
                {
                    Char = chars[k],
                    Forecolor = (ConsoleColor)i,
                    Backcolor = (ConsoleColor)j,
                    Lab = l
                });
            }
        }
}

Другим улучшением может быть прямой доступ к данным изображения с использованием LockBitsвместо использования GetPixel.

ОБНОВЛЕНИЕ : если в изображении есть части с одинаковым цветом, вы можете значительно ускорить процесс рисования фрагментов символов, имеющих одинаковые цвета, вместо отдельных символов:

public static void DrawImage(Bitmap source)
{
    int width = Console.WindowWidth - 1;
    int height = (int)(width * source.Height / 2.0 / source.Width);

    using (var bmp = new Bitmap(source, width, height))
    {
        var unit = GraphicsUnit.Pixel;
        using (var src = bmp.Clone(bmp.GetBounds(ref unit), PixelFormat.Format24bppRgb))
        {
            var bits = src.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, src.PixelFormat);
            byte[] data = new byte[bits.Stride * bits.Height];

            Marshal.Copy(bits.Scan0, data, 0, data.Length);

            for (int j = 0; j < height; j++)
            {
                StringBuilder builder = new StringBuilder();
                var fore = ConsoleColor.White;
                var back = ConsoleColor.Black;

                for (int i = 0; i < width; i++)
                {
                    int idx = j * bits.Stride + i * 3;
                    var pixel = DrawPixel(data[idx + 2], data[idx + 1], data[idx + 0]);


                    if (pixel.Forecolor != fore || pixel.Backcolor != back)
                    {
                        Console.ForegroundColor = fore;
                        Console.BackgroundColor = back;
                        Console.Write(builder);

                        builder.Clear();
                    }

                    fore = pixel.Forecolor;
                    back = pixel.Backcolor;
                    builder.Append(pixel.Char);
                }

                Console.ForegroundColor = fore;
                Console.BackgroundColor = back;
                Console.WriteLine(builder);
            }

            Console.ResetColor();
        }
    }
}

private static ConsolePixel DrawPixel(int r, int g, int b)
{
    var l = RGBtoLab(r, g, b);

    double diff = double.MaxValue;
    var pixel = pixels[0];

    foreach (var item in pixels)
    {
        var delta = CieLab.DeltaE(l, item.Lab);
        if (delta < diff)
        {
            diff = delta;
            pixel = item;
        }
    }

    return pixel;
}

Наконец, позвоните DrawImageтак:

static void Main(string[] args)
{
    ComputeColors();

    Bitmap image = new Bitmap("image.jpg", true);
    DrawImage(image);

}

Изображения результатов:

Следующие решения не основаны на символах, но предоставляют полные подробные изображения

Вы можете рисовать поверх любого окна, используя его обработчик для создания Graphicsобъекта. Чтобы получить обработчик консольного приложения, вы можете импортировать его GetConsoleWindow:

[DllImport("kernel32.dll", EntryPoint = "GetConsoleWindow", SetLastError = true)]
private static extern IntPtr GetConsoleHandle();

Затем создайте графику с помощью обработчика (using Graphics.FromHwnd) и нарисуйте изображение, используя методы в Graphicsобъекте, например:

static void Main(string[] args)
{            
    var handler = GetConsoleHandle();

    using (var graphics = Graphics.FromHwnd(handler))
    using (var image = Image.FromFile("img101.png"))
        graphics.DrawImage(image, 50, 50, 250, 200);
}

Это выглядит нормально, но если размер консоли изменяется или прокручивается, изображение исчезает, потому что окна обновляются (возможно, в вашем случае возможна реализация какого-то механизма для перерисовки изображения).

Другое решение - встроить window ( Form) в консольное приложение. Для этого вам нужно импортировать SetParent(и MoveWindowпереместить окно внутри консоли):

[DllImport("user32.dll")]
public static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

[DllImport("user32.dll", SetLastError = true)]
public static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);

Затем вам просто нужно создать Formи установить BackgroundImageсвойство для желаемого изображения (сделайте это на Threadили, Taskчтобы не блокировать консоль):

static void Main(string[] args)
{
    Task.Factory.StartNew(ShowImage);

    Console.ReadLine();
}

static void ShowImage()
{
    var form = new Form
    {                
        BackgroundImage = Image.FromFile("img101.png"),
        BackgroundImageLayout = ImageLayout.Stretch
    };

    var parent = GetConsoleHandle();
    var child = form.Handle;

    SetParent(child, parent);
    MoveWindow(child, 50, 50, 250, 200, true);

    Application.Run(form);
}

Конечно, вы можете настроить FormBorderStyle = FormBorderStyle.Noneскрытие границ окон (правое изображение)

В этом случае вы можете изменить размер консоли, и изображение / окно все еще будут там.

Одним из преимуществ этого подхода является то, что вы можете разместить окно там, где хотите, и изменить изображение в любое время, просто изменив BackgroundImageсвойство.

Прямого пути нет. Но вы можете попробовать использовать конвертер изображений в ascii-art, подобный этому

Да, вы можете это сделать, если немного растянете вопрос, открыв Formиз приложения Console.

Вот как вы можете заставить консольное приложение открывать форму и отображать изображение:

• включите эти две ссылки в свой проект: System.DrawingиSystem.Windows.Forms
• также включите два пространства имен:

using System.Windows.Forms;
using System.Drawing;

Посмотрите этот пост о том, как это сделать !

Теперь все, что вам нужно, это добавить что-то вроде этого:

Form form1 = new Form();
form1.BackgroundImage = bmp;
form1.ShowDialog();

Конечно, вы также можете использовать PictureBox..

И вы можете использовать, form1.Show();чтобы консоль оставалась активной, пока отображается предварительный просмотр.

Исходный пост: Конечно, вы не можете правильно отобразить изображение внутри окна 25x80; даже если вы используете большее окно и блокируете графику, это будет не предварительный просмотр, а беспорядок!

Обновление: похоже, вы все-таки можете нарисовать изображение в форме консоли с помощью GDI; см. ответ Таффера!