Jakość zapisanego pliku JPG w języku C#

Question

Zrobiłem małą aplikację C#, aby utworzyć obraz w formacie .jpg.

pictureBox.Image.Save(name,ImageFormat.Jpeg); 

Obraz został pomyślnie utworzony. Wpisuję oryginalne zdjęcie, robię z nim pewne rzeczy i zapisuję je. Jakość tego nowego zdjęcia jest jednak niższa niż w oryginale.

Czy istnieje sposób na ustawienie żądanej jakości?

Answer 1

Poniższy przykład kodu pokazuje, jak utworzyć EncoderParameter za pomocą konstruktora EncoderParameter. Aby uruchomić ten przykład, wklej kod i wywołaj metodę VaryQualityLevel.

Ten przykład wymaga pliku obrazu o nazwie TestPhoto.jpg, który znajduje się pod adresem c :.

private void VaryQualityLevel() 
{ 
    // Get a bitmap. 
    Bitmap bmp1 = new Bitmap(@"c:\TestPhoto.jpg"); 
    ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg); 

    // Create an Encoder object based on the GUID 
    // for the Quality parameter category. 
    System.Drawing.Imaging.Encoder myEncoder = 
     System.Drawing.Imaging.Encoder.Quality; 

    // Create an EncoderParameters object. 
    // An EncoderParameters object has an array of EncoderParameter 
    // objects. In this case, there is only one 
    // EncoderParameter object in the array. 
    EncoderParameters myEncoderParameters = new EncoderParameters(1); 

    EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 
     50L); 
    myEncoderParameters.Param[0] = myEncoderParameter; 
    bmp1.Save(@"c:\TestPhotoQualityFifty.jpg", jgpEncoder, 
     myEncoderParameters); 

    myEncoderParameter = new EncoderParameter(myEncoder, 100L); 
    myEncoderParameters.Param[0] = myEncoderParameter; 
    bmp1.Save(@"c:\TestPhotoQualityHundred.jpg", jgpEncoder, 
     myEncoderParameters); 

    // Save the bitmap as a JPG file with zero quality level compression. 
    myEncoderParameter = new EncoderParameter(myEncoder, 0L); 
    myEncoderParameters.Param[0] = myEncoderParameter; 
    bmp1.Save(@"c:\TestPhotoQualityZero.jpg", jgpEncoder, 
     myEncoderParameters); 

} 

private ImageCodecInfo GetEncoder(ImageFormat format) 
{ 
    ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders(); 
    foreach (ImageCodecInfo codec in codecs) 
    { 
     if (codec.FormatID == format.Guid) 
     { 
      return codec; 
     } 
    } 
    return null; 
} 

Ref: http://msdn.microsoft.com/en-us/library/system.drawing.imaging.encoderparameter.aspx

Answer 2

Wyjazd artykuł MSDN w sprawie how to set JPEG Compression level.

Należy użyć innego przeciążenia Save(), które pobiera ImageEncoder i jego parametry.

Answer 3

To jest stary wątek, ale przepisałem Microsoft (jak na odpowiedź Dustina Getza), aby było trochę bardziej przydatne - zmniejszanie GetEncoderInfo i tworzenie rozszerzenia na Obrazie. Zresztą nic nowego, ale może się przydać:

