public static void Run()
{
TiffFile tiffFile = new TiffFile(Util.GetPath("Resources/Images/fw9_18.tif"));
Document document = tiffFile.GetDocument();
document.Draw(Util.GetPath("Output/TiffToPDF.pdf"));
}
// Convert a multipage TIFF image to a PDF document.
// This code uses the DynamicPDF Core Suite for .NET product.
// It used the following namespace from the ceTe.DynamicPDF.CoreSuite.NET NuGet package:
// * ceTe.DynamicPDF namespace for the Document class
// * ceTe.DynamicPDF.Imaging namespace for the TiffFile class
static void ConvertExampleOne()
{
TiffFile tiffFile = new TiffFile("../../../Resources/fw9_18.tif");
Document document = tiffFile.GetDocument();
document.Draw("core-suite-output.pdf");
}
public HeightMap GetHeightMap(FileMetadata metadata)
{
HeightMap heightMap = new HeightMap(metadata.Width, metadata.Height);
heightMap.Count = heightMap.Width * heightMap.Height;
var coords = new List <GeoPoint>(heightMap.Count);
// metadata.BitsPerSample
// When 16 we have 2 bytes per sample
// When 32 we have 4 bytes per sample
int bytesPerSample = metadata.BitsPerSample / 8;
byte[] byteScanline = new byte[metadata.ScanlineSize];
for (int y = 0; y < metadata.Height; y++)
{
TiffFile.ReadScanline(byteScanline, y);
double latitude = metadata.StartLat + (metadata.pixelSizeY * y);
for (int x = 0; x < metadata.Width; x++)
{
double longitude = metadata.StartLon + (metadata.pixelSizeX * x);
float heightValue = 0;
switch (metadata.SampleFormat)
{
case RasterSampleFormat.FLOATING_POINT:
heightValue = BitConverter.ToSingle(byteScanline, x * metadata.BitsPerSample / 8);
break;
case RasterSampleFormat.INTEGER:
heightValue = BitConverter.ToInt16(byteScanline, x * metadata.BitsPerSample / 8);
break;
case RasterSampleFormat.UNSIGNED_INTEGER:
heightValue = BitConverter.ToUInt16(byteScanline, x * metadata.BitsPerSample / 8);
break;
default:
throw new Exception("Sample format unsupported.");
}
if (heightValue < 32768)
{
heightMap.Minimum = Math.Min(metadata.MinimumAltitude, heightValue);
heightMap.Maximum = Math.Max(metadata.MaximumAltitude, heightValue);
}
else
{
heightValue = 0;
}
coords.Add(new GeoPoint(latitude, longitude, heightValue));
}
}
heightMap.Coordinates = coords;
return(heightMap);
}
public FileMetadata ParseMetaData()
{
FileMetadata metadata = new FileMetadata(FilePath);
///
metadata.Height = TiffFile.GetField(TiffTag.IMAGELENGTH)[0].ToInt();
metadata.Width = TiffFile.GetField(TiffTag.IMAGEWIDTH)[0].ToInt();
///
FieldValue[] modelPixelScaleTag = TiffFile.GetField(TiffTag.GEOTIFF_MODELPIXELSCALETAG);
FieldValue[] modelTiepointTag = TiffFile.GetField(TiffTag.GEOTIFF_MODELTIEPOINTTAG);
byte[] modelPixelScale = modelPixelScaleTag[1].GetBytes();
double pixelSizeX = BitConverter.ToDouble(modelPixelScale, 0);
double pixelSizeY = BitConverter.ToDouble(modelPixelScale, 8) * -1;
metadata.pixelSizeX = pixelSizeX;
metadata.pixelSizeY = pixelSizeY;
metadata.PixelScaleX = BitConverter.ToDouble(modelPixelScale, 0);
metadata.PixelScaleY = BitConverter.ToDouble(modelPixelScale, 8);
// Ignores first set of model points (3 bytes) and assumes they are 0's...
byte[] modelTransformation = modelTiepointTag[1].GetBytes();
metadata.OriginLongitude = BitConverter.ToDouble(modelTransformation, 24);
metadata.OriginLatitude = BitConverter.ToDouble(modelTransformation, 32);
double startLat = metadata.OriginLatitude + (pixelSizeY / 2.0);
double startLon = metadata.OriginLongitude + (pixelSizeX / 2.0);
metadata.StartLat = startLat;
metadata.StartLon = startLon;
var scanline = new byte[TiffFile.ScanlineSize()];
metadata.ScanlineSize = TiffFile.ScanlineSize();
//TODO: Check if band is stored in 1 byte or 2 bytes.
//If 2, the following code would be required
var scanline16Bit = new ushort[TiffFile.ScanlineSize() / 2];
Buffer.BlockCopy(scanline, 0, scanline16Bit, 0, scanline.Length);
// Grab some raster metadata
metadata.BitsPerSample = TiffFile.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
var sampleFormat = TiffFile.GetField(TiffTag.SAMPLEFORMAT);
// Add other information about the data
metadata.SampleFormat = sampleFormat[0].Value.ToString();
// TODO: Read this from tiff metadata or determine after parsing
metadata.NoDataValue = "-10000";
metadata.WorldUnits = "meter";
return(metadata);
}
public static void Run(string outputPdfPath)
{
// Create a TiffFile object from the TIFF image
TiffFile tiffFile = new TiffFile(Util.GetResourcePath("Images/fw9_18.tif"));
// Create a document object from the file
Document document = tiffFile.GetDocument();
// Save the PDF document
document.Draw(outputPdfPath);
}
/// <summary>
/// Konvertiert die PDF-Datei in Tiff-Dateien.
/// Gibt eine liste mit den Pfaden der Tiff-Dateien zurück.
/// </summary>
public List <string> ConvertPDFToImage(string pathFolder, bool tempPrefix, DocumentParam param)
{
List <string> list = new List <string>();
try
{
if (string.CompareOrdinal(pathFolder, string.Empty) == 0)
{
return(list);
}
FileInfo fileInfo = new FileInfo(param.FilePath);
if (fileInfo.Exists == false)
{
return(list);
}
FilesFunctions.DeleteFilesInFolder(pathFolder, Tiff);
// open existing PDF document
using (PdfDocument pdfDocument = new PdfDocument(param.FilePath, true))
{
// set resolution
//pdfDocument.RenderingSettings.Resolution = new Resolution(param.Resolution, param.Resolution);
//// set rendering mode - optimal balance between rendering speed and quality
//pdfDocument.RenderingSettings.RenderingMode = PdfRenderingMode.HighSpeed;
for (int pageCount = 0; pageCount < pdfDocument.Pages.Count; pageCount++)
{
string tempName = FilesFunctions.GetRandomName(pathFolder, fileInfo, tempPrefix, Tiff);
// create new TIFF file
using (TiffFile tiffFile = new TiffFile(tempName, TiffFileFormat.LittleEndian))
{
tiffFile.Pages.EncoderSettings.Compression = TiffCompression.Zip;
tiffFile.Pages.Add(pdfDocument.Pages[pageCount].Render());
tiffFile.SaveChanges();
list.Add(tempName);
}
}
}
return(list);
}
catch (Exception ex)
{
FileLogger.FileLogger.Instance.WriteExeption(ex);
return(list);
}
}
public float GetElevationAtPoint(FileMetadata metadata, int x, int y)
{
float heightValue = 0;
try
{
if (this.IsTiled)
{
// TODO store in metadata
int tileWidth = this.TileWidth;
int tileHeight = this.TileHeight;
int tileSize = this.TileSize;
byte[] buffer;
var tileX = (x / tileWidth) * tileWidth;
var tileY = (y / tileHeight) * tileHeight;
if (tilesCache == null)
{
tilesCache = new Dictionary <int, byte[]>();
}
var tileKey = (x / tileWidth) + (y / tileHeight) * (metadata.Width / tileWidth + 1);
if (!tilesCache.TryGetValue(tileKey, out buffer))
{
buffer = new byte[tileSize];
TiffFile.ReadTile(buffer, 0, tileX, tileY, 0, 0);
tilesCache.Add(tileKey, buffer);
}
var offset = x - tileX + (y - tileY) * tileHeight;
heightValue = GetElevationAtPoint(metadata, offset, buffer);
}
else
{
// metadata.BitsPerSample
// When 16 we have 2 bytes per sample
// When 32 we have 4 bytes per sample
int bytesPerSample = metadata.BitsPerSample / 8;
byte[] byteScanline = new byte[metadata.ScanlineSize];
TiffFile.ReadScanline(byteScanline, y);
heightValue = GetElevationAtPoint(metadata, x, byteScanline);
}
}
catch (Exception e)
{
throw new Exception($"Error in ParseGeoDataAtPoint: {e.Message}");
}
return(heightValue);
}
//public bool Colour { get; set; }
//public int Compression { get; set; }
//public bool KeepOriginal { get; set; }
/// <summary>
/// Von dem PDF-Dokument wird die erste Seite in tiff konvertiert und gespeichert.
/// die funktion liefert den Path zu der neue Datei zurück.
/// </summary>
public string GetFirstPageAsImageFromDocument(DocumentParam param)
{
try
{
string fileName = string.Empty;
FileInfo fileInfo = new FileInfo(param.FilePath);
if (fileInfo.Exists == false)
{
return(fileName);
}
string pathFolder = Path.GetTempPath();
using (PdfDocument pdfDocument = new PdfDocument(param.FilePath, true))
{
// set resolution
pdfDocument.RenderingSettings.Resolution = new Resolution(param.Resolution, param.Resolution);
// set rendering mode - optimal balance between rendering speed and quality
pdfDocument.RenderingSettings.RenderingMode = PdfRenderingMode.HighQuality;
string tempName = FilesFunctions.GetRandomName(pathFolder, fileInfo, true, Tiff);
for (int pageCount = 0; pageCount < pdfDocument.Pages.Count; pageCount++)
{
// create new TIFF file
using (TiffFile tiffFile = new TiffFile(tempName, TiffFileFormat.LittleEndian))
{
tiffFile.Pages.EncoderSettings.Compression = TiffCompression.Lzw;
tiffFile.Pages.Add(pdfDocument.Pages[pageCount].Render());
tiffFile.SaveChanges();
fileName = tempName;
}
}
}
return(fileName);
}
catch (Exception ex)
{
FileLogger.FileLogger.Instance.WriteExeption(ex);
return(string.Empty);
}
}
static void Main(string[] args)
{
using (TiffFile file = new TiffFile("F:\\Downloads\\Public\\VLI\\heic0601a.ptiff"))
{
TiffImage image = file.Images[5];
using (Bitmap bitmap = image.GetTile(0 * 256, 0 * 256))
bitmap.Save("0.jpg", ImageFormat.Jpeg);
using (Bitmap bitmap = image.GetTile(1 * 256, 0 * 256))
bitmap.Save("1.jpg", ImageFormat.Jpeg);
using (Bitmap bitmap = image.GetTile(0 * 256, 1 * 256))
bitmap.Save("2.jpg", ImageFormat.Jpeg);
using (Bitmap bitmap = image.GetTile(1 * 256, 1 * 256))
bitmap.Save("3.jpg", ImageFormat.Jpeg);
}
}
public float ParseGeoDataAtPoint(FileMetadata metadata, int x, int y)
{
float heightValue = 0;
try
{
byte[] scanline = new byte[metadata.ScanlineSize];
ushort[] scanline16Bit = new ushort[metadata.ScanlineSize / 2];
TiffFile.ReadScanline(scanline, y);
Buffer.BlockCopy(scanline, 0, scanline16Bit, 0, scanline.Length);
heightValue = ParseGeoDataAtPoint(metadata, x, scanline16Bit);
}
catch (Exception e)
{
throw new Exception($"Error in ParseGeoDataAtPoint: {e.Message}");
}
return(heightValue);
}
public float GetElevationAtPoint(FileMetadata metadata, int x, int y)
{
float heightValue = 0;
try
{
// metadata.BitsPerSample
// When 16 we have 2 bytes per sample
// When 32 we have 4 bytes per sample
int bytesPerSample = metadata.BitsPerSample / 8;
byte[] byteScanline = new byte[metadata.ScanlineSize];
TiffFile.ReadScanline(byteScanline, y);
heightValue = GetElevationAtPoint(metadata, x, byteScanline);
}
catch (Exception e)
{
throw new Exception($"Error in ParseGeoDataAtPoint: {e.Message}");
}
return(heightValue);
}
public HeightMap ParseGeoDataInBBox(BoundingBox bbox, FileMetadata metadata, float noDataValue = 0)
{
// metadata.BitsPerSample
// When 16 we have 2 bytes per sample
// When 32 we have 4 bytes per sample
int bytesPerSample = metadata.BitsPerSample / 8;
byte[] byteScanline = new byte[metadata.ScanlineSize];
int yStart = (int)Math.Floor((bbox.yMax - metadata.StartLat) / metadata.pixelSizeY);
int yEnd = (int)Math.Ceiling((bbox.yMin - metadata.StartLat) / metadata.pixelSizeY);
int xStart = (int)Math.Floor((bbox.xMin - metadata.StartLon) / metadata.pixelSizeX);
int xEnd = (int)Math.Ceiling((bbox.xMax - metadata.StartLon) / metadata.pixelSizeX);
xStart = Math.Max(0, xStart);
xEnd = Math.Min(metadata.Width - 1, xEnd);
yStart = Math.Max(0, yStart);
yEnd = Math.Min(metadata.Height - 1, yEnd);
HeightMap heightMap = new HeightMap(xEnd - xStart + 1, yEnd - yStart + 1);
heightMap.Count = heightMap.Width * heightMap.Height;
var coords = new List <GeoPoint>(heightMap.Count);
heightMap.BoundingBox = new BoundingBox(0, 0, 0, 0);
for (int y = yStart; y <= yEnd; y++)
{
TiffFile.ReadScanline(byteScanline, y);
double latitude = metadata.StartLat + (metadata.pixelSizeY * y);
// bounding box
if (y == yStart)
{
heightMap.BoundingBox.yMax = latitude;
heightMap.BoundingBox.xMin = metadata.StartLon + (metadata.pixelSizeX * xStart);
heightMap.BoundingBox.xMax = metadata.StartLon + (metadata.pixelSizeX * xEnd);
}
else if (y == yEnd)
{
heightMap.BoundingBox.yMin = latitude;
}
for (int x = xStart; x <= xEnd; x++)
{
double longitude = metadata.StartLon + (metadata.pixelSizeX * x);
float heightValue = 0;
switch (metadata.SampleFormat)
{
case "IEEEFP":
heightValue = BitConverter.ToSingle(byteScanline, x * bytesPerSample);
break;
case "INT":
heightValue = BitConverter.ToInt16(byteScanline, x * bytesPerSample);
break;
case "UINT":
heightValue = BitConverter.ToUInt16(byteScanline, x * bytesPerSample);
break;
default:
throw new Exception("Sample format unsupported.");
}
if (heightValue < 32768)
{
heightMap.Mininum = Math.Min(heightMap.Mininum, heightValue);
heightMap.Maximum = Math.Max(heightMap.Maximum, heightValue);
}
else
{
heightValue = (float)noDataValue;
}
coords.Add(new GeoPoint(latitude, longitude, heightValue, x, y));
}
}
Debug.Assert(heightMap.Width * heightMap.Height == coords.Count);
heightMap.Coordinates = coords;
return(heightMap);
}
public HeightMap GetHeightMapInBBox(BoundingBox bbox, FileMetadata metadata, float noDataValue = 0)
{
int yStart = 0;
int yEnd = 0;
int xStart = 0;
int xEnd = 0;
if (metadata.FileFormat.Registration == DEMFileRegistrationMode.Grid)
{
yStart = (int)Math.Floor((bbox.yMax - metadata.PhysicalEndLat) / metadata.pixelSizeY);
yEnd = (int)Math.Ceiling((bbox.yMin - metadata.PhysicalEndLat) / metadata.pixelSizeY);
xStart = (int)Math.Floor((bbox.xMin - metadata.PhysicalStartLon) / metadata.pixelSizeX);
xEnd = (int)Math.Ceiling((bbox.xMax - metadata.PhysicalStartLon) / metadata.pixelSizeX);
}
else
{
yStart = (int)Math.Floor((bbox.yMax - metadata.DataEndLat) / metadata.pixelSizeY);
yEnd = (int)Math.Ceiling((bbox.yMin - metadata.DataEndLat) / metadata.pixelSizeY);
xStart = (int)Math.Floor((bbox.xMin - metadata.DataStartLon) / metadata.pixelSizeX);
xEnd = (int)Math.Ceiling((bbox.xMax - metadata.DataStartLon) / metadata.pixelSizeX);
}
// Tiled geotiffs like aster have overlapping 1px borders
int overlappingPixel = this.IsTiled ? 1 : 0;
xStart = Math.Max(0, xStart);
xEnd = Math.Min(metadata.Width - 1, xEnd) - overlappingPixel;
yStart = Math.Max(0, yStart);
yEnd = Math.Min(metadata.Height - 1, yEnd) - overlappingPixel;
HeightMap heightMap = new HeightMap(xEnd - xStart + 1, yEnd - yStart + 1);
heightMap.Count = heightMap.Width * heightMap.Height;
var coords = new List <GeoPoint>(heightMap.Count);
heightMap.BoundingBox = new BoundingBox(0, 0, 0, 0);
if (this.IsTiled)
{
// Tiled rasters are composed of multiple "sub" images
// TODO store in metadata
int tileWidth = this.TileWidth;
int tileHeight = this.TileHeight;
int tileSize = this.TileSize;
byte[] buffer;
for (int y = yStart; y <= yEnd; y++)
{
double latitude = metadata.DataEndLat + (metadata.pixelSizeY * y);
// bounding box
if (y == yStart)
{
heightMap.BoundingBox.yMax = latitude;
heightMap.BoundingBox.xMin = metadata.DataStartLon + (metadata.pixelSizeX * xStart);
heightMap.BoundingBox.xMax = metadata.DataStartLon + (metadata.pixelSizeX * xEnd);
}
if (y == yEnd)
{
heightMap.BoundingBox.yMin = latitude;
}
for (int x = xStart; x <= xEnd; x++)
{
double longitude = metadata.DataStartLon + (metadata.pixelSizeX * x);
var tileX = (x / tileWidth) * tileWidth;
var tileY = (y / tileHeight) * tileHeight;
if (tilesCache == null)
{
tilesCache = new Dictionary <int, byte[]>();
}
var tileKey = (x / tileWidth) + (y / tileHeight) * (metadata.Width / tileWidth + 1);
if (!tilesCache.TryGetValue(tileKey, out buffer))
{
buffer = new byte[tileSize];
TiffFile.ReadTile(buffer, 0, tileX, tileY, 0, 0);
tilesCache.Add(tileKey, buffer);
}
var offset = x - tileX + (y - tileY) * tileHeight;
float heightValue = GetElevationAtPoint(metadata, offset, buffer);
if (heightValue <= 0)
{
heightMap.Minimum = Math.Min(heightMap.Minimum, heightValue);
heightMap.Maximum = Math.Max(heightMap.Maximum, heightValue);
}
else if (heightValue < 32768)
{
heightMap.Minimum = Math.Min(heightMap.Minimum, heightValue);
heightMap.Maximum = Math.Max(heightMap.Maximum, heightValue);
}
else
{
heightValue = (float)noDataValue;
}
coords.Add(new GeoPoint(latitude, longitude, heightValue));
}
}
}
else
{
// metadata.BitsPerSample
// When 16 we have 2 bytes per sample
// When 32 we have 4 bytes per sample
int bytesPerSample = metadata.BitsPerSample / 8;
byte[] byteScanline = new byte[metadata.ScanlineSize];
double endLat = metadata.DataEndLat + metadata.pixelSizeY / 2d;
double startLon = metadata.DataStartLon + metadata.pixelSizeX / 2d;
for (int y = yStart; y <= yEnd; y++)
{
TiffFile.ReadScanline(byteScanline, y);
// TODO: handle Cell registered DEMs: lat is 1/2 pixel off
double latitude = endLat + (metadata.pixelSizeY * y);
// bounding box
if (y == yStart)
{
heightMap.BoundingBox.yMax = latitude;
heightMap.BoundingBox.xMin = startLon + (metadata.pixelSizeX * xStart);
heightMap.BoundingBox.xMax = startLon + (metadata.pixelSizeX * xEnd);
}
else if (y == yEnd)
{
heightMap.BoundingBox.yMin = latitude;
}
for (int x = xStart; x <= xEnd; x++)
{
double longitude = startLon + (metadata.pixelSizeX * x);
float heightValue = 0;
switch (metadata.SampleFormat)
{
case RasterSampleFormat.FLOATING_POINT:
heightValue = BitConverter.ToSingle(byteScanline, x * bytesPerSample);
break;
case RasterSampleFormat.INTEGER:
heightValue = BitConverter.ToInt16(byteScanline, x * bytesPerSample);
break;
case RasterSampleFormat.UNSIGNED_INTEGER:
heightValue = BitConverter.ToUInt16(byteScanline, x * bytesPerSample);
break;
default:
throw new Exception("Sample format unsupported.");
}
if (heightValue <= 0)
{
heightMap.Minimum = Math.Min(heightMap.Minimum, heightValue);
heightMap.Maximum = Math.Max(heightMap.Maximum, heightValue);
}
else if (heightValue < 32768)
{
heightMap.Minimum = Math.Min(heightMap.Minimum, heightValue);
heightMap.Maximum = Math.Max(heightMap.Maximum, heightValue);
}
else
{
heightValue = (float)noDataValue;
}
coords.Add(new GeoPoint(latitude, longitude, heightValue));
}
}
}
heightMap.BoundingBox.zMin = heightMap.Minimum;
heightMap.BoundingBox.zMax = heightMap.Maximum;
Debug.Assert(heightMap.Width * heightMap.Height == coords.Count);
heightMap.Coordinates = coords;
return(heightMap);
}
public FileMetadata ParseMetaData(DEMFileDefinition format)
{
FileMetadata metadata = new FileMetadata(FilePath, format);
///
metadata.Height = TiffFile.GetField(TiffTag.IMAGELENGTH)[0].ToInt();
metadata.Width = TiffFile.GetField(TiffTag.IMAGEWIDTH)[0].ToInt();
///
FieldValue[] modelPixelScaleTag = TiffFile.GetField(TiffTag.GEOTIFF_MODELPIXELSCALETAG);
FieldValue[] modelTiepointTag = TiffFile.GetField(TiffTag.GEOTIFF_MODELTIEPOINTTAG);
byte[] modelPixelScale = modelPixelScaleTag[1].GetBytes();
double pixelSizeX = BitConverter.ToDouble(modelPixelScale, 0);
double pixelSizeY = BitConverter.ToDouble(modelPixelScale, 8) * -1;
metadata.pixelSizeX = pixelSizeX;
metadata.pixelSizeY = pixelSizeY;
metadata.PixelScaleX = BitConverter.ToDouble(modelPixelScale, 0);
metadata.PixelScaleY = BitConverter.ToDouble(modelPixelScale, 8);
// Ignores first set of model points (3 bytes) and assumes they are 0's...
byte[] modelTransformation = modelTiepointTag[1].GetBytes();
metadata.DataStartLon = BitConverter.ToDouble(modelTransformation, 24);
metadata.DataStartLat = BitConverter.ToDouble(modelTransformation, 32);
metadata.DataEndLon = metadata.DataStartLon + metadata.Width * pixelSizeX;
metadata.DataEndLat = metadata.DataStartLat + metadata.Height * pixelSizeY;
if (metadata.DataStartLon > metadata.DataEndLon)
{
double temp = metadata.DataStartLon;
metadata.DataStartLon = metadata.DataEndLon;
metadata.DataEndLon = temp;
}
if (metadata.DataStartLat > metadata.DataEndLat)
{
double temp = metadata.DataStartLat;
metadata.DataStartLat = metadata.DataEndLat;
metadata.DataEndLat = temp;
}
if (format.Registration == DEMFileRegistrationMode.Grid)
{
metadata.PhysicalStartLat = metadata.DataStartLat;
metadata.PhysicalStartLon = metadata.DataStartLon;
metadata.PhysicalEndLat = metadata.DataEndLat;
metadata.PhysicalEndLon = metadata.DataEndLon;
metadata.DataStartLat = Math.Round(metadata.DataStartLat + (metadata.PixelScaleY / 2.0), 10);
metadata.DataStartLon = Math.Round(metadata.DataStartLon + (metadata.PixelScaleX / 2.0), 10);
metadata.DataEndLat = Math.Round(metadata.DataEndLat - (metadata.PixelScaleY / 2.0), 10);
metadata.DataEndLon = Math.Round(metadata.DataEndLon - (metadata.PixelScaleX / 2.0), 10);
}
else
{
metadata.PhysicalStartLat = metadata.DataStartLat;
metadata.PhysicalStartLon = metadata.DataStartLon;
metadata.PhysicalEndLat = metadata.DataEndLat;
metadata.PhysicalEndLon = metadata.DataEndLon;
}
var scanline = new byte[TiffFile.ScanlineSize()];
metadata.ScanlineSize = TiffFile.ScanlineSize();
// Grab some raster metadata
metadata.BitsPerSample = TiffFile.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
var sampleFormat = TiffFile.GetField(TiffTag.SAMPLEFORMAT);
// Add other information about the data
metadata.SampleFormat = sampleFormat[0].Value.ToString();
// TODO: Read this from tiff metadata or determine after parsing
metadata.NoDataValue = "-10000";
metadata.WorldUnits = "meter";
return(metadata);
}
public TiffTileProvider(string filePath)
{
file = new TiffFile(filePath);
}
