In che modo GDI + funziona così velocemente?

Question

Sto tentando di ricreare funzioni GDI + molto semplici, come ridimensionare e ruotare un'immagine. Il motivo è che alcune funzioni GDI non possono essere eseguite su più thread (ho trovato un modo di aggirare l'utilizzo dei processi ma non volevo entrare in quello), e l'elaborazione di migliaia di immagini su un thread non stava quasi tagliandola. Anche le mie immagini sono in scala di grigi, quindi una funzione personalizzata dovrebbe preoccuparsi solo di un valore invece di 4.

Indipendentemente dal tipo di funzione che cerco di ricreare, anche quando altamente ottimizzato, è sempre SEMPRE più lento, nonostante sia notevolmente semplificato rispetto a ciò che GDI sta facendo (sto operando su un array 1D di byte, un byte per pixel)

Ho pensato che forse il modo in cui ruotavo ogni punto poteva essere la differenza, quindi l'ho tolto completamente, e fondamentalmente aveva una funzione che attraversa ogni pixel e la imposta su ciò che è già, e che era solo approssimativamente legata alla velocità di GDI, anche se GDI stava facendo una rotazione effettiva e cambiando 4 valori diversi per pixel.

Che cosa rende possibile questo? C'è un modo per abbinarlo usando la tua funzione?

Answer 1

Il codice GDI + è scritto in C/C++, o forse anche parzialmente in assembly. Alcune chiamate GDI + possono utilizzare GDI, un'API vecchia e ottimizzata. Troverai difficile abbinare le prestazioni, anche se conosci tutti i trucchi di manipolazione dei pixel.

Answer 2

Sto aggiungendo la mia risposta insieme al mio codice per aiutare chiunque altro stia cercando di farlo.

Da una combinazione di puntatori e utilizzando un'approssimazione di Seno e Coseno invece di chiamare una funzione esterna per la rotazione, sono arrivato quasi alla velocità di raggiungere le velocità GDI. Nessuna funzione esterna viene chiamata affatto.

Ci vuole ancora circa il 50% di tempo in più rispetto a GDI, ma la mia precedente implementazione ha richiesto oltre 10 volte di più rispetto a GDI. E quando si considera il multi-threading, questo metodo può essere 10 volte più veloce di GDI. Questa funzione può ruotare un'immagine 300x400 in 3 millisecondi sulla mia macchina.

Ricordare che questo è per immagini in scala di grigi e ogni byte nell'array di input rappresenta un pixel. Se hai qualche idea per renderlo più veloce, per favore condividi!

private unsafe byte[] rotate(byte[] input, int inputWidth, int inputHeight, int cx, int cy, double angle) 
    { 
     byte[] result = new byte[input.Length]; 

     int 
      tx, ty, ix, iy, x1, y1; 
     double 
      px, py, fx, fy, sin, cos, v; 
     byte a, b; 

     //Approximate Sine and Cosine of the angle 
     if (angle < 0) 
      sin = 1.27323954 * angle + 0.405284735 * angle * angle; 
     else 
      sin = 1.27323954 * angle - 0.405284735 * angle * angle; 
     angle += 1.57079632; 
     if (angle > 3.14159265) 
      angle -= 6.28318531; 
     if (angle < 0) 
      cos = 1.27323954 * angle + 0.405284735 * angle * angle; 
     else 
      cos = 1.27323954 * angle - 0.405284735 * angle * angle; 
     angle -= 1.57079632; 


     fixed (byte* pInput = input, pResult = result) 
     { 
      byte* pi = pInput; 
      byte* pr = pResult; 

      for (int x = 0; x < inputWidth; x++) 
       for (int y = 0; y < inputHeight; y++) 
       { 
        tx = x - cx; 
        ty = y - cy; 
        px = tx * cos - ty * sin + cx; 
        py = tx * sin + ty * cos + cy; 
        ix = (int)px; 
        iy = (int)py; 
        fx = px - ix; 
        fy = py - iy; 

        if (ix < inputWidth && iy < inputHeight && ix >= 0 && iy >= 0) 
        { 
         //keep in array bounds 
         x1 = ix + 1; 
         y1 = iy + 1; 
         if (x1 >= inputWidth) 
          x1 = ix; 
         if (y1 >= inputHeight) 
          y1 = iy; 

         //bilinear interpolation using pointers 
         a = *(pInput + (iy * inputWidth + ix)); 
         b = *(pInput + (y1 * inputWidth + ix)); 
         v = a + ((*(pInput + (iy * inputWidth + x1)) - a) * fx); 
         pr = (pResult + (y * inputWidth + x)); 
         *pr = (byte)(v + (((b + ((*(pInput + (y1 * inputWidth + x1)) - b) * fx)) - v) * fy)); 
        } 
       } 
     } 

     return result; 
    }