/// <summary> 
    /// Retrieves the Encoder Information for a given MimeType 
    /// </summary> 
    /// <param name="mimeType">String: Mimetype</param> 
    /// <returns>ImageCodecInfo: Mime info or null if not found</returns> 
    private static ImageCodecInfo GetEncoderInfo(String mimeType) 
    { 
     var encoders = ImageCodecInfo.GetImageEncoders(); 
     return encoders.FirstOrDefault(t => t.MimeType == mimeType); 
    } 

    /// <summary> 
    /// Save an Image as a JPeg with a given compression 
    /// Note: Filename suffix will not affect mime type which will be Jpeg. 
    /// </summary> 
    /// <param name="image">Image: Image to save</param> 
    /// <param name="fileName">String: File name to save the image as. Note: suffix will not affect mime type which will be Jpeg.</param> 
    /// <param name="compression">Long: Value between 0 and 100.</param> 
    private static void SaveJpegWithCompressionSetting(Image image, string fileName, long compression) 
    { 
     var eps = new EncoderParameters(1); 
     eps.Param[0] = new EncoderParameter(Encoder.Quality, compression); 
     var ici = GetEncoderInfo("image/jpeg"); 
     image.Save(fileName, ici, eps); 
    } 

    /// <summary> 
    /// Save an Image as a JPeg with a given compression 
    /// Note: Filename suffix will not affect mime type which will be Jpeg. 
    /// </summary> 
    /// <param name="image">Image: This image</param> 
    /// <param name="fileName">String: File name to save the image as. Note: suffix will not affect mime type which will be Jpeg.</param> 
    /// <param name="compression">Long: Value between 0 and 100.</param> 
    public static void SaveJpegWithCompression(this Image image, string fileName, long compression) 
    { 
     SaveJpegWithCompressionSetting(image, fileName, compression); 
    } 

Answer 4

Jeśli używasz .NET Compact Framework, alternatywą może być użycie IE bezstratny format PNG:

image.Save(filename, ImageFormat.Png); 

Answer 5

Oto nawet bardziej zwarty fragment kodu do zapisywania jako JPEG o określonej jakości:

var encoder = ImageCodecInfo.GetImageEncoders().First(c => c.FormatID == ImageFormat.Jpeg.Guid); 
var encParams = new EncoderParameters() { Param = new[] { new EncoderParameter(Encoder.Quality, 90L) } }; 
image.Save(path, encoder, encParams); 

lub, jeśli 120 znaków szerokie linie są zbyt długie dla ciebie:

var encoder = ImageCodecInfo.GetImageEncoders() 
          .First(c => c.FormatID == ImageFormat.Jpeg.Guid); 
var encParams = new EncoderParameters(1); 
encParams.Param[0] = new EncoderParameter(Encoder.Quality, 90L); 
image.Save(path, encoder, encParams); 

Upewnij się, że jakość jest long lub dostaniesz ArgumentException!

Answer 6

Korzystanie z atrybutów bez nazwy GDI + (https://msdn.microsoft.com/en-us/library/windows/desktop/ms533845(v=vs.85).aspx) do ustawiania jakości JPEG wygląda na przesadę.

bezpośredni sposób powinien wyglądać następująco:

FileStream stream = new FileStream("new.jpg", FileMode.Create); 
JpegBitmapEncoder encoder = new JpegBitmapEncoder(); 
encoder.QualityLevel = 100; // "100" for maximum quality (largest file size). 
encoder.Frames.Add(BitmapFrame.Create(image)); 
encoder.Save(stream); 

Ref: https://msdn.microsoft.com/en-us/library/system.windows.media.imaging.jpegbitmapencoder.rotation(v=vs.110).aspx#Anchor_2

Answer 7

Odpowiedź wiki społeczność, która jest akceptowana, referrs na przykład firmy Microsoft.

Jednakże, w celu zaoszczędzenia czasu niektórzy z was, ja gotuje je w dół do istoty i

• pakiety go do właściwej metody
• Wdrożone IDisposable. Nie widziałem using (...) { w żadnej innej odpowiedzi.Aby uniknąć wycieku pamięci, najlepszą praktyką jest pozbycie się wszystkiego, co implementuje IDisposable.

---

public static void SaveJpeg(string path, Bitmap image) 
{ 
    SaveJpeg(path, image, 95L); 
} 
public static void SaveJpeg(string path, Bitmap image, long quality) 
{ 
    using (EncoderParameters encoderParameters = new EncoderParameters(1)) 
    using (EncoderParameter encoderParameter = new EncoderParameter(Encoder.Quality, quality)) 
    { 
     ImageCodecInfo codecInfo = ImageCodecInfo.GetImageDecoders().First(codec => codec.FormatID == ImageFormat.Jpeg.Guid); 
     encoderParameters.Param[0] = encoderParameter; 
     image.Save(path, codecInfo, encoderParameters); 
    } 
}