protected void getStrips(int fid, out uint[] stripPos, out uint[] stripCount, out uint rowsCount) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; try { Array temp = dataStruct.searchData(TiffInfoCollection.StripOffsets); if (temp is uint[]) { stripPos = temp as uint[]; } else { stripPos = new uint[temp.Length]; for (int i = 0; i < temp.Length; i++) { stripPos[i] = Convert.ToUInt32(temp.GetValue(i)); } } temp = dataStruct.searchData(TiffInfoCollection.StripByteCounts); if (temp is uint[]) { stripCount = temp as uint[]; } else { stripCount = new uint[temp.Length]; for (int i = 0; i < temp.Length; i++) { stripCount[i] = Convert.ToUInt32(temp.GetValue(i)); } } } catch { throw new ReadFileException("Unable to read image info: "); } try { rowsCount = Convert.ToUInt32(dataStruct.searchData(TiffInfoCollection.RowsPerStrip).GetValue(0)); } catch { int height, width; getImageSize(fid, out width, out height); rowsCount = Convert.ToUInt32(height / stripPos.Length); } }
internal virtual void finalizeImageWriting(TiffInfoCollection allInfo, TiffStruct fileData) { System.IO.Stream stream = writer.BaseStream; uint tagPos = toWordBoundary(); stream.Seek(nextIFDpos, System.IO.SeekOrigin.Begin); writer.Write(tagPos); stream.Seek(tagPos, System.IO.SeekOrigin.Begin); fileData.setFromInfoCollection(allInfo); fileData.NextIFD = 0; fileData.write(writer, out nextIFDpos); }
/// <summary> /// Get compression type. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Compression type. Read TIFF documentation for details.</returns> public MyTiffCompression.CompressionMethod getCompressionTagNumber(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; Array ca = dataStruct.searchData(TiffInfoCollection.Compression); if (ca == null || ca.Length == 0) { return(MyTiffCompression.CompressionMethod.UNCOMPRESSED); } return((MyTiffCompression.CompressionMethod)Convert.ToInt32(ca.GetValue(0))); }
/// <summary> /// Get planar configuration. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Planar configuration. Read TIFF documents</returns> public int getPlanarConfiguration(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; int pc = 0; try { pc = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.PlanarConfiguration).GetValue(0)); } catch { return(1); } return(pc); }
/// <summary> /// Get sample per pixel. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Number of samples per pixel. 1 for grayscale, 3 for RGB</returns> public int getSamplePerPixel(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; int spp = 0; try { spp = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.SamplesPerPixel).GetValue(0)); } catch { throw new ReadFileException("Unable to read image info: "); } return(spp); }
/// <summary> /// Determine if image data represent float point numbers. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>True if image data represent float-point numbers.</returns> public bool isDataFloatPoint(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; ushort nbits = 0; try { nbits = Convert.ToUInt16(dataStruct.searchData(TiffInfoCollection.SampleFormat).GetValue(0)); } catch { return(false); } return(nbits == 3); }
/// <summary> /// Determine if differencing was used for compression /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Predictor. Read TIFF documentation for details.</returns> public bool getDifferencePredictor(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; Array ca = dataStruct.searchData(TiffInfoCollection.DifferencingPredictor); if (ca == null || ca.Length == 0) { return(false); } else { return((MyTiffCompression.DifferencePredictor)Convert.ToInt32(ca.GetValue(0)) == MyTiffCompression.DifferencePredictor.Horizontal); } }
/// <summary> /// Read a piece of info. /// </summary> /// <param name="tag">Tag of the info to be read.</param> /// <param name="fid">Zero-based index of images.</param> /// <returns>An instance of TIFFinfo that contains the info.</returns> public virtual TiffData getInfo(int tag, int fid) { if (fid < 0 || fid >= IFDs.Length) { return(null); } TiffStruct fileData = IFDs[fid]; TiffDirData dir = fileData.search(tag); if (dir == null) { return(null); } if (dir.Offset > 0) { reader.BaseStream.Seek(dir.Offset, System.IO.SeekOrigin.Begin); dir.readData(reader); } return(dir.Data); }
/// <summary> /// Get photo metric interpretation. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Photo metric interpretation. Read TIFF documentation for details.</returns> public int getPhotometricInterpretation(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; int pmi = 0; try { pmi = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.PhotometricInterpretation).GetValue(0)); } catch { return(1); } return(pmi); }
/// <summary> /// Get the image bit depth. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Image depth in number of bits.</returns> public int getNumBits(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; int nbits = 0; try { nbits = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.BitsPerSample).GetValue(0)); } catch { throw new ReadFileException("Unable to read image info: "); } return(nbits); }
/// <summary> /// Get image size. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <param name="height">Height.</param> /// <param name="width">Width.</param> public void getImageSize(int fid, out int width, out int height) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; try { width = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.ImageWidth).GetValue(0)); height = Convert.ToInt32(dataStruct.searchData(TiffInfoCollection.ImageLength).GetValue(0)); } catch { throw new ReadFileException("Unable to read image info: "); } if (width <= 0 || height <= 0) { throw new ReadFileException("Invalid image info."); } }
protected bool checkTIFF() { System.IO.Stream stream = reader.BaseStream; if (stream == null) { return(false); } byte[] fileType = new byte[2]; List <TiffStruct> IFDlist = new List <TiffStruct>(); try { stream.Seek(0, System.IO.SeekOrigin.Begin); stream.Read(fileType, 0, 2); if (fileType[1] == 'M' && fileType[0] == 'M') { reader.IsLittleEndian = false; } else if (fileType[1] == 'I' && fileType[0] == 'I') { reader.IsLittleEndian = true; } else { return(false); } ushort num = reader.ReadUInt16(); if (num != 42) { return(false); } long firstIFD = reader.ReadUInt32(); if (firstIFD <= 0) { return(false); } while (firstIFD > 0) { stream.Seek(firstIFD, System.IO.SeekOrigin.Begin); TiffStruct ifd = createNewStruct(); ifd.read(reader); IFDlist.Add(ifd); firstIFD = ifd.NextIFD; } } catch (Exception ex) { if (IFDlist.Count == 0) { if (ex is ReadFileException) { throw ex; } throw new ReadFileException("Unexpected error, " + ex.Message); } } finally { IFDs = IFDlist.ToArray(); } return(true); }
/// <summary> /// Get colormap. /// </summary> /// <param name="fid">Zero-based index of images.</param> /// <returns>Colormap for palette-color images</returns> public byte[][] getColormap(int fid) { if (fid >= IFDs.Length) { throw new ReadFileException("Image # " + fid + " doesn't exist."); } TiffStruct dataStruct = IFDs[fid]; ushort[] temp; byte[][] colormap; int nbits; try { Array t = dataStruct.searchData(TiffInfoCollection.BitsPerSample); if (t == null || t.Length == 0) { return(null); } nbits = Convert.ToInt32(t.GetValue(0)); nbits = 1 << nbits; temp = dataStruct.searchData(TiffInfoCollection.ColorMap) as ushort[]; if (temp.Length != 3 * nbits) { nbits = temp.Length / 3; if (nbits != 256) { throw new ReadFileException("Colormap bit number error."); } } colormap = new byte[3][]; for (int k = 0; k < 3; k++) { colormap[k] = new byte[nbits]; } int highBits = 0; int lowBits = 0; for (int k = 1; k <= 3; k++) { highBits += temp[nbits - k] >> 8; lowBits += temp[nbits - k] & 0xff; } if (highBits > lowBits) { for (int k = 0; k < 3; k++) { for (int i = 0; i < nbits; i++) { colormap[k][i] = Convert.ToByte(temp[k * nbits + i] >> 8); } } } else { for (int k = 0; k < 3; k++) { for (int i = 0; i < nbits; i++) { colormap[k][i] = Convert.ToByte(temp[k * nbits + i] & 0xff); } } } } catch (Exception ex) { throw new ReadFileException("Unable to read image info: ", ex); } return(colormap); }