Ersetzen Sie GDI + DrawImage durch PInvoked GDI und transparente PNGs

  • Ich habe in C # einen Image-Service erstellt, der ein Basis-Layer-Image (JPG) aufnimmt, ein weiteres transparentes PNG (32 Bit) erstellt und dann ein endgültiges JPG-Image ausgibt. Ich versuche, jede letzte Millisekunde aus dieser Funktion herauszuholen, und mein Code wird beim DrawImage-Aufruf in GDI + zu Engpässen. Verwalteter Code hier:

     // Load base image and create graphics
    Image image = LoadImage(renderSettings.RenderedImageDirectory + baseLayer);
    
    Graphics graphics = Graphics.FromImage(image);              
    graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
    graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; 
    graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
    graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighSpeed;
    
    // Draw additional layers to final image
    for (int i = 1; i < renderLayers.Count; i++) {
        // SLOW -- LoadImage just a utility method that returns an Image from disk or cache
        graphics.DrawImage(LoadImage(renderSettings.RenderedImageDirectory + renderLayers[i]), 0, 0, image.Width, image.Height);            
    }
    
    if (graphics != null) graphics.Dispose();
     

    Nun habe ich über die Leistungssteigerungen gelesen, die durch den direkten Aufruf von GDI durch P / Invoke erzielt werden und hat versucht, den DrawImage-Aufruf zu ersetzen. Ich habe einen Komponententest erstellt, um zu versuchen, die gleiche Funktionalität wie das Laden eines JPGs zu kopieren und dann ein transparentes PNG darüber zu schichten.

    Ref: http://social.msdn.microsoft.com/Forums/en-US/winforms/thread/29582142-0068-40dd-bd99-4b3883a76350

     Bitmap sourceImage = new Bitmap("c:\\base.jpg");
    Bitmap overlayImage = new Bitmap("c:\\layer1.png");
    
    // NOTE: ImageHelper is a utility class containing all the P/Invoke stuff
    
    // Get source image in memory
    Graphics sourceImageGraphics = Graphics.FromImage(sourceImage);
    IntPtr sourceImageHDC = sourceImageGraphics.GetHdc();
    IntPtr sourceImageCDC = ImageHelper.CreateCompatibleDC(sourceImageHDC);
    IntPtr sourceImageHandle = sourceImage.GetHbitmap();
    ImageHelper.SelectObject(sourceImageCDC, sourceImageHandle);
    
    // Get overlay image in memory
    Graphics overlayImageGraphics = Graphics.FromImage(overlayImage);
    IntPtr overlayImageHDC = overlayImageGraphics.GetHdc();
    IntPtr overlayImageCDC = ImageHelper.CreateCompatibleDC(overlayImageHDC);
    IntPtr overlayImageHandle = overlayImage.GetHbitmap();
    
    ImageHelper.SelectObject(overlayImageCDC, overlayImageHandle);
    ImageHelper.BitBlt(sourceImageHDC, 0, 0, sourceImage.Width, sourceImage.Height, overlayImageCDC, 0, 0, ImageHelper.TernaryRasterOperations.SRCAND);
    ImageHelper.AlphaBlend(sourceImageHDC, 0, 0, sourceImage.Width, sourceImage.Height, overlayImageCDC, 0, 0, sourceImage.Width, sourceImage.Height, new ImageHelper.BLENDFUNCTION(ImageHelper.AC_SRC_OVER, 0, 0xff, ImageHelper.AC_SRC_ALPHA));
    
    // Release source Image memory.
    ImageHelper.DeleteDC(sourceImageCDC);
    ImageHelper.DeleteObject(sourceImageHandle);
    sourceImageGraphics.ReleaseHdc(sourceImageHDC);
    sourceImageGraphics.Dispose();
    
    // Release overlay Image memory.
    ImageHelper.DeleteDC(overlayImageCDC);
    ImageHelper.DeleteObject(overlayImageHandle);
    overlayImageGraphics.ReleaseHdc(overlayImageHDC);
    overlayImageGraphics.Dispose();
    
    // Save to jpg
    sourceImage.Save("c:\\output.jpg", ImageFormat.Jpeg);
     

    Dies erzeugt jedoch kein mehrschichtiges Bild. Nur die PNG ohne die Basis JPG. Was soll ich anders machen? Ich bin ein bisschen außerhalb meiner Liga, wenn es um direkte GDI geht.

    01 March 2012
    Dfaussio
