Pętle, większe kwadraty z pixeli, losowy obrazek

W C# pisze sobie programik na wlasny uzytek generujacy losowy obraz x, na x pixeli. spoko dziala.
chce zmodyfikowac to aby losowanie bylo z kaflami po np 10 pixeli na 10 pixeli. nie potrafie tego zrobic
kto pomoze? :D

            int szerokosc = 20;
            int[] tab_bmp = new int[szerokosc];
            int[] tab_bmp2 = new int[szerokosc];
            int[] tab_bmp3 = new int[szerokosc];
            int[] tab_bmp4 = new int[szerokosc];
            Bitmap ok = new Bitmap(szerokosc, szerokosc);
            Random okokok = new Random();
            int ppp;
            int kkk;
            int lll;
            int ooo;
            ppp = 250;
            kkk = 250;
            lll = 250;
            ooo = 250;
            int st;
            int end;
            bool reset = true;
                for (int j = 0; j < szerokosc; j++)
                {
                    for (int g = 0; g < 5; g++)//zmiana zapamietany ma byc jeden record przy piatym ma byc reset
                    {


                        for (int i = 0; i < szerokosc; i++)
                        {
                            //if ((j % 5) == 0)
                            //{
                            //    if ((i % 5) == 0)
                            //    {
                            if ((i % 5) == 0)
                            {


                                ppp = okokok.Next(255);
                                kkk = okokok.Next(255);
                                lll = okokok.Next(255);
                                ooo = okokok.Next(255);
                            }
                        }

                        tab_bmp[i] = ppp;
                        tab_bmp2[i] = kkk;
                        tab_bmp3[i] = lll;
                        tab_bmp4[i] = ooo;
                    }
                    for (int k = 0; k <szerokosc; k++)
                    {
                        for (int p = 0; p < szerokosc; p++)
                        {
                            ok.SetPixel(p, k, Color.FromArgb(tab_bmp[p], tab_bmp2[p], tab_bmp3[p], tab_bmp4[p]));
                        }

                    }

                }
            
            pictureBox1.Image = ok;
            ok.Save("ok.png");

kazdy pixel losowo akurat prosto kod dzialajacy 1 wersja:

   int szerokosc = 100;
            int[] tab_bmp = new int[szerokosc];
            int[] tab_bmp2 = new int[szerokosc];
            int[] tab_bmp3 = new int[szerokosc];
            int[] tab_bmp4 = new int[szerokosc];
            Bitmap ok = new Bitmap(szerokosc, szerokosc);
            Random okokok = new Random();

                for (int j = 0; j < szerokosc; j++)
                {
                    for (int i = 0; i < szerokosc; i++)
                    {
                        tab_bmp[i] = okokok.Next(255);
                        tab_bmp2[i] = okokok.Next(255);
                        tab_bmp3[i] = okokok.Next(255);
                        tab_bmp4[i] = okokok.Next(255);
                        ok.SetPixel(i, j, Color.FromArgb(tab_bmp[i], tab_bmp2[i], tab_bmp3[i], tab_bmp4[i]));
                    }
                }
                       
                    
            pictureBox1.Image = ok;
            ok.Save("ok.png");

Nic z tego kodu nie idzie zrozumieć, ponazywaj sensowniej te zmienne, zamiast pisać litanie kodu wyodrębnij poszczególne kawałki do osobny funkcji. Formatowanie też popraw.

int Obraz_Bok_Kwadrat = 100;
int[] Tablica_Kolor = new int[Obraz_Bok_Kwadrat];//przezroczystosc koloru
int[] Tablica_Kolor2 = new int[Obraz_Bok_Kwadrat];//intensywność czerwonego
int[] Tablica_Kolor3 = new int[Obraz_Bok_Kwadrat];//intensywność zielonego
int[] Tablica_Kolor4 = new int[Obraz_Bok_Kwadrat];//intensywność niebieskiego
Bitmap Obraz = new Bitmap(Obraz_Bok_Kwadrat, Obraz_Bok_Kwadrat);
Random Losowanie_Wartosci_Koloru = new Random();

for (int j = 0; j < Obraz_Bok_Kwadrat; j++)
{
    for (int i = 0; i < Obraz_Bok_Kwadrat; i++)
    {
		Tablica_Kolor[i] = Losowanie_Wartosci_Koloru.Next(255);
		Tablica_Kolor2[i] = Losowanie_Wartosci_Koloru.Next(255);
		Tablica_Kolor3[i] = Losowanie_Wartosci_Koloru.Next(255);
		Tablica_Kolor4[i] = Losowanie_Wartosci_Koloru.Next(255);
		Obraz.SetPixel(i, j, Color.FromArgb(Tablica_Kolor[i], Tablica_Kolor2[i], Tablica_Kolor3[i], Tablica_Kolor4[i]));
    }
}
pictureBox1.Image = Obraz;
Obraz.Save("ok.png");

teraz chce napisac to tak aby: losowal jednego koloru po 10 pixeli na 10 pixeli, zaraz nastepny innego losowego

koloru. wiec musze wymanewrowac tak petlami i/lub zmiennymi aby kolor byl losowany co te 10. dlatego dalem tam

if ((j % 5) == 0) kombinowalem (wczesniej tez z 5 tym sie nie sugerujcie) i doszedlem do wniosku ze chyba ze

zmiennymi jest tez nie tak jak powinno byc. potrzeba losowania i zapamietania calego rekordu a potem drugi

licznik i dzielenie modulo do tego bool'a ktora by restartowala wylosowane i zapamietane zmienne nastepnie

losowanie by nastapiwalo od nowa.

moze z trzema petlami?

ten pierwszy kod jedna z moich prób nieudanych

Że takie coś chcesz osiągnąć?

Zamiast pisać pixel po pixelu lepiej użyć Graphics, SolidBrush i funkcji FillRectangle.
Kod:

private static readonly Random random = new Random();

private void Generate_Click(object sender, EventArgs e)
{
    var bitmap = new Bitmap(this.pictureBox1.Width, this.pictureBox1.Height);

    const int RectangleWidth = 10;
    const int RectangleHeight = 10;

    using (Graphics g = Graphics.FromImage(bitmap))
    {
        for (int i = 0; i < 50; i++)
        {
            for (int j = 0; j < 50; j++)
            {
                var color = Color.FromArgb(random.Next(256), random.Next(256),
                                 random.Next(256), random.Next(256));
                using (SolidBrush brush = new SolidBrush(color))
                {
                    var x = RectangleWidth * i;
                    var y = j * RectangleHeight;
                    g.FillRectangle(brush, x, y, RectangleWidth, RectangleHeight);
                }
            }
        }

        this.pictureBox1.Image = bitmap;
    }
}