gdi + Grafik :: DrawImage wirklich langsam ~~

Wenn Sie mithilfe von GDI+, die Klasse TextureBrush, was Sie brauchen für den rendering-Bilder schnell. Ich habe geschrieben ein paar 2d-Spiele mit ihm, immer um die 30 FPS oder so.

Habe ich nie geschrieben .NET-code in C++, hier ist also ein C#-ish Beispiel:

Bitmap bmp = new Bitmap(...)
TextureBrush myBrush = new TextureBrush(bmp)

private void Paint(object sender, PaintEventArgs e):
{
    //Don't draw the bitmap directly. 
    //Only draw TextureBrush inside the Paint event.
    e.Graphics.FillRectangle(myBrush, ...)
}

InformationsquelleAutor der Antwort Cybis

Erkunden Sie die Auswirkungen der expliziten festlegen der Interpolations-Modus zu NearestNeighbor (wobei, in deinem Beispiel sieht es aus wie die interpolation ist eigentlich nicht nötig! Aber 300ms ist die Art von Kosten zu tun hohe Qualität der interpolation, wenn keine interpolation nötig, so seine einen Versuch Wert)

Andere Sache, zu erkunden, ist das ändern der Farbtiefe der bitmap.

InformationsquelleAutor der Antwort Will

ich glaube nicht, dass Sie dir eine ganz andere, aber da bist du eigentlich nicht benötigen, um die Größe des Bildes, versuchen Sie es mit der überlastung der DrawImagedie nicht (versuchen), um die Größe:

DrawImage(bitmap,0,0);

Wie gesagt, ich bezweifle, es wird keinen Unterschied machen, denn ich bin sicherdass DrawImage prüft die Breite und Höhe der bitmap, und wenn es keine Skalierung benötigt, ruft einfach diese überlastung. (ich hoffe, dass es nicht darum gehen, durch alle 12 Millionen Pixel darstellenden keine Arbeit).

Update: Meine Grübeleien sind falsch. ich hatte inzwischen heraus gefunden, aber Jungs Kommentar erinnert mich an meine alte Antwort: Sie wollen zu geben Sie die Ziel-Größe; auch wenn es die Quelle entspricht der Größe:

DrawImage(bitmap, 0, 0, bitmap.GetWidth, bitmap.GetHeight);

Der Grund ist, weil die dpi-Unterschiede zwischen den dpi-Wert des bitmap und den dpi-Wert des Ziels. GDI+ wird, führen Sie die Skalierung, um das image zu kommen die richtige "Größe" (d.h. Zoll)

Was ich gelernt habe, auf meine eigenen seit Oktober letzten Jahres ist, dass Sie wirklich wollen, ziehen eine "im Cache" - version Ihrer bitmap. Es ist ein CachedBitmap Klasse in GDI+. Es gibt einige tricks, um es zu benutzen. Aber im Ende habe ich eine Funktion bit von (Delphi -) code, der das macht.

Die Einschränkung ist, dass die CachedBitmap können unwirksam sein - was bedeutet, es kann nicht verwendet werden, um zu zeichnen. Dies geschieht, wenn der Benutzer änderungen, Auflösungen oder Farbtiefen (z.B. Remote Desktop). In diesem Fall wird die DrawImage schlägt fehl, und Sie müssen neu erstellt werden, die CachedBitmap:

class procedure TGDIPlusHelper.DrawCachedBitmap(image: TGPImage;
      var cachedBitmap: TGPCachedBitmap;
      Graphics: TGPGraphics; x, y: Integer; width, height: Integer);
var
   b: TGPBitmap;
begin
   if (image = nil) then
   begin
      //i've chosen to not throw exceptions during paint code - it gets very nasty
      Exit;
   end;

   if (graphics = nil) then
   begin
      //i've chosen to not throw exceptions during paint code - it gets very nasty
      Exit;
   end;

   //Check if we have to invalidate the cached image because of size mismatch
   //i.e. if the user has "zoomed" the UI
   if (CachedBitmap <> nil) then
   begin
      if (CachedBitmap.BitmapWidth <> width) or (CachedBitmap.BitmapHeight <> height) then
         FreeAndNil(CachedBitmap); //nil'ing it will force it to be re-created down below
   end;

   //Check if we need to create the "cached" version of the bitmap
   if CachedBitmap = nil then
   begin
      b := TGDIPlusHelper.ResizeImage(image, width, height);
      try
         CachedBitmap := TGPCachedBitmap.Create(b, graphics);
      finally
         b.Free;
      end;
end;

    if (graphics.DrawCachedBitmap(cachedBitmap, x, y) <> Ok) then
begin
       //The calls to DrawCachedBitmap failed
       //The API is telling us we have to recreate the cached bitmap
       FreeAndNil(cachedBitmap);
       b := TGDIPlusHelper.ResizeImage(image, width, height);
       try
          CachedBitmap := TGPCachedBitmap.Create(b, graphics);
       finally
          b.Free;
       end;

       graphics.DrawCachedBitmap(cachedBitmap, x, y);
    end;
 end;

Den cachedBitmap übergeben nach Verweis. Der erste Aufruf DrawCachedBitmap es zwischengespeichert version erstellt werden. Sie übergeben werden, die in nachfolgenden aufrufen, z.B.:

