C # में बिटमैप ऑब्जेक्ट का उपयोग करके छवि प्रारूप प्राप्त करें

83

मैं छवि फ़ाइल हार्ड ड्राइव के बाइनरी बाइट्स को लोड कर रहा हूं और इसे बिटमैप ऑब्जेक्ट में लोड कर रहा हूं। मैं बिटमैप ऑब्जेक्ट से छवि प्रकार [जेपीईजी, पीएनजी, बीएमपी आदि] कैसे खोज सकता हूं?

तुच्छ दिखता है। लेकिन, यह पता नहीं लगा सका!

क्या कोई वैकल्पिक तरीका है?

आपकी प्रतिक्रिया की सराहना करते हैं।

अद्यतन सुधार समाधान:

@ सीएमएस: सही प्रतिक्रिया के लिए धन्यवाद!

इसे प्राप्त करने के लिए नमूना कोड।

using (MemoryStream imageMemStream = new MemoryStream(fileData))
{
    using (Bitmap bitmap = new Bitmap(imageMemStream))
    {
        ImageFormat imageFormat = bitmap.RawFormat;
        if (bitmap.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg))
            //It's a JPEG;
        else if (bitmap.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Png))
            //It's a PNG;
    }
}
c#  .net  image 
— pencilslate
स्रोत
3
आप System.Drawing.Imagingअपने निर्देशों का उपयोग करके नाम स्थान को जोड़ सकते हैं , प्रारूप जांच को कम करने के लिए
— क्रिया
@CMS: सहमत! अतिरिक्त जानकारी के लिए पूरा नाम स्थान प्रदर्शित करना चाहते थे।
— पेंसिल
2
हम्म् ... मैंने एक ही तकनीक की कोशिश की, लेकिन यह काम नहीं करता है। मेरे पास एक PNG भरी हुई है और जब मैं इसके रॉफॉर्मैट मूल्य की तुलना सभी ImageFormat से करता हूं। * उदाहरण, उनमें से कोई भी मैच नहीं करता है। वास्तविक रॉफ़ॉर्मैट मान {b96b3caf-0728-11d3-9d7b-0000f81ef32e} है।
— इगोर ब्रेजक

जवाबों:

105

यदि आप किसी छवि का प्रारूप जानना चाहते हैं, तो आप फ़ाइल को छवि वर्ग के साथ लोड कर सकते हैं , और इसकी RawFormat संपत्ति की जांच कर सकते हैं:

using(Image img = Image.FromFile(@"C:\path\to\img.jpg"))
{
    if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg))
    {
      // ...
    }
}
— क्रिश्चियन सी। साल्वादो
स्रोत
29
नोट: ऐसा प्रतीत होता है कि img.RawFormat == ImageFormat.Jpegकाम नहीं करता है। आप राशि का उपयोग करने के img.RawFormat.Equals(ImageFormat.Jpeg)।
— ब्लूराजा - डैनी पफ्लुगुएफ्ट
1
@BlueRaja, हाँ, ऐसा क्यों है? अधिकांश .NET कक्षाएं समान () विधि और ऑपरेटर दोनों को ओवरराइड नहीं करती हैं? या, शायद मैं इसे गलत बता रहा हूँ - .NET का उपयोग नहीं करता है। == ऑपरेटर का उपयोग करते समय डिफ़ॉल्ट रूप से () विधि का उपयोग करता है? क्या मैं गलत हूँ?
— पंडिंकस
गाह! कोई आश्चर्य नहीं कि काम नहीं कर रहा था। मैंने मान लिया == चाल चली। अरे नहीं! धन्यवाद दोस्तों, मुझे अभी समय का एक गुच्छा बचाया।
— सर्वव्यापी चे
1
जब तक यह ओवरराइड नहीं होता है या कुछ अंतर्निहित प्रकारों में से एक होता है, ==संदर्भ समानता का उपयोग करता है, न कि Equals। Equalsस्वयं का उपयोग करने के अलावा , आप साधारण नल सुरक्षा के लिए स्थैतिक object.Equals(obj1, obj2)(जो कॉल करते हैं Equals) का उपयोग कर सकते हैं ।
— टिम एस।
57

