用C#读取图片的EXIF信息的方法

最新推荐文章于 2023-10-25 18:48:15 发布
最新推荐文章于 2023-10-25 18:48:15 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： C# 文章标签： c# string flash 工具 存储 数据结构

文章来源：http://www.cnblogs.com/rexsp/articles/10668.html

用C#读取图片的EXIF信息的方法

引言：

EXIF，是英文Exchangeable Image File(可交换图像文件)的缩写，最初由日本电子工业发展协会(JEIDA --Japan Electronic Industry Development Association) 制订，目前的版本是修改发表于1998年6月的2.1版。国际标准化组织(ISO)正在制订的相机文件设计标准（DCF -- Design role for Camera File system）就是以EXIF2.1格式为基础而设定的。记住，EXIF是一种图像文件格式，只是文件的后缀名还是沿用大家熟悉的jpg而已。实际上，EXIF信息就是由数码相机在拍摄过程中采集一系列的信息，然后把信息放置在我们熟知的jpg文件的头部，也就是说EXIF信息是镶嵌在JPEG图像文件格式内的一组拍摄参数，主要包括摄影时的光圈、快门、ISO、日期时间等各种与当时摄影条件相关的讯息，相机品牌型号，色彩编码，拍摄时录制的声音以及全球定位系统（GPS）等信息。简单的说，它就好像是傻瓜相机的日期打印功能一样，只不过EXIF信息所记录的资讯更为详尽和完备。不过，具有EXIF信息的JPEG图像文件要比普通的JPEG文件略大一点。就目前市场而言，新一代的数码相机都具有附加EXIF信息功能，大多数的数码相机厂商也都会随数码相机发售时附赠能够读取EXIF信息的软件，例如 Nikon 系列的数码相机就附赠 NikonView 软件，Agfa系列的相机则附赠 Photowize V1.8版，而富士相机附送的EXIF viewer软件更是这方面的领军人物(目前已在很多网站提供免费下载。还有一部分的数码相机会自动将EXIF信息转存成文档文件，例如：NIKON CoolPix 990和SONY FD系列。除了硬件厂商随数码相机附带的EXIF信息查看软件，很多专业的图像软件厂商在这方面也不甘示弱，相继推出自己公司看图软件的最新版来支持这种近乎完美的JPEG-EXIF图像信息附加技术,如最近刚推出的ACDSee 4.0版本，就对现在流行的各种数码相机有相当好的支持，在EXIF图像信息附加方面较之其3.0版本也有很大的进步。不管是硬件厂商的配套软件还是专业名门的看图工具，所有这些软件都是为了方便数码摄影者能更方便地保存查看摄影图像的重要信息。我们将这些读取EXIF信息的软件归纳后分为四类：专业EXIF信息查看工具（以富士的EXIF viewer为例） 、具有查看EXIF信息的强大通用看图工具（以ACDSee为例）、支持EXIF信息查看的操作系统（微软的Windows XP）以及可以修改EXIF信息的另类工具（EXIF Editer），而我们这里要讲的是通过C#在WEB上读取一个图片的EXIF信息。

二、相关类（GetEXIFMetaData）：

因为代码比较长，有五百多行，我只能将关键代码的片段拿出来讲讲，这个类中构造了两个结构MetadataDetail　和　Metadata　　，前者是为了存储ＥＸＩＦ中某元素信息的三种格式，起到中间转化的作用，一个是十六进制的索引信息，一个是没用处理过的信息代码，一个是显示信息。后面的那个结构就是存储一张图片所有ＥＸＩＦ信息元素的。　有两个方法LookupEXIFValue　和　GetEXIFMetaData　，前一个方法是处理特殊元素的对应显示的，后者从图片中读取相关信息然后填充到MetaData结构中。

 

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections;
using System.ComponentModel;

namespace Test.Image
{
    /**////<summary>
    /// 功能：获得图片EXIF信息
    /// 作者：Rexsp
    /// 创建日期：2004-03-20
    /// 作者MSN：yubo@x263.net
    ///</summary>
publicclass EXIFMetaData
    {
        构造函数#region 构造函数
        /**////<summary>
        /// 构造函数
        ///</summary>
public EXIFMetaData()
        {
        }
        #endregion

        数据转换结构#region 数据转换结构
        /**////<summary>
        /// 转换数据结构
        ///</summary>
publicstruct MetadataDetail
        {
            publicstring Hex;//十六进制字符串
publicstring RawValueAsString;//原始值串
publicstring DisplayValue;//显示值串
        }
        #endregion

        EXIF元素结构#region EXIF元素结构
        /**////<summary>
        /// 结构：存储EXIF元素信息
        ///</summary>
publicstruct Metadata
        {
            public MetadataDetail EquipmentMake;
            public MetadataDetail CameraModel;
            public MetadataDetail ExposureTime;//曝光时间
public MetadataDetail Fstop;
            public MetadataDetail DatePictureTaken;
            public MetadataDetail ShutterSpeed;// 快门速度
public MetadataDetail MeteringMode;//曝光模式
public MetadataDetail Flash;//闪光灯
public MetadataDetail XResolution;
            public MetadataDetail YResolution;
            public MetadataDetail ImageWidth;//照片宽度
public MetadataDetail ImageHeight;//照片高度

            public MetadataDetail FNumber;// added f值，光圈数
public MetadataDetail ExposureProg;// added 曝光程序
public MetadataDetail SpectralSense;// added
public MetadataDetail ISOSpeed;// added ISO感光度
public MetadataDetail OECF;// added
public MetadataDetail Ver;// added EXIF版本
public MetadataDetail CompConfig;// added 色彩设置
public MetadataDetail CompBPP;// added 压缩比率
public MetadataDetail Aperture;// added 光圈值
public MetadataDetail Brightness;// added 亮度值Ev
public MetadataDetail ExposureBias;// added 曝光补偿
public MetadataDetail MaxAperture;// added 最大光圈值

            public MetadataDetail SubjectDist;// added主体距离
public MetadataDetail LightSource;// added 白平衡
public MetadataDetail FocalLength;// added 焦距
public MetadataDetail FPXVer;// added FlashPix版本
public MetadataDetail ColorSpace;// added 色彩空间
public MetadataDetail Interop;// added
public MetadataDetail FlashEnergy;// added
public MetadataDetail SpatialFR;// added
public MetadataDetail FocalXRes;// added
public MetadataDetail FocalYRes;// added
public MetadataDetail FocalResUnit;// added
public MetadataDetail ExposureIndex;// added 曝光指数
public MetadataDetail SensingMethod;// added 感应方式
public MetadataDetail SceneType;// added
public MetadataDetail CfaPattern;// added
        }
        #endregion

        查找EXIF元素值#region 查找EXIF元素值
        publicstring LookupEXIFValue(string Description, string Value)
        {
            string DescriptionValue =null;

            switch(Description)
            {
                case"MeteringMode":

                    MeteringMode#region  MeteringMode
                {
                    switch(Value)
                    {
                        case"0":
                            DescriptionValue ="Unknown";break;
                        case"1":
                            DescriptionValue ="Average";break;
                        case"2":
                            DescriptionValue ="Center Weighted Average";break;
                        case"3":
                            DescriptionValue ="Spot";break;
                        case"4":
                            DescriptionValue ="Multi-spot";break;
                        case"5":
                            DescriptionValue ="Multi-segment";break;
                        case"6":
                            DescriptionValue ="Partial";break;
                        case"255":
                            DescriptionValue ="Other";break;
                    }
                }
                    #endregion
                    
                    break;
                case"ResolutionUnit":

                    ResolutionUnit#region ResolutionUnit
                {
                    switch(Value)
                    {
                        case"1":
                            DescriptionValue ="No Units";break;
                        case"2":
                            DescriptionValue ="Inch";break;
                        case"3":
                            DescriptionValue ="Centimeter";break;
                    }
                }

                    #endregion

                    break;
                case"Flash":

                    Flash#region Flash
                {
                    switch(Value)
                    {
                        case"0":
                            DescriptionValue ="未使用";break;
                        case"1":
                            DescriptionValue ="闪光";break;
                        case"5":
                            DescriptionValue ="Flash fired but strobe return light not detected";break;
                        case"7":
                            DescriptionValue ="Flash fired and strobe return light detected";break;
                    }
                }
                    #endregion

                    break;
                case"ExposureProg":

                    ExposureProg#region ExposureProg
                {
                    switch(Value)
                    {
                        case"0":
                            DescriptionValue ="没有定义";break;
                        case"1":
                            DescriptionValue ="手动控制";break;
                        case"2":
                            DescriptionValue ="程序控制";break;
                        case"3":
                            DescriptionValue ="光圈优先";break;
                        case"4":
                            DescriptionValue ="快门优先";break;
                        case"5":
                            DescriptionValue ="夜景模式";break;
                        case"6":
                            DescriptionValue ="运动模式";break;
                        case"7":
                            DescriptionValue ="肖像模式";break;
                        case"8":
                            DescriptionValue ="风景模式";break;
                        case"9":
                            DescriptionValue ="保留的";break;
                    }
                }

                    #endregion

                    break;
                case"CompConfig":

                    CompConfig#region CompConfig
                {
                    switch(Value)
                    {
                    
                        case"513":
                            DescriptionValue ="YCbCr";break;
                    }
                }
                    #endregion

                    break;
                case"Aperture":

                    Aperture#region Aperture
                    DescriptionValue = Value;
                    #endregion

                    break;
                case"LightSource":

                    LightSource#region LightSource
                {
                    switch(Value)
                    {
                        case"0":
                            DescriptionValue ="未知";break;
                        case"1":
                            DescriptionValue ="日光";break;
                        case"2":
                            DescriptionValue ="荧光灯";break;
                        case"3":
                            DescriptionValue ="白炽灯";break;
                        case"10":
                            DescriptionValue ="闪光灯";break;
                        case"17":
                            DescriptionValue ="标准光A";break;
                        case"18":
                            DescriptionValue ="标准光B";break;
                        case"19":
                            DescriptionValue ="标准光C";break;
                        case"20":
                            DescriptionValue ="标准光D55";break;
                        case"21":
                            DescriptionValue ="标准光D65";break;
                        case"22":
                            DescriptionValue ="标准光D75";break;
                        case"255":
                            DescriptionValue ="其它";break;
                    }
                }


                    #endregion
                    break;

            }
            return DescriptionValue;
        }
        #endregion

        取得图片的EXIF信息#region 取得图片的EXIF信息
        public Metadata GetEXIFMetaData(string PhotoName)
        {
            // 创建一个图片的实例
            System.Drawing.Image MyImage = System.Drawing.Image.FromFile(PhotoName);
            // 创建一个整型数组来存储图像中属性数组的ID
int[] MyPropertyIdList = MyImage.PropertyIdList;
            //创建一个封闭图像属性数组的实例
            PropertyItem[] MyPropertyItemList =new PropertyItem[MyPropertyIdList.Length];
            //创建一个图像EXIT信息的实例结构对象，并且赋初值

            创建一个图像EXIT信息的实例结构对象，并且赋初值#region 创建一个图像EXIT信息的实例结构对象，并且赋初值
            Metadata MyMetadata =new Metadata();
            MyMetadata.EquipmentMake.Hex ="10f";
            MyMetadata.CameraModel.Hex ="110";
            MyMetadata.DatePictureTaken.Hex    ="9003";
            MyMetadata.ExposureTime.Hex    ="829a";
            MyMetadata.Fstop.Hex ="829d";
            MyMetadata.ShutterSpeed.Hex ="9201";
            MyMetadata.MeteringMode.Hex ="9207";
            MyMetadata.Flash.Hex ="9209";
            MyMetadata.FNumber.Hex ="829d"; //added
            MyMetadata.ExposureProg.Hex =""; //added
            MyMetadata.SpectralSense.Hex ="8824"; //added
            MyMetadata.ISOSpeed.Hex ="8827"; //added
            MyMetadata.OECF.Hex ="8828"; //added
            MyMetadata.Ver.Hex ="9000"; //added
            MyMetadata.CompConfig.Hex ="9101"; //added
            MyMetadata.CompBPP.Hex ="9102"; //added
            MyMetadata.Aperture.Hex ="9202"; //added
            MyMetadata.Brightness.Hex ="9203"; //added
            MyMetadata.ExposureBias.Hex ="9204"; //added
            MyMetadata.MaxAperture.Hex ="9205"; //added
            MyMetadata.SubjectDist.Hex ="9206"; //added
            MyMetadata.LightSource.Hex ="9208"; //added
            MyMetadata.FocalLength.Hex ="920a"; //added
            MyMetadata.FPXVer.Hex ="a000"; //added
            MyMetadata.ColorSpace.Hex ="a001"; //added
            MyMetadata.FocalXRes.Hex ="a20e"; //added
            MyMetadata.FocalYRes.Hex ="a20f"; //added
            MyMetadata.FocalResUnit.Hex ="a210"; //added
            MyMetadata.ExposureIndex.Hex ="a215"; //added
            MyMetadata.SensingMethod.Hex ="a217"; //added
            MyMetadata.SceneType.Hex ="a301";
            MyMetadata.CfaPattern.Hex ="a302";
            #endregion

            // ASCII编码
            System.Text.ASCIIEncoding Value =new System.Text.ASCIIEncoding();
            
            int index =0;
            int MyPropertyIdListCount=MyPropertyIdList.Length;
            if(MyPropertyIdListCount!=0)
            {
                foreach (int MyPropertyId in MyPropertyIdList)
                {
                    string hexVal ="";
                    MyPropertyItemList[index] = MyImage.GetPropertyItem(MyPropertyId);

                    初始化各属性值#region 初始化各属性值
                    string myPropertyIdString=MyImage.GetPropertyItem(MyPropertyId).Id.ToString("x");
                    switch(myPropertyIdString)
                    {
                        case"10f":
                        {
                            MyMetadata.EquipmentMake.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem (MyPropertyId).Value);
                            MyMetadata.EquipmentMake.DisplayValue = Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }

                        case"110":
                        {
                            MyMetadata.CameraModel.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.CameraModel.DisplayValue =Value.GetString(MyPropertyItemList[index].Value);
                            break;

                        }

                        case"9003":
                        {
                            MyMetadata.DatePictureTaken.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.DatePictureTaken.DisplayValue =Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }

                        case"9207":
                        {
                            MyMetadata.MeteringMode.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.MeteringMode.DisplayValue = LookupEXIFValue("MeteringMode",BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString());
                            break;
                        }

                        case"9209":
                        {
                            MyMetadata.Flash.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.Flash.DisplayValue = LookupEXIFValue("Flash",BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString());
                            break;
                        }

                        case"829a":
                        {
                            MyMetadata.ExposureTime.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            string StringValue ="";
                            for (int Offset =0; Offset < MyImage.GetPropertyItem (MyPropertyId).Len; Offset = Offset +4)
                            {
                                StringValue += BitConverter.ToInt32(MyImage.GetPropertyItem(MyPropertyId).Value,Offset).ToString() +"/";
                            }
                            MyMetadata.ExposureTime.DisplayValue =StringValue.Substring(0,StringValue.Length-1);
                            break;
                        }
                        case"829d":
                        {
                            MyMetadata.Fstop.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            int int1;
                            int int2;
                            int1 =BitConverter.ToInt32(MyImage.GetPropertyItem(MyPropertyId).Value,0);
                            int2 = BitConverter.ToInt32(MyImage.GetPropertyItem(MyPropertyId).Value,4);
                            MyMetadata.Fstop.DisplayValue ="F/"+(int1/int2);

                            MyMetadata.FNumber.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.FNumber.DisplayValue = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();

                            break;
                        }
                        case"9201":
                        {
                            MyMetadata.ShutterSpeed.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            string StringValue = BitConverter.ToInt32(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            MyMetadata.ShutterSpeed.DisplayValue ="1/"+ StringValue;
                            break;
                        }

                        case"8822":
                        {
                            MyMetadata.ExposureProg.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.ExposureProg.DisplayValue = LookupEXIFValue("ExposureProg",BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString());
                            break;
                        }

                        case"8824":
                        {
                            MyMetadata.SpectralSense.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.SpectralSense.DisplayValue =Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }
                        case"8827":
                        {
                            hexVal ="";
                            MyMetadata.ISOSpeed.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            hexVal = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value).Substring(0,2);
                            MyMetadata.ISOSpeed.DisplayValue = Convert.ToInt32(hexVal,16).ToString();//Value.GetString(MyPropertyItemList[index].Value);
break;
                        }

                        case"8828":
                        {
                            MyMetadata.OECF.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.OECF.DisplayValue =Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }

                        case"9000":
                        {
                            MyMetadata.Ver.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.Ver.DisplayValue =Value.GetString(MyPropertyItemList[index].Value).Substring(1,1)+"."+Value.GetString(MyPropertyItemList[index].Value).Substring(2,2);
                            break;
                        }

                        case"9101":
                        {
                            MyMetadata.CompConfig.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.CompConfig.DisplayValue = LookupEXIFValue("CompConfig",BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString());
                            break;
                        }

                        case"9102":
                        {
                            MyMetadata.CompBPP.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.CompBPP.DisplayValue = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            break;
                        }

                        case"9202":
                        {
                            hexVal ="";
                            MyMetadata.Aperture.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            hexVal = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value).Substring(0,2);
                            hexVal = Convert.ToInt32(hexVal,16).ToString();
                            hexVal = hexVal +"00";
                            MyMetadata.Aperture.DisplayValue = hexVal.Substring(0,1)+"."+hexVal.Substring(1,2);
                            break;
                        }

                        case"9203":
                        {
                            hexVal ="";
                            MyMetadata.Brightness.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            hexVal = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value).Substring(0,2);
                            hexVal = Convert.ToInt32(hexVal,16).ToString();
                            hexVal = hexVal +"00";
                            MyMetadata.Brightness.DisplayValue = hexVal.Substring(0,1)+"."+hexVal.Substring(1,2);
                            break;
                        }

                        case"9204":
                        {
                            MyMetadata.ExposureBias.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.ExposureBias.DisplayValue = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            break;
                        }

                        case"9205":
                        {
                            hexVal ="";
                            MyMetadata.MaxAperture.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            hexVal = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value).Substring(0,2);
                            hexVal = Convert.ToInt32(hexVal,16).ToString();
                            hexVal = hexVal +"00";
                            MyMetadata.MaxAperture.DisplayValue = hexVal.Substring(0,1)+"."+hexVal.Substring(1,2);
                            break;
                        }

                        case"9206":
                        {
                            MyMetadata.SubjectDist.RawValueAsString =BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.SubjectDist.DisplayValue =Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }

                        case"9208":
                        {
                            MyMetadata.LightSource.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.LightSource.DisplayValue = LookupEXIFValue("LightSource",BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString());
                            break;
                        }

                        case"920a":
                        {
                            hexVal ="";
                            MyMetadata.FocalLength.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            hexVal = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value).Substring(0,2);
                            hexVal = Convert.ToInt32(hexVal,16).ToString();
                            hexVal = hexVal +"00";
                            MyMetadata.FocalLength.DisplayValue = hexVal.Substring(0,1)+"."+hexVal.Substring(1,2);
                            break;
                        }

                        case"a000":
                        {
                            MyMetadata.FPXVer.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.FPXVer.DisplayValue = Value.GetString(MyPropertyItemList[index].Value).Substring(1,1)+"."+Value.GetString(MyPropertyItemList[index].Value).Substring(2,2);
                            break;
                        }

                        case"a001":
                        {
                            MyMetadata.ColorSpace.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            if (BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString() =="1")
                                MyMetadata.ColorSpace.DisplayValue ="RGB";
                            if (BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString() =="65535")
                                MyMetadata.ColorSpace.DisplayValue ="Uncalibrated";
                            break;
                        }

                        case"a20e":
                        {
                            MyMetadata.FocalXRes.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.FocalXRes.DisplayValue =BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            break;
                        }

                        case"a20f":
                        {
                            MyMetadata.FocalYRes.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.FocalYRes.DisplayValue = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            break;
                        }

                        case"a210":
                        {
                            string aa;
                            MyMetadata.FocalResUnit.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            aa = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();;
                            if (aa =="1") MyMetadata.FocalResUnit.DisplayValue ="没有单位";
                            if (aa =="2") MyMetadata.FocalResUnit.DisplayValue ="英尺";
                            if (aa =="3") MyMetadata.FocalResUnit.DisplayValue ="厘米";
                            break;
                        }

                        case"a215":
                        {
                            MyMetadata.ExposureIndex.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.ExposureIndex.DisplayValue = Value.GetString(MyPropertyItemList[index].Value);
                            break;
                        }

                        case"a217":
                        {
                            string aa;
                            aa = BitConverter.ToInt16(MyImage.GetPropertyItem(MyPropertyId).Value,0).ToString();
                            MyMetadata.SensingMethod.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            if (aa =="2") MyMetadata.SensingMethod.DisplayValue ="1 chip color area sensor";
                            break;
                        }

                        case"a301":
                        {
                            MyMetadata.SceneType.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.SceneType.DisplayValue = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            break;
                        }

                        case"a302":
                        {
                            MyMetadata.CfaPattern.RawValueAsString = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            MyMetadata.CfaPattern.DisplayValue = BitConverter.ToString(MyImage.GetPropertyItem(MyPropertyId).Value);
                            break;
                        }



                    }
                    #endregion
                    
                    index++;
                }
            }

            MyMetadata.XResolution.DisplayValue = MyImage.HorizontalResolution.ToString();
            MyMetadata.YResolution.DisplayValue = MyImage.VerticalResolution.ToString();
            MyMetadata.ImageHeight.DisplayValue = MyImage.Height.ToString();
            MyMetadata.ImageWidth.DisplayValue = MyImage.Width.ToString();
            MyImage.Dispose();
            return MyMetadata;
        }
        #endregion
    }
}