Image imgPrintInvoice = new Image.FromFile("printer.png");
CachedBitmap imgPrintInvoiceCached = null;

...

int glyphSize = 16 * (GetCurrentDpi() /96);

DrawCachedBitmap(imgPrintInvoice , ref imgPrintInvoiceCached , graphics, 
      0, 0, glyphSize, glyphSize);

verwende ich die routine zum zeichnen der Glyphen auf Schaltflächen, unter Berücksichtigung der aktuellen DPI. Das gleiche könnte verwendet worden sein, die durch das Internet Explorer-team, um Bilder zeichnen, wenn der Benutzer läuft, auf dem hohen dpi (ie ist sehr langsam zeichnen von gezoomten Bildern, weil Sie die GDI+ verwenden).

InformationsquelleAutor der Antwort Ian Boyd

/*
Erstmal sorry für ma Deutsch, Englisch, und der code ist teilweise in Polnisch, aber es ist einfach zu verstehen.
Ich hatte das gleiche problem und ich fand die beste Lösung. Hier ist es.

Nicht mit: Graphics graphics(hdc); Grafik.DrawImage(gpBitmap, 0, 0); Es ist langsam.

Verwenden: GetHBITMAP(Gdiplus::Color(), &g_hBitmap) für HBITMAP und zeichnen mit meiner Funktion ShowBitmapStretch().

Können Sie die Größe, und es ist viel schneller! Artur Czekalski /Polen

*/

//--------Global-----------
Bitmap *g_pGDIBitmap; //for loading picture
int gRozXOkna, gRozYOkna; //size of working window
int gRozXObrazu, gRozYObrazu; //Size of picture X,Y
HBITMAP g_hBitmap = NULL; //for displaying on window
//------------------------------------------------------------------------------
int ShowBitmapStretch(HDC hdc, HBITMAP hBmp, int RozX, int RozY, int RozXSkal, int RozYSkal, int PozX, int PozY) 
{
    if (hBmp == NULL) return -1;
    HDC hdc_mem = CreateCompatibleDC(hdc); //utworzenie kontekstu pamięciowego
    if (NULL == hdc_mem) return -2;
    //Trzeba połączyć BMP z hdc_mem, tzn. umieścić bitmapę w naszym kontekście pamięciowym
    if (DeleteObject(SelectObject(hdc_mem, hBmp)) == NULL) return -3; 

    SetStretchBltMode(hdc, COLORONCOLOR); //important! for smoothness
    if (StretchBlt(hdc, PozX, PozY, RozXSkal, RozYSkal, hdc_mem, 0, 0, RozX, RozY, SRCCOPY) == 0) return -4;

    if (DeleteDC(hdc_mem) == 0) return -5;
    return 0; //OK
}
//---------------------------------------------------------------------------
void ClearBitmaps(void)
{
    if (g_hBitmap) { DeleteObject(g_hBitmap);  g_hBitmap = NULL; }
    if (g_pGDIBitmap) { delete g_pGDIBitmap;  g_pGDIBitmap = NULL; }
}
//---------------------------------------------------------------------------
void MyOpenFile(HWND hWnd, szFileName)
{
    ClearBitmaps(); //Important!
    g_pGDIBitmap = new Bitmap(szFileName); //load a picture from file

    if (g_pGDIBitmap == 0) return;
    //---Checking if picture was loaded
    gRozXObrazu = g_pGDIBitmap->GetWidth();
    gRozYObrazu = g_pGDIBitmap->GetHeight();
    if (gRozXObrazu == 0 || gRozYObrazu == 0) return;

    //---Uworzenie bitmapy do wyświatlaia; DO IT ONCE HERE!
    g_pGDIBitmap->GetHBITMAP(Gdiplus::Color(), &g_hBitmap); //creates a GDI bitmap from this Bitmap object
    if (g_hBitmap == 0) return;

    //---We need to force the window to redraw itself
    InvalidateRect(hWnd, NULL, TRUE);
    UpdateWindow(hWnd);
}
//---------------------------------------------------------------------------
void MyOnPaint(HDC hdc, HWND hWnd) //in case WM_PAINT; DO IT MANY TIMES
{
    if (g_hBitmap)
    {
        double SkalaX = 1.0, SkalaY = 1.0; //scale
        if (gRozXObrazu > gRozXOkna || gRozYObrazu > gRozYOkna || //too big picture, więc zmniejsz; 
           (gRozXObrazu < gRozXOkna && gRozYObrazu < gRozYOkna)) //too small picture, można powiększyć 
        {
            SkalaX = (double)gRozXOkna /(double)gRozXObrazu; //np. 0.7 dla zmniejszania; FOR DECREASE
            SkalaY = (double)gRozYOkna /(double)gRozYObrazu; //np. 1.7 dla powiększania; FOR INCREASE
            if (SkalaY < SkalaX) SkalaX = SkalaY; //ZAWSZE wybierz większe skalowanie, czyli mniejszą wartość i utaw w SkalaX
        }

    if (ShowBitmapStretch(hdc, g_hBitmap, gRozXObrazu, gRozYObrazu, (int)(gRozXObrazu*SkalaX), (int)(gRozYObrazu*SkalaX), 0, 0, msg) < 0) return;

InformationsquelleAutor der Antwort Sator666