यहाँ मेरी विस्तार विधि है। आशा है कि यह किसी की मदद करेंगे।

public static System.Drawing.Imaging.ImageFormat GetImageFormat(this System.Drawing.Image img)
    {             
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg))
            return System.Drawing.Imaging.ImageFormat.Jpeg;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Bmp))
            return System.Drawing.Imaging.ImageFormat.Bmp;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Png))
            return System.Drawing.Imaging.ImageFormat.Png;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Emf))
            return System.Drawing.Imaging.ImageFormat.Emf;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Exif))
            return System.Drawing.Imaging.ImageFormat.Exif;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Gif))
            return System.Drawing.Imaging.ImageFormat.Gif;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Icon))
            return System.Drawing.Imaging.ImageFormat.Icon;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.MemoryBmp))
            return System.Drawing.Imaging.ImageFormat.MemoryBmp;
        if (img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Tiff))
            return System.Drawing.Imaging.ImageFormat.Tiff;
        else
            return System.Drawing.Imaging.ImageFormat.Wmf;            
    }
— sebacipo
स्रोत
9
मुझे विश्वास नहीं हो रहा है कि .NET फ्रेमवर्क में यह बेक नहीं है और यह एकमात्र तरीका है। मैं वास्तव में सदमे में हूं।
— simonlchilds
18

इसके लिए यहां मेरा कोड है। आपको पहले पूर्ण छवि या हेडर (पहले 4 बाइट्स) को बाइट सरणी में लोड करना होगा।

public enum ImageFormat
{
    Bmp,
    Jpeg,
    Gif,
    Tiff,
    Png,
    Unknown
}

public static ImageFormat GetImageFormat(byte[] bytes)
{
    // see http://www.mikekunz.com/image_file_header.html  
    var bmp    = Encoding.ASCII.GetBytes("BM");     // BMP
    var gif    = Encoding.ASCII.GetBytes("GIF");    // GIF
    var png    = new byte[] { 137, 80, 78, 71 };    // PNG
    var tiff   = new byte[] { 73, 73, 42 };         // TIFF
    var tiff2  = new byte[] { 77, 77, 42 };         // TIFF
    var jpeg   = new byte[] { 255, 216, 255, 224 }; // jpeg
    var jpeg2  = new byte[] { 255, 216, 255, 225 }; // jpeg canon

    if (bmp.SequenceEqual(bytes.Take(bmp.Length)))
        return ImageFormat.Bmp;

    if (gif.SequenceEqual(bytes.Take(gif.Length)))
        return ImageFormat.Gif;

    if (png.SequenceEqual(bytes.Take(png.Length)))
        return ImageFormat.Png;

    if (tiff.SequenceEqual(bytes.Take(tiff.Length)))
        return ImageFormat.Tiff;

    if (tiff2.SequenceEqual(bytes.Take(tiff2.Length)))
        return ImageFormat.Tiff;

    if (jpeg.SequenceEqual(bytes.Take(jpeg.Length)))
        return ImageFormat.Jpeg;

    if (jpeg2.SequenceEqual(bytes.Take(jpeg2.Length)))
        return ImageFormat.Jpeg;

    return ImageFormat.Unknown;
}
— एलेक्स
स्रोत
1
JPEG को {255, 216, 255} के लिए चेक करना होगा। यहाँ जानकारी है en.wikipedia.org/wiki/JPEG
— Mirodil
9

बेशक आप कर सकते हैं। ImageFormatज्यादा मतलब नहीं है। ImageCodecInfoबहुत अधिक अर्थ है।

red_dot.png

red_dot.png

<a href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==">
    <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" alt="red_dot.png" title="red_dot.png"/>
</a>

कोड:

using System.Linq;

//...

//get image
var file_bytes = System.Convert.FromBase64String(@"iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==");
var file_stream = new System.IO.MemoryStream(file_bytes);
var file_image = System.Drawing.Image.FromStream(file_stream);

