c# - significa - Mostrar una imagen en una aplicación de consola

seo imagenes wordpress

Question

Tengo una aplicación de consola que gestiona imágenes. Ahora necesito algo como una vista previa de las imágenes dentro de la aplicación de consola. ¿Hay alguna manera de mostrarlos en la consola?

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

Entrada:

Salida:

Answer 1

Además jugué con el código de @DieterMeemken. Reduje a la mitad la resolución vertical y agregué tramado a través de ░▒▓. A la izquierda está el resultado de Dieter Meemken, a la derecha mi. En la parte inferior hay una imagen original redimensionada para que coincida con la salida. Si bien la función de conversión de Malwyns es impresionante, no utiliza todos los colores grises, lo que es una pena.

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 ( here , here 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, por lo que sospecho que hay muy pocos colores para elegir.

El resto es solo la comparación de la fuerza bruta del color con todas las combinaciones de colores y patrones (= símbolos). Indiqué 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 al primero. Pero si las proporciones no fueran tan uniformes (depende de la fuente), los resultados podrían cambiar, por lo 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. Por lo tanto, todavía hay margen de mejora.

Answer 2

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

En realidad, una vez que he comenzado 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 que funciona:

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

Así es como 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 de WinApi adicionales necesarios:

[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:

[

Answer 3

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

Citando la página de Wikipedia CIELAB , 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 coincide estrechamente con la percepción humana de la ligereza. Por lo tanto, se puede utilizar para hacer correcciones precisas del balance de color modificando las curvas de salida en los componentes ayb.

Para medir la distancia entre colores puede usar la distancia Delta E.

Con esto puede aproximarse mejor de Color a ConsoleColor :

En primer lugar, puede definir una clase CieLab 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 especificando la cantidad de cada color ( Combine ).

Y para transformar de RGB a LAB puede usar el siguiente método (desde here ):

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 sombra como @AntoninLejsek do (''█'', ''▓'', ''▒'', ''░''), esto le permite obtener más de 16 colores combinando los colores de la consola (usando el método Combine ).

Aquí, podemos hacer algunas mejoras calculando previamente los colores a utilizar:

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 la imagen usando LockBits lugar de usar GetPixel .

ACTUALIZACIÓN : Si la imagen tiene partes con el mismo color, puede acelerar considerablemente el proceso de dibujar trozos de caracteres que tienen 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 a DrawImage así:

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

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

}

Imágenes del resultado:

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

Puede dibujar sobre cualquier ventana utilizando su controlador para crear un objeto de Graphics . 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, cree gráficos con el controlador (usando Graphics.FromHwnd ) y dibuje la imagen usando los métodos en el objeto Graphics , 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);
}

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 volver a dibujar la imagen en su caso).

Otra solución es incrustar una ventana ( Form ) en la aplicación de consola. Para hacer esto, debe 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);

Luego solo necesita crear un Form y establecer la propiedad BackgroundImage en la imagen deseada (hágalo 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);
}

Por supuesto, puede configurar FormBorderStyle = FormBorderStyle.None para ocultar los bordes de las ventanas (imagen derecha)

En este caso, puede cambiar el tamaño de la consola y la imagen / ventana seguirá estando allí.

Una ventaja de este enfoque es que puede ubicar la ventana donde desee y cambiar la imagen en cualquier momento simplemente cambiando la propiedad BackgroundImage .

Answer 4

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

Answer 5

Sí, puede hacerlo si estira un poco la pregunta abriendo un Form desde la aplicación Consola.

Así es como puede hacer que su aplicación de consola abra un formulario y muestre una imagen:

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

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

¡Vea 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 puede usar form1.Show(); para mantener viva la consola mientras se muestra la vista previa ...

Publicación original: por supuesto, no puede mostrar correctamente una imagen dentro de 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!

Actualización: después de todo, parece que puede dibujar una imagen en el formulario de la consola; ¡Vea la respuesta del taffer!

Answer 6

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 desea más puede cambiar el tamaño de su consola con Console.WindowHeight = resSize.Height + 1; y Console.WindowWidth = resultSize.Width * 2;

• debes mantener la relación de aspecto de la imagen lo más lejos posible, para que no tengas 39x39 en la mayoría de los casos

• Malwyn publicó 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"));

entrada de muestra:

salida de muestra:

Answer 7

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

Descubrí que puedes establecer el color de fondo para cada carácter individual. Entonces, en lugar de usar dos caracteres ASCII 219 (█), usé 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, pongo ambas imágenes una al lado de la otra, para que pueda ver la diferencia fácilmente:

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. int sMax = 39; el tamaño de la consola, el tamaño de la vista previa sigue siendo 39 y se puede cambiar en int sMax = 39; .

La solución de taffer también es muy buena. Ustedes dos tienen mi voto ...