Weg um Colormatrixvorgang zu beschleunigen?

Gather · 7. August 2013, 19:30

Hallo liebe Community,
ich spiele mich derzeit etwas mit der Colormatrix-Klasse in .NET herum,
und frage mich deswegen ob man diesen Vorgang etwas beschleunigen kann.

Meine derzeitige Vorgehensweise ist:

VB.NET-Quellcode

Public Shared Function CompleteColorMatrix(ByVal b As Bitmap, ByVal cm As System.Drawing.Imaging.ColorMatrix) As Bitmap
Using ia As New System.Drawing.Imaging.ImageAttributes
ia.SetColorMatrix(cm)
Dim rc As New Rectangle(0, 0, b.Width, b.Height)
Using bClone As Bitmap = DirectCast(b.Clone, Bitmap)
Using g As Graphics = Graphics.FromImage(b)
g.Clear(Color.Transparent)
g.DrawImage(bClone, rc, 0, 0, bClone.Width, bClone.Height, GraphicsUnit.Pixel, ia)
g.Dispose()
End Using
End Using
End Using
Return b
End Function
''' <summary>
''' Uses the bluescale-filter at a given bitmap.
''' </summary>
''' <param name="b">The given bitmap.</param>
''' <returns>Bitmap</returns>
''' <remarks></remarks>
Public Shared Function BlueScale(ByVal b As Bitmap) As Bitmap
Dim cm As New System.Drawing.Imaging.ColorMatrix(New Single()() _
{New Single() {0, 0, 1, 0, 0}, _
New Single() {0, 1, 0, 0, 0}, _
New Single() {1, 0, 0, 0, 0}, _
New Single() {0, 0, 0, 1, 0}, _
New Single() {0, 0, 0, 0, 1}})
Return CompleteColorMatrix(b, cm)
End Function

Diese Methode dauert doch eine halbe Sekunde bis Sekunde (+).
Danke im Vorraus.

Artentus · 7. August 2013, 20:00

Warum nicht so?

VB.NET-Quellcode

Public Shared Function CompleteColorMatrix(ByVal b As Bitmap, ByVal cm As System.Drawing.Imaging.ColorMatrix) As Bitmap
Dim bClone As New Bitmap(b.Width, b.Height)
Dim rect As New Rectangle(0, 0, b.Width, b.Height)
Using ia As New System.Drawing.Imaging.ImageAttributes
ia.SetColorMatrix(cm)
Using g As Graphics = Graphics.FromImage(bClone)
g.Clear(Color.Transparent)
g.DrawImage(b, rect, 0, 0, b.Width, b.Height, GraphicsUnit.Pixel, ia)
g.Dispose()
End Using
End Using
Return bClone
End Function

Edit: uups, kleiner Fail, muss natürlich Graphics.FromImage(bClone) heißen.

Gather · 7. August 2013, 20:19

Weil es A. Nicht funktioniert,
und B. genau so schnell wäre (denke ich

)

Artentus · 7. August 2013, 20:23

Ach wirklich, was funktioniert denn nicht?
Ich dachte vielleicht es wäre schneller, wenn man das Bild nicht klont. Aber das ist GDI, allzu schnell ist das eh nicht, damit musst du leben.

Gather · 7. August 2013, 20:24

Artentus schrieb:

Ach wirklich, was funktioniert denn nicht?

Es passiert nichts. Keine Fehlermeldung. Kein Ergebnis.

Artentus schrieb:

Aber das ist GDI, allzu schnell ist das eh nicht, damit musst du leben.

Da hast du natürlich recht ^^.

thefiloe · 7. August 2013, 20:25

Wie wärs damit? [XAML] WPF Eigene Effekte leicht gemacht

Artentus · 7. August 2013, 20:27

Du hast aber schon meinen Edit gesehen?
Außerdem muss ich thefiloe natürlich auch Recht geben, WPF ist bei sowas immer gut.

Gather · 7. August 2013, 20:30

Danke, dennoch habe ich absichtlich nicht WPF gewählt, da ich ein bisschen mit Funktionen und GDI herumspiele.

