[c#] 콘솔 애플리케이션에 이미지 표시

내가 대해 읽고 있던 색 공간 및 실험실 공간은 당신을 위해 좋은 옵션이 될 것으로 보인다 (이 질문을 참조하십시오 색상 간의 정확한 “거리”찾기 및 색상의 유사성을 확인하는 알고리즘 )

Wikipedia CIELAB 페이지를 인용 하면이 색 공간의 장점은 다음과 같습니다.

RGB 및 CMYK 색상 모델과 달리 Lab 색상은 인간의 시각에 가깝게 설계되었습니다. 지각 적 균일 성을 열망하고 L 구성 요소는 인간의 가벼움 인식과 밀접하게 일치합니다. 따라서 a 및 b 구성 요소의 출력 곡선을 수정하여 정확한 색상 균형 보정을 수행하는 데 사용할 수 있습니다.

색상 사이의 거리를 측정하려면 Delta E distance를 사용할 수 있습니다 .

이를 통해에서 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 };
    }
}

두 가지 정적 방법이 있습니다. 하나는 델타 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();

그런 다음 핸들러 (사용 Graphics.FromHwnd) 로 그래픽을 만들고 Graphicsobject 의 메서드를 사용하여 이미지를 그립니다. 예 :

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

이것은 괜찮아 보이지만 콘솔의 크기가 조정되거나 스크롤되면 창이 새로 고쳐지기 때문에 이미지가 사라집니다 (당신의 경우 이미지를 다시 그리는 메커니즘을 구현할 수 있습니다).

---

또 다른 해결책은 창 ( 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속성 만 변경하여 언제든지 이미지를 변경할 수 있다는 것 입니다.