//list image formats
var image_formats = typeof(System.Drawing.Imaging.ImageFormat).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static).ToList().ConvertAll(property => property.GetValue(null, null));
System.Diagnostics.Debug.WriteLine(image_formats.Count, "image_formats");
foreach(var image_format in image_formats) {
    System.Diagnostics.Debug.WriteLine(image_format, "image_formats");
}

//get image format
var file_image_format = typeof(System.Drawing.Imaging.ImageFormat).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static).ToList().ConvertAll(property => property.GetValue(null, null)).Single(image_format => image_format.Equals(file_image.RawFormat));
System.Diagnostics.Debug.WriteLine(file_image_format, "file_image_format");

//list image codecs
var image_codecs = System.Drawing.Imaging.ImageCodecInfo.GetImageDecoders().ToList();
System.Diagnostics.Debug.WriteLine(image_codecs.Count, "image_codecs");
foreach(var image_codec in image_codecs) {
    System.Diagnostics.Debug.WriteLine(image_codec.CodecName + ", mime: " + image_codec.MimeType + ", extension: " + @image_codec.FilenameExtension, "image_codecs");
}

//get image codec
var file_image_format_codec = System.Drawing.Imaging.ImageCodecInfo.GetImageDecoders().ToList().Single(image_codec => image_codec.FormatID == file_image.RawFormat.Guid);
System.Diagnostics.Debug.WriteLine(file_image_format_codec.CodecName + ", mime: " + file_image_format_codec.MimeType + ", extension: " + file_image_format_codec.FilenameExtension, "image_codecs", "file_image_format_type");

डिबग आउटपुट:

image_formats: 10
image_formats: MemoryBMP
image_formats: Bmp
image_formats: Emf
image_formats: Wmf
image_formats: Gif
image_formats: Jpeg
image_formats: Png
image_formats: Tiff
image_formats: Exif
image_formats: Icon
file_image_format: Png
image_codecs: 8
image_codecs: Built-in BMP Codec, mime: image/bmp, extension: *.BMP;*.DIB;*.RLE
image_codecs: Built-in JPEG Codec, mime: image/jpeg, extension: *.JPG;*.JPEG;*.JPE;*.JFIF
image_codecs: Built-in GIF Codec, mime: image/gif, extension: *.GIF
image_codecs: Built-in EMF Codec, mime: image/x-emf, extension: *.EMF
image_codecs: Built-in WMF Codec, mime: image/x-wmf, extension: *.WMF
image_codecs: Built-in TIFF Codec, mime: image/tiff, extension: *.TIF;*.TIFF
image_codecs: Built-in PNG Codec, mime: image/png, extension: *.PNG
image_codecs: Built-in ICO Codec, mime: image/x-icon, extension: *.ICO
Built-in PNG Codec, mime: image/png, extension: *.PNG
— एलेक्स
स्रोत
अलेक्स खोजो! हालाँकि यह गन्दा लगता है, लेकिन मूल बातें नीचे स्वच्छ विस्तार विधियों के एक जोड़े में बदल गई।
— निकोलस पीटर्सन
2

बस आप बोल नहीं सकते। यही कारण है कि बिटमैप उसी प्रकार की छवि है जिस तरह जेपीईजी, पीएनजी, आदि हैं। एक बार जब आप बिटमैप में एक छवि को लोड करते हैं तो बिटमैप प्रारूप की छवि। बिटमैप को देखने और छवि के मूल एन्कोडिंग को समझने का कोई तरीका नहीं है (यदि यह बिटमैप से भिन्न भी है)।

— JaredPar
स्रोत
1
मुझे लगता है कि यह मामला बिटमैप (भ्रामक) C # में एक वर्ग का नाम है। बिटमैप क्लास में एक छवि होती है, जो संभवतः jpg, giff, bmp इत्यादि किसी भी अन्य परिस्थिति में हो सकती है हाँ आप बिल्कुल सही हैं।
— डार्सीटॉमस
2