Artentus schrieb:

Du hast aber schon meinen Edit gesehen?

Natürlich. :

VB.NET-Quellcode

Public Shared Function CompleteColorMatrixnew(ByVal b As Bitmap, ByVal cm As System.Drawing.Imaging.ColorMatrix) As Bitmap
Dim bClone As New Bitmap(b.Width, b.Height)
Dim rect As New Rectangle(0, 0, b.Width, b.Height)
Using ia As New System.Drawing.Imaging.ImageAttributes
ia.SetColorMatrix(cm)
Using g As Graphics = Graphics.FromImage(bClone)
g.Clear(Color.Transparent)
g.DrawImage(b, rect, 0, 0, b.Width, b.Height, GraphicsUnit.Pixel, ia)
g.Dispose()
End Using
End Using
Return bClone
End Function
Public Shared Function ColorFilter(ByVal b As Bitmap, ByVal eColorfilter As eColorFilter) As Bitmap
Dim cm As New System.Drawing.Imaging.ColorMatrix
Select Case eColorfilter
Case Filters.eColorFilter.Red
cm = New System.Drawing.Imaging.ColorMatrix(New Single()() _
{New Single() {1, 0, 0, 0, 0}, _
New Single() {0, 0, 0, 0, 0}, _
New Single() {0, 0, 0, 0, 0}, _
New Single() {0, 0, 0, 1, 0}, _
New Single() {0, 0, 0, 0, 1}})
End Case
Return CompleteColorMatrixNew(b, cm)
End Function

Edit://
Dennoch, vielleicht wage ich endlich den Umstieg 100%igen Umstieg auf WPF

Artentus · 7. August 2013, 20:33

Also was passiert jetzt genau? Bekommst du einfach das normale, unveränderte Bild oder gar kein Bild?

Und übrigens ist mir gerade aufgefallen, dass g.Dispose() unnötig ist, da du ja schon Using verwendest.

Gather · 7. August 2013, 21:03

@Artentus
Ich bekomme das unveränderte Bild.
Rufe ich die Methode Falsch auf?

VB.NET-Quellcode

Dim bb As New Bitmap("D:\Icons\bonus\icons-shadowless-32\balloon.png")
'Form Load:
PictureBox1.Image = bb
'Button
BitmapClasses.Filters.ColorFilter(bb, BitmapClasses.Filters.eColorFilter.Red) 'Andere Methode, selber Inhalt
PictureBox1.Image = bb

Artentus · 7. August 2013, 21:11

Ja, tust du. Sie hat ja nicht umsonst einen Rückgabewert.

VB.NET-Quellcode

PictureBox1.Image = BitmapClasses.Filters.ColorFilter(bb, BitmapClasses.Filters.eColorFilter.Red)

Gather · 7. August 2013, 21:20

Haha ja das stimmt natürlich

Komplett falsch geschrieben :O
Jop, logischerweise klappt es jetzt. Dennoch an der Geschwindigkeit änderz sich nichts. Dauert beides 19-20 Millisekunden.

Kann man wohl nichts machen.

RodFromGermany · 8. August 2013, 06:57

@Gather:: Sehe ich das richtig? Du willst RGB-Kanäle tauschen?
Am besten wäre es natürlich Unsave in C#, aber auch in VB geht es so:
Locke die Bits, hole sie in ein Byte-Array, tausche die Elemente von Hand und zurück.

ErfinderDesRades · 8. August 2013, 15:02

wobei ich find, das 20ms gar nich soo schlechte Performance ist, also wenns sich um ein 4megaPix Bild handelt...

~blaze~ · 12. August 2013, 16:48

Hi
hab' mal 'ne Testoptimierung gemacht. Die ist auf meinem PC zumindest nicht effizienter gewesen, als die ColorMatrix selber, aber ich fand es an sich interessant:

Spoiler anzeigen

VB.NET-Quellcode

