jpeg 标志

最新推荐文章于 2022-05-17 19:47:55 发布
最新推荐文章于 2022-05-17 19:47:55 发布
阅读量1k 收藏
点赞数
分类专栏： C language 文章标签： string byte encoding image compression null
 
C#代码 复制代码
  1. DialogUtil openFolder = new DialogUtil();   
  2. if (openFolder.ShowFolderDialog() == DialogResult.OK)   
  3. {   
  4.     DirectoryInfo source = new DirectoryInfo(openFolder.Path);   
  5.     foreach (FileInfo fi in source.GetFiles("*.jpg"))   
  6.     {   
  7.         ExifManager exif = new ExifManager(fi.FullName);   
  8.         exif.DateTimeOriginal = exif.DateTimeOriginal.AddHours(12);   
  9.         exif.DateTimeDigitized = exif.DateTimeDigitized.AddHours(12);   
  10.         exif.Save(fi.DirectoryName + "\\new\\" + fi.Name);   
  11.         exif.Dispose();   
  12.     }   
  13. }  


C#代码 复制代码  收藏代码
  1. using System;   
  2. using System.Collections.Generic;   
  3. using System.Text;   
  4.   
  5. namespace ExifShow   
  6. {   
  7. //    
  8. // Utility class for working with EXIF data in images. Provides abstraction   
  9. // for most common data and generic utilities for work with all other.    
  10. //    
  11. //    
  12. // Copyright (c) Michal A. Valášek - Altair Communications, 2003-2005   
  13. // Copmany: http://software.altaircom.net, E-mail: support@altaircom.net   
  14. // Private: http://www.rider.cz, E-mail: rider@rider.cz   
  15. // This is free software licensed under GNU Lesser General Public License   
  16. //    
  17. //    
  18. // [altair] 10.09.2003 Created   
  19. // [altair] 12.06.2004 Added capability to write EXIF data   
  20. // [altair] 11.07.2004 Added option to change encoding   
  21. // [altair] 04.09.2005 Changed source of Width and Height properties from EXIF to image   
  22. // [altair] 05.09.2005 Code clean-up and minor changes   
  23. // [marco.ridoni@virgilio.it] 02-11-2006 C# translation   
  24. //    
  25. public class ExifManager : IDisposable   
  26. {   
  27.   
  28. private System.Drawing.Bitmap _Image;   
  29. private System.Text.Encoding _Encoding = System.Text.Encoding.UTF8;  
  30.  
  31. #region Type declarations   
  32.   
  33. //    
  34. // Contains possible values of EXIF tag names (ID)   
  35. //    
  36. // See GdiPlusImaging.h   
  37. //    
  38. // [altair] 10.09.2003 Created   
  39. //    
  40.   
  41. public enum TagNames : int  
  42. {   
  43. ExifIFD = 0x8769,   
  44. GpsIFD = 0x8825,   
  45. NewSubfileType = 0xFE,   
  46. SubfileType = 0xFF,   
  47. ImageWidth = 0x100,   
  48. ImageHeight = 0x101,   
  49. BitsPerSample = 0x102,   
  50. Compression = 0x103,   
  51. PhotometricInterp = 0x106,   
  52. ThreshHolding = 0x107,   
  53. CellWidth = 0x108,   
  54. CellHeight = 0x109,   
  55. FillOrder = 0x10A,   
  56. DocumentName = 0x10D,   
  57. ImageDescription = 0x10E,   
  58. EquipMake = 0x10F,   
  59. EquipModel = 0x110,   
  60. StripOffsets = 0x111,   
  61. Orientation = 0x112,   
  62. SamplesPerPixel = 0x115,   
  63. RowsPerStrip = 0x116,   
  64. StripBytesCount = 0x117,   
  65. MinSampleValue = 0x118,   
  66. MaxSampleValue = 0x119,   
  67. XResolution = 0x11A,   
  68. YResolution = 0x11B,   
  69. PlanarConfig = 0x11C,   
  70. PageName = 0x11D,   
  71. XPosition = 0x11E,   
  72. YPosition = 0x11F,   
  73. FreeOffset = 0x120,   
  74. FreeByteCounts = 0x121,   
  75. GrayResponseUnit = 0x122,   
  76. GrayResponseCurve = 0x123,   
  77. T4Option = 0x124,   
  78. T6Option = 0x125,   
  79. ResolutionUnit = 0x128,   
  80. PageNumber = 0x129,   
  81. TransferFuncition = 0x12D,   
  82. SoftwareUsed = 0x131,   
  83. DateTime = 0x132,   
  84. Artist = 0x13B,   
  85. HostComputer = 0x13C,   
  86. Predictor = 0x13D,   
  87. WhitePoint = 0x13E,   
  88. PrimaryChromaticities = 0x13F,   
  89. ColorMap = 0x140,   
  90. HalftoneHints = 0x141,   
  91. TileWidth = 0x142,   
  92. TileLength = 0x143,   
  93. TileOffset = 0x144,   
  94. TileByteCounts = 0x145,   
  95. InkSet = 0x14C,   
  96. InkNames = 0x14D,   
  97. NumberOfInks = 0x14E,   
  98. DotRange = 0x150,   
  99. TargetPrinter = 0x151,   
  100. ExtraSamples = 0x152,   
  101. SampleFormat = 0x153,   
  102. SMinSampleValue = 0x154,   
  103. SMaxSampleValue = 0x155,   
  104. TransferRange = 0x156,   
  105. JPEGProc = 0x200,   
  106. JPEGInterFormat = 0x201,   
  107. JPEGInterLength = 0x202,   
  108. JPEGRestartInterval = 0x203,   
  109. JPEGLosslessPredictors = 0x205,   
  110. JPEGPointTransforms = 0x206,   
  111. JPEGQTables = 0x207,   
  112. JPEGDCTables = 0x208,   
  113. JPEGACTables = 0x209,   
  114. YCbCrCoefficients = 0x211,   
  115. YCbCrSubsampling = 0x212,   
  116. YCbCrPositioning = 0x213,   
  117. REFBlackWhite = 0x214,   
  118. ICCProfile = 0x8773,   
  119. Gamma = 0x301,   
  120. ICCProfileDescriptor = 0x302,   
  121. SRGBRenderingIntent = 0x303,   
  122. ImageTitle = 0x320,   
  123. Copyright = 0x8298,   
  124. ResolutionXUnit = 0x5001,   
  125. ResolutionYUnit = 0x5002,   
  126. ResolutionXLengthUnit = 0x5003,   
  127. ResolutionYLengthUnit = 0x5004,   
  128. PrintFlags = 0x5005,   
  129. PrintFlagsVersion = 0x5006,   
  130. PrintFlagsCrop = 0x5007,   
  131. PrintFlagsBleedWidth = 0x5008,   
  132. PrintFlagsBleedWidthScale = 0x5009,   
  133. HalftoneLPI = 0x500A,   
  134. HalftoneLPIUnit = 0x500B,   
  135. HalftoneDegree = 0x500C,   
  136. HalftoneShape = 0x500D,   
  137. HalftoneMisc = 0x500E,   
  138. HalftoneScreen = 0x500F,   
  139. JPEGQuality = 0x5010,   
  140. GridSize = 0x5011,   
  141. ThumbnailFormat = 0x5012,   
  142. ThumbnailWidth = 0x5013,   
  143. ThumbnailHeight = 0x5014,   
  144. ThumbnailColorDepth = 0x5015,   
  145. ThumbnailPlanes = 0x5016,   
  146. ThumbnailRawBytes = 0x5017,   
  147. ThumbnailSize = 0x5018,   
  148. ThumbnailCompressedSize = 0x5019,   
  149. ColorTransferFunction = 0x501A,   
  150. ThumbnailData = 0x501B,   
  151. ThumbnailImageWidth = 0x5020,   
  152. ThumbnailImageHeight = 0x502,   
  153. ThumbnailBitsPerSample = 0x5022,   
  154. ThumbnailCompression = 0x5023,   
  155. ThumbnailPhotometricInterp = 0x5024,   
  156. ThumbnailImageDescription = 0x5025,   
  157. ThumbnailEquipMake = 0x5026,   
  158. ThumbnailEquipModel = 0x5027,   
  159. ThumbnailStripOffsets = 0x5028,   
  160. ThumbnailOrientation = 0x5029,   
  161. ThumbnailSamplesPerPixel = 0x502A,   
  162. ThumbnailRowsPerStrip = 0x502B,   
  163. ThumbnailStripBytesCount = 0x502C,   
  164. ThumbnailResolutionX = 0x502D,   
  165. ThumbnailResolutionY = 0x502E,   
  166. ThumbnailPlanarConfig = 0x502F,   
  167. ThumbnailResolutionUnit = 0x5030,   
  168. ThumbnailTransferFunction = 0x5031,   
  169. ThumbnailSoftwareUsed = 0x5032,   
  170. ThumbnailDateTime = 0x5033,   
  171. ThumbnailArtist = 0x5034,   
  172. ThumbnailWhitePoint = 0x5035,   
  173. ThumbnailPrimaryChromaticities = 0x5036,   
  174. ThumbnailYCbCrCoefficients = 0x5037,   
  175. ThumbnailYCbCrSubsampling = 0x5038,   
  176. ThumbnailYCbCrPositioning = 0x5039,   
  177. ThumbnailRefBlackWhite = 0x503A,   
  178. ThumbnailCopyRight = 0x503B,   
  179. LuminanceTable = 0x5090,   
  180. ChrominanceTable = 0x5091,   
  181. FrameDelay = 0x5100,   
  182. LoopCount = 0x5101,   
  183. PixelUnit = 0x5110,   
  184. PixelPerUnitX = 0x5111,   
  185. PixelPerUnitY = 0x5112,   
  186. PaletteHistogram = 0x5113,   
  187. ExifExposureTime = 0x829A,   
  188. ExifFNumber = 0x829D,   
  189. ExifExposureProg = 0x8822,   
  190. ExifSpectralSense = 0x8824,   
  191. ExifISOSpeed = 0x8827,   
  192. ExifOECF = 0x8828,   
  193. ExifVer = 0x9000,   
  194. ExifDTOrig = 0x9003,   
  195. ExifDTDigitized = 0x9004,   
  196. ExifCompConfig = 0x9101,   
  197. ExifCompBPP = 0x9102,   
  198. ExifShutterSpeed = 0x9201,   
  199. ExifAperture = 0x9202,   
  200. ExifBrightness = 0x9203,   
  201. ExifExposureBias = 0x9204,   
  202. ExifMaxAperture = 0x9205,   
  203. ExifSubjectDist = 0x9206,   
  204. ExifMeteringMode = 0x9207,   
  205. ExifLightSource = 0x9208,   
  206. ExifFlash = 0x9209,   
  207. ExifFocalLength = 0x920A,   
  208. ExifMakerNote = 0x927C,   
  209. ExifUserComment = 0x9286,   
  210. ExifDTSubsec = 0x9290,   
  211. ExifDTOrigSS = 0x9291,   
  212. ExifDTDigSS = 0x9292,   
  213. ExifFPXVer = 0xA000,   
  214. ExifColorSpace = 0xA001,   
  215. ExifPixXDim = 0xA002,   
  216. ExifPixYDim = 0xA003,   
  217. ExifRelatedWav = 0xA004,   
  218. ExifInterop = 0xA005,   
  219. ExifFlashEnergy = 0xA20B,   
  220. ExifSpatialFR = 0xA20C,   
  221. ExifFocalXRes = 0xA20E,   
  222. ExifFocalYRes = 0xA20F,   
  223. ExifFocalResUnit = 0xA210,   
  224. ExifSubjectLoc = 0xA214,   
  225. ExifExposureIndex = 0xA215,   
  226. ExifSensingMethod = 0xA217,   
  227. ExifFileSource = 0xA300,   
  228. ExifSceneType = 0xA301,   
  229. ExifCfaPattern = 0xA302,   
  230. GpsVer = 0x0,   
  231. GpsLatitudeRef = 0x1,   
  232. GpsLatitude = 0x2,   
  233. GpsLongitudeRef = 0x3,   
  234. GpsLongitude = 0x4,   
  235. GpsAltitudeRef = 0x5,   
  236. GpsAltitude = 0x6,   
  237. GpsGpsTime = 0x7,   
  238. GpsGpsSatellites = 0x8,   
  239. GpsGpsStatus = 0x9,   
  240. GpsGpsMeasureMode = 0xA,   
  241. GpsGpsDop = 0xB,   
  242. GpsSpeedRef = 0xC,   
  243. GpsSpeed = 0xD,   
  244. GpsTrackRef = 0xE,   
  245. GpsTrack = 0xF,   
  246. GpsImgDirRef = 0x10,   
  247. GpsImgDir = 0x11,   
  248. GpsMapDatum = 0x12,   
  249. GpsDestLatRef = 0x13,   
  250. GpsDestLat = 0x14,   
  251. GpsDestLongRef = 0x15,   
  252. GpsDestLong = 0x16,   
  253. GpsDestBearRef = 0x17,   
  254. GpsDestBear = 0x18,   
  255. GpsDestDistRef = 0x19,   
  256. GpsDestDist = 0x1A   
  257. }   
  258.   
  259.   
  260. //    
  261. // Real position of 0th row and column of picture   
  262. //    
  263. //    
  264. //    
  265. // [altair] 10.09.2003 Created   
  266. //    
  267.   
  268. public enum Orientations   
  269. {   
  270. TopLeft = 1,   
  271. TopRight = 2,   
  272. BottomRight = 3,   
  273. BottomLeft = 4,   
  274. LeftTop = 5,   
  275. RightTop = 6,   
  276. RightBottom = 7,   
  277. LftBottom = 8   
  278. }   
  279.   
  280.   
  281. //    
  282. // Exposure programs   
  283. //    
  284. //    
  285. //    
  286. // [altair] 10.09.2003 Created   
  287. //    
  288.   
  289. public enum ExposurePrograms   
  290. {   
  291. Manual = 1,   
  292. Normal = 2,   
  293. AperturePriority = 3,   
  294. ShutterPriority = 4,   
  295. Creative = 5,   
  296. Action = 6,   
  297. Portrait = 7,   
  298. Landscape = 8,   
  299. }   
  300.   
  301.   
  302. //    
  303. // Exposure metering modes   
  304. //    
  305. //    
  306. //    
  307. // [altair] 10.09.2003 Created   
  308. //    
  309.   
  310. public enum ExposureMeteringModes   
  311. {   
  312. Unknown = 0,   
  313. Average = 1,   
  314. CenterWeightedAverage = 2,   
  315. Spot = 3,   
  316. MultiSpot = 4,   
  317. MultiSegment = 5,   
  318. Partial = 6,   
  319. Other = 255   
  320. }   
  321.   
  322.   
  323. //    
  324. // Flash activity modes   
  325. //    
  326. //    
  327. //    
  328. // [altair] 10.09.2003 Created   
  329. //    
  330.   
  331. public enum FlashModes   
  332. {   
  333. NotFired = 0,   
  334. Fired = 1,   
  335. FiredButNoStrobeReturned = 5,   
  336. FiredAndStrobeReturned = 7,   
  337. }   
  338.   
  339.   
  340. //    
  341. // Possible light sources (white balance)   
  342. //    
  343. //    
  344. //    
  345. // [altair] 10.09.2003 Created   
  346. //    
  347.   
  348. public enum LightSources   
  349. {   
  350. Unknown = 0,   
  351. Daylight = 1,   
  352. Fluorescent = 2,   
  353. Tungsten = 3,   
  354. Flash = 10,   
  355. StandardLightA = 17,   
  356. StandardLightB = 18,   
  357. StandardLightC = 19,   
  358. D55 = 20,   
  359. D65 = 21,   
  360. D75 = 22,   
  361. Other = 255   
  362. }   
  363.   
  364.   
  365. //    
  366. // EXIF data types   
  367. //    
  368. //    
  369. //    
  370. // [altair] 12.6.2004 Created   
  371. //    
  372. public enum ExifDataTypes : short  
  373. {   
  374. UnsignedByte = 1,   
  375. AsciiString = 2,   
  376. UnsignedShort = 3,   
  377. UnsignedLong = 4,   
  378. UnsignedRational = 5,   
  379. SignedByte = 6,   
  380. Undefined = 7,   
  381. SignedShort = 8,   
  382. SignedLong = 9,   
  383. SignedRational = 10,   
  384. SingleFloat = 11,   
  385. DoubleFloat = 12   
  386. }   
  387.   
  388.   
  389. //    
  390. // Represents rational which is type of some Exif properties   
  391. //    
  392. //    
  393. //    
  394. // [altair] 10.09.2003 Created   
  395. //    
  396. public struct Rational   
  397. {   
  398. public Int32 Numerator;   
  399. public Int32 Denominator;   
  400.   
  401.   
  402. //    
  403. // Converts rational to string representation   
  404. //    
  405. // Optional, default "/". String to be used as delimiter of components.   
  406. // String representation of the rational.   
  407. //    
  408. //    
  409. // [altair] 10.09.2003 Created   
  410. //    
  411.   
  412. public override string ToString()   
  413. {   
  414. return ToString("/");   
  415. }   
  416.   
  417. public string ToString(string Delimiter)   
  418. {   
  419. return Numerator + "/" + Denominator;   
  420. }   
  421.   
  422. //    
  423. // Converts rational to double precision real number   
  424. //    
  425. // The rational as double precision real number.   
  426. //    
  427. //    
  428. // [altair] 10.09.2003 Created   
  429. //    
  430.   
  431. public double ToDouble()   
  432. {   
  433. return (double)Numerator / Denominator;   
  434. }   
  435. }  
  436.  
  437. #endregion   
  438.   
  439. //    
  440. // Initializes new instance of this class.   
  441. //    
  442. // Bitmap to read exif information from   
  443. //    
  444. //    
  445. // [altair] 10.09.2003 Created   
  446. //    
  447. public ExifManager(System.Drawing.Bitmap Bitmap)   
  448. {   
  449. if (Bitmap == null)   
  450. throw new ArgumentNullException("Bitmap");   
  451. this._Image = Bitmap;   
  452. }   
  453.   
  454. //    
  455. // Initializes new instance of this class.   
  456. //    
  457. // Name of file to be loaded   
  458. //    
  459. //    
  460. // [altair] 13.06.2004 Created   
  461. //    
  462. public ExifManager(string FileName)   
  463. {   
  464. this._Image = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile(FileName);   
  465. }   
  466.   
  467. //    
  468. // Get or set encoding used for string metadata   
  469. //    
  470. // Encoding used for string metadata   
  471. // Default encoding is UTF-8   
  472. //    
  473. // [altair] 11.07.2004 Created   
  474. // [altair] 05.09.2005 Changed from shared to instance member   
  475. //    
  476. public System.Text.Encoding Encoding   
  477. {   
  478. get  
  479. {   
  480. return this._Encoding;   
  481. }   
  482. set  
  483. {   
  484. if (value == null)   
  485. throw new ArgumentNullException();   
  486. this._Encoding = value;   
  487. }   
  488. }   
  489.   
  490. //    
  491. // Returns copy of bitmap this instance is working on   
  492. //    
  493. //    
  494. //    
  495. //    
  496. // [altair] 13.06.2004 Created   
  497. //    
  498. public System.Drawing.Bitmap GetBitmap()   
  499. {   
  500. return (System.Drawing.Bitmap)this._Image.Clone();   
  501. }   
  502.   
  503. //    
  504. // Returns all available data in formatted string form   
  505. //    
  506. //    
  507. //    
  508. //    
  509. // [altair] 10.09.2003 Created   
  510. //    
  511. public override string ToString()   
  512. {   
  513. System.Text.StringBuilder SB = new StringBuilder();   
  514.   
  515. SB.Append("照片信息:");   
  516. SB.Append("\n\t尺寸: " + this.Width + " x " + this.Height + " px");   
  517. SB.Append("\n\t分辨率: " + this.ResolutionX + " x " + this.ResolutionY + " dpi");   
  518. SB.Append("\n\t方向: " + Enum.GetName(typeof(Orientations), this.Orientation));   
  519. SB.Append("\n\t标题: " + this.Title);   
  520. SB.Append("\n\t描述: " + this.Description);   
  521. SB.Append("\n\t作者: " + this.Artist);   
  522. SB.Append("\n\t版权信息: " + this.Copyright);   
  523. SB.Append("\n相机信息:");   
  524. SB.Append("\n\t制造商: " + this.EquipmentMaker);   
  525. SB.Append("\n\t型号: " + this.EquipmentModel);   
  526. SB.Append("\n\t编辑软件: " + this.Software);   
  527. SB.Append("\n时间信息:");   
  528. SB.Append("\n\t最后编辑时间: " + this.DateTimeLastModified.ToString());   
  529. SB.Append("\n\t原始拍照时间: " + this.DateTimeOriginal.ToString());   
  530. SB.Append("\n\t数字化时间: " + this.DateTimeDigitized.ToString());   
  531. SB.Append("\n拍摄信息:");   
  532. SB.Append("\n\t曝光时间: " + this.ExposureTime.ToString("N4") + " s");   
  533. SB.Append("\n\t曝光模式: " + Enum.GetName(typeof(ExposurePrograms), this.ExposureProgram));   
  534. SB.Append("\n\t测光模式: " + Enum.GetName(typeof(ExposureMeteringModes), this.ExposureMeteringMode));   
  535. SB.Append("\n\t光圈值: F" + this.Aperture.ToString("N1"));   
  536. SB.Append("\n\tISO感光度: " + this.ISO);   
  537. SB.Append("\n\t拍摄距离: " + this.SubjectDistance.ToString("N2") + " m");   
  538. SB.Append("\n\t焦距: " + this.FocalLength + " mm");   
  539. SB.Append("\n\t闪光灯: " + Enum.GetName(typeof(FlashModes), this.FlashMode));   
  540. SB.Append("\n\t白平衡(WB): " + Enum.GetName(typeof(LightSources), this.LightSource));   
  541. //SB.Replace("\n", vbCrLf);   
  542. //SB.Replace("\t", vbTab);   
  543. return SB.ToString();   
  544. }  
  545.  
  546. #region Nicely formatted well-known properties   
  547.   
  548. //    
  549. // Brand of equipment (EXIF EquipMake)   
  550. //    
  551. //    
  552. //    
  553. //    
  554. // [altair] 10.09.2003 Created   
  555. //    
  556. public string EquipmentMaker   
  557. {   
  558. get  
  559. {   
  560. return this.GetPropertyString((int)TagNames.EquipMake);   
  561. }   
  562. }   
  563.   
  564. //    
  565. // Model of equipment (EXIF EquipModel)   
  566. //    
  567. //    
  568. //    
  569. //    
  570. // [altair] 10.09.2003 Created   
  571. //    
  572. public string EquipmentModel   
  573. {   
  574. get  
  575. {   
  576. return this.GetPropertyString((int)TagNames.EquipModel);   
  577. }   
  578. }   
  579.   
  580. //    
  581. // Software used for processing (EXIF Software)   
  582. //    
  583. //    
  584. //    
  585. //    
  586. // [altair] 10.09.2003 Created   
  587. //    
  588. public string Software   
  589. {   
  590. get  
  591. {   
  592. return this.GetPropertyString((int)TagNames.SoftwareUsed);   
  593. }   
  594. }   
  595.   
  596. //    
  597. // Orientation of image (position of row 0, column 0) (EXIF Orientation)   
  598. //    
  599. //    
  600. //    
  601. //    
  602. // [altair] 10.09.2003 Created   
  603. //    
  604. public Orientations Orientation   
  605. {   
  606. get  
  607. {   
  608. Int32 X = this.GetPropertyInt16((int)TagNames.Orientation);   
  609.   
  610. if (!Enum.IsDefined(typeof(Orientations), X))   
  611. return Orientations.TopLeft;   
  612. else  
  613. return (Orientations)Enum.Parse(typeof(Orientations), Enum.GetName(typeof(Orientations), X));   
  614. }   
  615. }   
  616.   
  617. //    
  618. // Time when image was last modified (EXIF DateTime).   
  619. //    
  620. //    
  621. //    
  622. //    
  623. // [altair] 10.09.2003 Created   
  624. //    
  625. public DateTime DateTimeLastModified   
  626. {   
  627. get  
  628. {   
  629. try  
  630. {   
  631. return DateTime.ParseExact(this.GetPropertyString((int)TagNames.DateTime), @"yyyy\:MM\:dd HH\:mm\:ss", null);   
  632. }   
  633. catch  
  634. {   
  635. return DateTime.MinValue;   
  636. }   
  637. }   
  638. set  
  639. {   
  640. try  
  641. {   
  642. this.SetPropertyString((int)TagNames.DateTime, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));   
  643. }   
  644. catch  
  645. { }   
  646. }   
  647. }   
  648.   
  649. //    
  650. // Time when image was taken (EXIF DateTimeOriginal).   
  651. //    
  652. //    
  653. //    
  654. //    
  655. // [altair] 10.09.2003 Created   
  656. //    
  657. public DateTime DateTimeOriginal   
  658. {   
  659. get  
  660. {   
  661. try  
  662. {   
  663. return DateTime.ParseExact(this.GetPropertyString((int)TagNames.ExifDTOrig), @"yyyy\:MM\:dd HH\:mm\:ss", null);   
  664. }   
  665. catch  
  666. {   
  667. return DateTime.MinValue;   
  668. }   
  669. }   
  670. set  
  671. {   
  672. try  
  673. {   
  674. this.SetPropertyString((int)TagNames.ExifDTOrig, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));   
  675. }   
  676. catch  
  677. { }   
  678. }   
  679. }   
  680.   
  681. //    
  682. // Time when image was digitized (EXIF DateTimeDigitized).   
  683. //    
  684. //    
  685. //    
  686. //    
  687. // [altair] 10.09.2003 Created   
  688. //    
  689. public DateTime DateTimeDigitized   
  690. {   
  691. get  
  692. {   
  693. try  
  694. {   
  695. return DateTime.ParseExact(this.GetPropertyString((int)TagNames.ExifDTDigitized), @"yyyy\:MM\:dd HH\:mm\:ss", null);   
  696. }   
  697. catch  
  698. {   
  699. return DateTime.MinValue;   
  700. }   
  701. }   
  702. set  
  703. {   
  704. try  
  705. {   
  706. this.SetPropertyString((int)TagNames.ExifDTDigitized, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));   
  707. }   
  708. catch  
  709. { }   
  710. }   
  711. }   
  712.   
  713. //    
  714. // Image width   
  715. //    
  716. //    
  717. //    
  718. //    
  719. // [altair] 10.09.2003 Created   
  720. // [altair] 04.09.2005 Changed output to Int32, load from image instead of EXIF   
  721. //    
  722. public Int32 Width   
  723. {   
  724. get { return this._Image.Width; }   
  725. }   
  726.   
  727. //    
  728. // Image height   
  729. //    
  730. //    
  731. //    
  732. //    
  733. // [altair] 10.09.2003 Created   
  734. // [altair] 04.09.2005 Changed output to Int32, load from image instead of EXIF   
  735. //    
  736. public Int32 Height   
  737. {   
  738. get { return this._Image.Height; }   
  739. }   
  740.   
  741. //    
  742. // X resolution in dpi (EXIF XResolution/ResolutionUnit)   
  743. //    
  744. //    
  745. //    
  746. //    
  747. // [altair] 10.09.2003 Created   
  748. //    
  749. public double ResolutionX   
  750. {   
  751. get  
  752. {   
  753. double R = this.GetPropertyRational((int)TagNames.XResolution).ToDouble();   
  754.   
  755. if (this.GetPropertyInt16((int)TagNames.ResolutionUnit) == 3)   
  756. {   
  757. // -- resolution is in points/cm   
  758. return R * 2.54;   
  759. }   
  760. else  
  761. {   
  762. // -- resolution is in points/inch   
  763. return R;   
  764. }   
  765. }   
  766. }   
  767.   
  768. //    
  769. // Y resolution in dpi (EXIF YResolution/ResolutionUnit)   
  770. //    
  771. //    
  772. //    
  773. //    
  774. // [altair] 10.09.2003 Created   
  775. //    
  776. public double ResolutionY   
  777. {   
  778. get  
  779. {   
  780. double R = this.GetPropertyRational((int)TagNames.YResolution).ToDouble();   
  781.   
  782. if (this.GetPropertyInt16((int)TagNames.ResolutionUnit) == 3)   
  783. {   
  784. // -- resolution is in points/cm   
  785. return R * 2.54;   
  786. }   
  787. else  
  788. {   
  789. // -- resolution is in points/inch   
  790. return R;   
  791. }   
  792. }   
  793. }   
  794.   
  795. //    
  796. // Image title (EXIF ImageTitle)   
  797. //    
  798. //    
  799. //    
  800. //    
  801. // [altair] 10.09.2003 Created   
  802. //    
  803. public string Title   
  804. {   
  805. get  
  806. {   
  807. return this.GetPropertyString((int)TagNames.ImageTitle);   
  808. }   
  809. set  
  810. {   
  811. try  
  812. {   
  813. this.SetPropertyString((int)TagNames.ImageTitle, value);   
  814. }   
  815. catch { }   
  816. }   
  817. }   
  818.   
  819. //    
  820. // User comment (EXIF UserComment)   
  821. //    
  822. //    
  823. //    
  824. //    
  825. // [altair] 13.06.2004 Created   
  826. //    
  827. public string UserComment   
  828. {   
  829. get  
  830. {   
  831. return this.GetPropertyString((int)TagNames.ExifUserComment);   
  832. }   
  833. set  
  834. {   
  835. try  
  836. {   
  837. this.SetPropertyString((int)TagNames.ExifUserComment, value);   
  838. }   
  839. catch { }   
  840. }   
  841. }   
  842.   
  843. //    
  844. // Artist name (EXIF Artist)   
  845. //    
  846. //    
  847. //    
  848. //    
  849. // [altair] 13.06.2004 Created   
  850. //    
  851. public string Artist   
  852. {   
  853. get  
  854. {   
  855. return this.GetPropertyString((int)TagNames.Artist);   
  856. }   
  857. set  
  858. {   
  859. try  
  860. {   
  861. this.SetPropertyString((int)TagNames.Artist, value);   
  862. }   
  863. catch { }   
  864. }   
  865. }   
  866.   
  867. //    
  868. // Image description (EXIF ImageDescription)   
  869. //    
  870. //    
  871. //    
  872. //    
  873. // [altair] 10.09.2003 Created   
  874. //    
  875. public string Description   
  876. {   
  877. get  
  878. {   
  879. return this.GetPropertyString((int)TagNames.ImageDescription);   
  880. }   
  881. set  
  882. {   
  883. try  
  884. {   
  885. this.SetPropertyString((int)TagNames.ImageDescription, value);   
  886. }   
  887. catch { }   
  888. }   
  889. }   
  890.   
  891. //    
  892. // Image copyright (EXIF Copyright)   
  893. //    
  894. //    
  895. //    
  896. //    
  897. // [altair] 10.09.2003 Created   
  898. //    
  899. public string Copyright   
  900. {   
  901. get  
  902. {   
  903. return this.GetPropertyString((int)TagNames.Copyright);   
  904. }   
  905. set  
  906. {   
  907. try  
  908. {   
  909. this.SetPropertyString((int)TagNames.Copyright, value);   
  910. }   
  911. catch { }   
  912. }   
  913. }   
  914.   
  915.   
  916. //    
  917. // Exposure time in seconds (EXIF ExifExposureTime/ExifShutterSpeed)   
  918. //    
  919. //    
  920. //    
  921. //    
  922. // [altair] 10.09.2003 Created   
  923. //    
  924. public double ExposureTimeAbs   
  925. {   
  926. get  
  927. {   
  928. if (this.IsPropertyDefined((int)TagNames.ExifExposureTime))   
  929. // -- Exposure time is explicitly specified   
  930. return this.GetPropertyRational((int)TagNames.ExifExposureTime).ToDouble();   
  931. else  
  932. if (this.IsPropertyDefined((int)TagNames.ExifShutterSpeed))   
  933. //'-- Compute exposure time from shutter spee    
  934. return (1 / Math.Pow(2, this.GetPropertyRational((int)TagNames.ExifShutterSpeed).ToDouble()));   
  935. else  
  936. // -- Can't figure out    
  937. return 0;   
  938. }   
  939. }   
  940.   
  941. public Rational ExposureTime   
  942. {   
  943. get  
  944. {   
  945. if (this.IsPropertyDefined((int)TagNames.ExifExposureTime))   
  946. // -- Exposure time is explicitly specified   
  947. return this.GetPropertyRational((int)TagNames.ExifExposureTime);   
  948. else  
  949. return new Rational();   
  950. }   
  951. }   
  952.   
  953. //    
  954. // Aperture value as F number (EXIF ExifFNumber/ExifApertureValue)   
  955. //    
  956. //    
  957. //    
  958. //    
  959. // [altair] 10.09.2003 Created   
  960. //    
  961. public double Aperture   
  962. {   
  963. get  
  964. {   
  965. if (this.IsPropertyDefined((int)TagNames.ExifFNumber))   
  966. return this.GetPropertyRational((int)TagNames.ExifFNumber).ToDouble();   
  967. else  
  968. if (this.IsPropertyDefined((int)TagNames.ExifAperture))   
  969. return Math.Pow(System.Math.Sqrt(2), this.GetPropertyRational((int)TagNames.ExifAperture).ToDouble());   
  970. else  
  971. return 0;   
  972. }   
  973. }   
  974.   
  975. //    
  976. // Exposure program used (EXIF ExifExposureProg)   
  977. //    
  978. //    
  979. // If not specified, returns Normal (2)   
  980. //    
  981. // [altair] 10.09.2003 Created   
  982. //    
  983. public ExposurePrograms ExposureProgram   
  984. {   
  985. get  
  986. {   
  987. Int32 X = this.GetPropertyInt16((int)TagNames.ExifExposureProg);   
  988.   
  989. if (Enum.IsDefined(typeof(ExposurePrograms), X))   
  990. return (ExposurePrograms)Enum.Parse(typeof(ExposurePrograms), Enum.GetName(typeof(ExposurePrograms), X));   
  991. else  
  992. return ExposurePrograms.Normal;   
  993. }   
  994. }   
  995.   
  996. //    
  997. // ISO sensitivity   
  998. //    
  999. //    
  1000. //    
  1001. //    
  1002. // [altair] 10.09.2003 Created   
  1003. //    
  1004. public Int16 ISO   
  1005. {   
  1006. get { return this.GetPropertyInt16((int)TagNames.ExifISOSpeed); }   
  1007. }   
  1008.   
  1009. //    
  1010. // Subject distance in meters (EXIF SubjectDistance)   
  1011. //    
  1012. //    
  1013. //    
  1014. //    
  1015. // [altair] 10.09.2003 Created   
  1016. //    
  1017. public double SubjectDistance   
  1018. {   
  1019. get { return this.GetPropertyRational((int)TagNames.ExifSubjectDist).ToDouble(); }   
  1020. }   
  1021.   
  1022. //    
  1023. // Exposure method metering mode used (EXIF MeteringMode)   
  1024. //    
  1025. //    
  1026. // If not specified, returns Unknown (0)   
  1027. //    
  1028. // [altair] 10.09.2003 Created   
  1029. //    
  1030. public ExposureMeteringModes ExposureMeteringMode   
  1031. {   
  1032. get  
  1033. {   
  1034. Int32 X = this.GetPropertyInt16((int)TagNames.ExifMeteringMode);   
  1035.   
  1036. if (Enum.IsDefined(typeof(ExposureMeteringModes), X))   
  1037. return (ExposureMeteringModes)Enum.Parse(typeof(ExposureMeteringModes), Enum.GetName(typeof(ExposureMeteringModes), X));   
  1038. else  
  1039. return ExposureMeteringModes.Unknown;   
  1040. }   
  1041. }   
  1042.   
  1043. //    
  1044. // Focal length of lenses in mm (EXIF FocalLength)   
  1045. //    
  1046. //    
  1047. //    
  1048. //    
  1049. // [altair] 10.09.2003 Created   
  1050. //    
  1051. public double FocalLength   
  1052. {   
  1053. get { return this.GetPropertyRational((int)TagNames.ExifFocalLength).ToDouble(); }   
  1054. }   
  1055.   
  1056. //    
  1057. // Flash mode (EXIF Flash)   
  1058. //    
  1059. //    
  1060. // If not present, value NotFired (0) is returned   
  1061. //    
  1062. // [altair] 10.09.2003 Created   
  1063. //    
  1064. public FlashModes FlashMode   
  1065. {   
  1066. get  
  1067. {   
  1068. Int32 X = this.GetPropertyInt16((int)TagNames.ExifFlash);   
  1069.   
  1070. if (Enum.IsDefined(typeof(FlashModes), X))   
  1071. return (FlashModes)Enum.Parse(typeof(FlashModes), Enum.GetName(typeof(FlashModes), X));   
  1072. else  
  1073. return FlashModes.NotFired;   
  1074. }   
  1075. }   
  1076.   
  1077. //    
  1078. // Light source / white balance (EXIF LightSource)   
  1079. //    
  1080. //    
  1081. // If not specified, returns Unknown (0).   
  1082. //    
  1083. // [altair] 10.09.2003 Created   
  1084. //    
  1085. public LightSources LightSource   
  1086. {   
  1087. get  
  1088. {   
  1089. Int32 X = this.GetPropertyInt16((int)TagNames.ExifLightSource);   
  1090.   
  1091. if (Enum.IsDefined(typeof(LightSources), X))   
  1092. return (LightSources)Enum.Parse(typeof(LightSources), Enum.GetName(typeof(LightSources), X));   
  1093. else  
  1094. return LightSources.Unknown;   
  1095. }   
  1096. }  
  1097.  
  1098. #endregion  
  1099.  
  1100. #region Support methods for working with EXIF properties   
  1101.   
  1102. //    
  1103. // Checks if current image has specified certain property   
  1104. //    
  1105. //    
  1106. // True if image has specified property, False otherwise.   
  1107. //    
  1108. //    
  1109. // [altair] 10.09.2003 Created   
  1110. //    
  1111. public bool IsPropertyDefined(Int32 PID)   
  1112. {   
  1113. return (Array.IndexOf(this._Image.PropertyIdList, PID) > -1);   
  1114. }   
  1115.   
  1116. //    
  1117. // Gets specified Int32 property   
  1118. //    
  1119. // Property ID   
  1120. // Optional, default 0. Default value returned if property is not present.   
  1121. // Value of property or DefaultValue if property is not present.   
  1122. //    
  1123. //    
  1124. // [altair] 10.09.2003 Created   
  1125. //    
  1126. public Int32 GetPropertyInt32(Int32 PID)   
  1127. {   
  1128. return GetPropertyInt32(PID, 0);   
  1129. }   
  1130.   
  1131. public Int32 GetPropertyInt32(Int32 PID, Int32 DefaultValue)   
  1132. {   
  1133. if (IsPropertyDefined(PID))   
  1134. return GetInt32(this._Image.GetPropertyItem(PID).Value);   
  1135. else  
  1136. return DefaultValue;   
  1137. }   
  1138.   
  1139. //    
  1140. // Gets specified Int16 property   
  1141. //    
  1142. // Property ID   
  1143. // Optional, default 0. Default value returned if property is not present.   
  1144. // Value of property or DefaultValue if property is not present.   
  1145. //    
  1146. //    
  1147. // [altair] 10.09.2003 Created   
  1148. //    
  1149. public Int16 GetPropertyInt16(Int32 PID)   
  1150. {   
  1151. return GetPropertyInt16(PID, 0);   
  1152. }   
  1153.   
  1154. public Int16 GetPropertyInt16(Int32 PID, Int16 DefaultValue)   
  1155. {   
  1156. if (IsPropertyDefined(PID))   
  1157. return GetInt16(this._Image.GetPropertyItem(PID).Value);   
  1158. else  
  1159. return DefaultValue;   
  1160. }   
  1161.   
  1162. //    
  1163. // Gets specified string property   
  1164. //    
  1165. // Property ID   
  1166. // Optional, default String.Empty. Default value returned if property is not present.   
  1167. //    
  1168. // Value of property or DefaultValue if property is not present.   
  1169. //    
  1170. // [altair] 10.09.2003 Created   
  1171. //    
  1172. public string GetPropertyString(Int32 PID)   
  1173. {   
  1174. return GetPropertyString(PID, "");   
  1175. }   
  1176.   
  1177. public string GetPropertyString(Int32 PID, string DefaultValue)   
  1178. {   
  1179. if (IsPropertyDefined(PID))   
  1180. return GetString(this._Image.GetPropertyItem(PID).Value);   
  1181. else  
  1182. return DefaultValue;   
  1183. }   
  1184.   
  1185. //    
  1186. // Gets specified property in raw form   
  1187. //    
  1188. // Property ID   
  1189. // Optional, default Nothing. Default value returned if property is not present.   
  1190. //    
  1191. // Is recommended to use typed methods (like etc.) instead, when possible.   
  1192. //    
  1193. // [altair] 05.09.2005 Created   
  1194. //    
  1195. public byte[] GetProperty(Int32 PID, byte[] DefaultValue)   
  1196. {   
  1197. if (IsPropertyDefined(PID))   
  1198. return this._Image.GetPropertyItem(PID).Value;   
  1199. else  
  1200. return DefaultValue;   
  1201. }   
  1202.   
  1203. public byte[] GetProperty(Int32 PID)   
  1204. {   
  1205. return GetProperty(PID, null);   
  1206. }   
  1207.   
  1208. //    
  1209. // Gets specified rational property   
  1210. //    
  1211. // Property ID   
  1212. //    
  1213. // Value of property or 0/1 if not present.   
  1214. //    
  1215. // [altair] 10.09.2003 Created   
  1216. //    
  1217. public Rational GetPropertyRational(Int32 PID)   
  1218. {   
  1219. if (IsPropertyDefined(PID))   
  1220. return GetRational(this._Image.GetPropertyItem(PID).Value);   
  1221. else  
  1222. {   
  1223. Rational R;   
  1224. R.Numerator = 0;   
  1225. R.Denominator = 1;   
  1226. return R;   
  1227. }   
  1228. }   
  1229.   
  1230. //    
  1231. // Sets specified string property   
  1232. //    
  1233. // Property ID   
  1234. // Value to be set   
  1235. //    
  1236. //    
  1237. // [altair] 12.6.2004 Created   
  1238. //    
  1239. public void SetPropertyString(Int32 PID, string Value)   
  1240. {   
  1241. byte[] Data = this._Encoding.GetBytes(Value + '\0');   
  1242. SetProperty(PID, Data, ExifDataTypes.AsciiString);   
  1243. }   
  1244.   
  1245. //    
  1246. // Sets specified Int16 property   
  1247. //    
  1248. // Property ID   
  1249. // Value to be set   
  1250. //    
  1251. //    
  1252. // [altair] 12.6.2004 Created   
  1253. //    
  1254. public void SetPropertyInt16(Int32 PID, Int16 Value)   
  1255. {   
  1256. byte[] Data = new byte[2];   
  1257. Data[0] = (byte)(Value & 0xFF);   
  1258. Data[1] = (byte)((Value & 0xFF00) >> 8);   
  1259. SetProperty(PID, Data, ExifDataTypes.SignedShort);   
  1260. }   
  1261.   
  1262. //    
  1263. // Sets specified Int32 property   
  1264. //    
  1265. // Property ID   
  1266. // Value to be set   
  1267. //    
  1268. //    
  1269. // [altair] 13.06.2004 Created   
  1270. //    
  1271. public void SetPropertyInt32(Int32 PID, Int32 Value)   
  1272. {   
  1273. byte[] Data = new byte[4];   
  1274. for (int I = 0; I < 4; I++)   
  1275. {   
  1276. Data[I] = (byte)(Value & 0xFF);   
  1277. Value >>= 8;   
  1278. }   
  1279. SetProperty(PID, Data, ExifDataTypes.SignedLong);   
  1280. }   
  1281.   
  1282. //    
  1283. // Sets specified property in raw form   
  1284. //    
  1285. // Property ID   
  1286. // Raw data   
  1287. // EXIF data type   
  1288. // Is recommended to use typed methods (like etc.) instead, when possible.   
  1289. //    
  1290. // [altair] 12.6.2004 Created   
  1291. //    
  1292. public void SetProperty(Int32 PID, byte[] Data, ExifDataTypes Type)   
  1293. {   
  1294. System.Drawing.Imaging.PropertyItem P = this._Image.PropertyItems[0];   
  1295. P.Id = PID;   
  1296. P.Value = Data;   
  1297. P.Type = (Int16)Type;   
  1298. P.Len = Data.Length;   
  1299. this._Image.SetPropertyItem(P);   
  1300. }   
  1301.   
  1302. //    
  1303. // Reads Int32 from EXIF bytearray.   
  1304. //    
  1305. // EXIF bytearray to process   
  1306. //    
  1307. //    
  1308. //    
  1309. // [altair] 10.09.2003 Created   
  1310. // [altair] 05.09.2005 Changed from public shared to private instance method   
  1311. //    
  1312. private Int32 GetInt32(byte[] B)   
  1313. {   
  1314. if (B.Length < 4)   
  1315. throw new ArgumentException("Data too short (4 bytes expected)", "B");   
  1316.   
  1317. return B[3] << 24 | B[2] << 16 | B[1] << 8 | B[0];   
  1318. }   
  1319.   
  1320. //    
  1321. // Reads Int16 from EXIF bytearray.   
  1322. //    
  1323. // EXIF bytearray to process   
  1324. //    
  1325. //    
  1326. //    
  1327. // [altair] 10.09.2003 Created   
  1328. // [altair] 05.09.2005 Changed from public shared to private instance method   
  1329. //    
  1330. private Int16 GetInt16(byte[] B)   
  1331. {   
  1332. if (B.Length < 2)   
  1333. throw new ArgumentException("Data too short (2 bytes expected)", "B");   
  1334.   
  1335. return (short)(B[1] << 8 | B[0]);   
  1336. }   
  1337.   
  1338. //    
  1339. // Reads string from EXIF bytearray.   
  1340. //    
  1341. // EXIF bytearray to process   
  1342. //    
  1343. //    
  1344. //    
  1345. // [altair] 10.09.2003 Created   
  1346. // [altair] 05.09.2005 Changed from public shared to private instance method   
  1347. //    
  1348. private string GetString(byte[] B)   
  1349. {   
  1350. string R = this._Encoding.GetString(B);   
  1351. if (R.EndsWith("\0"))   
  1352. R = R.Substring(0, R.Length - 1);   
  1353. return R;   
  1354. }   
  1355.   
  1356. //    
  1357. // Reads rational from EXIF bytearray.   
  1358. //    
  1359. // EXIF bytearray to process   
  1360. //    
  1361. //    
  1362. //    
  1363. // [altair] 10.09.2003 Created   
  1364. // [altair] 05.09.2005 Changed from public shared to private instance method   
  1365. //    
  1366. private Rational GetRational(byte[] B)   
  1367. {   
  1368. Rational R = new Rational();   
  1369. byte[] N = new byte[4];   
  1370. byte[] D = new byte[4];   
  1371. Array.Copy(B, 0, N, 0, 4);   
  1372. Array.Copy(B, 4, D, 0, 4);   
  1373. R.Denominator = this.GetInt32(D);   
  1374. R.Numerator = this.GetInt32(N);   
  1375. return R;   
  1376. }   
  1377.   
  1378. public void Save(string fileName){   
  1379.     this._Image.Save(fileName);   
  1380. }  
  1381. #endregion  
  1382.  
  1383. #region " IDisposable implementation "   
  1384.   
  1385. //    
  1386. // Disposes unmanaged resources of this class   
  1387. //    
  1388. //    
  1389. //    
  1390. // [altair] 10.09.2003 Created   
  1391. //    
  1392. public void Dispose()   
  1393. {   
  1394. this._Image.Dispose();   
  1395. }  
  1396.  
  1397. #endregion   
  1398.   
  1399. }   
  1400. }  