पुराने विषय पर परेशान करने के लिए नहीं, लेकिन इस चर्चा को पूरा करने के लिए, मैं विंडोज़ द्वारा ज्ञात सभी छवि प्रारूपों को क्वेरी करने के लिए अपना रास्ता साझा करना चाहता हूं ।

using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;

public static class ImageExtentions
{
    public static ImageCodecInfo GetCodecInfo(this System.Drawing.Image img)
    {
        ImageCodecInfo[] decoders = ImageCodecInfo.GetImageDecoders();
        foreach (ImageCodecInfo decoder in decoders)
            if (img.RawFormat.Guid == decoder.FormatID)
                return decoder;
        return null;
    }
}

अब आप इसे एक छवि विस्तार के रूप में उपयोग कर सकते हैं जैसा कि नीचे दिखाया गया है:

public void Test(Image img)
{
    ImageCodecInfo info = img.GetCodecInfo();
    if (info == null)
        Trace.TraceError("Image format is unkown");
    else
        Trace.TraceInformation("Image format is " + info.FormatDescription);
}
— एजेंट सी.के.
स्रोत
1

ऊपर एलेक्स के काम के आधार पर (जो मैं वास्तव में समाधान के रूप में वोट करता हूं, क्योंकि यह एक पंक्ति है - लेकिन मैं अभी तक वोट नहीं दे सकता हाहा), मैं एक छवि पुस्तकालय के लिए निम्नलिखित फ़ंक्शन के साथ आया था। इसके लिए 4.0 की आवश्यकता है

  Public Enum Formats
    Unknown
    Bmp
    Emf
    Wmf
    Gif
    Jpeg
    Png
    Tiff
    Icon
  End Enum

  Public Shared Function ImageFormat(ByVal Image As System.Drawing.Image) As Formats
    If Not System.Enum.TryParse(Of Formats)(System.Drawing.Imaging.ImageCodecInfo.GetImageDecoders().ToList().[Single](Function(ImageCodecInfo) ImageCodecInfo.FormatID = Image.RawFormat.Guid).FormatDescription, True, ImageFormat) Then
      Return Formats.Unknown
    End If
  End Function
— toddmo
स्रोत
0

Imageएलेक्स के ऊपर ( ImageCodecInfo.GetImageDecoders()) के आधार पर, इसे निर्धारित करने के लिए टाइप पर साफ विस्तार विधियों का एक जोड़ा ।

यह पहली कॉल के बाद अत्यधिक अनुकूलित है, क्योंकि स्टैटिक इमेजकोडेसडर मेमोरी में सेव किया गया है (लेकिन केवल एक बार उपयोग करने के बाद ही)।

public static class ImageCodecInfoX
{

    private static Dictionary<Guid, ImageCodecInfoFull> _imageCodecsDictionary;

    public static Dictionary<Guid, ImageCodecInfoFull> ImageCodecsDictionary 
    {
        get
        {
            if (_imageCodecsDictionary == null) {
                _imageCodecsDictionary =
                    ImageCodecInfo.GetImageDecoders()
                    .Select(i => {
                        var format = ImageFormats.Unknown;
                        switch (i.FormatDescription.ToLower()) {
                            case "jpeg": format = ImageFormats.Jpeg; break;
                            case "png": format = ImageFormats.Png; break;
                            case "icon": format = ImageFormats.Icon; break;
                            case "gif": format = ImageFormats.Gif; break;
                            case "bmp": format = ImageFormats.Bmp; break;
                            case "tiff": format = ImageFormats.Tiff; break;
                            case "emf": format = ImageFormats.Emf; break;
                            case "wmf": format = ImageFormats.Wmf; break;
                        }
                        return new ImageCodecInfoFull(i) { Format = format };
                    })
                    .ToDictionary(c => c.CodecInfo.FormatID);
            }
            return _imageCodecsDictionary;
        }
    }

    public static ImageCodecInfoFull CodecInfo(this Image image)
    {
        ImageCodecInfoFull codecInfo = null;

        if (!ImageCodecsDictionary.TryGetValue(image.RawFormat.Guid, out codecInfo))
            return null;
        return codecInfo;
    }