2 answers
  • Ich habe am Ende SharpDX verwendet, um auf die WIC- und Direct2d-API zuzugreifen. Die Ergebnisse sind beeindruckend, um es gelinde auszudrücken. Beim Compositing mit Direct2d stelle ich eine um 400-500% höhere Leistung gegenüber GDI + fest.

    Ich habe auch versucht, mit GDI + und der Task Parallel Library Bilder in vier Quandranten zu unterteilen und Compositing-Arbeiten in jedem Kern auszuführen. Die Ergebnisse waren bei weitem nicht so bedeutsam wie die Verwendung von SharpDX.

    Hier ist der Code, den ich verwendet habe. Der Verweis auf "renderSettings" ist nur ein Konfigurationsobjekt. Ersetzen Sie bei Bedarf zusammen mit der RenderLayer-Image-Liste.

     /* SharpDX */
    using SharpDX;
    using SharpDX.Direct2D1;
    using SharpDX.DirectWrite;
    using SharpDX.DXGI;
    using SharpDX.IO;
    using SharpDX.WIC;
    using AlphaMode = SharpDX.Direct2D1.AlphaMode;
    using WicBitmap = SharpDX.WIC.Bitmap;
    using D2DPixelFormat = SharpDX.Direct2D1.PixelFormat;
    using WicPixelFormat = SharpDX.WIC.PixelFormat;
    using Rectangle = System.Drawing.Rectangle;
    using Bitmap = System.Drawing.Bitmap;
    
    public Image FlattenImageDirect2d()
    {
    
        List<string> renderLayers = new List<string>()
        {
            "image1.jpg", "image1.png", "image2.png", "image3.png", "image4.png", "image5.png", "image6.png", "image7.png"
        };
    
        // Base image
        string baseLayer = renderLayers[0];
    
        // Create WIC and D2D factories
        var wicFactory = new ImagingFactory();
        var ddFactory = new SharpDX.Direct2D1.Factory();
    
        // Get image size using WIC
        int baseWidth, baseHeight;
        using (var wicStream = new WICStream(wicFactory, renderDirectory + baseLayer, NativeFileAccess.Read)) {
            var jpegDecoder = new JpegBitmapDecoder(wicFactory);
            jpegDecoder.Initialize(wicStream, DecodeOptions.CacheOnDemand);
            var frame = jpegDecoder.GetFrame(0);
            baseWidth = frame.Size.Width;
            baseHeight = frame.Size.Height;
            frame.Dispose();
            jpegDecoder.Dispose();
        }
    
        // Resize image?
        bool resizeImage = (baseWidth != renderSettings.RenderWidth) || (baseHeight != renderSettings.RenderHeight);
    
        // Bitmaps and render target settings
        var wicBitmap = new WicBitmap(wicFactory, renderSettings.RenderWidth, renderSettings.RenderHeight, SharpDX.WIC.PixelFormat.Format32bppBGR, BitmapCreateCacheOption.CacheOnLoad);
        var renderTargetProperties = new RenderTargetProperties(RenderTargetType.Default, new D2DPixelFormat(Format.Unknown, AlphaMode.Unknown), 0, 0, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT);
        var wicRenderTarget = new WicRenderTarget(ddFactory, wicBitmap, renderTargetProperties);
    
        // Create bitmap render target used to draw all images to
        SharpDX.Direct2D1.BitmapRenderTarget bitmapRenderTarget = new SharpDX.Direct2D1.BitmapRenderTarget(wicRenderTarget, CompatibleRenderTargetOptions.None, new D2DPixelFormat(Format.Unknown, AlphaMode.Premultiplied));
    
        // Draw render layers
        for (int i = 0; i < renderLayers.Count; i++) {
            // First layer is always a jpeg, all other subsequent layers are png's
            ImageFormat imageFormat = (i == 0) ? ImageFormat.Jpeg : ImageFormat.Png;
    
            using (SharpDX.WIC.BitmapSource bitmapSource = LoadWicBitmap(wicFactory, renderDirectory + renderLayers[i], imageFormat, resizeImage, renderSettings.RenderWidth, renderSettings.RenderHeight)) {
    
                // Convert WIC pixel format to D2D1 format
                var formatConverter = new FormatConverter(wicFactory);
                formatConverter.Initialize(bitmapSource, SharpDX.WIC.PixelFormat.Format32bppPBGRA, BitmapDitherType.None, null, 0f, BitmapPaletteType.MedianCut);
    
                // Create direct 2d bitmap from wic bitmap
                SharpDX.Direct2D1.Bitmap direct2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap(bitmapRenderTarget, formatConverter);
    
                // Draw direct2d image to bitmap render target
                wicRenderTarget.BeginDraw();
                wicRenderTarget.DrawBitmap(direct2DBitmap, 1.0f, SharpDX.Direct2D1.BitmapInterpolationMode.Linear);
                wicRenderTarget.EndDraw();
    
                // Clean up
                formatConverter.Dispose();
                direct2DBitmap.Dispose();
            }
        }
    
        // Final image data
        byte[] imageData;
    
        // Create streams to write output to. 
        using (var memoryStream = new MemoryStream()) {
            using (var wicStream = new WICStream(wicFactory, memoryStream)) {
    
                // Encode wic bitmap
                var encoder = new JpegBitmapEncoder(wicFactory);
                encoder.Initialize(wicStream);
    
                var frameEncoder = new BitmapFrameEncode(encoder);
                frameEncoder.Initialize();
                frameEncoder.SetSize(renderSettings.RenderWidth, renderSettings.RenderHeight);
                frameEncoder.PixelFormat = WicPixelFormat.FormatDontCare;
                frameEncoder.WriteSource(wicBitmap);
                frameEncoder.Commit();
                encoder.Commit();
    
                // Set image data
                memoryStream.Position = 0;
                imageData = memoryStream.ToArray();
    
                // Clean up 
                frameEncoder.Dispose();
                encoder.Dispose();
                wicBitmap.Dispose();
                wicRenderTarget.Dispose();
                bitmapRenderTarget.Dispose();
                ddFactory.Dispose();
                wicFactory.Dispose();
                frameEncoder = null;
                encoder = null;
                wicBitmap = null;
                wicRenderTarget = null;
                bitmapRenderTarget = null;                  
                ddFactory = null;
                wicFactory = null;
            }
        }
    
        return Image.FromStream(new MemoryStream(imageData));
    }
    
    private BitmapSource LoadWicBitmap(ImagingFactory wicFactory, string path, ImageFormat imageFormat, bool resize, int resizeWidth = 0, int resizeHeight = 0)
    {
        PngBitmapDecoder pngDecoder;
        JpegBitmapDecoder jpegDecoder;
        BitmapFrameDecode bitmapFrameDecode;
    
        var stream = new WICStream(wicFactory, path, NativeFileAccess.Read);
    
        // Load the appropriate decoder
        if (imageFormat == ImageFormat.Jpeg) {
            jpegDecoder = new JpegBitmapDecoder(wicFactory);
            jpegDecoder.Initialize(stream, DecodeOptions.CacheOnLoad);
            bitmapFrameDecode = jpegDecoder.GetFrame(0);
            jpegDecoder.Dispose();
        }
        else {
            pngDecoder = new PngBitmapDecoder(wicFactory);
            pngDecoder.Initialize(stream, DecodeOptions.CacheOnDemand);
            bitmapFrameDecode = pngDecoder.GetFrame(0);
            pngDecoder.Dispose();
        }
    
        // Clean up
        stream.Dispose();
    
        // Resize if necessary
        if (resize) {
            // Prepare scaler
            var scaler = new BitmapScaler(wicFactory);
            scaler.Initialize(bitmapFrameDecode, resizeWidth, resizeHeight, SharpDX.WIC.BitmapInterpolationMode.Fant);
            return (BitmapSource)scaler;
        }
    
        return (BitmapSource)bitmapFrameDecode;
    }
     
    03 March 2012
    Dfaussio
  • Dies sollte funktionieren:

         private Bitmap GetImage() {
            //##################### Get the Bitmaps ############################
            Bitmap sourceImage = new Bitmap("c:\\1.png");
            Bitmap overlayImage = new Bitmap("c:\\2.png");
    
            //##################### Get Hdc from baselayer ############################
            Graphics sourceImageGraphics = Graphics.FromImage(sourceImage);
            IntPtr sourceImageHDC = sourceImageGraphics.GetHdc();
    
            //##################### Get Cdc from second layer ############################
            IntPtr overlayImageCDC = CreateCompatibleDC(sourceImageHDC);
            IntPtr overlayImageHandle = overlayImage.GetHbitmap();
            SelectObject(overlayImageCDC, overlayImageHandle);
    
            /*
             * BitBlt from sourceImage is not neccessary,
             * because Graphics.FromImage(sourceImage) already did it for you
            */
    
            //##################### Draw the second layer ############################
            AlphaBlend(sourceImageHDC, 0, 0, overlayImage.Width, overlayImage.Height, overlayImageCDC, 0, 0, overlayImage.Width, overlayImage.Height, new BLENDFUNCTION(AC_SRC_OVER, 0, 0xff, AC_SRC_ALPHA));
    
            //##################### Release everthing ############################
            sourceImageGraphics.ReleaseHdc(sourceImageHDC);
            sourceImageGraphics.Dispose();
    
            DeleteDC(overlayImageCDC);
            DeleteObject(overlayImageHandle);
    
            //##################### Return Image ############################
            return sourceImage;
        }
     
    11 October 2011
    Wowa