然后就是个调用的问题，有了这个类，我如何读取图片的ＥＸＩＦ信息呢？代码如下：

              EXIFMetaData em = new EXIFMetaData();

              string filePath = Server.MapPath( " Test.jpg " ); // 这里可以动态传递图片路径的

              EXIFMetaData.Metadata m = em.GetEXIFMetaData(filePath); // 这里就是调用，传图片绝对路径

              string exif = m.Ver.DisplayValue;

              string camera = m.CameraModel.DisplayValue;

              string model = m.CameraModel.DisplayValue;

              string aperture = m.Aperture.DisplayValue;

              string shutter = m.ShutterSpeed.DisplayValue;

              string sensitive = m.ExposureIndex.DisplayValue;

 

有什么不明白的，欢迎提出来，此代码经过测试，功能正常。

daiafei
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#语言Winform利用ExifLibrary库给照片写入GPS经纬高数据
05-22
分别用导入ExifLibrary库的dll方式和直接加入.c .h文件的方式实现了往照片里写入经纬高数据的功能，且可多次写入、修改。
C#读取图片Exif信息
weixin_34308389的博客
11-03 222
Exif是可交换图像文件的缩写，是专门为数码相机的照片设定的，可以记录数码照片的属性和拍摄数据     ////调用 //string strFile="fffff.jpg";//文件名 //System.Drawing.Bitmap bmp = new Bitmap(strFile); //EXIF.EXIFextractor er = new EXIF.EXIFextractor(...
用C#读取(数码相机)图片的EXIF信息 .
weixin_34239592的博客
08-30 222
对于数码相机所拍摄出的图片，Exif信息非常重要.参考网上的文章，结合我的实际需求，整理了一下，一共三个类文件EXIFextractor .cs,Translation.cs,EXIFMetaData,cs (Translation.cs,EXIFMetaData,cs 参看用C#读取图片的EXIF信息2) ///EXIFextractor .cs using System; u...
.net c#通过Exif获取图片信息(参数)
qhzhen的博客
03-30 3202
简介 想要获取图片的信息，例如快门速度、ISO值等等，我们可以通过读取Exif中存储的信息。Exif（Exchangeable Image File）是存储在JPEG格式照片头部的一段信息，相机和手机拍摄的照片都会携带这些信息，但是需要注意，PS的照片的时候采用低质量保存会丢失这些信息。在PS中保存为10-12等级的时候不会丢失，在美图秀秀中保存质量为100%不会丢失。软件在处理的时...
C# 读取照片的EXIF信息
于大大大洋
06-29 5875
一、使用 MetadataExtractor 读取 EXIF 信息 1、NuGet 中安装 在 NuGet 中搜索并安装 MetadataExtractor； 2、包信息 我安装后会有两个包：MetadataExtractor 2.0.0 和 XmpCore 5.1.3 3、代码实现 我是创建的 WPF 项目： private void BTOpen_Click(object...
C# 获取图片的EXIF 信息
热门推荐
yang073402的专栏
04-10 1万+
关于 EXIF 信息的介绍。1  EXIF，是英文Exchangeable Image File(可交换图像文件)的缩写。EXIF是一种图像文件格式，只是文件的后缀名为jpg。EXIF信息是由数码相机在拍摄过程中采集一系列的信息，然后把信息放置在jpg文件的头部，也就是说EXIF信息是镶嵌在JPEG图像文件格式内的一组拍摄参数，主要包括摄影时的光圈、快门、ISO、日期时间等各种与当时摄影条件相
C# 根据图片的EXIF自动调整图片方向
.NET 人工智能实践
08-01 557
C# 根据图片的EXIF自动调整图片方向
用C#读取图片的EXIF信息的方法(读取照片ISO等信息原代码)
04-17
摘要：本文讲述了使用 C# 读取图片的 EXIF 信息的方法，包括读取照片 ISO 感光度、曝光时间、快门速度、闪光灯、曝光模式、照片宽度、高度、f 值、曝光程序、光谱感知、EXIF 版本、色彩设置、压缩比率、光圈值、亮度...
C#使用EXIF读取图片信息（很受用哦！）
12-05
在本文中，我们将深入探讨如何使用C#编程语言来读取和处理图片的EXIF（Exchangeable Image File Format）信息。EXIF是一种嵌入在JPEG、TIFF等图像文件格式中的元数据，它包含了拍摄照片时相机记录的各种参数，如日期...
C#获取照片EXIF信息显示拍摄时间
03-16
每张都带有Exif信息，在Exif中记录了照片的很多拍摄参数、比如快门速度、快门次数、光圈大小等，当然也包括了拍摄时间，本例就是通过使用C#的相关图像操作方法来读取Exif信息的拍摄时间。通过指定的数据流来创建...
C# 读取图片Exif信息
08-16
C# 读取图片Exif信息C# 读取图片Exif信息
C#读取JPEG图片的Exif信息
04-19
[Serializable] public class EXIF { #region -- Class level members -- // Class level members. private Image _picture; #endregion #region -- Constructors -- // Constructors. /// <summary> /// This is default constructor of the EXIF class. /// </summary> public EXIF() { } /// <summary> /// This is base constructor of the EXIF class. /// </summary> public EXIF(string filePath) { _picture = Image.FromFile(filePath); } #endregion #region -- Public methods -- /// <summary> /// This method returns EXIF property values. /// </summary> /// <param name="exifCode">EXIF property to be returned.</param> public string GetEXIFProperty(Definitions.exifCode exifCode) { // Declare local variables. string returnValue; try { // All of the EXIF properties will return strings to display in the control. // Some of the properties require additional formatting or massaging // of the data once it is returned. Those properties have their own // methods. switch (exifCode) { case Definitions.exifCode.ImageDescription: returnValue = ParsedString(Definitions.exifCode.ImageDescription); break; case Definitions.exifCode.Make: returnValue = ParsedString(Definitions.exifCode.Make); break; case Definitions.exifCode.Model: returnValue = ParsedString(Definitions.exifCode.Model); break; case Definitions.exifCode.Orientation: returnValue = Orientation(); break; case Definitions.exifCode.XResolution: returnValue = ParseResolution(Definitions.exifCode.XResolution); break; case Definitions.exifCode.YResolution: returnValue = ParseResolution(Definitions.exifCode.YResolution); break; case Definitions.exifCode.ResolutionUnit: returnValue = ResolutionUnit(); break; case Definitions.exifCode.Software: returnValue = ParsedString(Definitions.exifCode.Software); break; case Definitions.exifCode.DateTime: returnValue = ParsedDate(Definitions.exifCode.DateTime).ToString(); break; case Definitions.exifCode.WhitePoint: returnValue = WhitePoint(); break; case Definitions.exifCode.PrimaryChromaticities: returnValue = PrimaryChromaticities(); break; case Definitions.exifCode.YCbCrCoefficients: returnValue = YCbCrCoefficients(); break; case Definitions.exifCode.YCbCrPositioning: returnValue = YCbCrPositioning(); break; case Definitions.exifCode.ReferenceBlackWhite: returnValue = ReferenceBlackWhite(); break; case Definitions.exifCode.Copyright: returnValue = ParsedString(Definitions.exifCode.Copyright); break; case Definitions.exifCode.ExposureTime: returnValue = ExposureTime(); break; case Definitions.exifCode.FNumber: returnValue = FNumber(); break; case Definitions.exifCode.ExposureProgram: returnValue = ExposureProgram(); break; case Definitions.exifCode.ISOSpeedRatings: returnValue = UnformattedShort(Definitions.exifCode.ISOSpeedRatings); break; case Definitions.exifCode.ExifVersion: returnValue = ParsedString(Definitions.exifCode.ExifVersion); break; case Definitions.exifCode.DateTimeOriginal: returnValue = ParsedDate(Definitions.exifCode.DateTimeOriginal).ToString(); break; case Definitions.exifCode.DateTimeDigitized: returnValue = ParsedDate(Definitions.exifCode.DateTimeDigitized).ToString(); break; case Definitions.exifCode.ComponentsConfiguration: returnValue = ComponentsConfiguration(); break; case Definitions.exifCode.CompressedBitsPerPixel: returnValue = CompressedBitsPerPixel(); break; case Definitions.exifCode.ShutterSpeedValue: returnValue = ShutterSpeedValue(); break; case Definitions.exifCode.ApertureValue: returnValue = ApertureValue(); break; case Definitions.exifCode.BrightnessValue: returnValue = BrightnessValue(); break; case Definitions.exifCode.ExposureBiasValue: returnValue = ExposureBiasValue(); break; case Definitions.exifCode.MaxApertureValue: returnValue = MaxApertureValue(); break; case Definitions.exifCode.SubjectDistance: returnValue = SubjectDistance(); break; case Definitions.exifCode.MeteringMode: returnValue = MeteringMode(); break; case Definitions.exifCode.LightSource: returnValue = LightSource(); break; case Definitions.exifCode.Flash: returnValue = Flash(); break; case Definitions.exifCode.FocalLength: returnValue = FocalLength(); break; case Definitions.exifCode.MakerNote: returnValue = MakerNote(); break; case Definitions.exifCode.UserComment: returnValue = ParsedString(Definitions.exifCode.UserComment); break; case Definitions.exifCode.SubsecTime: returnValue = ParsedString(Definitions.exifCode.SubsecTime); break; case Definitions.exifCode.SubsecTimeOriginal: returnValue = ParsedString(Definitions.exifCode.SubsecTimeOriginal); break; case Definitions.exifCode.SubsecTimeDigitized: returnValue = ParsedString(Definitions.exifCode.SubsecTimeDigitized); break; case Definitions.exifCode.FlashpixVersion: returnValue = ParsedString(Definitions.exifCode.FlashpixVersion); break; case Definitions.exifCode.ColorSpace: returnValue = ColorSpace(); break; case Definitions.exifCode.RelatedSoundFile: returnValue = ParsedString(Definitions.exifCode.RelatedSoundFile); break; case Definitions.exifCode.FocalPlaneXResolution: returnValue = FocalPlaneXResolution(); break; case Definitions.exifCode.FocalPlaneYResolution: returnValue = FocalPlaneYResolution(); break; case Definitions.exifCode.FocalPlaneResolutionUnit: returnValue = ResolutionUnit(); break; case Definitions.exifCode.ExposureIndex: returnValue = ExposureIndex(); break; case Definitions.exifCode.SensingMethod: returnValue = SensingMethod(); break; case Definitions.exifCode.FileSource: returnValue = FileSource(); break; case Definitions.exifCode.SceneType: returnValue = SceneType(); break; case Definitions.exifCode.CFAPattern: returnValue = ParsedString(Definitions.exifCode.CFAPattern); break; case Definitions.exifCode.InteroperabilityIndex: returnValue = ParsedString(Definitions.exifCode.InteroperabilityIndex); break; case Definitions.exifCode.ImageWidth: returnValue = UnformattedShort(Definitions.exifCode.ImageWidth); break; case Definitions.exifCode.ImageLength: returnValue = UnformattedShort(Definitions.exifCode.ImageLength); ; break; case Definitions.exifCode.BitsPerSample: returnValue = BitsPerSample(); break; case Definitions.exifCode.Compression: returnValue = Compression(); break; case Definitions.exifCode.PhotometricInterpretation: returnValue = PhotometricInterpretation(); break; case Definitions.exifCode.StripOffsets: returnValue = StripOffsets(); break; case Definitions.exifCode.SamplesPerPixel: returnValue = UnformattedShort(Definitions.exifCode.SamplesPerPixel); break; case Definitions.exifCode.RowsPerStrip: returnValue = UnformattedShort(Definitions.exifCode.RowsPerStrip); break; case Definitions.exifCode.StripByteCounts: returnValue = StripByteCounts(); break; case Definitions.exifCode.PlanarConfiguration: returnValue = PlanarConfiguration(); break; case Definitions.exifCode.YCbCrSubSampling: returnValue = YCbCrSubSampling(); break; case Definitions.exifCode.ImageUniqueID: returnValue = ParsedString(Definitions.exifCode.ImageUniqueID); break; case Definitions.exifCode.JPEGInterchangeFormatLength: returnValue = UnformattedShort(Definitions.exifCode.JPEGInterchangeFormatLength); break; case Definitions.exifCode.TransferFunction: returnValue = "Not implemented."; break; case Definitions.exifCode.PixelXDimension: returnValue = UnformattedShort(Definitions.exifCode.PixelXDimension); break; case Definitions.exifCode.PixelYDimension: returnValue = UnformattedShort(Definitions.exifCode.PixelYDimension); break; case Definitions.exifCode.SpectralSensitivity: returnValue = ParsedString(Definitions.exifCode.SpectralSensitivity); break; case Definitions.exifCode.OECF: returnValue = ParsedString(Definitions.exifCode.OECF); break; case Definitions.exifCode.CustomRendered: returnValue = CustomRendered(); break; case Definitions.exifCode.ExposureMode: returnValue = ExposureMode(); break; case Definitions.exifCode.WhiteBalance: returnValue = WhiteBalance(); break; case Definitions.exifCode.DigitalZoomRatio: returnValue = DigitalZoomRatio(); break; case Definitions.exifCode.FocalLengthIn35mmFilm: returnValue = FocalLengthIn35mmFilm(); break; case Definitions.exifCode.SceneCaptureType: returnValue = SceneCaptureType(); break; case Definitions.exifCode.GainControl: returnValue = GainControl(); break; case Definitions.exifCode.Contrast: returnValue = Contrast(); break; case Definitions.exifCode.Saturation: returnValue = Saturation(); break; case Definitions.exifCode.Sharpness: returnValue = Sharpness(); break; case Definitions.exifCode.DeviceSettingDescription: returnValue = ParsedString(Definitions.exifCode.DeviceSettingDescription); break; case Definitions.exifCode.SubjectDistanceRange: returnValue = SubjectDistanceRange(); break; default: returnValue = "EXIF property not found."; break; } return returnValue; } catch { return "N/A"; } } #endregion #region -- EXIF Methods -- /// <summary> /// This method returns the bits per sample EXIF property. /// </summary> private string BitsPerSample() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.BitsPerSample); //Translate the EXIF code into a readable value. if (!data.Equals(null)) { returnValue = data[0].ToString() + " " + data[1].ToString() + " " + data[2].ToString(); } return returnValue; } /// <summary> /// This method returns the compression EXIF property. /// </summary> private string Compression() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.Compression); //Translate the EXIF code into a readable value. if (!data.Equals(null)) { switch (data[0]) { case 1: returnValue = "uncompressed"; break; case 6: returnValue = "JPEG compression (thumbnails only)"; break; default: returnValue = "reserved"; break; } } return returnValue; } /// <summary> /// This method returns the photometric interpretation EXIF property. /// </summary> private string PhotometricInterpretation() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.PhotometricInterpretation); //Translate the EXIF code into a readable value. if (data != null) { switch (data[0]) { case 2: returnValue = "RBG"; break; case 6: returnValue = "YCbCr"; break; default: returnValue = "reserved"; break; } } return returnValue; } /// <summary> /// This method returns the strip offsets EXIF property. /// </summary> private string StripOffsets() { return "Not implemented."; } /// <summary> /// This method returns the strip byte counts EXIF property. /// </summary> private string StripByteCounts() { return "Not implemented."; } /// <summary> /// This method returns the planar configuration EXIF property. /// </summary> private string PlanarConfiguration() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.PlanarConfiguration); //Translate the EXIF code into a readable value. if (data != null) { switch (data[0]) { case 1: returnValue = "chunky format"; break; case 2: returnValue = "planar format"; break; default: returnValue = "reserved"; break; } } return returnValue; } /// <summary> /// This method returns the YCbCr subsampling EXIF property. /// </summary> private string YCbCrSubSampling() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.YCbCrSubSampling); //Translate the EXIF code into a readable value. if (data != null) { switch (data[0]) { case 2: if (data[1] == 1) { returnValue = "YCbCr4:2:2"; } else { returnValue = "YCbCr4:2:0"; } break; default: returnValue = "reserved"; break; } } return returnValue; } /// <summary> /// This method returns the orientation EXIF property. /// </summary> private string Orientation() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.Orientation); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side."; break; case 2: returnValue = "The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side."; break; case 3: returnValue = "The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side."; break; case 4: returnValue = "The 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side."; break; case 5: returnValue = "The 0th row is at the visual left-hand side of the image, and the 0th column is the visual top."; break; case 6: returnValue = "The 0th row is at the visual right-hand side of the image, and the 0th column is the visual top."; break; case 7: returnValue = "The 0th row is at the visual right-hand side of the image, and the 0th column is the visual bottom."; break; case 8: returnValue = "The 0th row is at the visual left-hand side of the image, and the 0th column is the visual bottom."; break; default: returnValue = "Other"; break; } } return returnValue; } /// <summary> /// This method returns the resolution unit EXIF property. /// </summary> private string ResolutionUnit() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] resUnit = GetPropertyValue(Definitions.exifCode.ResolutionUnit); //Translate the EXIF code into a readable value. if (resUnit != null) { switch (resUnit[0]) { case 2: returnValue = "inches"; break; case 3: returnValue = "centimeters"; break; default: returnValue = "reserved"; break; } } return returnValue; } /// <summary> /// This method returns the white point EXIF property. /// </summary> private string WhitePoint() { string returnValue = "EXIF property not found."; EXIFRational[] data = ParsedRationalArray(Definitions.exifCode.WhitePoint); if (data.Length > 0) { returnValue = data[0].Denominator.ToString() + ", " + data[1].Denominator.ToString(); } return returnValue; } /// <summary> /// This method returns the primary chromaticities EXIF property. /// </summary> private string PrimaryChromaticities() { string returnValue = "EXIF property not found."; EXIFRational[] data = ParsedRationalArray(Definitions.exifCode.PrimaryChromaticities); if (data.Length > 0) { returnValue = data[0].Denominator.ToString() + ", " + data[1].Denominator.ToString() + ", " + data[2].Denominator.ToString() + ", " + data[3].Denominator.ToString() + ", " + data[4].Denominator.ToString() + ", " + data[5].Denominator.ToString(); } return returnValue; } /// <summary> /// This method returns the YCbCr coefficients EXIF property. /// </summary> private string YCbCrCoefficients() { string returnValue = "EXIF property not found."; EXIFRational[] data = ParsedRationalArray(Definitions.exifCode.YCbCrCoefficients); if (data.Length > 0) { returnValue = data[0].Denominator.ToString() + ", " + data[1].Denominator.ToString() + ", " + data[2].Denominator.ToString(); } return returnValue; } /// <summary> /// This method returns the YCbCr positioning EXIF property. /// </summary> private string YCbCrPositioning() { //Declare local variables. string returnValue = ""; byte[] data = GetPropertyValue(Definitions.exifCode.YCbCrPositioning); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "centered"; break; case 2: returnValue = "co-sited"; break; default: returnValue = "reserved"; break; } } else { returnValue = "EXIF property not found."; } return returnValue; } /// <summary> /// This method returns the reference black white EXIF property. /// </summary> private string ReferenceBlackWhite() { string returnValue = "EXIF property not found."; EXIFRational[] data = ParsedRationalArray(Definitions.exifCode.ReferenceBlackWhite); if (data.Length > 0) { returnValue = "[" + data[0].Denominator.ToString() + ", " + data[1].Denominator.ToString() + ", " + data[2].Denominator.ToString() + ", " + data[3].Denominator.ToString() + ", " + data[4].Denominator.ToString() + ", " + data[5].Denominator.ToString() + "]"; } return returnValue; } /// <summary> /// This method returns the exposure time EXIF property. /// </summary> private string ExposureTime() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational exposureTime = ParsedRational(Definitions.exifCode.ExposureTime); //Translate the EXIF code into a readable value. if (!exposureTime.Equals(null)) { if (exposureTime.Numerator == 0 && exposureTime.Denominator == 0) { returnValue = "N/A"; } else { returnValue = string.Format("{0}/{1} s", exposureTime.Numerator, exposureTime.Denominator); } } else { returnValue = "N/A"; } return returnValue; } /// <summary> /// This method returns the FNumber EXIF property. /// </summary> private string FNumber() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational fNumber = ParsedRational(Definitions.exifCode.FNumber); //Translate the EXIF code into a readable value. if (!fNumber.Equals(null)) { returnValue = string.Format("f{0}", (float)(fNumber.Numerator / fNumber.Denominator)); } return returnValue; } /// <summary> /// This method returns the exposure program EXIF property. /// </summary> private string ExposureProgram() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.ExposureProgram); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Not defined"; break; case 1: returnValue = "Manual"; break; case 2: returnValue = "Normal program"; break; case 3: returnValue = "Aperture priority"; break; case 4: returnValue = "Shutter priority"; break; case 5: returnValue = "Creative program (biased toward depth of field)"; break; case 6: returnValue = "Action program (biased toward fast shutter speed)"; break; case 7: returnValue = "Portrait mode (for closeup photos with the background out of focus)"; break; case 8: returnValue = "Landscape mode (for landscape photos with the background in focus)"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the components configuration EXIF property. /// </summary> private string ComponentsConfiguration() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.ComponentsConfiguration); switch (data[0]) { case 1: returnValue = "YCbCr"; break; case 4: returnValue = "RGB"; break; default: returnValue = "Reserved"; break; } return returnValue; } /// <summary> /// This method returns the compressed bits per pixel EXIF property. /// </summary> // This method needs to fixed to return the correct value. private string CompressedBitsPerPixel() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational cbpp = ParsedRational(Definitions.exifCode.CompressedBitsPerPixel); //Translate the EXIF code into a readable value. if (!cbpp.Equals(null)) { returnValue = string.Format("{0}/{1}", cbpp.Numerator, cbpp.Denominator); } return returnValue; } /// <summary> /// This method returns the aperture value EXIF property. /// </summary> private string ApertureValue() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational fNumber = ParsedRational(Definitions.exifCode.FNumber); //Translate the EXIF code into a readable value. if (!fNumber.Equals(null)) { double av = Math.Round(2 * Math.Log(((fNumber.Numerator / fNumber.Denominator)), 2.00)); returnValue = string.Format("f{0}", (double)av); } return returnValue; } /// <summary> /// This method returns the shutter speed value EXIF property. /// </summary> private string ShutterSpeedValue() { //Declare local variables. string returnValue = "EXIF property not found."; returnValue = ExposureTime(); return returnValue; } /// <summary> /// This method returns the subject distance EXIF property. /// </summary> private string SubjectDistance() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational sd = ParsedRational(Definitions.exifCode.SubjectDistance); //Translate the EXIF code into a readable value. if (!sd.Equals(null)) { returnValue = string.Format("{0}", sd.Numerator); } return returnValue; } /// <summary> /// This method returns the metering mode EXIF property. /// </summary> private string MeteringMode() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.MeteringMode); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Unknown"; break; case 1: returnValue = "Average"; break; case 2: returnValue = "CenterWeightedAverage"; break; case 3: returnValue = "Spot"; break; case 4: returnValue = "MultiSpot"; break; case 5: returnValue = "Pattern"; break; case 6: returnValue = "Partial"; break; case 255: returnValue = "Other"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the light source EXIF property. /// </summary> private string LightSource() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.LightSource); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "Daylight"; break; case 2: returnValue = "Fluorescent"; break; case 3: returnValue = "Tungsten (incandescent light)"; break; case 4: returnValue = "Flash"; break; case 9: returnValue = "Fine weather"; break; case 10: returnValue = "Cloudy weather"; break; case 11: returnValue = "Shade"; break; case 12: returnValue = "Daylight fluorescent (D 5700 - 7100K)"; break; case 13: returnValue = "Day white fluorescent (N 4600 - 5400K)"; break; case 14: returnValue = "Cool white fluorescent (W 3900 - 4500K)"; break; case 15: returnValue = "White fluorescent (WW 3200 - 3700K)"; break; case 17: returnValue = "Standard light A"; break; case 18: returnValue = "Standard light B"; break; case 19: returnValue = "Standard light C"; break; case 20: returnValue = "D55"; break; case 21: returnValue = "D65"; break; case 22: returnValue = "D75."; break; case 23: returnValue = "D50"; break; case 24: returnValue = "ISO studio tungsten"; break; case 255: returnValue = "other light source"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the flash EXIF property. /// </summary> private string Flash() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.Flash); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Flash did not fire."; break; case 1: returnValue = "Flash fired."; break; case 5: returnValue = "Strobe return light not detected."; break; case 7: returnValue = "Strobe return light detected."; break; case 9: returnValue = "Flash fired, compulsory flash mode."; break; case 13: returnValue = "Flash fired, compulsory flash mode, return light not detected."; break; case 15: returnValue = "Flash fired, compulsory flash mode, return light detected."; break; case 16: returnValue = "Flash did not fire, compulsory flash mode."; break; case 24: returnValue = "Flash did not fire, auto mode."; break; case 25: returnValue = "Flash fired, auto mode."; break; case 29: returnValue = "Flash fired, auto mode, return light not detected."; break; case 31: returnValue = "Flash fired, auto mode, return light detected."; break; case 32: returnValue = "No flash function."; break; case 65: returnValue = "Flash fired, red-eye reduction mode."; break; case 69: returnValue = "Flash fired, red-eye reduction mode, return light not detected."; break; case 71: returnValue = "Flash fired, red-eye reduction mode, return light detected."; break; case 73: returnValue = "Flash fired, compulsory flash mode, red-eye reduction mode."; break; case 77: returnValue = "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected."; break; case 79: returnValue = "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected."; break; case 89: returnValue = "Flash fired, auto mode, red-eye reduction mode."; break; case 93: returnValue = "Flash fired, auto mode, return light not detected, red-eye reduction mode."; break; case 95: returnValue = "Flash fired, auto mode, return light detected, red-eye reduction mode."; break; default: returnValue = "Not defined, reserved."; break; } } return returnValue; } /// <summary> /// This method returns the focal length EXIF property. /// </summary> private string FocalLength() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational focalLength = ParsedRational(Definitions.exifCode.FocalLength); //Translate the EXIF code into a readable value. if (!focalLength.Equals(null)) { if (focalLength.Numerator == 0 && focalLength.Denominator == 0) { returnValue = "N/A"; } else { returnValue = string.Format("{0:N0} mm", focalLength.Numerator * 1.0 / focalLength.Denominator); } } return returnValue; } /// <summary> /// This method returns the maker note EXIF property. /// </summary> private string MakerNote() { return "Not implemented."; } /// <summary> /// This method returns the color space EXIF property. /// </summary> private string ColorSpace() { //Declare local variables. string returnValue = "EXIF property not found."; byte[] data = GetPropertyValue(Definitions.exifCode.ColorSpace); //Translate the EXIF code into a readable value. if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "sRGB"; break; case 255: returnValue = "Uncalibrated"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the focal plane x resolution EXIF property. /// </summary> private string FocalPlaneXResolution() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational focalPlaneXRes = ParsedRational(Definitions.exifCode.FocalPlaneXResolution); //Translate the EXIF code into a readable value. if (!focalPlaneXRes.Equals(null)) { returnValue = string.Format("{0:N0} mm", (focalPlaneXRes.Numerator * 1.0 / focalPlaneXRes.Denominator)); } return returnValue; } /// <summary> /// This method returns the focal plane y resolution EXIF property. /// </summary> private string FocalPlaneYResolution() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational focalPlaneYRes = ParsedRational(Definitions.exifCode.FocalPlaneYResolution); //Translate the EXIF code into a readable value. if (!focalPlaneYRes.Equals(null)) { returnValue = string.Format("{0:N0} mm", focalPlaneYRes.Numerator * 1.0 / focalPlaneYRes.Denominator); } return returnValue; } /// <summary> /// This method returns the exposure index EXIF property. /// </summary> private string ExposureIndex() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational expIndex = ParsedRational(Definitions.exifCode.ExposureIndex); //Translate the EXIF code into a readable value. if (!expIndex.Equals(null)) { returnValue = string.Format("{0:N0} mm", expIndex.Numerator * 1.0 / expIndex.Denominator); } return returnValue; } /// <summary> /// This method returns the sensing method EXIF property. /// </summary> private string SensingMethod() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.SensingMethod); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "Not defined."; break; case 2: returnValue = "One-chip color area sensor."; break; case 3: returnValue = "Two-chip color area sensor."; break; case 4: returnValue = "Three-chip color area sensor."; break; case 5: returnValue = "Color sequential area sensor."; break; case 7: returnValue = "Trilinear sensor."; break; case 8: returnValue = "Color sequential linear sensor"; break; default: returnValue = "Reserved."; break; } } return returnValue; } /// <summary> /// This method returns the file source EXIF property. /// </summary> private string FileSource() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.FileSource); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 3: returnValue = "DSC"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the scene type EXIF property. /// </summary> private string SceneType() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.FileSource); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 1: returnValue = "A directly photographed image."; break; default: returnValue = "Reserved."; break; } } return returnValue; } /// <summary> /// This method returns the custom rendered EXIF property. /// </summary> private string CustomRendered() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.CustomRendered); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Normal process"; break; case 1: returnValue = "Custom process"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the exposure mode EXIF property. /// </summary> private string ExposureMode() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.ExposureMode); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Auto exposure"; break; case 1: returnValue = "Manual exposure"; break; case 2: returnValue = "Auto bracket"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the white balance EXIF property. /// </summary> private string WhiteBalance() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.WhiteBalance); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Auto white balance"; break; case 1: returnValue = "Manual white balance"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the focal length in 35mm film EXIF property. /// </summary> private string FocalLengthIn35mmFilm() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.FocalLengthIn35mmFilm); string returnValue = "EXIF property not found."; if (data.Length > 0) { if (data[0] == 0) { returnValue = "Unknown"; } else if (data[0].ToString().Trim() == "NaN") { returnValue = "N/A"; } else { returnValue = data[0].ToString() + "mm"; } } return returnValue; } /// <summary> /// This method returns the scene capture type EXIF property. /// </summary> private string SceneCaptureType() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.SceneCaptureType); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Standard"; break; case 1: returnValue = "Landscape"; break; case 2: returnValue = "Portrait"; break; case 3: returnValue = "Night scene"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the gain control EXIF property. /// </summary> private string GainControl() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.GainControl); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "None"; break; case 1: returnValue = "Low gain up"; break; case 2: returnValue = "High gain up"; break; case 3: returnValue = "Low gain down"; break; case 4: returnValue = "High gain down"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the contrast EXIF property. /// </summary> private string Contrast() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.Contrast); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Normal"; break; case 1: returnValue = "Soft"; break; case 2: returnValue = "Hard"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the saturation EXIF property. /// </summary> private string Saturation() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.Saturation); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Normal"; break; case 1: returnValue = "Low saturation"; break; case 2: returnValue = "High saturation"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the sharpness EXIF property. /// </summary> private string Sharpness() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.Sharpness); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Normal"; break; case 1: returnValue = "Soft"; break; case 2: returnValue = "Hard"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the subject distance range EXIF property. /// </summary> private string SubjectDistanceRange() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.SubjectDistanceRange); string returnValue = "EXIF property not found."; if (data.Length > 0) { switch (data[0]) { case 0: returnValue = "Unknown"; break; case 1: returnValue = "Macro"; break; case 2: returnValue = "Close view"; break; case 3: returnValue = "Distant view"; break; default: returnValue = "Reserved"; break; } } return returnValue; } /// <summary> /// This method returns the subject location EXIF property. /// </summary> private string SubjectLocation() { // Declare local variables. // Get the value for this EXIF property. byte[] data = GetPropertyValue(Definitions.exifCode.SubjectLocation); string returnValue = "EXIF property not found."; if (data.Length > 0) { returnValue = "(" + data[0].ToString() + ", " + data[1].ToString() + ")"; } return returnValue; } /// <summary> /// This method returns the digital zoom ratio EXIF property. /// </summary> private string DigitalZoomRatio() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational dzr = ParsedRational(Definitions.exifCode.DigitalZoomRatio); //Translate the EXIF code into a readable value. if (!dzr.Equals(null)) { returnValue = dzr.Numerator.ToString() + ":" + dzr.Denominator.ToString(); } return returnValue; } /// <summary> /// This method returns the brightness value EXIF property. /// </summary> private string BrightnessValue() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational data = ParsedRational(Definitions.exifCode.DigitalZoomRatio); //Translate the EXIF code into a readable value. if (!data.Equals(null)) { if ((long)data.Numerator >= Int32.MaxValue) { returnValue = "Unknown"; } else { returnValue = Math.Log(data.Numerator / data.Denominator, 2.0).ToString(); } } return returnValue; } /// <summary> /// This method returns the max aperture value EXIF property. /// </summary> private string MaxApertureValue() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational data = ParsedRational(Definitions.exifCode.MaxApertureValue); //Translate the EXIF code into a readable value. if (!data.Equals(null)) { returnValue = string.Format("f{0}", (double)(data.Numerator / data.Denominator)); } return returnValue; } /// <summary> /// This method returns the exposure bias value EXIF property. /// </summary> private string ExposureBiasValue() { //Declare local variables. string returnValue = "EXIF property not found."; EXIFRational data = ParsedRational(Definitions.exifCode.ExposureBiasValue); //Translate the EXIF code into a readable value. if (!data.Equals(null)) { returnValue = string.Format("f{0}", (double)(data.Numerator / data.Denominator)); } return returnValue; } #endregion #region -- Private helper functions -- // Private helper functions. /// <summary> /// This method retrieves the data from the propery items collection. /// </summary> private byte[] GetPropertyValue(Definitions.exifCode exifCode) { return _picture.GetPropertyItem((int)exifCode).Value; } /// <summary> /// This method returns string EXIF data. /// </summary> private string ParsedString(Definitions.exifCode exifCode) { // Declare local variables. // Retrieve the data for this EXIF property. byte[] data = GetPropertyValue(exifCode); // Holds the return value. string parsed = ""; // If there's data, go ahead and parse it. if (data.Length > 1) { // Allocate some memory. IntPtr h = Marshal.AllocHGlobal(data.Length); int i = 0; foreach (byte b in data) { Marshal.WriteByte(h, i, b); i++; } parsed = Marshal.PtrToStringAnsi(h); Marshal.FreeHGlobal(h); } return parsed; } /// <summary> /// This method returns rational EXIF data. /// </summary> private EXIFRational ParsedRational(Definitions.exifCode exifCode) { // Declare local variables. // Retrieve the data for this EXIF property. byte[] data = GetPropertyValue(exifCode); // Parse the data. EXIFRational parsed = new EXIFRational(data); return parsed; } /// <summary> /// This method returns an array of rational EXIF data. /// </summary> private EXIFRational[] ParsedRationalArray(Definitions.exifCode exifCode) { // Declare local variables. // Retrieve the data for this EXIF property. byte[] data = GetPropertyValue(exifCode); // Holds the return value. EXIFRational[] parsed = null; int arraySize = (data.Length / 8); if (arraySize > 0) { parsed = new EXIFRational[arraySize]; for (int i = 0; i < arraySize; i++) { parsed[i] = new EXIFRational(data, i * 8); } } return parsed; } /// <summary> /// This method returns date/time EXIF data. /// </summary> private DateTime ParsedDate(Definitions.exifCode exifCode) { // Declare local variables. // Create a new date object. DateTime ret = new DateTime(1900, 1, 1, 0, 0, 0); // Parse the data. string date = ParsedString(exifCode); // Format the data. if (date.Length >= 19) {
获取图片exif信息
06-15
相机序列号，快门次数，相机型号等
gma.Drawing.ImageInfo.rar_C#图片EXIF_C++图片exif信息_drawing_exif
09-22
在C#中，我们通常使用System.Drawing命名空间下的Image类来处理图片，但这个类并不直接支持读取EXIF数据。因此，"gma.Drawing.ImageInfo"库提供了更便捷的方法。 这个库的核心功能包括： 1. **EXIF信息读取**：通过...
c#使用ExifLib库提取图像的相机型号、光圈、快门、iso、曝光时间、焦距信息等EXIF信息
最新发布
weixin_32155265的博客
10-25 1157
读取一路径下的所有图片，然后提取每张图像的exif信息，并将结果显示到界面。开发上，语言选择c#，搭配WPF框架，并选择ExifLib这个轻量化的EXIF信息提取库获。
用C#读取图片的EXIF信息的方法（转）
weixin_34080903的博客
01-14 386
引言：EXIF，是英文Exchangeable Image File(可交换图像文件)的缩写，最初由日本电子工业发展协会(JEIDA --Japan Electronic Industry Development Association) 制订，目前的版本是修改发表于1998年6月的2.1版。国际标准化组织(ISO)正在制订的相机文件设计标准（DCF -- Design role for Came...
C#读取EXIF信息类
weixin_34344677的博客
08-29 144
[转]C#读取EXIF信息类 ExifWorks using System; using System.Collections.Generic; using System.Text; namespace ExifWorks { // // Utility class for working with EXIF data in images. Provides abstra...
C#读取XML文件的三种方法详解
"这篇文章主要讲解了C#编程中如何读取XML文件的实例代码，包括使用XmlDocument、XmlTextReader和LinqToXml三种方法。文章指出XML文件在多个领域广泛应用，如配置文件等，是一种结构化数据存储方式。文中还提到了DOM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值