mcs/class/System.Drawing/System.Drawing.Imaging/ImageCodec.jvm.cs

   1 using System;\r
   2 using System.Configuration;\r
   3 using System.Collections;\r
   4 using System.Collections.Specialized;\r
   5 using System.Drawing.Imaging;\r
   6 using System.Xml;\r
   7 using Mainsoft.Drawing.Configuration;\r
   8 \r
   9 using imageio = javax.imageio;\r
  10 using stream = javax.imageio.stream;\r
  11 using awt = java.awt;\r
  12 using image = java.awt.image;\r
  13 using spi = javax.imageio.spi;\r
  14 using dom = org.w3c.dom;\r
  15 \r
  16 namespace Mainsoft.Drawing.Imaging {\r
  17         /// <summary>\r
  18         /// Summary description for ImageCodec.\r
  19         /// </summary>\r
  20         public class ImageCodec : IDisposable {\r
  21 \r
  22                 #region Members\r
  23 \r
  24                 imageio.ImageReader _nativeReader = null;\r
  25                 imageio.ImageWriter _nativeWriter = null;\r
  26                 stream.ImageInputStream _nativeStream = null;\r
  27 \r
  28                 ImageFormat _imageFormat = null;\r
  29 \r
  30                 int _currentFrame = 0;\r
  31 \r
  32                 #endregion\r
  33 \r
  34                 #region Constructros\r
  35 \r
  36                 protected ImageCodec() {\r
  37                 }\r
  38 \r
  39                 static ImageCodec() {\r
  40                 }\r
  41 \r
  42                 #endregion\r
  43 \r
  44                 #region Internal properties\r
  45 \r
  46                 internal imageio.ImageReader NativeReader {\r
  47                         get { return _nativeReader; }\r
  48                         set { \r
  49                                 _nativeReader = value; \r
  50                                 if (value == null)\r
  51                                         return;\r
  52                                 _imageFormat = MimeTypesToImageFormat( value.getOriginatingProvider().getMIMETypes() );\r
  53                         }\r
  54                 }\r
  55                 internal imageio.ImageWriter NativeWriter {\r
  56                         get { return _nativeWriter; }\r
  57                         set { \r
  58                                 _nativeWriter = value; \r
  59                                 if (value == null)\r
  60                                         return;\r
  61                                 _imageFormat = MimeTypesToImageFormat( value.getOriginatingProvider().getMIMETypes() );\r
  62                         }\r
  63                 }\r
  64 \r
  65                 internal stream.ImageInputStream NativeStream {\r
  66                         get { return _nativeStream; }\r
  67                         set {\r
  68                                 _nativeStream = value;\r
  69                                 if (value == null)\r
  70                                         return;\r
  71 \r
  72                                 if (NativeReader != null)\r
  73                                         NativeReader.setInput( value );\r
  74 \r
  75                                 if (NativeWriter != null)\r
  76                                         NativeWriter.setOutput( value );\r
  77                         }\r
  78                 }\r
  79 \r
  80                 #endregion\r
  81 \r
  82                 #region ImageCodec factory methods\r
  83 \r
  84                 public static ImageCodec CreateReader(stream.ImageInputStream inputStream) {\r
  85                         java.util.Iterator iter = imageio.ImageIO.getImageReaders( inputStream );\r
  86                         return CreateReader(iter);\r
  87                 }\r
  88 \r
  89                 public static ImageCodec CreateReader(ImageFormat imageFormat) {\r
  90                         return CreateReader( ImageFormatToClsid( imageFormat ) );\r
  91                 }\r
  92 \r
  93                 public static ImageCodec CreateReader(Guid clsid) {\r
  94                         ImageCodec codec = null;\r
  95                         try {\r
  96                                 ImageCodecInfo codecInfo = (ImageCodecInfo) Decoders[clsid];\r
  97                                 java.util.Iterator iter = imageio.ImageIO.getImageReadersByMIMEType( codecInfo.MimeType );\r
  98                                 codec = CreateReader(iter);\r
  99                         }\r
 100                         catch {}\r
 101 \r
 102                         if (codec == null) {\r
 103                                 ImageFormat format = ClsidToImageFormat(clsid);\r
 104                                 string name = (format != null) ? format.ToString() : clsid.ToString();\r
 105                                 throw new NotSupportedException(String.Format("The '{0}' format decoder is not installed.", name));\r
 106                         }\r
 107 \r
 108                         return codec;\r
 109                 }\r
 110 \r
 111                 private static ImageCodec CreateReader(java.util.Iterator iter) {\r
 112                         if ( !iter.hasNext() )
 113                                 return null;
 114 \r
 115                         ImageCodec imageCodec = new ImageCodec();\r
 116                         imageCodec.NativeReader = (imageio.ImageReader) iter.next();\r
 117                         return imageCodec;\r
 118                 }\r
 119 \r
 120                 public static ImageCodec CreateWriter(ImageFormat imageFormat) {\r
 121                         return CreateWriter( ImageFormatToClsid( imageFormat ) );\r
 122                 }\r
 123 \r
 124                 public static ImageCodec CreateWriter(Guid clsid) {\r
 125                         ImageCodec codec = null;\r
 126                         try {\r
 127                                 ImageCodecInfo codecInfo = (ImageCodecInfo) Encoders[clsid];\r
 128                                 java.util.Iterator iter = imageio.ImageIO.getImageWritersByMIMEType( codecInfo.MimeType );\r
 129                                 codec = CreateWriter(iter);\r
 130                         }\r
 131                         catch {}\r
 132 \r
 133                         if (codec == null) {\r
 134                                 ImageFormat format = ClsidToImageFormat(clsid);\r
 135                                 string name = (format != null) ? format.ToString() : clsid.ToString();\r
 136                                 throw new NotSupportedException(String.Format("The '{0}' format encoder is not installed.", name));\r
 137                         }\r
 138 \r
 139                         return codec;\r
 140                 }\r
 141 \r
 142                 private static ImageCodec CreateWriter(java.util.Iterator iter) {\r
 143                         if ( !iter.hasNext() )
 144                                 return null;
 145                         \r
 146                         ImageCodec imageCodec = new ImageCodec();\r
 147                         imageCodec.NativeWriter = (imageio.ImageWriter) iter.next();\r
 148                         return imageCodec;\r
 149                 }\r
 150 \r
 151                 #endregion\r
 152 \r
 153                 #region Codec enumerations\r
 154 \r
 155                 internal static Hashtable Decoders {
 156                         get {
 157                                 const string MYNAME = "System.Drawing.Imaging.ImageCodecInfo.decoders";
 158                                 Hashtable o = (Hashtable) AppDomain.CurrentDomain.GetData (MYNAME);
 159                                 if (o != null)
 160                                         return o;
 161                                 o = new ReaderSpiIterator().Iterate();
 162                                 AppDomain.CurrentDomain.SetData(MYNAME, o);
 163                                 return o;
 164                         }
 165                 }
 166
 167                 internal static Hashtable Encoders {
 168                         get {
 169                                 const string MYNAME = "System.Drawing.Imaging.ImageCodecInfo.encoders";
 170                                 Hashtable o = (Hashtable) AppDomain.CurrentDomain.GetData (MYNAME);
 171                                 if (o != null)
 172                                         return o;
 173                                 o = new WriterSpiIterator().Iterate();
 174                                 AppDomain.CurrentDomain.SetData(MYNAME, o);
 175                                 return o;
 176                         }
 177                 }
 178
 179                 internal static ImageCodecInfo FindEncoder (Guid clsid) {
 180                         return (ImageCodecInfo) Encoders[clsid];
 181                 }
 182
 183                 internal static ImageCodecInfo FindDecoder (Guid clsid) {
 184                         return (ImageCodecInfo) Decoders[clsid];
 185                 }
 186 \r
 187                 #endregion\r
 188 \r
 189                 #region SpiIterators
 190
 191                 abstract class BaseSpiIterator {
 192                         protected abstract java.util.Iterator GetIterator (string mimeType);
 193                         protected abstract spi.ImageReaderWriterSpi GetNext (java.util.Iterator iter);
 194
 195                         #region ProcessOneCodec
 196                         private ImageCodecInfo ProcessOneCodec (Guid clsid, Guid formatID, string mimeType) {
 197                                 ImageCodecInfo ici = new ImageCodecInfo ();
 198                                 ici.Clsid = clsid;
 199                                 ici.FormatID = formatID;
 200                                 ici.MimeType = mimeType;
 201                                 java.util.Iterator iter = GetIterator (mimeType);
 202                                 while (iter.hasNext ()) {
 203                                         spi.ImageReaderWriterSpi rw = GetNext (iter);
 204                                         try {
 205                                                 ici.CodecName = rw.getDescription (java.util.Locale.getDefault ());
 206                                                 ici.DllName = null;
 207                                                 foreach (string suffix in rw.getFileSuffixes ()) {
 208                                                         if (ici.FilenameExtension != null)
 209                                                                 ici.FilenameExtension += ";";
 210                                                         ici.FilenameExtension += "*."+suffix;
 211                                                 }
 212                                                 ici.Flags = ImageCodecFlags.Builtin|ImageCodecFlags.SupportBitmap;
 213                                                 if (rw is spi.ImageReaderSpi) {
 214                                                         ici.Flags |= ImageCodecFlags.Decoder;
 215                                                         if ((rw as spi.ImageReaderSpi).getImageWriterSpiNames().Length != 0)
 216                                                                 ici.Flags |= ImageCodecFlags.Encoder;
 217                                                 }
 218                                                 if (rw is spi.ImageWriterSpi) {
 219                                                         ici.Flags |= ImageCodecFlags.Encoder;
 220                                                         if ((rw as spi.ImageWriterSpi).getImageReaderSpiNames().Length != 0)
 221                                                                 ici.Flags |= ImageCodecFlags.Decoder;
 222                                                 }
 223                                                 ici.FormatDescription = string.Join(";",
 224                                                         rw.getFormatNames());
 225                                                 ici.Version = (int)Convert.ToDouble(rw.getVersion ());
 226                                                 break;
 227                                         }
 228                                         catch {
 229                                         }
 230                                 }
 231                                 return ici;
 232                         }
 233                         #endregion
 234
 235                         internal Hashtable Iterate () {
 236                                 // TBD: Insert Exception handling here
 237                                 NameValueCollection nvc = (NameValueCollection) System.Configuration.ConfigurationSettings
 238                                         .GetConfig ("system.drawing/codecs");
 239                                 Hashtable codecs = new Hashtable (10);
 240
 241                                 for (int i=0; i<nvc.Count; i++) {
 242                                         Guid clsid = new Guid (nvc.GetKey (i));
 243                                         ImageFormat format = ClsidToImageFormat (clsid);
 244                                         ImageCodecInfo codec = ProcessOneCodec (clsid, format.Guid, nvc[i]);
 245                                         if (codec.FilenameExtension != null)
 246                                                 codecs [clsid] = codec;
 247                                 }
 248                                 return codecs;
 249                         }
 250                 }
 251
 252                 class ReaderSpiIterator: BaseSpiIterator {
 253                         protected override java.util.Iterator GetIterator(string mimeType) {\r
 254                                 return imageio.ImageIO.getImageReadersByMIMEType (mimeType);\r
 255                         }\r
 256                         protected override javax.imageio.spi.ImageReaderWriterSpi GetNext(java.util.Iterator iter) {\r
 257                                 imageio.ImageReader r = (imageio.ImageReader) iter.next ();\r
 258                                 return r.getOriginatingProvider ();\r
 259                         }\r
 260                 }
 261
 262                 class WriterSpiIterator: BaseSpiIterator {
 263                         protected override java.util.Iterator GetIterator(string mimeType) {\r
 264                                 return imageio.ImageIO.getImageWritersByMIMEType (mimeType);\r
 265                         }\r
 266                         protected override javax.imageio.spi.ImageReaderWriterSpi GetNext(java.util.Iterator iter) {\r
 267                                 imageio.ImageWriter w = (imageio.ImageWriter) iter.next ();\r
 268                                 return w.getOriginatingProvider ();\r
 269                         }\r
 270                 }
 271                 #endregion
 272 \r
 273                 #region Clsid and FormatID
 274                 static Guid BmpClsid = new Guid ("557cf400-1a04-11d3-9a73-0000f81ef32e");
 275                 static Guid JpegClsid = new Guid ("557cf401-1a04-11d3-9a73-0000f81ef32e");
 276                 static Guid GifClsid = new Guid ("557cf402-1a04-11d3-9a73-0000f81ef32e");
 277                 static Guid EmfClsid = new Guid ("557cf403-1a04-11d3-9a73-0000f81ef32e");
 278                 static Guid WmfClsid = new Guid ("557cf404-1a04-11d3-9a73-0000f81ef32e");
 279                 static Guid TiffClsid = new Guid ("557cf405-1a04-11d3-9a73-0000f81ef32e");
 280                 static Guid PngClsid = new Guid ("557cf406-1a04-11d3-9a73-0000f81ef32e");
 281                 static Guid IconClsid = new Guid ("557cf407-1a04-11d3-9a73-0000f81ef32e");
 282
 283                 private static ImageFormat MimeTypesToImageFormat (string [] mimeTypes) {
 284                         foreach (ImageCodecInfo codec in Decoders.Values)
 285                                 for (int i=0; i<mimeTypes.Length; i++)
 286                                         if (codec.MimeType == mimeTypes [i])
 287                                                 return new ImageFormat (codec.FormatID);
 288                         return null;
 289                 }
 290
 291                 internal static ImageFormat ClsidToImageFormat (Guid clsid) {
 292                         if (clsid.Equals (BmpClsid))
 293                                 return ImageFormat.Bmp;
 294                         else if (clsid.Equals (JpegClsid))
 295                                 return ImageFormat.Jpeg;
 296                         else if (clsid.Equals (GifClsid))
 297                                 return ImageFormat.Gif;
 298                         else if (clsid.Equals (EmfClsid))
 299                                 return ImageFormat.Emf;
 300                         else if (clsid.Equals (WmfClsid))
 301                                 return ImageFormat.Wmf;
 302                         else if (clsid.Equals (TiffClsid))
 303                                 return ImageFormat.Tiff;
 304                         else if (clsid.Equals (PngClsid))
 305                                 return ImageFormat.Png;
 306                         else if (clsid.Equals (IconClsid))
 307                                 return ImageFormat.Icon;
 308                         else
 309                                 return null;
 310                 }
 311
 312                 internal static Guid ImageFormatToClsid (ImageFormat format) {
 313                         if (format == null)
 314                                 return Guid.Empty;
 315
 316                         if (format.Guid.Equals (ImageFormat.Bmp.Guid))
 317                                 return BmpClsid;
 318                         else if (format.Guid.Equals (ImageFormat.Jpeg.Guid))
 319                                 return JpegClsid;
 320                         else if (format.Guid.Equals (ImageFormat.Gif))
 321                                 return GifClsid;
 322                         else if (format.Guid.Equals (ImageFormat.Emf.Guid))
 323                                 return EmfClsid;
 324                         else if (format.Guid.Equals (ImageFormat.Wmf.Guid))
 325                                 return WmfClsid;
 326                         else if (format.Guid.Equals (ImageFormat.Tiff.Guid))
 327                                 return TiffClsid;
 328                         else if (format.Guid.Equals (ImageFormat.Png.Guid))
 329                                 return PngClsid;
 330                         else if (format.Guid.Equals (ImageFormat.Icon.Guid))
 331                                 return IconClsid;
 332                         else
 333                                 return Guid.Empty;
 334                 }
 335
 336                 private FrameDimension FormatFrameDimesion {
 337                         get {
 338                                 if (ImageFormat == null)
 339                                         return FrameDimension.Page;
 340
 341                                 if (ImageFormat.Guid.Equals (ImageFormat.Bmp.Guid))
 342                                         return FrameDimension.Page;
 343                                 else if (ImageFormat.Guid.Equals (ImageFormat.Jpeg.Guid))
 344                                         return FrameDimension.Page;
 345                                 else if (ImageFormat.Guid.Equals (ImageFormat.Gif))
 346                                         return FrameDimension.Time;
 347                                 else if (ImageFormat.Guid.Equals (ImageFormat.Emf.Guid))
 348                                         return FrameDimension.Page;
 349                                 else if (ImageFormat.Guid.Equals (ImageFormat.Wmf.Guid))
 350                                         return FrameDimension.Page;
 351                                 else if (ImageFormat.Guid.Equals (ImageFormat.Tiff.Guid))
 352                                         return FrameDimension.Page;
 353                                 else if (ImageFormat.Guid.Equals (ImageFormat.Png.Guid))
 354                                         return FrameDimension.Page;
 355                                 else if (ImageFormat.Guid.Equals (ImageFormat.Icon.Guid))
 356                                         return FrameDimension.Resolution;
 357                                 else
 358                                         return FrameDimension.Page;
 359                         }
 360                 }
 361
 362                 #endregion
 363                 \r
 364                 #region Image read/write methods\r
 365 \r
 366                 public PlainImage ReadPlainImage() {\r
 367                         awt.Image img = ReadImage( _currentFrame );\r
 368                         if (img == null)\r
 369                                 return null;\r
 370 \r
 371                         // its possible to fail to load thumbnails and metadata, but image is ok.\r
 372                         awt.Image [] th = null;\r
 373 #if THUMBNAIL_SUPPORTED\r
 374                         try {\r
 375                                 th = ReadThumbnails( _currentFrame );\r
 376                         }\r
 377                         catch (Exception) {}\r
 378 #endif\r
 379                         \r
 380                         XmlDocument md = null;\r
 381                         imageio.metadata.IIOMetadata nativeMd = null;\r
 382                         try {\r
 383                                 nativeMd = ReadImageMetadata( _currentFrame );\r
 384                                 md = ConvertImageMetadata( nativeMd );\r
 385                         }\r
 386                         catch (Exception) {}\r
 387 \r
 388                         float [] resolution = GetResolution( md );\r
 389 \r
 390                         PlainImage pi = new PlainImage( img, th, ImageFormat, resolution[0], resolution[1], FormatFrameDimesion );\r
 391                         pi.NativeMetadata = nativeMd;\r
 392                         return pi;\r
 393                 }\r
 394 \r
 395                 public PlainImage ReadNextPlainImage() {\r
 396                         _currentFrame++;\r
 397                         return ReadPlainImage();\r
 398                 }\r
 399 \r
 400                 private awt.Image ReadImage(int frame) {\r
 401                         if (NativeStream == null)\r
 402                                 throw new Exception("Input stream not specified");\r
 403 \r
 404                         try {\r
 405                                 return NativeReader.read (frame);
 406                         }
 407                         catch (java.lang.IndexOutOfBoundsException) {
 408                                 return null;
 409                         }
 410                         catch (java.io.IOException ex) {
 411                                 throw new System.IO.IOException(ex.Message, ex);
 412                         }
 413                 }\r
 414 \r
 415 #if THUMBNAIL_SUPPORTED\r
 416                 private awt.Image [] ReadThumbnails(int frameIndex) {\r
 417                         awt.Image [] thArray = null;
 418
 419                         try {
 420                                 if (NativeReader.readerSupportsThumbnails()) {
 421                                         int tmbNumber = NativeReader.getNumThumbnails(frameIndex);
 422
 423                                         if (tmbNumber > 0) {
 424                                                 thArray = new awt.Image[ tmbNumber ];
 425
 426                                                 for (int i = 0; i < tmbNumber; i++) {
 427                                                         thArray[i] = NativeReader.readThumbnail(frameIndex, i);
 428                                                 }
 429                                         }
 430                                 }\r
 431                                 return thArray;\r
 432                         }\r
 433                         catch (java.io.IOException ex) {
 434                                 throw new System.IO.IOException(ex.Message, ex);
 435                         }
 436                 }\r
 437 #endif\r
 438                 public void WritePlainImage(PlainImageCollection pic) {\r
 439                         if ((pic == null) || (pic.Count == 0))\r
 440                                 return;\r
 441 \r
 442                         if (pic.Count == 1) {\r
 443                                 WritePlainImage( pic[0] );\r
 444                                 return;\r
 445                         }\r
 446 \r
 447                         try {\r
 448                                 if (NativeWriter.canWriteSequence ()) {\r
 449                                         NativeWriter.prepareWriteSequence (null);\r
 450                                         for (int i=0; i < pic.Count; i++) {\r
 451                                                 imageio.IIOImage iio = GetIIOImageContainer( pic[i] );\r
 452                                                 NativeWriter.writeToSequence (iio, null);\r
 453                                         }\r
 454                                         NativeWriter.endWriteSequence ();\r
 455                                 }\r
 456                                 else\r
 457                                         WritePlainImage( pic[0] );\r
 458                         }\r
 459                         catch (java.io.IOException ex) {
 460                                 throw new System.IO.IOException(ex.Message, ex);
 461                         }
 462                 }\r
 463 \r
 464                 public void WritePlainImage(PlainImage pi) {\r
 465                         try {\r
 466                                 imageio.IIOImage iio = GetIIOImageContainer( pi );\r
 467                                 WriteImage( iio );\r
 468                         }\r
 469                         catch (java.io.IOException ex) {
 470                                 throw new System.IO.IOException(ex.Message, ex);
 471                         }\r
 472                 }\r
 473 \r
 474                 private void WriteImage(imageio.IIOImage iio) {\r
 475                         if (NativeStream == null)\r
 476                                 throw new Exception("Output stream not specified");\r
 477 \r
 478                         NativeWriter.write( iio );\r
 479                         NativeStream.flush();\r
 480                 }\r
 481                 \r
 482                 private imageio.IIOImage GetIIOImageContainer(PlainImage pi) {\r
 483                         java.util.ArrayList al = null;\r
 484                         \r
 485                         // prepare thumbnails list\r
 486                         if (pi.Thumbnails != null) {\r
 487                                 al = new java.util.ArrayList( pi.Thumbnails.Length );\r
 488                                 for (int i=0; i < pi.Thumbnails.Length; i++)\r
 489                                         al.add(pi.Thumbnails[i]);\r
 490                         }\r
 491 \r
 492                         // prepare IIOImage container\r
 493                         if (pi.NativeImage is image.BufferedImage) {\r
 494                                 imageio.IIOImage iio = new javax.imageio.IIOImage(\r
 495                                         (image.BufferedImage)pi.NativeImage, al, null /*pi.NativeMetadata*/);\r
 496                                 return iio;\r
 497                         }\r
 498                         else\r
 499                                 // TBD: This codec is for raster formats only\r
 500                                 throw new NotSupportedException("Only raster formats are supported");\r
 501                 }\r
 502 \r
 503 \r
 504                 private imageio.metadata.IIOMetadata ReadImageMetadata(int frameIndex) {\r
 505                         if (NativeStream == null)\r
 506                                 throw new Exception("Input stream not specified");\r
 507 \r
 508                         try {\r
 509                                 imageio.metadata.IIOMetadata md = NativeReader.getImageMetadata( frameIndex );\r
 510                                 return md;\r
 511                         }\r
 512                         catch (java.io.IOException ex) {
 513                                 throw new System.IO.IOException(ex.Message, ex);
 514                         }
 515                 }\r
 516 \r
 517                 #endregion\r
 518 \r
 519                 #region Extra properties\r
 520 \r
 521                 public ImageFormat ImageFormat {\r
 522                         get { return _imageFormat; }\r
 523                 }\r
 524 \r
 525                 #endregion\r
 526 \r
 527                 #region Metadata parse\r
 528 \r
 529                 private float [] GetResolution(XmlDocument metaData) {\r
 530                         if (metaData == null)\r
 531                                 return new float[]{0, 0};\r
 532 \r
 533                         ResolutionConfigurationCollection rcc =
 534                                 (ResolutionConfigurationCollection)
 535                                 ConfigurationSettings.GetConfig("system.drawing/codecsmetadata");
 536
 537                         if (rcc == null)
 538                                 throw new ConfigurationException("Configuration section codecsmetadata not found");
 539
 540                         ResolutionConfiguration rc = rcc[ ImageFormat.ToString() ];
 541
 542                         if (rc == null)
 543                                 return new float[]{0, 0};
 544
 545                         // Horizontal resolution
 546                         string xResPath = rc.XResPath;
 547                         string xRes;
 548
 549                         if (xResPath == string.Empty)
 550                                 xRes = rc.XResDefault;
 551                         else
 552                                 xRes = GetValueFromMetadata(metaData, xResPath);
 553
 554                         if ((xRes == null) || (xRes == string.Empty))
 555                                 xRes = rc.XResDefault;
 556
 557                         // Vertical resolution
 558                         string yResPath = rc.YResPath;
 559                         string yRes;
 560
 561                         if (yResPath == string.Empty)
 562                                 yRes = rc.YResDefault;
 563                         else
 564                                 yRes = GetValueFromMetadata(metaData, yResPath);
 565
 566                         if ((yRes == null) || (yRes == string.Empty))
 567                                 yRes = rc.YResDefault;
 568
 569                         // Resolution units
 570                         string resUnitsPath = rc.UnitsTypePath;
 571                         string resUnitsType;
 572
 573                         if (resUnitsPath == string.Empty)
 574                                 resUnitsType = rc.UnitsTypeDefault;
 575                         else
 576                                 resUnitsType = GetValueFromMetadata(metaData, resUnitsPath);
 577
 578                         if (resUnitsType == null)
 579                                 resUnitsType = rc.UnitsTypeDefault;
 580
 581                         // Unit scale
 582                         string unitScale = rc.UnitsScale[resUnitsType].ToString();
 583
 584                         // Adjust resolution to its units
 585                         float [] res = new float[2];
 586                         res[0] = ParseFloatValue(xRes) * ParseFloatValue(unitScale);
 587                         res[1] = ParseFloatValue(yRes) * ParseFloatValue(unitScale);
 588
 589                         return res;
 590                 }\r
 591 \r
 592                 private string GetValueFromMetadata(XmlDocument metaData, string path) {\r
 593                         XmlNode n = metaData.SelectSingleNode(path);\r
 594                         if (n == null)\r
 595                                 return null;\r
 596 \r
 597                         return n.InnerText;\r
 598                 }\r
 599 \r
 600                 private XmlDocument ConvertImageMetadata(imageio.metadata.IIOMetadata metaData) {\r
 601                         string [] formatNames = metaData.getMetadataFormatNames();
 602                         dom.Element rootNode = (dom.Element) metaData.getAsTree(formatNames[0]);
 603
 604                         XmlDocument _metadataDocument = new XmlDocument();\r
 605                         XmlConvert(rootNode, _metadataDocument);\r
 606 \r
 607                         return _metadataDocument;\r
 608                 }\r
 609 \r
 610                 private void XmlConvert(dom.Node jNode, XmlNode nNode) {\r
 611                         XmlDocument document = nNode.OwnerDocument;\r
 612                         if (document == null)\r
 613                                 document = (XmlDocument)nNode;\r
 614 \r
 615                         XmlNode n = null;\r
 616                         switch (jNode.getNodeType()) {\r
 617                                 case 1 :\r
 618                                         n = document.CreateNode(XmlNodeType.Element, jNode.getNodeName(), jNode.getNamespaceURI());\r
 619                                         break;\r
 620 \r
 621                                 case 4 :\r
 622                                         n = document.CreateNode(XmlNodeType.CDATA, jNode.getNodeName(), jNode.getNamespaceURI());\r
 623                                         break;\r
 624 \r
 625                                 default:\r
 626                                         return;\r
 627                         }\r
 628                         //set value\r
 629                         n.InnerText = jNode.getNodeValue();\r
 630                         nNode.AppendChild( n );\r
 631 \r
 632                         //copy attributes\r
 633                         org.w3c.dom.NamedNodeMap nm = jNode.getAttributes();\r
 634                         for (int i=0; i<nm.getLength(); i++) {\r
 635                                 XmlAttribute a = document.CreateAttribute( nm.item(i).getNodeName() );\r
 636                                 a.Value = nm.item(i).getNodeValue();\r
 637                                 n.Attributes.Append( a );\r
 638                         }\r
 639 \r
 640                         //copy childs\r
 641                         org.w3c.dom.NodeList nl = jNode.getChildNodes();\r
 642                         for (int i=0; i<nl.getLength(); i++) {\r
 643                                 XmlConvert(nl.item(i), n);\r
 644                         }\r
 645                 }\r
 646 \r
 647                 protected virtual float ParseFloatValue(string strValue) {\r
 648                         try {\r
 649                                 if ((strValue != null) && (strValue != "")) {
 650                                         int dividerPos = strValue.IndexOf("/");
 651
 652                                         if (dividerPos < 0) {
 653                                                 return float.Parse(strValue);
 654                                         }
 655                                         else {
 656                                                 return float.Parse(strValue.Substring( 0, dividerPos )) /
 657                                                         float.Parse(strValue.Substring( dividerPos + 1 ));
 658                                         }
 659                                 }\r
 660                                 return float.NaN;\r
 661                         }\r
 662                         catch (Exception) {\r
 663                                 return float.NaN;\r
 664                         }\r
 665                 }\r
 666 \r
 667                 #endregion\r
 668 \r
 669                 #region IDisposable members\r
 670 \r
 671                 public void Dispose() {\r
 672                         if (NativeReader != null) {\r
 673                                 NativeReader.dispose();\r
 674                                 NativeReader = null;\r
 675                         }\r
 676 \r
 677                         if (NativeWriter != null) {\r
 678                                 NativeWriter.dispose();\r
 679                                 NativeWriter = null;\r
 680                         }\r
 681                 }\r
 682 \r
 683                 #endregion\r
 684 \r
 685         }\r
 686 }\r