Imports System.Runtime.InteropServices
Imports System.Reflection.Emit
Imports System.Drawing.Imaging
Imports System.Reflection
Public Structure Fixed32
Implements IEquatable(Of Fixed32)
Public Shared ReadOnly MinValue As Fixed32 = New Fixed32(Integer.MinValue)
Public Shared ReadOnly MaxValue As Fixed32 = New Fixed32(Integer.MaxValue)
Public Shared ReadOnly Epsilon As Fixed32 = New Fixed32(1)
Private _value As Integer
Public Shared Operator *(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(CInt(Math.BigMul(left._value, right._value) >> 32))
End Operator
Public Shared Operator /(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(CInt((CLng(left._value) << 16) \ right._value))
End Operator
Public Shared Operator -(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value - right._value)
End Operator
Public Shared Operator +(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value + right._value)
End Operator
Public Shared Operator And(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value And right._value)
End Operator
Public Shared Operator Or(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value Or right._value)
End Operator
Public Shared Operator Xor(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value Xor right._value)
End Operator
Public Shared Operator <<(ByVal left As Fixed32, ByVal right As Integer) As Fixed32
Return New Fixed32(left._value << right)
End Operator
Public Shared Operator >>(ByVal left As Fixed32, ByVal right As Integer) As Fixed32
Return New Fixed32(left._value >> right)
End Operator
Public Shared Operator =(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value = right._value
End Operator
Public Shared Operator <>(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value <> right._value
End Operator
Public Shared Operator <(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value < right._value
End Operator
Public Shared Operator >(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value > right._value
End Operator
Public Shared Operator <=(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value <= right._value
End Operator
Public Shared Operator >=(ByVal left As Fixed32, ByVal right As Fixed32) As Boolean
Return left._value >= right._value
End Operator
Public Shared Operator Mod(ByVal left As Fixed32, ByVal right As Fixed32) As Fixed32
Return New Fixed32(left._value Mod right._value)
End Operator
Public Shared Operator Not(ByVal value As Fixed32) As Fixed32
Return New Fixed32(Not value._value)
End Operator
Public Shared Operator +(ByVal value As Fixed32) As Fixed32
Return value
End Operator
Public Shared Operator -(ByVal value As Fixed32) As Fixed32
Return New Fixed32(-value._value)
End Operator
Private Sub New(ByVal value As Integer)
_value = value
End Sub
Public Shared Widening Operator CType(ByVal value As Short) As Fixed32
Return New Fixed32(CInt(value) << 16)
End Operator
Public Shared Narrowing Operator CType(ByVal value As Fixed32) As Short
Return CShort(value._value >> 16)
End Operator
Public Shared Narrowing Operator CType(ByVal value As Integer) As Fixed32
Return New Fixed32(value * (1 << 16))
End Operator
Public Overrides Function GetHashCode() As Integer
Return _value
End Function
Public Overrides Function Equals(ByVal obj As Object) As Boolean
Return obj IsNot Nothing AndAlso TypeOf obj Is Fixed32 AndAlso Equals(DirectCast(obj, Fixed32))
End Function
Public Overloads Function Equals(ByVal other As Fixed32) As Boolean Implements System.IEquatable(Of Fixed32).Equals
Return _value = other._value
End Function
Public Overrides Function ToString() As String
Dim output As New System.Text.StringBuilder()
Dim cv As Integer = _value
output.Append(cv >> 16)
cv = cv And &HFFFF
If cv <> 0 Then
output.Append(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)
Do
cv *= 10
output.Append(cv >> 16)
cv = cv And &HFFFF
Loop While cv > 0
End If
Return output.ToString()
End Function
Public Shared Function GetRaw(ByVal value As Fixed32) As Integer
Return value._value
End Function
Public Shared Function FromRaw(ByVal value As Integer) As Fixed32
Return New Fixed32(value)
End Function
End Structure
Public Structure Matrix4x4
'use c# unsafe fixed here and explicit layout
Public M11, M12, M13, M14,
M21, M22, M23, M24,
M31, M32, M33, M34,
M41, M42, M43, M44 As Fixed32
Public ReadOnly Property IsIdentity As Boolean
Get
Return M11 = 1S AndAlso M12 = 0S AndAlso M13 = 0S AndAlso M14 = 0S AndAlso _
M21 = 0S AndAlso M22 = 1S AndAlso M23 = 0S AndAlso M24 = 0S AndAlso _
M31 = 0S AndAlso M32 = 0S AndAlso M33 = 1S AndAlso M34 = 0S AndAlso _
M41 = 0S AndAlso M42 = 0S AndAlso M43 = 0S AndAlso M44 = 1S
End Get
End Property
'implement operators
Public Sub New(ByVal m11 As Fixed32, ByVal m12 As Fixed32, ByVal m13 As Fixed32, ByVal m14 As Fixed32,
ByVal m21 As Fixed32, ByVal m22 As Fixed32, ByVal m23 As Fixed32, ByVal m24 As Fixed32,
ByVal m31 As Fixed32, ByVal m32 As Fixed32, ByVal m33 As Fixed32, ByVal m34 As Fixed32,
ByVal m41 As Fixed32, ByVal m42 As Fixed32, ByVal m43 As Fixed32, ByVal m44 As Fixed32)
Me.M11 = m11 : Me.M12 = m12 : Me.M13 = m13 : Me.M14 = m14
Me.M21 = m21 : Me.M22 = m22 : Me.M23 = m23 : Me.M24 = m24
Me.M31 = m31 : Me.M32 = m32 : Me.M33 = m33 : Me.M34 = m34
Me.M41 = m41 : Me.M42 = m42 : Me.M43 = m43 : Me.M44 = m44
End Sub
Public Shared Function FromInt32(ByVal m11 As Integer, ByVal m12 As Integer, ByVal m13 As Integer, ByVal m14 As Integer,
ByVal m21 As Integer, ByVal m22 As Integer, ByVal m23 As Integer, ByVal m24 As Integer,
ByVal m31 As Integer, ByVal m32 As Integer, ByVal m33 As Integer, ByVal m34 As Integer,
ByVal m41 As Integer, ByVal m42 As Integer, ByVal m43 As Integer, ByVal m44 As Integer) As Matrix4x4
Return New Matrix4x4(CType(m11, Fixed32), CType(m12, Fixed32), CType(m13, Fixed32), CType(m14, Fixed32),
CType(m21, Fixed32), CType(m22, Fixed32), CType(m23, Fixed32), CType(m24, Fixed32),
CType(m31, Fixed32), CType(m32, Fixed32), CType(m33, Fixed32), CType(m34, Fixed32),
CType(m41, Fixed32), CType(m42, Fixed32), CType(m43, Fixed32), CType(m44, Fixed32))
End Function
End Structure
Public Class QuickColorMatrix
Private ReadOnly _handler As Action(Of Integer(), Integer, Integer)
Public Sub New(ByVal colorMatrix As Matrix4x4)
_handler = DefineMethod(colorMatrix)
End Sub
Private Shared Function DefineMethod(ByVal colorMatrix As Matrix4x4) As Action(Of Integer(), Integer, Integer)
If colorMatrix.IsIdentity Then Return Nothing
Dim matrix(15) As Integer
'unsafe <3
Dim gch As GCHandle = GCHandle.Alloc(colorMatrix, GCHandleType.Pinned)
Marshal.Copy(gch.AddrOfPinnedObject(), matrix, 0, matrix.Length)
gch.Free()
Dim method As New DynamicMethod(String.Empty, GetType(Void), New Type() {GetType(Integer()), GetType(Integer), GetType(Integer)}, GetType(QuickColorMatrix).Module, True)
Dim ilg As ILGenerator = method.GetILGenerator()
ilg.DeclareLocal(GetType(Integer).MakePointerType(), True) 'currentPtr
ilg.DeclareLocal(GetType(Integer).MakePointerType()) 'destPtr
ilg.DeclareLocal(GetType(Integer)) 'currentChannel
ilg.DeclareLocal(GetType(Integer)) 'currentValue
ilg.DeclareLocal(GetType(Long)) 'a
ilg.DeclareLocal(GetType(Long)) 'r
ilg.DeclareLocal(GetType(Long)) 'g
ilg.DeclareLocal(GetType(Long)) 'b
ilg.DeclareLocal(GetType(Integer()), True)
Dim initialized(3) As Boolean
Dim cond As Label = ilg.DefineLabel()
Dim bodyEnd As Label = ilg.DefineLabel()
'currentPtr = parameters[0] (pointer to array)
ilg.Emit(OpCodes.Ldarg_0)
ilg.Emit(OpCodes.Stloc_S, CByte(8))
ilg.Emit(OpCodes.Ldloc_S, CByte(8))
ilg.Emit(OpCodes.Ldc_I4_0)
ilg.Emit(OpCodes.Ldelema, GetType(Integer))
ilg.Emit(OpCodes.Ldarg_1)
ilg.Emit(OpCodes.Add)
ilg.Emit(OpCodes.Stloc_0)
'get end pointer
ilg.Emit(OpCodes.Ldloc_0)
ilg.Emit(OpCodes.Ldarg_2)
ilg.Emit(OpCodes.Ldc_I4_2)
ilg.Emit(OpCodes.Shl)
ilg.Emit(OpCodes.Add)
ilg.Emit(OpCodes.Stloc_1)
ilg.MarkLabel(cond)
'if current < dest is not true then go to end
ilg.Emit(OpCodes.Ldloc_0)
ilg.Emit(OpCodes.Ldloc_1)
ilg.Emit(OpCodes.Bge, bodyEnd)
'load value at address and store it in currentValue
ilg.Emit(OpCodes.Ldloc_0)
ilg.Emit(OpCodes.Ldind_I4)
ilg.Emit(OpCodes.Stloc_3)
'apply matrix multiplication, where required, skip additions of 0 and multiplication by 1
For column As Integer = 0 To 3
Dim ci As Byte = CByte(4 + column)
Dim used As Boolean = False
'extract channel value
ilg.Emit(OpCodes.Ldloc_3)
If column <> 3 Then 'skip bitshift where not required
ilg.Emit(OpCodes.Ldc_I4_S, CByte((3 - column) * 8))
ilg.Emit(OpCodes.Shr_Un)
End If
If column <> 0 Then 'skip mask where not required
ilg.Emit(OpCodes.Ldc_I4, 255)
ilg.Emit(OpCodes.And)
End If
ilg.Emit(OpCodes.Stloc_2) 'store local channel
For row As Integer = 0 To 3
Dim ccell As Integer = matrix(row * 4 + column)
If ccell <> 0 Then 'skip values of 0
ilg.Emit(OpCodes.Ldloc_2)
ilg.Emit(OpCodes.Conv_I8)
If ccell <> &H10000 Then 'skip multiplication for values of 1
ilg.Emit(OpCodes.Ldc_I8, CLng(ccell))
ilg.Emit(OpCodes.Mul)
Else
ilg.Emit(OpCodes.Ldc_I4_S, CByte(16))
ilg.Emit(OpCodes.Shl)
End If
If initialized(row) Then 'skip addition if the value has not been initialized
ilg.Emit(OpCodes.Add)
Else
initialized(row) = True
End If
used = True
End If
Next
If used Then ilg.Emit(OpCodes.Stloc_S, ci)
Next
Dim elsepart As Label
Dim endifcond As Label
ilg.Emit(OpCodes.Ldloc_0) 'push address for later use
For i As Integer = 0 To 3
endifcond = ilg.DefineLabel()
elsepart = ilg.DefineLabel()
'get, limit and combine values
ilg.Emit(OpCodes.Ldloc_S, CByte(7 - i))
ilg.Emit(OpCodes.Ldc_I4_S, CByte(16))
ilg.Emit(OpCodes.Shr)
ilg.Emit(OpCodes.Conv_I4)
ilg.Emit(OpCodes.Dup)
ilg.Emit(OpCodes.Stloc_2)
'clip 0
'if (value < 0)
ilg.Emit(OpCodes.Ldc_I4_0)
ilg.Emit(OpCodes.Bge, elsepart)
'load 0
'TODO: skip | if i > 0, otherwise push 0
ilg.Emit(OpCodes.Ldc_I4_0)
ilg.Emit(OpCodes.Br, endifcond)
'clip 0xff
ilg.MarkLabel(elsepart)
elsepart = ilg.DefineLabel()
'else if (value > 255)
ilg.Emit(OpCodes.Ldloc_2)
ilg.Emit(OpCodes.Ldc_I4, 255)
ilg.Emit(OpCodes.Blt, elsepart)
'load 0xff
ilg.Emit(OpCodes.Ldc_I4, 255)
ilg.Emit(OpCodes.Br, endifcond)
'else
ilg.MarkLabel(elsepart)
'load value
ilg.Emit(OpCodes.Ldloc_2)
ilg.MarkLabel(endifcond)
If i > 0 Then
ilg.Emit(OpCodes.Ldc_I4_S, CByte(i * 8))
ilg.Emit(OpCodes.Shl)
ilg.Emit(OpCodes.Or)
End If
Next
'store color (address has been pushed before the value evaluation)
ilg.Emit(OpCodes.Stind_I4)
'increment current ptr
ilg.Emit(OpCodes.Ldloc_0)
ilg.Emit(OpCodes.Ldc_I4_4)
ilg.Emit(OpCodes.Add)
ilg.Emit(OpCodes.Stloc_0)
'go to condition
ilg.Emit(OpCodes.Br, cond)
ilg.MarkLabel(bodyEnd)
ilg.Emit(OpCodes.Ret)
Return DirectCast(method.CreateDelegate(GetType(Action(Of Integer(), Integer, Integer))), Action(Of Integer(), Integer, Integer))
End Function
Public Sub Apply(ByVal bitmap As Bitmap)
If bitmap Is Nothing Then Throw New ArgumentNullException("bitmap")
If _handler Is Nothing Then Return
Dim target(bitmap.Width * bitmap.Height - 1) As Integer
Dim targetHandle As GCHandle = GCHandle.Alloc(target, GCHandleType.Pinned)
Dim data As BitmapData = Nothing
Try
data = bitmap.LockBits(New Rectangle(Point.Empty, bitmap.Size), _
ImageLockMode.UserInputBuffer Or ImageLockMode.ReadWrite, _
PixelFormat.Format32bppArgb, _
New BitmapData() With {.Width = bitmap.Width, _
.Height = bitmap.Height, _
.PixelFormat = PixelFormat.Format32bppArgb, _
.Scan0 = targetHandle.AddrOfPinnedObject(), _
.Stride = bitmap.Width * 4})
Apply(target)
Finally
targetHandle.Free()
If data IsNot Nothing Then bitmap.UnlockBits(data)
End Try
End Sub
Public Sub Apply(ByVal target() As Integer)
If target Is Nothing Then Throw New ArgumentNullException("target")
Dim pc As Integer = Environment.ProcessorCount - 1
Dim pid As Integer = target.Length \ pc
System.Threading.Tasks.Parallel.For(0, pc + 1,
Sub(p)
ApplySync(target, pc * p, If(p = pc, target.Length - pc * p, p))
End Sub)
End Sub
Public Sub ApplySync(target() As Integer, startIndex As Integer, count As Integer)
If count < 0 Then Throw New ArgumentException("Non-negative count expected.", "count")
If startIndex < 0 Then Throw New ArgumentException("Non-negative start index expected.", "startIndex")
If startIndex + count > target.Length Then Throw New IndexOutOfRangeException()
If target Is Nothing Then Throw New ArgumentNullException("target")
If _handler IsNot Nothing Then _handler.Invoke(target, startIndex, count)
End Sub
End Class

Gruß
~blaze~

Gather · 12. August 2013, 16:53

Ich werds mir dann mal ansehen

Weg um Colormatrixvorgang zu beschleunigen?

Weg um Colormatrixvorgang zu beschleunigen?

VB.NET-Quellcode

VB.NET-Quellcode

Artentus schrieb:

Artentus schrieb:

Artentus schrieb:

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

Tags

Ähnliche Themen

6 Benutzer haben hier geschrieben