C#代码 复制代码  收藏代码
  1. using System;   
  2. using System.Collections.Generic;   
  3. using System.Text;   
  4. using System.Windows.Forms;   
  5. using System.Windows.Forms.Design;   
  6.   
  7. /**  
  8.  * 对话框工具  
  9.  *   
  10.  * @author LianTao  
  11.  * @version 1.0     2008.11.01  
  12.  */  
  13. namespace Utils   
  14. {   
  15.     public class DialogUtil : FolderNameEditor   
  16.     {   
  17.         FolderNameEditor.FolderBrowser fDialog = new  
  18.         System.Windows.Forms.Design.FolderNameEditor.FolderBrowser();   
  19.            
  20.         /**   
  21.          * 构造函数  
  22.          */  
  23.         public DialogUtil()    
  24.         {    
  25.         }   
  26.   
  27.         /**   
  28.          * 打开“浏览”对话框  
  29.          */  
  30.         public DialogResult ShowFolderDialog()   
  31.         {   
  32.             return ShowFolderDialog("请选择一个文件夹");   
  33.         }   
  34.   
  35.         /**   
  36.          * 打开“浏览”对话框  
  37.          *   
  38.          * @param description  
  39.          *                          对话框的标题  
  40.         */  
  41.         public DialogResult ShowFolderDialog(string description)   
  42.         {   
  43.             fDialog.Description = description;   
  44.             fDialog.StartLocation = FolderBrowserFolder.Desktop;   
  45.             return fDialog.ShowDialog();   
  46.         }   
  47.         ~DialogUtil()   
  48.         {   
  49.             fDialog.Dispose();   
  50.         }   
  51.     }  
cherry_xidian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文教你如何用Python读取图片GPS定位
SunnyZhou-1024的博客
03-15 4666
JPEG（Joint Photographic Experts Group，联合图像专家组）标准定义了一套对静态图片进行压缩的算法，用于对图像或者视频进行压缩。JPEG标准定义了四种操作，分别是顺序DCT（sequential Discrete Cosine Transform） 模式、渐进DCT（progressive DCT）模式、无损（Lossless）模式和分层（hierarchical）模式。根据不同模式会对原是图像进行多次扫描，每扫描一次就得到一帧。
JPEG标准
御雪妃舞
04-06 4182
JPEG标准是一种适用于彩色和单色多灰度或连续色调
CSS3 经典教程系列：CSS3 圆角（border-radius）详解
weixin_34148508的博客
01-30 532
　　《CSS3 入门教程系列》前一篇文章详细介绍了 CSS3 RGBA 特性的用法，今天这篇文章我们在一起来看看 CSS3 中用于实现圆角效果的 border-radius 属性的具体用法。 　　以前制作圆角效果，我们都需要使用多张圆角图片做为背景分别应用到每个角上，我应用最多的就是在需要圆角的元素标签中加四个空标签，然后在每个空标签中应用一个圆角的背景位置，然后在对这几个应用了圆角的标签进...
JPEG编码细节介绍
Do1e_dpj的博客
08-22 4114
最近在学习如何进行JPEG编码，在网上找了很多文章，发现很少有文章将每一个细节都讲得十分清楚，以至于在编程时踩了不少的坑，因此打算尽量结合python代码写一个涉及细节部分的文章。具体程序可以参考我在。.....................
JPEG图像格式解析
QQ135102692的博客
05-17 1万+
jpg/jpeg是24位的图像文件格式，也是一种高效率的压缩格式，文件格式是JPEG（联合图像专家组）标准的产物，是面向连续色调静止图像的一种压缩标准备注：JPEG文件一般有２个DQT段，为Y值（亮度）定义１个, 为C值（色度）定义１个DQT标识：FF DB数据长度：00 43 (段长度2个字节，QT信息1个字节)+QT量化表的长度，此处QT量化表的长度是64)QT信息：00 QT号为0 QT精度8bit。
jpeg图片格式详解
热门推荐
zz460833359的博客
04-02 2万+
jpeg图片格式详解 1. JPEG文件简介 JPEG的全称是JointPhotographicExpertsGroup（联合图像专家小组），它是一种常用的图像存储格式， jpg/jpeg是24位的图像文件格式，也是一种高效率的压缩格式，文件格式是JPEG（联合图像专家组）标准的产物，该标准由ISO与CCI TT（国际电报电话咨询委员会）共同制定，是面向连续色调静止图像的一种压缩标准。其最初目的是使用64Kbps的通信线路传输720×576 分辨率压缩后的图像。通过损失极少的分辨率，可以将图像所需存储量减少
JPEG图像
萍水间人的小天地
09-30 350
算是阅读隐写学原理与技术做的笔记 JPEG图像编码流程 LSBR替换 LSBR容易产生值对效应 LSB隐写代码： input = 'th.jpg' file = 'message.txt' output = 'scover.bmp' % 读入图像矩阵 cover = imread(input); ste_cover = cov...
jpeg.rar_jpeg解压
09-21
当读取一个JPEG文件时，解压缩器首先识别SOI标志，然后解析各段信息，特别是DQT和DHT段，它们包含了压缩时使用的量化表和Huffman编码表。接着，解压缩器按顺序处理SOF和SOS段，恢复每个8x8像素块的DCT系数，应用逆...
PHP把JPEG图片转换成Progressive JPEG的方法
10-25
具体实现方法是使用imageinterlace()函数，这个函数设置了图像的隔行扫描标志。当设置为1时，图像将使用JPEG格式，并且以渐进式的方式进行存储。接下来，使用imagejpeg()函数输出转换后的图像，并保存为新的文件。...
NativeJpg_reset_jpeg_
09-30
"reset jpeg" 这个标签可能指的是在进行JPEG处理时需要确保所有相关设置复位到默认状态，包括Exif中的方向标志。这可能是因为某些图像处理操作可能无意中改变了这些设置，或者在进行批量处理时需要确保每张图片的元...
JPEG格式分析
10-25
- **SOI (Start Of Image) 段**：这是JPEG文件的起始标志，值为`0xFF D8`，表示图像数据的开始。 - **EOI (End Of Image) 段**：这是JPEG文件的结束标志，值为`0xFF D9`，表示图像数据的结束。 - **APP0 段**：此段...
deco.rar_Jpeg解码
09-14
2. **读取SOI（Start of Image）和EOI（End of Image）标记**：SOI标志着JPEG图像的开始，而EOI标记了图像的结束。这两个标记用于确定图像数据的范围。 3. **解析SOF（Start of Frame）标记**：SOF标记包含了图像的...
使用 Piexif 给图像增加GPS属性
simple的博客
02-28 1757
使用 Piexif 给图像增加GPS属性 安装Piexif pip install piexif 使用Piexif piexif库中主要有以下几个函数： load(filename) - 获取文件中的exif信息，返回值为字典dict类型 dump(exif_dict) - 将字典类型的exif信息变成bytes编码 insert(exif_bytes, filename) - 将bytes编码的exif信息exif_bytes插入文件名为filename的图像文件中（JPEG格式或WebP格式） re
自己写段代码批量修改照片的Exif数据
从Java看编程
05-24 1215
老爸老妈去欧洲画了一个圈，带回来一千多张照片（数量没法和年轻人比）。 虽然老爸晓得调节相机中的时间，但是毕竟年岁不饶人，整差了12个小时。 也就是下午4点拍的照片，Exif里显示是凌晨4点。 好在欧洲大陆都用相同的时区（偶没去过，不晓得，只是老爸说导游都是这样执行的），每张都 +12H 即可。 基本各种照片查看工具都有批量修改功能，但无奈咱需要“时间+12H”确谁也没有。 ...
使用FolderBrowserDialog， ShowDialog返回值一直是Cancel的问题
明日及时
09-03 1031
在百度，外国的网站搜索了好久，都没有找到合适的答案，其实这个问题应该也有好多人遇到，就是没人回答，甚至说着说着就没有下文了，也有答非所问，又或者是直接什么直接 newFolderBrowserDialog() 我真想给他一个 “papa” 下去，谁不会用这个呀，人家的问题时 为啥使用了FolderBrowserDialog这个窗体还是打开不了，而且其返回的ShowDialog 的值一...
Jpeg图片属性读取EXIF
hello simon
02-16 7976
jpeg图片属性读取 测试环境  Delphi XE 主要功能代码获取自其他作者 单元文件 unit utJpegInfo; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type Tf
关于打开文件夹目录的folderbrowsedialog
luyangchild的专栏
08-15 919
folderbrowsedialog是一个不错的组件，功能简单，足够实现选择目录 folderbrowsedialog openFolder; openFolder.ShowDialog();             if (" " != openFolder.SelectedPath)             {                 sourcefolder.Text
超市管理系统，基于javaweb.zip
最新发布
08-15
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无积分，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于收集和整理资料耗费时间的酬劳
JPEG2000压缩标准详解
JPEG 2000 Final Committee Draft Version 1.0发布于2000年3月16日，它标志着该标准的最终草案阶段。此标准的项目编号为1.29.15444，即JPEG2000（也称为ISO/IEC 15444-1）。文档的主要编辑者包括Martin Boliek、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值