c# - কনসোল অ্যাপ্লিকেশনটিতে একটি চিত্র প্রদর্শন করুন




image console (5)

আমি রঙ স্পেসগুলি সম্পর্কে পড়ছিলাম এবং ল্যাব স্পেসটি আপনার জন্য একটি ভাল বিকল্প হিসাবে উপস্থিত বলে মনে হচ্ছে (এই প্রশ্নগুলি দেখুন: রঙের অ্যালগরিদমের মধ্যে একটি সঠিক "দূরত্ব" সন্ধানের জন্য রঙের মিল )

উইকিপিডিয়া CIELAB পৃষ্ঠাটি উদ্ধৃত করে, এই রঙের স্থানের সুবিধাগুলি CIELAB :

আরজিবি এবং সিএমওয়াইকে রঙিন মডেলগুলির বিপরীতে ল্যাব রঙটি প্রায় মানুষের দৃষ্টিভঙ্গির জন্য ডিজাইন করা হয়েছে। এটি অনুধাবনযোগ্য অভিন্নতা অর্জনের উচ্চাকাঙ্ক্ষী এবং এর এল উপাদানটি স্বাচ্ছন্দ্যের সাথে মানুষের উপলব্ধি ঘনিষ্ঠভাবে মেলে। সুতরাং, এটি ক এবং খ উপাদানগুলিতে আউটপুট বক্ররেখা পরিবর্তন করে সঠিক রঙের ভারসাম্য সংশোধন করতে ব্যবহৃত হতে পারে।

রঙগুলির মধ্যে দূরত্ব পরিমাপ করতে আপনি ডেল্টা ই দূরত্ব ব্যবহার করতে পারেন।

এর সাহায্যে আপনি 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 };
    }
}

দুটি স্থিতিশীল পদ্ধতি রয়েছে, একটি DeltaE ডেল্টা ই ( ডেল্টা ) ব্যবহার করে দূরত্ব পরিমাপ করা এবং অন্যটি দুটি রঙের Combine প্রতিটি রঙের কতটা সংযুক্ত করে (সংযুক্ত)।

এবং RGB থেকে RGB রূপান্তরের জন্য আপনি নিম্নলিখিত পদ্ধতিটি (এখান থেকে) ব্যবহার করতে পারেন:

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

ধারণাটি হ'ল @ অ্যান্টোনিনলজেক ডু ('█', '▓', '▒', '░') এর মতো ছায়াযুক্ত অক্ষর ব্যবহার করুন, এটি আপনাকে কনসোল রঙগুলিকে সংযুক্ত করে 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 ব্যবহারের পরিবর্তে LockBits ব্যবহার করে চিত্রের ডেটাতে অ্যাক্সেস হতে পারে।

আপডেট : চিত্রটিতে একই রঙের অংশ থাকলে আপনি পৃথক অক্ষরের পরিবর্তে বর্ণের বর্ণের অঙ্কন অঙ্কন প্রক্রিয়াটি যথেষ্ট গতিতে করতে পারেন:

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 ) এবং 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);
}

এটি দুর্দান্ত দেখায় তবে কনসোলটির আকার পরিবর্তন বা স্ক্রোল করা থাকলে উইন্ডোজ সতেজ হওয়ার কারণে চিত্রটি অদৃশ্য হয়ে যায় (সম্ভবত আপনার ক্ষেত্রে চিত্র পুনর্নির্মাণের জন্য কোনও ধরণের প্রক্রিয়া প্রয়োগ করা সম্ভব))

