Создание изображения из чисел

using System;
using System.Drawing;
using System.Windows.Forms;
using System.IO;
namespace ImageArrayWF
{
    public partial class Form1 : Form
    {
    private string str = "";
    public Form1()
    {
        InitializeComponent();
    }
    private void button1_Click(object sender, EventArgs e)
    {
        const int stolb = 64, strok = 128;
        int[,] array2D = new int[stolb, strok];
        StreamReader streamReader = new StreamReader(@"Disp.txt");
        while (!streamReader.EndOfStream)
        {
            str += streamReader.ReadLine();
        }
        Console.WriteLine(str);
        Graphics dc = this.CreateGraphics();
        Brush[] brushes = {new SolidBrush(Color.Black),
            new SolidBrush(Color.White) };
        for (int i = 0; i < stolb; i++)
        {
            for (int j = 0; j < strok; j++)
            {
                array2D[i, j] = (int) char.GetNumericValue(str[i * strok + j]);
                dc.FillRectangle(brushes[array2D[i, j]], j * 10, i * 10, 10, 10);
            }
        }
    }
}
}

Как уже было сказано, в файле картинка хранится блоками размером 128 строк * 8 столбцов (то есть вся картинка - это 8 длинных полос друг под другом). Каждая строка в это блоке перевернута по горизонтали. Плюс само изображение повернуто на 90 градусов против часовой стрелки.

Что я сделал:

1. Считываем все строки, каждую строку переворачиваем
2. Считанные строки разбиваем на блоки для отрисовки
3. Каждый блок отрисовываем, переворачивая и отражая всё изображение.

Для отрисовки одной точки я написал такую функцию

    private static void Draw(char s, int x, int y)
    {
        Console.SetCursorPosition(x, y);
        Console.Write(s);
    }

Далее, определил константы для всего изображения и блока

    const int rows = 64, columns = 128;
    const int blockRows = 128, blockColumns = 8;

После считываем блоки

    private static IEnumerable<bool[]> ReadFile(string file)
    {
        var lines = File.ReadAllLines(file).Select(l => l.Reverse().ToArray()).ToArray();
        for (int i = 0; i < 8; i++)
        {
            var block = new bool[blockRows * blockColumns];
            for (var r = 0; r < 128; r++)
            {
                for (var c = 0; c < 8; c++)
                {
                    var ch = lines[i * 128 + r][c];
                    if (ch == '1') block[r * 8 + c] = true;
                }
            }
            yield return block;
        }
    }

Ну и основная функция с отрисовкой

    static void Main(string[] args)
    {
        Console.WindowWidth = columns;
        Console.WindowHeight = rows;
        var offsetRows = 0;
        foreach (var block in ReadFile(@"D:\temp\Disp.txt"))
        {
            for (var r = 0; r < 128; r++)
            {
                for (var c = 0; c < 8; c++)
                {
                    if (block[r * 8 + c])
                    {
                        Draw('▓', blockRows - r, offsetRows + c);
                    }
                }
            }
            offsetRows += blockColumns;
        }
        Console.ReadLine();
    }

Результат

Адаптированная под WinForms версия от @tym32167

public partial class Form1 : Form
{
    private readonly Rectangle[] _drawableRectangles;
    const int rows = 64, columns = 128;
    const int blockRows = 128, blockColumns = 8;
    const int scaleFactor = 10;
    const int margin = scaleFactor / 2;
    private static IEnumerable<bool[]> ReadFile(string file)
    {
        char[][] lines = File.ReadAllLines(file).Select(l => l.Reverse().ToArray()).ToArray();
        for (int i = 0; i < blockColumns; i++)
        {
            bool[] block = new bool[blockRows * blockColumns];
            for (int r = 0; r < blockRows; r++)
            {
                for (int c = 0; c < blockColumns; c++)
                {
                    char ch = lines[i * blockRows + r][c];
                    if (ch == '1') block[r * blockColumns + c] = true;
                }
            }
            yield return block;
        }
    }
    public Form1()
    {
        InitializeComponent();
        ClientSize = new Size(columns * scaleFactor + margin, rows * scaleFactor + margin);
        int offsetRows = 0;
        List<Point> points = new List<Point>();
        foreach (bool[] block in ReadFile(@"Disp.txt"))
        {
            for (int r = 0; r < blockRows; r++)
            {
                for (int c = 0; c < blockColumns; c++)
                {
                    if (block[r * blockColumns + c])
                    {
                        points.Add(new Point(margin + (blockRows - r) * scaleFactor, margin + (offsetRows + c) * scaleFactor));
                    }
                }
            }
            offsetRows += blockColumns;
        }
        _drawableRectangles = (from Point p in points select new Rectangle(p, new Size(scaleFactor / 2, scaleFactor / 2))).ToArray();
    }
    protected override void OnPaint(PaintEventArgs e)
    {
        e.Graphics.FillRectangle(Brushes.Black, ClientRectangle);
        e.Graphics.FillRectangles(Brushes.White, _drawableRectangles);
    }
}

Теоритический ответ

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

Но! Тут есть одно большое но, такого результат удалось достичь только после того, как я начал переворачивать массив считанной строки в обратную сторону, вот то что было до того как перевернул массив считанной строки:

Если хорошо присмотреться, то изображение не только перевернуто, но оно еще и отражено в обратную сторону, т.е. зеркально.

Далее я приложу свой код которым удалось достич такого эффекта, думаю если будет время я его сам дораьотаю, но к сожалению пока его нет.

Простой незамысловатый код чтения блоками сверху вниз по 8 ячеек:

public partial class Form1 : Form
{
    private readonly Rectangle[] _drawableRectangles;
    public Form1()
    {
        InitializeComponent();
        ClientSize = new Size(128 * 10, 64 * 10);
        bool[][][] _array3D;
        using (TextReader streamReader = new StreamReader(@"Disp2.txt"))
        {
            _array3D = new bool[16][][];
            for (int j = 0; j < 16; j++)
            {
                _array3D[j] = new bool[64][];
                for (int k = 0; k < 64; k++)
                {
                    char[] buffer = new char[8];
                    streamReader.ReadBlock(buffer, 0, 8);
                    Array.Reverse(buffer);
                    _array3D[j][k] = buffer.Select(c =>
                    {
                        return c == '1';
                    }).ToArray();
                    streamReader.ReadBlock(buffer, 0, 2);
                }
            }
        }
        List<Point> tempPoints = new List<Point>();
        for (int x = 15; x >= 0; x--)
        {
            for (int y = 63; y >= 0; y--)
            {
                for (int j = 7; j >= 0; j--)
                {
                    if (_array3D[x][y][j])
                    {
                        tempPoints.Add(new Point(j * x * 5, y * 5));
                    }
                }
            }
        }
        _drawableRectangles = tempPoints.Select(point => new Rectangle(point, new Size(5, 5))).ToArray();
    }
    protected override void OnPaint(PaintEventArgs e)
    {
        e.Graphics.FillRectangle(Brushes.Black, ClientRectangle);
        e.Graphics.FillRectangles(Brushes.White, _drawableRectangles);
    }
}