.jpg Datei verkleinern

  • VB.NET

Es gibt 14 Antworten in diesem Thema. Der letzte Beitrag () ist von ThuCommix.

    .jpg Datei verkleinern

    Hi,

    ich komme gerade aus dem Urlaub. :D

    Mit meiner Digicam mache ich .jpg Bilder die ich dann von meinem Laptop per e-Mail verschicke. Allerdings sind diese Bilder sehr groß. Und weil ich im Urlaub meist nur über wifi oder USB-Dongle ans Netz komme, dauert die Übertragung von einem einzigen Bild oft viel zu lang. Deshalb verkleinere ich die Bilder mit "Paint", dann klappt das Versenden besser.

    Könnte ich so etwas per VB realisieren, also ein bestimmtes Bild auf einen frei wählbaren Prozentsatz verkleinern.

    LG
    Peter

    Ja, ob Prozentual oder neue feste Breite oder Höhe.

    VB.NET-Quellcode

    1. Private Function ScaleImageToWidth(img As Bitmap, new_width As Integer) As Bitmap
    2. Dim factor As Double = img.Width / img.Height
    3. Dim nbmp As New Bitmap(new_width, CInt(new_width / factor))
    4. Using g As Graphics = Graphics.FromImage(nbmp)
    5. g.DrawImage(img, 0, 0, nbmp.Width, nbmp.Height)
    6. End Using
    7. Return nbmp
    8. End Function
    10. Private Function ScaleImageToHeight(img As Bitmap, new_height As Integer) As Bitmap
    11. Dim factor As Double = img.Height / img.Width
    12. Dim nbmp As New Bitmap(CInt(new_height / factor), new_height)
    13. Using g As Graphics = Graphics.FromImage(nbmp)
    14. g.DrawImage(img, 0, 0, nbmp.Width, nbmp.Height)
    15. End Using
    16. Return nbmp
    17. End Function
    19. Private Function SizeImagePercent(img As Bitmap, percent As Double) As Bitmap
    20. Dim factor As Double = img.Height / img.Width
    21. Dim new_width As Integer = CInt(img.Width / 100 * percent)
    22. Dim new_height As Integer = CInt(new_width * factor)
    23. Dim nbmp As New Bitmap(new_width, new_height)
    24. Using g As Graphics = Graphics.FromImage(nbmp)
    25. g.DrawImage(img, 0, 0, nbmp.Width, nbmp.Height)
    26. End Using
    27. Return nbmp
    28. End Function

    Recht herzlichen Dank für die Funktionen!

    LG
    Peter

    [edit] Die Antwort kam schneller als ich mein Edit ... danke auch für die nachfolgende Antwort!

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Peter329“ ()

    VB.NET-Quellcode

    1. dim DeinBild as new Bitmap("C:\DEINBILD.jpg")


    Aufrufe :

    VB.NET-Quellcode

    1. Picturebox.Image = SizeImagePercent(DeinBild,50)



    zum abspeichern könntest du es so machen :

    VB.NET-Quellcode

    1. SizeImagePercent(DeinBild,50).save("C:\TOLLESBILD.jpg")
    MFG 0x426c61636b4e6574776f726b426974
    InOffical VB-Paradise IRC-Server
    webchat.freenode.net/
    Channel : ##vbparadise

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „BlackNetworkBit“ ()

    So, die Sache mit dem Einlesen und Speichern klappt soweit.

    VB.NET-Quellcode

    1. Dim img As Bitmap = CType(Image.FromFile(strInPicture), Bitmap)
    2. SizeImagePercent(img, numPercentage.Value).Save(strOutPicture)


    Leider wird die Datei nur für 10 und 20 Prozent kleiner. Danach wird die Datei größer als das Original:

    Original Größe: 1.232 KB

    Verkleinerte Größe:

    10 % : 190 KB
    20 % : 708 KB
    30 %: 1.497 KB

    Ich hab versucht, das Coding nachzuvollziehen. Könnte es sein, dass beim Berechnen etwas schief läuft. Da werden long Zahlen dividiert - ist das ganzzahlig, d.h. werden da Nachkomma Stellen abgeschnitten ... ?

    LG
    Peter

    Lese dir dies mal durch:

    msdn.microsoft.com/de-de/library/bb882583%28v=vs.110%29.aspx

    damit könntest du vieleicht ein paar Bytes sparen.

    Edit: Die Doubles hab ich nur verwendet um eine möglichst massstabsgetreue Scallierung zu machen, würde mann dort eine Integer verwenden wäre dies nicht möglich. Klar werden die gerundet/abgeschnitten beim erzeugen der neuen Bitmap, da eine Bitmap als Argumente nur Ganzzahlen zulässt.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Derfuhr“ ()

    Peter329 schrieb:


    Leider wird die Datei nur für 10 und 20 Prozent kleiner. Danach wird die Datei größer als das Original..

    Hallo Peter,

    ich habe ein bisschen für Dich gespielt :) ..
    Hier hast Du eine Version, die genau das tut was Du willst (musst alles nur auf Deine Bedürfnisse anpassen):

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Drawing.Drawing2D
    2. Imports System.Drawing.Imaging
    4. Public Class Form1
    6. ''' <summary>
    7. ''' Push the button ;)
    8. ''' </summary>
    9. ''' <param name="sender"></param>
    10. ''' <param name="e"></param>
    11. ''' <remarks></remarks>
    12. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    13. ' Dein Ursprungsbild
    14. Dim DeinBild As New Bitmap("D:\test.jpg")
    16. ' verkleinerte, interpolierte und komprimierte Versionen
    17. JPEGCompression(PicResizeByPercent(DeinBild, 10), "D:\10.jpg", 75)
    18. JPEGCompression(PicResizeByPercent(DeinBild, 20), "D:\20.jpg", 75)
    19. JPEGCompression(PicResizeByPercent(DeinBild, 30), "D:\30.jpg", 75)
    20. JPEGCompression(PicResizeByPercent(DeinBild, 40), "D:\40.jpg", 75)
    21. JPEGCompression(PicResizeByPercent(DeinBild, 50), "D:\50.jpg", 75)
    22. JPEGCompression(PicResizeByPercent(DeinBild, 60), "D:\60.jpg", 75)
    23. JPEGCompression(PicResizeByPercent(DeinBild, 70), "D:\70.jpg", 75)
    24. JPEGCompression(PicResizeByPercent(DeinBild, 80), "D:\80.jpg", 75)
    25. JPEGCompression(PicResizeByPercent(DeinBild, 90), "D:\90.jpg", 75)
    26. End Sub
    29. ''' <summary>
    30. ''' Diese Funktion ändert die Größe eines Bilds und gibt es als Bitmap zurück. Hier ist die Prozentuale größe veränderbar.
    31. ''' </summary>
    32. ''' <remarks>
    33. ''' Autor: Tim Hartwick http://dotnet-snippets.de/snippet/bildgroesse-prozentual-veraendern-interpoliert/338
    34. ''' </remarks>
    35. ''' <param name="SourceImage">Das Bild dessen größe verändert werden soll</param>
    36. ''' <param name="Percent">Die neue größe des Bilds in Prozent (100% = Normale größe)</param>
    37. Public Function PicResizeByPercent(ByVal SourceImage As Image, ByVal Percent As Short) As Bitmap
    38. Dim NewWidth As Integer = ((Percent / 100) * SourceImage.Width)
    39. Dim NewHeigth As Integer = ((Percent / 100) * SourceImage.Height)
    40. Dim NewImage As New Bitmap(NewWidth, NewHeigth)
    41. Using G As Graphics = Graphics.FromImage(NewImage)
    42. G.InterpolationMode = InterpolationMode.HighQualityBicubic
    43. G.DrawImage(SourceImage, New Rectangle(0, 0, NewWidth, NewHeigth))
    44. End Using
    45. Return NewImage
    46. End Function
    48. ''' <summary>
    49. ''' Diese Funktion Komprimiert ein JPEG Bild und speichert dieses als neues Bild ab
    50. ''' </summary>
    51. ''' <remarks>
    52. ''' Autor: Tim Hartwick http://dotnet-snippets.de/snippet/jpeg-bild-komprimieren/167
    53. ''' </remarks>
    54. ''' <param name="Image">Das Bild welches komprimiert werden soll</param>
    55. ''' <param name="OutPutFile">Der Pfad des neuen komprimierten Bilds</param>
    56. ''' <param name="Qualitiy">Die Qualitätseinstellung 0-100</param>
    57. Public Sub JPEGCompression(ByVal Image As Image, ByVal OutPutFile As String, ByVal Qualitiy As Integer)
    58. Dim ImageCodecs() As ImageCodecInfo
    59. Dim ImageParameters As EncoderParameters
    61. ImageCodecs = ImageCodecInfo.GetImageEncoders()
    62. ImageParameters = New EncoderParameters(1)
    63. ImageParameters.Param(0) = New EncoderParameter(System.Drawing.Imaging.Encoder.Quality, Qualitiy)
    64. Image.Save(OutPutFile, ImageCodecs(1), ImageParameters)
    65. End Sub
    67. End Class


    Verkleinert wird bikubisch interpoliert und gespeichert wird komprimiert (änderbar).
    Quellenangaben der Methoden sind im Header.

    LG,
    Bruno

    Hallo Peter,

    und weils einfach besser aussieht, hier noch die Version, wo die Bilder noch ein bisschen geschärft werden (einstellbar).
    Und nun auch Strict ON 8-) ..

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    3. Imports System.Drawing.Drawing2D
    4. Imports System.Drawing.Imaging
    5. Imports System.Runtime.InteropServices
    7. Public Class Form1
    9. ''' <summary>
    10. ''' Push the button ;)
    11. ''' </summary>
    12. ''' <param name="sender"></param>
    13. ''' <param name="e"></param>
    14. ''' <remarks></remarks>
    15. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    16. ' Dein Ursprungsbild
    17. Dim DeinBild As New Bitmap("D:\test.jpg")
    19. ' verkleinerte, interpolierte, geschärfte und komprimierte Versionen
    20. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 10), 0.3), "D:\10.jpg", 75)
    21. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 20), 0.3), "D:\20.jpg", 75)
    22. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 30), 0.3), "D:\30.jpg", 75)
    23. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 40), 0.3), "D:\40.jpg", 75)
    24. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 50), 0.3), "D:\50.jpg", 75)
    25. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 60), 0.3), "D:\60.jpg", 75)
    26. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 70), 0.3), "D:\70.jpg", 75)
    27. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 80), 0.3), "D:\80.jpg", 75)
    28. JPEGCompression(Sharpen(PicResizeByPercent(DeinBild, 90), 0.3), "D:\90.jpg", 75)
    29. End Sub
    32. ''' <summary>
    33. ''' Diese Funktion ändert die Größe eines Bilds und gibt es als Bitmap zurück. Hier ist die Prozentuale größe veränderbar.
    34. ''' </summary>
    35. ''' <remarks>
    36. ''' Autor: Tim Hartwick http://dotnet-snippets.de/snippet/bildgroesse-prozentual-veraendern-interpoliert/338
    37. ''' </remarks>
    38. ''' <param name="SourceImage">Das Bild dessen größe verändert werden soll</param>
    39. ''' <param name="Percent">Die neue größe des Bilds in Prozent (100% = Normale größe)</param>
    40. Private Function PicResizeByPercent(ByVal SourceImage As Image, ByVal Percent As Short) As Bitmap
    41. Dim NewWidth As Integer = CInt(((Percent / 100) * SourceImage.Width))
    42. Dim NewHeigth As Integer = CInt(((Percent / 100) * SourceImage.Height))
    43. Dim NewImage As New Bitmap(NewWidth, NewHeigth)
    44. Using G As Graphics = Graphics.FromImage(NewImage)
    45. G.InterpolationMode = InterpolationMode.HighQualityBicubic
    46. G.DrawImage(SourceImage, New Rectangle(0, 0, NewWidth, NewHeigth))
    47. End Using
    48. Return NewImage
    49. End Function
    51. ''' <summary>
    52. ''' Diese Funktion Komprimiert ein JPEG Bild und speichert dieses als neues Bild ab
    53. ''' </summary>
    54. ''' <remarks>
    55. ''' Autor: Tim Hartwick http://dotnet-snippets.de/snippet/jpeg-bild-komprimieren/167
    56. ''' </remarks>
    57. ''' <param name="Image">Das Bild welches komprimiert werden soll</param>
    58. ''' <param name="OutPutFile">Der Pfad des neuen komprimierten Bilds</param>
    59. ''' <param name="Qualitiy">Die Qualitätseinstellung 0-100</param>
    60. Private Sub JPEGCompression(ByVal Image As Image, ByVal OutPutFile As String, ByVal Qualitiy As Integer)
    61. Dim ImageCodecs() As ImageCodecInfo
    62. Dim ImageParameters As EncoderParameters
    64. ImageCodecs = ImageCodecInfo.GetImageEncoders()
    65. ImageParameters = New EncoderParameters(1)
    66. ImageParameters.Param(0) = New EncoderParameter(System.Drawing.Imaging.Encoder.Quality, Qualitiy)
    67. Image.Save(OutPutFile, ImageCodecs(1), ImageParameters)
    68. End Sub
    70. ''' <summary>
    71. ''' Bild schärfen
    72. ''' </summary>
    73. ''' <param name="SourceImage"></param>
    74. ''' <param name="SharpenFac"></param>
    75. ''' <returns></returns>
    76. ''' <remarks></remarks>
    77. Private Function Sharpen(ByVal SourceImage As Bitmap, ByVal SharpenFac As Double) As Bitmap
    78. Using OrgBmp As New Bitmap(SourceImage)
    79. Dim Stride As Integer = OrgBmp.Width * 4
    80. Dim BmpData As Byte() = New Byte((OrgBmp.Height * Stride) - 1) {}
    81. Dim OrgBmbData As BitmapData = Nothing
    83. OrgBmbData = OrgBmp.LockBits(New Rectangle(0, 0, OrgBmp.Width, OrgBmp.Height), ImageLockMode.ReadOnly, OrgBmp.PixelFormat)
    85. Marshal.Copy(OrgBmbData.Scan0, BmpData, 0, BmpData.Length)
    86. OrgBmp.UnlockBits(OrgBmbData)
    88. Dim Bmp32Pos As New Integer
    89. Dim Red As New Double
    90. Dim Green As New Double
    91. Dim Blue As New Double
    93. For Y As Integer = 0 To OrgBmp.Height - 1
    94. For X As Integer = 0 To OrgBmp.Width - 1
    96. Bmp32Pos = (Y * Stride) + (X * 4)
    98. Red = BmpData(Bmp32Pos + 2)
    99. Green = BmpData(Bmp32Pos + 1)
    100. Blue = BmpData(Bmp32Pos + 0)
    102. If Y - 1 >= 0 Then
    103. If X - 1 >= 0 Then
    104. Bmp32Pos = ((Y - 1) * Stride) + ((X - 1) * 4)
    106. Red = Math.Abs(Red + (SharpenFac * (Red - BmpData(Bmp32Pos + 2))))
    107. Green = Math.Abs(Green + (SharpenFac * (Green - BmpData(Bmp32Pos + 1))))
    108. Blue = Math.Abs(Blue + (SharpenFac * (Blue - BmpData(Bmp32Pos + 0))))
    110. If Red > 255 Then Red = 255
    111. If Green > 255 Then Green = 255
    112. If Blue > 255 Then Blue = 255
    113. End If
    114. End If
    116. Bmp32Pos = (Y * Stride) + (X * 4)
    118. BmpData(Bmp32Pos + 2) = CByte(Red)
    119. BmpData(Bmp32Pos + 1) = CByte(Green)
    120. BmpData(Bmp32Pos + 0) = CByte(Blue)
    121. Next
    122. Next
    124. OrgBmbData = OrgBmp.LockBits(New Rectangle(0, 0, OrgBmp.Width, OrgBmp.Height), ImageLockMode.WriteOnly, OrgBmp.PixelFormat)
    126. Marshal.Copy(BmpData, 0, OrgBmbData.Scan0, BmpData.Length)
    128. OrgBmp.UnlockBits(OrgBmbData)
    129. OrgBmbData = Nothing
    131. Return New Bitmap(OrgBmp)
    132. End Using
    133. End Function
    135. End Class


    LG,
    Bruno

    Ich würde das Coding gern ausprobieren.

    Leider gibt es (neben einigen "strict on" Meldungen) einen Fehler, den ich nicht beheben kann:

    VB.NET-Quellcode

    1. G.InterpolationMode = InterpolationMode.HighQualityBicubic


    Fehler 1 "InterpolationMode" wurde nicht deklariert. Auf das Objekt kann aufgrund seiner Schutzstufe möglicherweise nicht zugegriffen werden.

    Da fehlt wohl irgend ein Import ...

    LG
    Peter

    [edit] Da hast du mich "überholt" ... ich schau in die neue Version gleich mal rein! :D

    Das mit den Imports hat sich geklärt. Ist alles richtig!

    Deine Routine klappt hervorragen! Die Compression ist jetzt super!

    Recht herzlichen Dank für deine Hilfe. Im nächsten Urlaub hab ich jetzt sehr viel weniger Arbeit! :D

    LG
    Peter

    Neee, Effekte brauch ich nicht. :D

    Also, ich hab die Routinen jetzt auf Herz und Nieren getestet.

    Die "PicResize" Routine passt die Bildgröße an, aber dabei wird die Dateigröße ggfs. massiv aufgebläht.

    Die "Sharpen" Routine wirkt sehr gut und entfernt die "Ecken", die beim Verkleinern entstehen.

    Die "JPGCompression" Routine ist einfach super! Die verkleinert das Datenvolumen drastisch! Auch ohne "Resize" wird die Datei entschieden kleiner, selbst wenn man die Bildgröße überhaupt nicht verändert! Vermutlich wird da jede Menge an Ballast aus der JPG Darstellung entfernt. Ein Beispiel: Bei einer Verkleinerung auf 30% schrumpft eine Datei von 1.2 MB auf gerade mal 94 KB ohne nennenswerte Einbußen an der Qualität. Da kann man nicht meckern. :D

    Ich bin begeistert! Das sind genau die Routinen, die ich gesucht habe.

    Also, recht herzlichen Dank noch einmal an "dylab" und natürlich auch an alle anderen Ratgeber!

    Have a great New Year 2014 everybody!
    LG
    Peter

Facebook
Telefonspende