Bildberechnungs OpenCL und dann Bildschirm Rendering

Question

Ich weiß nicht, wie das Projekt zu starten, dies umzusetzen:

1. Eine Matrix von 16-Bit-Integer in GPU-Speicher geladen (Dies ist ein Graustufenbild Radiologie) (Kontraststeigerungs Algorithmus zum Beispiel)
2. ein Bereich von Interesse der zweiten Matrix umgewandelt wird in ein RGB-Bild für die Bildschirmanzeige
3. eine zweite Matrix aus 16 Bits der ganzen Zahlen wird von dem ersten Array, berechnet durch eine Funktion der Anwendung .

Ich kann Schritt eins und zwei tun, und ich bin auf Schritt 3 fest! Ich habe das alles in der CPU implementiert, also geht es hier nicht darum, Graustufen- oder RGB-Bilder zu bearbeiten oder Bitmaps für die Anzeige zu erstellen. Ich habe auch die ersten beiden Schritte in OpenCL implementiert und dann die resultierende Matrix im CPU-Speicher für RGB-Bitmap-Konvertierung gelesen und dann angezeigt. Aber das ist natürlich langsam, weil Daten zwischen CPU- und GPU-Speicher hin und her bewegt werden (Bilder sind wirklich groß: mehr als 100 Megapixel).

Jede Hilfe wird geschätzt. Ich programmiere mit Delphi 10, aber Beispielcode in C/C++ ist in Ordnung. Ich habe VC2010 und erfolgreich NVidia OpenCL oclNbody Beispielanwendung neu erstellen.

Answer 1

Die Lösung Ihres Problems hängt stark davon ab, was Sie rendern möchten. Wahrscheinlich, wenn Sie medizinische Bilder verarbeiten, müssen Sie qualitativ hochwertige Bilder anzeigen.

Basierend auf Ihren Worten ist ROI-Auflösung viel größer als die der Anzeige. Ich weiß nicht viel über die Qualität der integrierten OpenGL-Bildskalierungsfilter, also würde ich zuerst testen, ob OpenGL eine Option ist, bevor ich den komplexen OpenCL-OpenGL-Interop-Code schreibe. Jedenfalls hätte ich lieber einen Skalierungsfilter, den ich anpassen kann.

Die flexibelste Option besteht also darin, zwei OpenCL-Puffer gleicher Größe zu erstellen, um die Auflösung anzuzeigen. Dann implementieren OpenCL-Kernel, die Graustufen -> RGB-Konvertierung & Downsampling durchführen.

Pseudo-Code lautet wie folgt:

// Original grayscale image; 
cl_mem orig_image = clCreateBuffer(sizeof(uint16_t)*orig_width*orig_heigth); 

// Grayscale ROI, downscaled to dispaly resolution, still 16 bits; 
cl_mem disp_grayscale = clCreateBuffer(sizeof(uint16_t)*disp_width*disp_heigth); 

// RGB image to display; 
cl_mem disp_rgb = clCreateBuffer(sizeof(uint8_t)*3*disp_width*disp_heigth); 

clEnqueueNDRangeKernel(DownscaleFilter, orig_image, disp_grayscale); 
clEnqueueNDRangeKernel(GrayscaleToRGb, disp_grayscale, disp_rgb); 

uint8_t *pixels = clEnqueueMapBuffer(disp_rgb); 
// Deal with it as with usual image; 

clEnqueueUnmapMemoryObject(disp_rgb); 
// pixels are no longer available; 

IMO, das komplexeste Problem hierbei ist, qualitativ hochwertige absteuernd Filter zu entwickeln. Ich habe einen 8-Tap-Downscale-Filter vom neuen HEVC-Videocodierungsstandard getestet, das war ziemlich gut.