আর একটি সমাধান কনসোল অ্যাপ্লিকেশনটিতে একটি উইন্ডো ( 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 সেট করতে পারেন windows উইন্ডোস সীমানা লুকানোর জন্য FormBorderStyle = FormBorderStyle.None নেই (ডান চিত্র)

এই ক্ষেত্রে আপনি কনসোলটির আকার পরিবর্তন করতে পারেন এবং চিত্র / উইন্ডোটি এখনও সেখানে থাকবে।

এই পদ্ধতির সাথে একটি সুবিধা হ'ল আপনি যে উইন্ডোটি চান তা সন্ধান করতে পারেন এবং যে কোনও সময় কেবল BackgroundImage সম্পত্তি পরিবর্তন করে চিত্রটি পরিবর্তন করতে পারেন।

আমার কাছে একটি কনসোল অ্যাপ্লিকেশন রয়েছে যা চিত্রগুলি পরিচালনা করে। এখন আমার কনসোল অ্যাপ্লিকেশনটির মধ্যে চিত্রগুলির পূর্বরূপের মতো কিছু দরকার। এগুলি কনসোলে প্রদর্শন করার কোনও উপায় আছে কি?

এখানে বর্তমান চরিত্র ভিত্তিক উত্তরের তুলনা করা হল:

ইনপুট:

আউটপুট:


আমি আরও @ ডিটারমিমকেনের কোড দিয়ে খেলি। আমি উল্লম্ব রেজোলিউশনকে অর্ধেক রেখেছি এবং d এর মধ্য দিয়ে কিছুটা যুক্ত করেছি ░▒▓ বামদিকে ডিয়েটার মেমকেন ফলাফল, ডানদিকে আমার। নীচের অংশে আউটপুটটির সাথে রাগলি মিলিয়ে আসল চিত্রটির আকার পরিবর্তন করা হয়েছে। মালওয়াইন্স রূপান্তর ফাংশনটি চিত্তাকর্ষক হলেও, এটি ধূসর রঙের সমস্ত ধরণের রঙ ব্যবহার করে না।

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

সম্পাদনা

রঙের দূরত্ব জটিল বিষয় ( here , here এবং সেই পৃষ্ঠাগুলিতে লিঙ্কগুলি ...)। আমি ইউইউভিতে দূরত্ব গণনা করার চেষ্টা করেছি এবং ফলাফলগুলি আরজিবি থেকে তুলনায় আরও খারাপ ছিল। ল্যাব এবং ডেল্টা দিয়ে তারা আরও ভাল হতে পারে তবে আমি এটি চেষ্টা করি নি। আরজিবিতে দূরত্ব যথেষ্ট ভাল বলে মনে হচ্ছে। বাস্তবে আরজিবি রঙের জায়গাতে ইউক্লিডিয়ান এবং ম্যানহাটনের দূরত্ব উভয়ের জন্য ফলাফলগুলি খুব অনুকরণীয়, তাই আমি সন্দেহ করি যে চয়ন করার জন্য খুব কম রঙ রয়েছে।

বাকিগুলি হ'ল রঙ এবং নিদর্শনগুলির সমস্ত সংমিশ্রণের সাথে রঙের তুলনা করা (নিদর্শনগুলি) নিষ্ঠুর বলের। আমি 1/4, 2/4, 3/4 এবং 4/4 এর জন্য পূরণের অনুপাত বলেছি। সেক্ষেত্রে তৃতীয় প্রতীকটি আসলে প্রথমটির কাছে অপ্রয়োজনীয়। তবে যদি অনুপাতগুলি এ জাতীয় অভিন্ন না হয় (ফন্টের উপর নির্ভর করে), ফলাফল পরিবর্তন হতে পারে, তাই ভবিষ্যতের উন্নতির জন্য আমি এটি সেখানে রেখেছি। প্রতীকের গড় রঙ পূরণ করা অনুপাত অনুসারে অগ্রভাগী রঙ এবং ব্যাকগ্রাউন্ড কালারের ওজনের গড় হিসাবে গণনা করা হয়। এটি লিনিয়ার রঙগুলি ধরে নিয়েছে, এটি বড় সরলকরণ কী। সুতরাং এখনও উন্নতির জন্য জায়গা আছে।


কনসোলে কোনও চিত্র দেখানো কনসোলের উদ্দেশ্যে ব্যবহার নয়, আপনি অবশ্যই অন্যান্য জিনিসগুলি হ্যাক করতে পারেন, কারণ কনসোল উইন্ডোটি অন্য উইন্ডোগুলির মতো একটি উইন্ডো মাত্র।

আসলে, একবার আমি গ্রাফিক্স সমর্থন সহ কনসোল অ্যাপ্লিকেশনগুলির জন্য একটি পাঠ্য নিয়ন্ত্রণ লাইব্রেরি বিকাশ শুরু করেছি। আমি কখনই এটি শেষ করিনি, যদিও আমার কাছে ধারণার ডেমো-র কার্য-প্রমাণ রয়েছে:

এবং যদি আপনি কনসোল ফন্টের আকার পান তবে আপনি চিত্রটি খুব স্পষ্টভাবে রাখতে পারেন।

এইভাবে আপনি এটি করতে পারেন:

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 হবে না

  • Malwyn রূপান্তর করতে একটি সম্পূর্ণ Malwyn পদ্ধতি পোস্ট করেছে

সুতরাং আমার পদ্ধতির হবে

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

তাই আপনি যা করতে পারেন

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

নমুনা ইনপুট:

নমুনা আউটপুট:


হ্যাঁ, আপনি যদি কনসোল অ্যাপ্লিকেশন থেকে কোনও Form খোলার মাধ্যমে প্রশ্নটি কিছুটা প্রসারিত করেন তবে আপনি এটি করতে পারেন।

আপনি কীভাবে অ্যাপ্লিকেশনটিকে একটি ফর্ম খুলতে এবং একটি চিত্র প্রদর্শন করতে পারেন তা এখানে:

  • আপনার প্রকল্পে এই দুটি রেফারেন্স অন্তর্ভুক্ত করুন: System.Windows.Forms এবং System.Windows.Forms
  • পাশাপাশি দুটি নামস্থানও অন্তর্ভুক্ত করুন:
using System.Windows.Forms;
using System.Drawing;

কিভাবে যে এই পোস্টে দেখুন!

এই জাতীয় কিছু যুক্ত করার জন্য এখন আপনার যা দরকার তা হল:

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

অবশ্যই আপনি PictureBox ব্যবহার করতে পারেন ..

এবং আপনি form1.Show(); ব্যবহার করতে পারেন। form1.Show(); পূর্বরূপ দেখানোর সময় কনসোলটি বাঁচিয়ে রাখতে ..

আসল পোস্ট: অবশ্যই আপনি 25x80 উইন্ডোর ভিতরে কোনও চিত্র সঠিকভাবে প্রদর্শন করতে পারবেন না; এমনকি যদি আপনি আরও বড় উইন্ডো ব্যবহার করেন এবং গ্রাফিকগুলি ব্লক করেন তবে এটি পূর্বরূপ নয় বরং গোলযোগ হবে!

আপডেট: দেখে মনে হচ্ছে আপনি সমস্ত জিডিআই পরে কনসোল ফর্মটিতে একটি চিত্র আঁকতে পারেন; টাফারের উত্তর দেখুন!







console