[c#]Disegnare immagine velocemente

[rangers97]

Buongiorno, da poco mi sono cimentato nella programmazione in c# e sto cercando si esportare un progetto da java che consiste di disegnare un frattale. ho riscontrato un aumento delle tempistiche di disegno rispetto a java e volevo chiedere in che modo posso velocizzare il processo

 private void panel1_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = panel1.CreateGraphics();   
            
            Bitmap bm = new Bitmap(800,800);
            bm.SetPixel(0, 0, Color.Red);   
            double a, b;
            int b1 = 0, a1 = 0;
            for (int i = -400; i < 400; i++)
            {
                b1 = 0;
                for (int y = -400; y < 400; y++)
                {
                     a = (double)i/zoom+zoomx;
                     b = (double)y/zoom+zoomy;
                    int c = funz2(a, b);
                    if (c==iterazioni)


                    {
                        bm.SetPixel(a1, b1, Color.Black);
                    }
                  else
                    {
                        bm.SetPixel(a1, b1, getColor(c%120));
                    }
                    b1++;
                }
                a1++;
            }
            g.DrawImageUnscaled(bm, 0, 0);




        }

[Marsh]

con aumento delle tempistiche cosa intendi? di quanto parliamo?

se possiedi il framework 3 o superiore puoi usare il componente WritableBitmap
è una classe costruita appositamente per disegnare un'immagine, inoltre deriva da BitmapSource,
quindi puoi, in seguito, utilizzarla direttamente come fonte sorgente.

            
// bitmap scrivibile: larghezza, altezza, x punti per inch (scala), y punti per inch (scala), formato colore, ev. paletta colori           
WriteableBitmap m_WBitmap = newWriteableBitmap(800, 800, 800, 800, PixelFormats.Bgra32, null);
           
// rettangolo di disegno: posizione x, posizione y, larghezza, altezza           
Int32Rect m_Bound = newInt32Rect(0, 0, m_WBitmap.PixelWidth, m_WBitmap.PixelHeight);
           
// bytes per pixel: bgra = 32 byte = 8 => 32 / 8 = 4           
int m_BytesPerPixel = (m_WBitmap.Format.BitsPerPixel) / 8;
             
// passo della riga: lunghezza della riga per il numero di bytes per pixel, serve per sapere quando andare a capo          
int m_Stride = m_WBitmap.PixelWidth * m_BytesPerPixel;
            
// dimensione array dei colori: lunghezza * altezza * il numero di bytes per pixel          
int m_ColorArraySize = m_Stride * m_WBitmap.PixelHeight; 
          
// array dei colori          
byte[] m_ColorArray = newbyte[m_ColorArraySize];
             
// riempiamo il nostro array dei colori, esempio: una colonna rossa, una blu         
for (int x = 0; x < m_WBitmap.PixelWidth * m_BytesPerPixel; x += 4)
{               
    for (int y = 0; y < m_WBitmap.PixelHeight * m_BytesPerPixel; y += 4)
    {
        int pos = x * m_WBitmap.PixelWidth + y;
        if (y / 4 % 2 == 0)
        {
            m_ColorArray[pos + 0] = Colors.Red.B;
            m_ColorArray[pos + 1] = Colors.Red.G;
            m_ColorArray[pos + 2] = Colors.Red.R;
            m_ColorArray[pos + 3] = Colors.Red.A;
         }                     
         else
         {
             m_ColorArray[pos + 0] = Colors.Blue.B;
             m_ColorArray[pos + 1] = Colors.Blue.G;
             m_ColorArray[pos + 2] = Colors.Blue.R;
             m_ColorArray[pos + 3] = Colors.Blue.A;
          }
     }
}
             
// scriviamo i bytes calcolati: rettanglo di disegno, array dei colori, passo della riga, eventuale offset
m_WBitmap.WritePixels(m_Bound, m_ColorArray, m_Stride, 0);
             
// deriva da bitmap source, quindi si può mettere come sorgente d'immagine
iBitmap.Source = m_WBitmap;

eseguendo alcune prove, un'immagine 800*800 impiega circa 18ms a prepararsi,
se necessiti di un ulteriore speedup, potresti impiegare le tecniche del multithread, molto utili in questo genere di problemi.
se ancora risulta troppo lento per gli standard prefissati, dovresti puntare sulla programmazione degli shader, necessari alla comunicazione con le schede grafiche.