GDI + графика:: DrawImage очень медленно~~

Если вы используете GDI+, класс TextureBrush-это то, что вам нужно для быстрого рендеринга изображений. Я написал пару 2d-игр с ним, получая около 30 кадров в секунду или около того.

Я никогда не писал .NET-код на C++, поэтому вот пример C# - ish:

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, ...)
}

просто мысль, а не получать ширину и высоту изображения перед рисованием, почему бы не кэшировать эти значения при загрузке изображения?

исследуйте влияние явной установки режима интерполяции на NearestNeighbor (где, в вашем примере, похоже, что интерполяция на самом деле не нужна! Но 300ms-это стоимость высококачественной интерполяции, когда интерполяция не требуется, поэтому стоит попробовать)

другое дело для изучения меняется глубина цвета растрового изображения.

к сожалению, когда у меня была аналогичная проблема, я обнаружил, что GDI+, как известно, намного медленнее, чем GDI, и обычно не аппаратное ускорение, но теперь Microsoft перешла на WPF, они не вернутся, чтобы улучшить GDI+!

все производители видеокарт перешли на производительность 3D и, похоже, не заинтересованы в 2D-ускорении, и нет четкого источника информации о том, какие функции являются или могут быть аппаратными ускоренными или нет. Очень расстраивает, потому что написав приложение в .NET с помощью GDI+, я не рад переходить на совершенно другую технологию, чтобы ускорить его до разумных уровней.

Я не думаю, что они будут сильно отличаться, но поскольку вам на самом деле не нужно изменять размер изображения, попробуйте использовать перегрузку функция drawImage это не (попытка) размер:

DrawImage(bitmap,0,0);

как я уже сказал, я сомневаюсь, что это будет иметь значение, потому что я обязательно это функция drawImage проверка ширина и Высота растрового изображения, и если нет необходимости в изменении размера, просто вызывает эту перегрузку. (я будем надеяться, что он не потрудится пройти через все 12 миллионов пикселей, не выполняя никакой реальной работы).

Update: мои размышления ошибочны. с тех пор я узнал, но комментарий парней напомнил мне мой старый ответ: Ты хочу чтобы указать размер назначения; даже если он соответствует размеру источника:

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

причина заключается в разнице dpi между dpi bitmap и dpi назначения. GDI+ выполнит масштабирование, чтобы получить изображение правильный "размер" (т. е. в дюймах)

что я узнал самостоятельно с прошлого октября, так это то, что вы действительно хотите нарисовать "кэшированные" версия вашего растрового изображения. Есть CachedBitmap класс В GDI+. Есть несколько трюков, чтобы использовать его. Но в конце концов у меня есть бит функции (Delphi) кода, который это делает.

нюанс заключается в том, что CachedBitmap может стать недействительным-это означает, что его нельзя использовать для рисования. Это происходит, если пользователь меняет разрешения или цвет глубины (например, удаленный рабочий стол). В этом случае DrawImage потерпит неудачу, и вы должны воссоздать 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;

на cachedBitmap передается по ссылке. Первый звонок в DrawCachedBitmap это кэшированные версия будет создана. Затем вы передаете его в последующих вызовах, например:

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

...

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

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

Я использую процедуру для рисования глифов на кнопках с учетом текущего DPI. То же самое могло быть использовано командой Internet Explorer для рисования изображений, когда пользователь работает с высоким dpi (т. е. очень медленно рисует увеличенные изображения, потому что они используют GDI+).

попробуйте использовать копию растрового изображения из файла. Функция FromFile на некоторых файлах возвращает "медленное" изображение, но его копия будет рисовать быстрее.

Bitmap *bitmap = Bitmap::FromFile("XXXX",...);

Bitmap *bitmap2 = new Bitmap(bitmap); // make copy

DrawImage(bitmap2,0,0,width,height);

/* Сначала извините за ma English, и код частично на польском языке, но его легко понять. У меня была такая же проблема и я нашел лучшее решение. Вот оно.

Не используйте: графика графика (hdc); графика.DrawImage (gpBitmap, 0, 0); он медленный.

использовать: GetHBITMAP (Gdiplus::Color (), &g_hBitmap) для HBITMAP и рисовать с помощью моей функции ShowBitmapStretch ().

вы можете изменить его размер, и это намного быстрее! Czekalski Артур / Польша!--2-->

*/

//--------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;

Я провел некоторые исследования и не смог найти способ рендеринга изображений с помощью GDI / GDI+ быстрее, чем

Graphics.DrawImage/DrawImageUnscaled

и в то же время простое, как это.

пока я не обнаружил

ImageList.Draw(GFX,Point,Index)

и да, это действительно так быстро и просто.