Parallelisieren von GDI+ Bild Vergrößern .net

Prozesse Nutzen.

GDI+ Blöcke pro Prozess eine Menge von Möglichkeiten. Yep, ein Schmerz, aber es gibt keine Möglichkeit um ihn herum. Zum Glück mit Aufgaben wie diese (und eine, die Prozesse, Dateien auf dem Dateisystem), es ist zu einfach, nur teilen Sie die Arbeitslast zwischen mehreren Prozessen. Glücklicherweise sieht es aus wie GDI+ ist mit sperren, die nicht mutex, so ist es die gleichzeitige!

Wir haben einige Grafik-Programme, wo ich Arbeit zu tun Bildverarbeitung. Ein Programmierer beginnt 6-7 Kopien auf einmal eine Umwandlung Programm, in der Produktion. So ist es nicht unordentlich, Vertrauen Sie mir. Hack? Du bist nicht dafür bezahlt werden, hübsch Aussehen. Den job zu erledigen!

Billig Beispiel (Hinweis: dies funktioniert NICHT in der ide, erstellen Sie und führen Sie die EXE-Datei):

Imports System.Drawing
Module Module1
    Dim CPUs As Integer = Environment.ProcessorCount

    Dim pRuns As New System.Collections.Generic.List(Of Process)

    Sub Main()
        Dim ts As Date = Now
        Try
            If Environment.GetCommandLineArgs.Length > 1 Then
                LongTerm(Environment.GetCommandLineArgs(1))
                Exit Sub
            End If

            Dim i As Integer = 0
            Dim files As String() = IO.Directory.GetFiles("D:\TEMP", "*.jpg")
            Dim MAX As Integer = Math.Min(26, files.Count)
            While pRuns.Count > 0 Or i < MAX

                System.Threading.Thread.Sleep(100)

                If pRuns.Count < CInt(CPUs * 1.5) And i < MAX Then ''//x2 = assume I/O has low CPU load
                    Console.WriteLine("Starting process pRuns.count = " & pRuns.Count & " for " & files(i) & " path " & _
                                        Environment.GetCommandLineArgs(0))
                    Dim p As Process = Process.Start(Environment.GetCommandLineArgs(0), """" & files(i) & """")
                    pRuns.Add(p)
                    i += 1
                End If

                Dim i2 As Integer
                i2 = 0
                While i2 < pRuns.Count
                    If pRuns(i2).HasExited Then
                        pRuns.RemoveAt(i2)
                    End If
                    i2 += 1
                End While


            End While
        Catch ex As Exception
            Console.WriteLine("Blew up." & ex.ToString)
        End Try
        Console.WriteLine("Done, press enter. " & Now.Subtract(ts).TotalMilliseconds)
        Console.ReadLine()
    End Sub


    Sub LongTerm(ByVal file As String)
        Try
            Dim newImageHeight As Integer
            Dim oldImage As Image
            Console.WriteLine("Reading " & CStr(file))
            oldImage = Image.FromFile(CStr(file))
            Dim rect As Rectangle

            newImageHeight = Convert.ToInt32(850 * oldImage.Height / oldImage.Width)
            Using newImage As New Bitmap(850, newImageHeight, oldImage.PixelFormat)
                Using graph As Graphics = Graphics.FromImage(newImage)
                    rect = New Rectangle(0, 0, 850, newImageHeight)

                    With graph
                        .CompositingQuality = Drawing2D.CompositingQuality.HighQuality
                        .SmoothingMode = Drawing2D.SmoothingMode.HighQuality
                        .InterpolationMode = Drawing2D.InterpolationMode.HighQualityBicubic
                    End With

                    Console.WriteLine("Converting " & CStr(file))
                    graph.DrawImage(oldImage, rect)

                    Console.WriteLine("Saving " & CStr(file))
                    newImage.Save("d:\temp\Resized\" & _
                                  IO.Path.GetFileNameWithoutExtension(CStr(file)) & ".JPG", _
                                   System.Drawing.Imaging.ImageFormat.Jpeg)
                End Using
            End Using
        Catch ex As Exception
            Console.WriteLine("Blew up on  " & CStr(file) & vbCrLf & ex.ToString)
            Console.WriteLine("Press enter")
            Console.ReadLine()
        End Try
    End Sub

End Module

Wenn Sie nichts dagegen haben eine WPF-Ansatz, hier etwas zu versuchen. Im folgenden ist ein einfaches skalieren Methode akzeptiert Bild streams und erzeugt ein byte[] mit der resultierenden JPEG-Daten. Da Sie nicht wollen, um tatsächlich ziehen die Bilder mit GDI+, ich dachte, dies sei für Sie geeignet, obwohl Sie WPF-basiert. (Die einzige Voraussetzung ist die Referenz WindowsBase und PresentationCore in Ihrem Projekt.)

Vorteile sind die schnellere Codierung (von 200-300% auf meinem Rechner) und bessere parallele speedup, obwohl ich auch einige unerwünschte Serialisierung des WPF-rendering-Pfad. Lassen Sie mich wissen, wie das funktioniert für Sie. Ich bin sicher, es könnte noch weiter optimiert werden, wenn nötig.

Code:

 byte[] ResizeImage(Stream source)
 {
    BitmapFrame frame = BitmapFrame.Create(source, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.None);
    var newWidth = frame.PixelWidth >> 1;
    var newHeight = frame.PixelHeight >> 1;
    var rect = new Rect(new System.Windows.Size(newWidth, newHeight));
    var drawingVisual = new DrawingVisual();
    using (var drawingContext = drawingVisual.RenderOpen())
        drawingContext.DrawImage(frame, rect);
    var resizedImage = new RenderTargetBitmap(newWidth, newHeight, 96.0, 96.0, PixelFormats.Default);
    resizedImage.Render(drawingVisual);
    frame = BitmapFrame.Create(resizedImage);

    using (var ms = new MemoryStream())
    {
        var encoder = new JpegBitmapEncoder();
        encoder.Frames.Add(frame);
        encoder.Save(ms);
        return ms.ToArray();
    }
 }