private static double ProcessScanLine(geotiffdata geotiffdata, int y, byte[] scanline)
{
if (scanline == null)
{
}
if (geotiffdata.bits == 16)
{
return((short)((scanline[y * 2 + 1] << 8) + scanline[y * 2]));
}
else if (geotiffdata.bits == 32 && geotiffdata.type == 1)
{
return(BitConverter.ToUInt32(scanline, y * 4));
}
else if (geotiffdata.bits == 32 && geotiffdata.type == 2)
{
return(BitConverter.ToInt32(scanline, y * 4));
}
else if (geotiffdata.bits == 32 && geotiffdata.type == 3)
{
if (y * 4 > scanline.Length)
{
return(short.MinValue);
}
return(BitConverter.ToSingle(scanline, y * 4));
}
throw new Exception("ProcessScanLine: Invalid geotiff coord");
}
private static double GetAlt(geotiffdata geotiffdata, int x, int y)
{
if (x < 0 || y < 0 || x >= geotiffdata.width || y >= geotiffdata.height)
{
return(short.MinValue);
}
// if the image is to large use the direct to file approach
return(GetAltNoCache(geotiffdata, x, y));
}
private static double GetAlt(geotiffdata geotiffdata, int x, int y)
{
// if the image is to large use the direct to file approach
if (!geotiffdata.cacheable)
{
return(GetAltNoCache(geotiffdata, x, y));
}
// use our cache
return(cache[geotiffdata.FileName][x, y]);
}
private static void ExtractScanLineFromTile(geotiffdata geotiffdata, int line)
{
FieldValue[] value = geotiffdata.Tiff.GetField(TiffTag.IMAGEWIDTH);
int imageWidth = value[0].ToInt();
value = geotiffdata.Tiff.GetField(TiffTag.IMAGELENGTH);
int imageLength = value[0].ToInt();
value = geotiffdata.Tiff.GetField(TiffTag.TILEWIDTH);
int tileWidth = value[0].ToInt();
value = geotiffdata.Tiff.GetField(TiffTag.TILELENGTH);
int tileLength = value[0].ToInt();
var bytespersample = geotiffdata.bits / 8;
byte[][] scanlines = new byte[tileLength][];
for (int i = 0; i < scanlines.Length; i++)
{
scanlines[i] = new byte[(imageWidth + tileWidth) * bytespersample];
}
int tiley = 0;
byte[] buf = new byte[geotiffdata.Tiff.TileSize()];
for (int y = 0; y < imageLength; y += tileLength)
{
for (int x = 0; x < imageWidth; x += tileWidth)
{
if (y + tileLength < line || y > line)
{
break;
}
tiley = y;
geotiffdata.Tiff.ReadTile(buf, 0, x, y, 0, 0);
//int row = line % tileLength;
for (int i = 0; i < tileLength; i++)
{
Array.Copy(buf, i * bytespersample * tileLength, scanlines[i], x * bytespersample, tileWidth * bytespersample);
//Array.Copy(buf, row * bytespersample * tileLength, scanline, x * bytespersample, tileWidth * bytespersample);
}
}
}
foreach (var scanline in scanlines)
{
AddToCache(geotiffdata, tiley, scanline);
tiley++;
}
}
private static void AddToCache(geotiffdata geotiffdata, int x, byte[] scanline)
{
lock (cachescanlines)
{
var ci = cachescanlines.CreateEntry(geotiffdata.FileName + x.ToString());
ci.Value = scanline;
ci.Size = ((byte[])ci.Value).Length;
// evict after no access
ci.SlidingExpiration = TimeSpan.FromMinutes(5);
ci.Dispose();
}
}
private static double GetAltNoCache(geotiffdata geotiffdata, int x, int y)
{
byte[] scanline;
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName + x.ToString()) as byte[];
if (scanline == null)
{
//Task.Run(() =>
{
lock (geotiffdata)
if (geotiffdata.Tiff == null)
{
geotiffdata.Tiff = Tiff.Open(geotiffdata.FileName, "r");
}
lock (geotiffdata.Tiff)
{
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName + x.ToString()) as byte[];
if (scanline == null)
{
if (geotiffdata.Tiff.GetField(TiffTag.TILEWIDTH) != null &&
geotiffdata.Tiff.GetField(TiffTag.TILEWIDTH).Length >= 1)
{
//log.Info("read tile scanline " + x);
//return short.MinValue;
ExtractScanLineFromTile(geotiffdata, x);
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName + x.ToString()) as byte[];
}
else
{
//log.Info("read scanline " + x);
scanline = new byte[geotiffdata.Tiff.ScanlineSize()];
geotiffdata.Tiff.ReadScanline(scanline, x);
AddToCache(geotiffdata, x, scanline);
}
}
}
}
//);
//return short.MinValue;
if (scanline == null)
{
return(short.MinValue);
}
}
return(ProcessScanLine(geotiffdata, y, scanline));
}
private static void generateIndex()
{
var files = Directory.GetFiles(srtm.datadirectory, "*.tif");
foreach (var file in files)
{
try
{
geotiffdata tif = new geotiffdata();
tif.LoadFile(file);
}
catch
{
}
}
}
private static void AddToCache(geotiffdata geotiffdata, int x, byte[] scanline)
{
lock (cachescanlines)
{
if (cachescanlines.Get(geotiffdata.FileName.GetHashCode() ^ x.GetHashCode()) != null)
{
return;
}
var ci = cachescanlines.CreateEntry(geotiffdata.FileName.GetHashCode() ^ x.GetHashCode());
ci.Value = scanline;
ci.Size = ((byte[])ci.Value).Length;
// evict after no access
ci.SlidingExpiration = TimeSpan.FromMinutes(5);
ci.Dispose();
}
}
private static double GetAltNoCache(geotiffdata geotiffdata, int x, int y)
{
using (Tiff tiff = Tiff.Open(geotiffdata.FileName, "r"))
{
byte[] scanline = new byte[tiff.ScanlineSize()];
for (int row = 0; row < geotiffdata.height; row++)
{
tiff.ReadScanline(scanline, x);
if (geotiffdata.bits == 16)
{
return((short)((scanline[y * 2 + 1] << 8) + scanline[y * 2]));
}
else if (geotiffdata.bits == 32)
{
return(BitConverter.ToSingle(scanline, y * 4));
}
}
}
throw new Exception("GetAltNoCache: Invalid geotiff coord");
}
private static void generateIndex()
{
if (!Directory.Exists(srtm.datadirectory))
{
return;
}
var files = Directory.GetFiles(srtm.datadirectory, "*.tif");
foreach (var file in files)
{
try
{
geotiffdata tif = new geotiffdata();
tif.LoadFile(file);
}
catch (Exception ex)
{
log.Error(ex);
}
}
}
private static void generateIndex()
{
if (!Directory.Exists(srtm.datadirectory))
return;
var files = Directory.GetFiles(srtm.datadirectory, "*.tif");
foreach (var file in files)
{
try
{
geotiffdata tif = new geotiffdata();
tif.LoadFile(file);
}
catch (Exception ex)
{
log.Error(ex);
}
}
}
private static void generateIndex()
{
var files = Directory.GetFiles(srtm.datadirectory, "*.tif");
foreach (var file in files)
{
try
{
geotiffdata tif = new geotiffdata();
tif.LoadFile(file);
}
catch
{
}
}
}
private static double GetAltNoCache(geotiffdata geotiffdata, int x, int y)
{
byte[] scanline;
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName.GetHashCode() ^ x.GetHashCode()) as byte[];
if (scanline == null)
{
//Task.Run(() =>
{
lock (geotiffdata)
if (geotiffdata.Tiff == null)
{
geotiffdata.Tiff = Tiff.Open(geotiffdata.FileName, "r");
}
lock (geotiffdata.Tiff)
{
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName.GetHashCode() ^ x.GetHashCode()) as byte[];
if (scanline == null)
{
if (geotiffdata.Tiff.GetField(TiffTag.TILEWIDTH) != null &&
geotiffdata.Tiff.GetField(TiffTag.TILEWIDTH).Length >= 1)
{
//log.Info("read tile scanline " + x);
//return short.MinValue;
ExtractScanLineFromTile(geotiffdata, x);
lock (cachescanlines)
scanline = cachescanlines.Get(geotiffdata.FileName.GetHashCode() ^ x.GetHashCode()) as byte[];
}
else
{
//log.Info("read scanline " + x);
//RowsPerStrip
//http://www.libtiff.org/man/TIFFReadScanline.3t.html
var rps = geotiffdata.Tiff.GetField(TiffTag.ROWSPERSTRIP);
if (rps != null && rps.Length > 0 && (int)rps[0].Value > 1)
{
var start = x - (x % (int)rps[0].Value);
for (int i = start; i < start + (int)rps[0].Value; i++)
{
scanline = new byte[geotiffdata.Tiff.ScanlineSize()];
geotiffdata.Tiff.ReadScanline(scanline, i);
AddToCache(geotiffdata, i, scanline);
}
}
else
{
scanline = new byte[geotiffdata.Tiff.ScanlineSize()];
geotiffdata.Tiff.ReadScanline(scanline, x);
AddToCache(geotiffdata, x, scanline);
}
}
}
}
}
//);
//return short.MinValue;
if (scanline == null)
{
return(short.MinValue);
}
}
return(ProcessScanLine(geotiffdata, y, scanline));
}
