Pregunta Mostrar una imagen en una aplicación de consola


Tengo una aplicación de consola que administra imágenes. Ahora necesito algo así como una vista previa de las Imágenes dentro de la aplicación de la consola. ¿Hay alguna forma de mostrarlos en la consola?

Aquí hay una comparación de las respuestas basadas en caracteres actuales:

Entrada:

enter image description here

Salida:

enter image description here

enter image description here

enter image description here

enter image description here


75
2017-11-05 07:08


origen


Respuestas:


Además jugué con el código de @DieterMeemken. Reduje a la mitad la resolución vertical y añadí el difuminado a través de ░▒▓. A la izquierda está el resultado Dieter Meemken, a la derecha mi. En la parte inferior se cambia el tamaño de la imagen original para que coincida con la salida. Output result Si bien la función de conversión de Malwyns es impresionante, no utiliza todos los colores grises, lo que es lástima.

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();
}

uso:

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

EDITAR

La distancia de color es un tema complejo (aquí, aquí y enlaces en esas páginas ...). Traté de calcular la distancia en YUV y los resultados fueron bastante peores que en RGB. Podrían ser mejores con Lab y DeltaE, pero no lo intenté. La distancia en RGB parece ser lo suficientemente buena. De hecho, los resultados son muy similares para la distancia euclidiana y manhattan en el espacio de color RGB, así que sospecho que hay muy pocos colores para elegir.

El resto es solo la comparación de la fuerza bruta del color contra todas las combinaciones de colores y patrones (= símbolos). Declaré que la relación de llenado para ° ▒▓█ es 1/4, 2/4, 3/4 y 4/4. En ese caso, el tercer símbolo es de hecho redundante para el primero. Pero si las proporciones no fueran tan uniformes (depende de la fuente), los resultados podrían cambiar, así que lo dejé allí para futuras mejoras. El color promedio del símbolo se calcula como el promedio ponderado de foregroudColor y backgroundColor según la relación de relleno. Asume colores lineales, lo que también es una gran simplificación. Entonces todavía hay margen de mejora.


49
2017-11-15 00:44



Aunque mostrar una imagen en una consola no es el uso previsto de la consola, seguramente puede piratear las cosas, ya que la ventana de la consola es solo una ventana, como cualquier otra ventana.

En realidad, una vez que comencé a desarrollar una biblioteca de controles de texto para aplicaciones de consola con soporte de gráficos. Nunca he terminado eso, aunque tengo una demostración de prueba de concepto en funcionamiento:

Text controls with image

Y si obtiene el tamaño de fuente de la consola, puede colocar la imagen con mucha precisión.

Así es como puedes hacerlo:

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);
        }
    }
}

A continuación, le mostramos cómo puede obtener el tamaño de fuente de la consola actual:

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);            
}

Y las llamadas, constantes y tipos adicionales necesarios de 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;

Y el resultado:

[Graphics in Console


79
2017-11-11 14:22



Si usa ASCII 219 (█) dos veces, tiene algo así como un píxel (██). Ahora está restringido por la cantidad de píxeles y la cantidad de colores en su aplicación de consola.

  • si mantiene la configuración predeterminada, tiene aproximadamente 39x39 píxeles, si quiere más puede cambiar el tamaño de su consola con Console.WindowHeight = resSize.Height + 1;y Console.WindowWidth = resultSize.Width * 2;

  • debe mantener la relación de aspecto de la imagen lo más posible, de modo que no tendrá 39x39 en la mayoría de los casos

  • Malwyn publicado un método totalmente subestimado para convertir System.Drawing.Color a System.ConsoleColor

entonces mi enfoque sería

using System.Drawing;

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);
    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("██");
        }
        System.Console.WriteLine();
    }
}

así que puedes

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

muestra de entrada:

enter image description here

muestra de salida:

enter image description here


53
2017-11-09 07:46



eso fue divertido. Gracias fubo, probé su solución y pude aumentar la resolución de la vista previa en 4 (2x2).

Descubrí que puede establecer el color de fondo para cada char individual. Entonces, en lugar de usar dos caracteres ASCII 219 (█), utilicé ASCII 223 (▀) dos veces con diferentes colores de primer plano y fondo. Eso divide el gran Pixel (██) en 4 subpíxeles como este (▀▄).

En este ejemplo, puse ambas imágenes una al lado de la otra, para que pueda ver la diferencia fácilmente:

enter image description here

Aquí está el código:

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();
    }
  }
}

Para ejecutar el ejemplo, el mapa de bits "image.bmp" debe estar en el mismo directorio que el ejecutable. Aumenté el tamaño de la consola, el tamaño de la vista previa sigue siendo 39 y se puede cambiar a int sMax = 39;.