    public static ImageFormats Format(this Image image)
    {
        var codec = image.CodecInfo();
        return codec == null ? ImageFormats.Unknown : codec.Format;
    }
}

public enum ImageFormats { Jpeg, Png, Icon, Gif, Bmp, Emf, Wmf, Tiff, Unknown }

/// <summary>
/// Couples ImageCodecInfo with an ImageFormats type.
/// </summary>
public class ImageCodecInfoFull
{
    public ImageCodecInfoFull(ImageCodecInfo codecInfo = null)
    {
        Format = ImageFormats.Unknown;
        CodecInfo = codecInfo;
    }

    public ImageCodecInfo CodecInfo { get; set; }

    public ImageFormats Format { get; set; }

}
— निकोलस पीटरसन
स्रोत
0

एक अजीब समस्या का सामना करना पड़ा जब मैं छवि प्रकार का उपयोग कर माइम प्राप्त करने की कोशिश कर रहा था .. कुछ png फ़ाइलों के लिए guids बिल्कुल समान नहीं थे ...

पहले मैं ImageCodecinfo के साथ जांच कर रहा था और अगर कोड को इमेजफॉर्म नहीं मिलता है तो मैंने मैथियसियस वुटके के समाधान का उपयोग करके छविरूप की तुलना की।

यदि उपर्युक्त दोनों उपाय विफल हो गए तो फ़ाइल माइम प्रकार पाने के लिए विस्तार विधि का उपयोग किया।

यदि माइम प्रकार बदलता है तो फ़ाइल भी बदल जाती है, हम डाउनलोड की गई फ़ाइलों की गणना कर रहे थे सर्वर पर मूल फ़ाइल के चेकसम के साथ मिलान करने के लिए .. तो हमारे लिए आउटपुट के रूप में उचित फ़ाइल प्राप्त करना महत्वपूर्ण था।

— सैमुअल जॉय
स्रोत
0

एजेंट CK , मुझे आपकी एक्सटेंशन विधि पसंद आई और मैंने एक स्ट्रिंग अधिभार जोड़ दिया, साथ ही मैंने आपकी विधि के लिए कोड घटा दिया:

public static class ImageExtentions
{
    public static ImageCodecInfo GetCodecInfo(this Image img) =>
        ImageCodecInfo.GetImageDecoders().FirstOrDefault(decoder => decoder.FormatID == img.RawFormat.Guid);

    // Note: this will throw an exception if "file" is not an Image file
    // quick fix is a try/catch, but there are more sophisticated methods
    public static ImageCodecInfo GetCodecInfo(this string file)
    {
        using (var img = Image.FromFile(file))
            return img.GetCodecInfo();
    }
}

// Usage:
string file = @"C:\MyImage.tif";
string description = $"Image format is {file.GetCodecInfo()?.FormatDescription ?? "unknown"}.";
Console.WriteLine(description);
— JohnnyIV
स्रोत
0

सबसे सरल विधि Cesare Imperiali द्वारा इस प्रकार पेश की गई थी :

var format = new ImageFormat(Image.FromFile(myFile).RawFormat.Guid);

हालाँकि, .ToString () .jpg रिटर्न के लिए "[ImageFormat: b96b3cae-0728-11d3-9d7b-0000f81ef32e]" "Jpeg" के बजाय। अगर यह आपके लिए मायने रखता है, तो यहां मेरा समाधान है:

public static class ImageFilesHelper
{
    public static List<ImageFormat> ImageFormats =>
        typeof(ImageFormat).GetProperties(BindingFlags.Static | BindingFlags.Public)
          .Select(p => (ImageFormat)p.GetValue(null, null)).ToList();

    public static ImageFormat ImageFormatFromRawFormat(ImageFormat raw) =>
        ImageFormats.FirstOrDefault(f => raw.Equals(f)) ?? ImageFormat.Bmp;

}
// usage:
var format = ImageFilesHelper.ImageFormatFromRawFormat(Image.FromFile(myFile).RawFormat);
— JohnnyIV
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.