La solución de Taffer también es genial Ustedes dos tienen mi voto positivo ...


35
2017-11-13 09:06



Estuve leyendo sobre espacios de color y LABORATORIO el espacio parece ser una buena opción para ti (mira estas preguntas: Encontrar una "distancia" precisa entre los colores y Algoritmo para verificar la similitud de colores)

Citando Wikipedia CIELAB página, las ventajas de este espacio de color son:

A diferencia de los modelos de color RGB y CMYK, el color Lab está diseñado para aproximarse a la visión humana. Aspira a la uniformidad perceptiva, y su componente L se aproxima mucho a la percepción humana de la ligereza. Por lo tanto, se puede usar para realizar correcciones de balance de color precisas modificando las curvas de salida en los componentes a y b.

Para medir la distancia entre los colores puedes usar Delta E distancia.

Con esto puedes aproximarte mejor de Color a ConsoleColor:

En primer lugar, puedes definir un CieLab clase para representar colores en este espacio:

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 };
    }
}

Hay dos métodos estáticos, uno para medir la distancia usando Delta E (DeltaE) y otro para combinar dos colores que especifican cuánto de cada color (Combine)

Y para transformar de RGB a LAB puedes usar el siguiente método (desde aquí)

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))
    };
}

La idea es usar caracteres de sombreado como @AntoninLejsek do ('█', '▓', '▒', '░'), esto le permite obtener más de 16 colores combinando los colores de la consola (usando Combine método).

Aquí, podemos hacer algunas mejoras al calcular previamente los colores a usar:

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
                });
            }
        }
}

Otra mejora podría ser el acceso directo a los datos de imagen usando LockBits En lugar de usar GetPixel.

ACTUALIZAR: Si la imagen tiene partes con el mismo color, puede acelerar considerablemente el proceso de dibujo de fragmentos de caracteres con los mismos colores, en lugar de caracteres individuales:

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;
}

Finalmente, llame DrawImage al igual que:

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

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

}

Imágenes de resultados:

Console1

Console2



Las siguientes soluciones no se basan en caracteres pero proporciona imágenes detalladas completas


Puede dibujar sobre cualquier ventana usando su entrenador de animales para crear un Graphics objeto. Para obtener el controlador de una aplicación de consola, puede hacerlo importando GetConsoleWindow:

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

Luego, crea un gráfico con el controlador (usando Graphics.FromHwnd) y dibuja la imagen usando los métodos en Graphicsobjeto, por ejemplo:

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);
}

Version 1

Esto se ve bien, pero si la consola cambia de tamaño o se desplaza, la imagen desaparece porque las ventanas se actualizan (tal vez sea posible implementar algún tipo de mecanismo para redibujar la imagen en su caso).


Otra solución es incrustar una ventana (Form) en la aplicación de la consola. Para hacer esto, debes importar SetParent (y MoveWindow para reubicar la ventana dentro de la consola):

[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);

Entonces solo necesitas crear un Form y establecer BackgroundImage propiedad a la imagen deseada (hazlo en un Thread o Task para evitar bloquear la consola):

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);
}

Version2

Por supuesto, puedes establecer FormBorderStyle = FormBorderStyle.None para ocultar los bordes de las ventanas (imagen de la derecha)

En este caso, puede cambiar el tamaño de la consola y la imagen / ventana aún estará allí.

Un beneficio de este enfoque es que puede ubicar la ventana donde desea y cambiar la imagen en cualquier momento simplemente cambiando BackgroundImage propiedad.


19
2018-04-29 22:14



No hay forma directa. Pero puede intentar usar un convertidor de imagen a arte como éste


4
2017-11-05 07:10



Sí, puedes hacerlo, si amplías un poco la pregunta abriendo un Form desde dentro de la aplicación de la Consola.

Aquí se muestra cómo puede hacer que la aplicación de la consola abra un formulario y muestre una imagen:

  • incluya estas dos referencias en su proyecto: System.Drawing y System.Windows.Forms
  • incluir los dos espacios de nombres también:

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

Ver esta publicación sobre cómo hacer eso!

Ahora todo lo que necesita para agregar algo como esto:

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

Por supuesto, también puedes usar un PictureBox..

Y puedes usar form1.Show(); para mantener viva la consola mientras se muestra la vista previa ...

Publicación original: Por supuesto, no se puede mostrar correctamente una imagen dentro una ventana de 25x80; incluso si usa una ventana más grande y bloquea gráficos, ¡no sería una vista previa sino un desastre!

Actualizar: Parece que después de todo puedes dibujar una imagen en el Formulario de consola; ¡mira la respuesta de Taffer!


1
2017-11-05 10:35