kopia lustrzana https://github.com/dl2alf/AirScout
1348 wiersze
57 KiB
C#
1348 wiersze
57 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using ScoutBase;
|
|
using ScoutBase.Core;
|
|
using ScoutBase.Elevation;
|
|
using SQLiteDatabase;
|
|
using Ionic.Zip;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace ElevationTileGenerator
|
|
{
|
|
public partial class MainDlg : Form
|
|
{
|
|
DataTableSRTM3 srtm3 = new DataTableSRTM3();
|
|
|
|
List<string> Files1 = new List<string>();
|
|
List<string> Files2 = new List<string>();
|
|
|
|
ElevationCatalogue Tiles = new ElevationCatalogue();
|
|
|
|
public MainDlg()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
private void MainDlg_Load(object sender, EventArgs e)
|
|
{
|
|
// string[] a = ElevationModel.Database.GetLocsFromRect(50, 0, 51, 2);
|
|
// fill compare files catalogues
|
|
if (!String.IsNullOrEmpty(tb_Tile1.Text))
|
|
{
|
|
// check for multiple files
|
|
if (tb_Tile1.Text.Contains(";"))
|
|
{
|
|
string[] a = tb_Tile1.Text.Split(';');
|
|
foreach (string file in a)
|
|
Files1.Add(file);
|
|
}
|
|
else
|
|
Files1.Add(tb_Tile1.Text);
|
|
}
|
|
if (!String.IsNullOrEmpty(tb_Tile2.Text))
|
|
{
|
|
// check for multiple files
|
|
if (tb_Tile2.Text.Contains(";"))
|
|
{
|
|
string[] a = tb_Tile2.Text.Split(';');
|
|
foreach (string file in a)
|
|
Files2.Add(file);
|
|
}
|
|
else
|
|
Files2.Add(tb_Tile2.Text);
|
|
}
|
|
}
|
|
|
|
private void btn_Start_Click(object sender, EventArgs e)
|
|
{
|
|
Scan();
|
|
}
|
|
|
|
public bool IsGLOBEFile(string filename)
|
|
{
|
|
// checks for a valid filename with/witout extension
|
|
// filename must have a xxxx. notation
|
|
// [0]: 'A'..'P'
|
|
// [1],[2]: nn = version
|
|
// [3]: 'G','B','S','T' = status
|
|
// 'S' and 'T' are not used
|
|
if (String.IsNullOrEmpty(filename))
|
|
return false;
|
|
string upperfilename = Path.GetFileNameWithoutExtension(filename).ToUpper();
|
|
// return on extension not empty
|
|
string extension = Path.GetExtension(filename);
|
|
if (!String.IsNullOrEmpty(extension))
|
|
return false;
|
|
char index = upperfilename[0];
|
|
char status = upperfilename[3];
|
|
// check length of filename
|
|
if (upperfilename.Length != 4)
|
|
return false;
|
|
// check allowed chars
|
|
if ((index < 'A')
|
|
|| (index > 'P')
|
|
|| !Char.IsDigit(upperfilename[1])
|
|
|| !Char.IsDigit(upperfilename[2])
|
|
|| ((status != 'G') && (status != 'B'))
|
|
)
|
|
return false;
|
|
//check length
|
|
long l = 0;
|
|
switch (index)
|
|
{
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'M':
|
|
case 'N':
|
|
case 'O':
|
|
case 'P':
|
|
l = 4800 * 10800 * 2;
|
|
break;
|
|
case 'E':
|
|
case 'F':
|
|
case 'G':
|
|
case 'H':
|
|
case 'I':
|
|
case 'J':
|
|
case 'K':
|
|
case 'L':
|
|
l = 6000 * 10800 * 2;
|
|
break;
|
|
}
|
|
if (l != new System.IO.FileInfo(filename).Length)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public bool IsSRTM3File(string filename)
|
|
{
|
|
// checks for a valid SRTM filename with extension
|
|
// filename must have a XnnYnnn.hgt notation
|
|
// [0]: 'N' or 'S'
|
|
// [1],[2]: nn = Latitude
|
|
// [3]: 'E' or 'W'
|
|
// [4],[5],[6]: nnn = Longitude
|
|
if (String.IsNullOrEmpty(filename))
|
|
return false;
|
|
if (Path.GetExtension(filename).ToUpper() != ".HGT")
|
|
return false;
|
|
string upperfilename = Path.GetFileNameWithoutExtension(filename).ToUpper();
|
|
if ((upperfilename[0] != 'N') && (upperfilename[0] != 'S'))
|
|
return false;
|
|
if ((upperfilename[3] != 'W') && (upperfilename[3] != 'E'))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[1]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[2]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[4]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[5]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[6]))
|
|
return false;
|
|
// check file size
|
|
long l = 1201 * 1201 * 2;
|
|
if (l != new System.IO.FileInfo(filename).Length)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public bool IsSRTM1File(string filename)
|
|
{
|
|
// checks for a valid SRTM filename with extension
|
|
// filename must have a XnnYnnn.hgt notation
|
|
// [0]: 'N' or 'S'
|
|
// [1],[2]: nn = Latitude
|
|
// [3]: 'E' or 'W'
|
|
// [4],[5],[6]: nnn = Longitude
|
|
if (String.IsNullOrEmpty(filename))
|
|
return false;
|
|
if (Path.GetExtension(filename).ToUpper() != ".HGT")
|
|
return false;
|
|
string upperfilename = Path.GetFileNameWithoutExtension(filename).ToUpper();
|
|
if ((upperfilename[0] != 'N') && (upperfilename[0] != 'S'))
|
|
return false;
|
|
if ((upperfilename[3] != 'W') && (upperfilename[3] != 'E'))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[1]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[2]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[4]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[5]))
|
|
return false;
|
|
if (!Char.IsDigit(upperfilename[6]))
|
|
return false;
|
|
// check file size
|
|
long l = 3601 * 3601 * 2;
|
|
if (l != new System.IO.FileInfo(filename).Length)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
private void ProcessTile(string tilename, int current, int count)
|
|
{
|
|
if (IsSRTM3File(tilename) || IsSRTM1File(tilename))
|
|
{
|
|
string srtmindex = Path.GetFileNameWithoutExtension(tilename).ToUpper();
|
|
int latbase = (srtmindex[0] == 'S') ? -System.Convert.ToInt32(srtmindex.Substring(1, 2)) : System.Convert.ToInt32(srtmindex.Substring(1, 2));
|
|
int lonbase = (srtmindex[3] == 'W') ? -System.Convert.ToInt32(srtmindex.Substring(4, 3)) : System.Convert.ToInt32(srtmindex.Substring(4, 3));
|
|
string tilebase = MaidenheadLocator.LocFromLatLon(latbase, lonbase, false, 3).Substring(0,4);
|
|
|
|
// creating dir
|
|
string dir = Path.Combine(Properties.Settings.Default.DestDir, tilebase.Substring(0, 2), tilebase.Substring(2, 2));
|
|
int rows;
|
|
int cols;
|
|
if (IsSRTM3File(tilename))
|
|
{
|
|
rows = 1201;
|
|
cols = 1201;
|
|
}
|
|
else
|
|
{
|
|
rows = 3601;
|
|
cols = 3601;
|
|
}
|
|
FileStream fs = File.OpenRead(tilename);
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.SetLength(fs.Length);
|
|
fs.Read(ms.GetBuffer(), 0, (int)fs.Length);
|
|
using (BinaryReader br = new BinaryReader(ms))
|
|
{
|
|
bool all_void = true;
|
|
ElevationTileDesignator tile;
|
|
char x = (lonbase % 2 == 0) ? 'A' : 'M';
|
|
for (int i = 0; i < 12; i++)
|
|
{
|
|
char y = 'A';
|
|
for (int j = 0; j < 24; j++)
|
|
{
|
|
Stopwatch st = new Stopwatch();
|
|
st.Start();
|
|
string filename = tilebase + x + y + ".loc";
|
|
if (!File.Exists(Path.Combine(dir, filename)))
|
|
{
|
|
tile = new ElevationTileDesignator();
|
|
tile.TileIndex = tilebase + x + y;
|
|
tile.Rows = rows / 24;
|
|
tile.Columns = cols / 12;
|
|
short[,] b = new short[tile.Columns, tile.Rows];
|
|
byte[] a16 = new byte[2];
|
|
for (int k = 0; k < tile.Columns; k++)
|
|
{
|
|
for (int l = 0; l < tile.Rows; l++)
|
|
{
|
|
br.BaseStream.Position = ((rows - 2 - j * tile.Rows - l) * cols + i * tile.Columns + k) * 2;
|
|
br.Read(a16, 0, 2);
|
|
Array.Reverse(a16);
|
|
short e = BitConverter.ToInt16(a16, 0);
|
|
b[k, l] = e;
|
|
if ((e != ElevationData.Database.ElvMissingFlag) && (e < tile.MinElv))
|
|
{
|
|
tile.MinElv = e;
|
|
tile.MinLon = tile.BaseLon + k * tile.StepWidthLon;
|
|
tile.MinLat = tile.BaseLat + l * tile.StepWidthLat;
|
|
}
|
|
if ((e != ElevationData.Database.ElvMissingFlag) && (e > tile.MaxElv))
|
|
{
|
|
tile.MaxElv = e;
|
|
tile.MaxLon = tile.BaseLon + k * tile.StepWidthLon;
|
|
tile.MaxLat = tile.BaseLat + l * tile.StepWidthLat;
|
|
}
|
|
if (e != ElevationData.Database.ElvMissingFlag)
|
|
all_void = false;
|
|
}
|
|
}
|
|
tile.Elv = b;
|
|
tile.LastUpdated = DateTime.UtcNow;
|
|
if (!all_void)
|
|
{
|
|
// ElevationModel.Database.ElevationTileInsertOrUpdateIfNewer(tile);
|
|
// create dir if not exists
|
|
if (!Directory.Exists(dir))
|
|
Directory.CreateDirectory(dir);
|
|
// write json file
|
|
ms = new MemoryStream();
|
|
using (StreamWriter sw = new StreamWriter(ms))
|
|
{
|
|
string json = tile.ToJSON();
|
|
sw.WriteLine(json);
|
|
sw.Flush();
|
|
ms.Position = 0;
|
|
File.WriteAllBytes(Path.Combine(dir, filename), ms.ToArray());
|
|
}
|
|
File.SetCreationTimeUtc(Path.Combine(dir, filename), tile.LastUpdated);
|
|
File.SetLastWriteTimeUtc(Path.Combine(dir, filename), tile.LastUpdated);
|
|
}
|
|
}
|
|
st.Stop();
|
|
tsl_Status.Text = "[" + Path.GetFileNameWithoutExtension(tilename) + ", " + current.ToString() + " of " + count.ToString() + "] Processing tile: " + tilebase + x + y + ", " + st.ElapsedMilliseconds.ToString() + "ms";
|
|
Application.DoEvents();
|
|
y++;
|
|
}
|
|
x++;
|
|
}
|
|
}
|
|
}
|
|
else if (IsGLOBEFile(tilename))
|
|
{
|
|
char index = Path.GetFileName(tilename.ToUpper())[0];
|
|
int latbase;
|
|
int lonbase;
|
|
int rows;
|
|
int cols;
|
|
switch (index)
|
|
{
|
|
case 'A':
|
|
latbase = 50;
|
|
lonbase = -180;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'B':
|
|
latbase = 50;
|
|
lonbase = -90;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'C':
|
|
latbase = 50;
|
|
lonbase = 0;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'D':
|
|
latbase = 50;
|
|
lonbase = 90;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'E':
|
|
latbase = 0;
|
|
lonbase = -180;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'F':
|
|
latbase = 0;
|
|
lonbase = -90;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'G':
|
|
latbase = 0;
|
|
lonbase = 0;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'H':
|
|
latbase = 0;
|
|
lonbase = 90;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'I':
|
|
latbase = -50;
|
|
lonbase = -180;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'J':
|
|
latbase = -50;
|
|
lonbase = -90;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'K':
|
|
latbase = -50;
|
|
lonbase = 0;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'L':
|
|
latbase = -50;
|
|
lonbase = 90;
|
|
cols = 10800;
|
|
rows = 6000;
|
|
break;
|
|
case 'M':
|
|
latbase = -90;
|
|
lonbase = -180;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'N':
|
|
latbase = -90;
|
|
lonbase = -90;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'O':
|
|
latbase = -90;
|
|
lonbase = -0;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
case 'P':
|
|
latbase = -90;
|
|
lonbase = 90;
|
|
cols = 10800;
|
|
rows = 4800;
|
|
break;
|
|
default:
|
|
latbase = 0;
|
|
lonbase = 0;
|
|
cols = 0;
|
|
rows = 0;
|
|
break;
|
|
}
|
|
|
|
string tilebase = MaidenheadLocator.LocFromLatLon(latbase, lonbase, false, 3).Substring(0, 4);
|
|
FileStream fs = File.OpenRead(tilename);
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.SetLength(fs.Length);
|
|
fs.Read(ms.GetBuffer(), 0, (int)fs.Length);
|
|
using (BinaryReader br = new BinaryReader(ms))
|
|
{
|
|
ElevationTileDesignator tile;
|
|
for (int i0 = 0; i0 <= 4; i0++)
|
|
{
|
|
int j0max = (rows == 6000) ? 4 : 3;
|
|
for (int j0 = 0; j0 <= j0max; j0++)
|
|
{
|
|
int i1max = (i0 < 4) ? 9 : 4;
|
|
for (int i1 = 0; i1 <= i1max; i1++)
|
|
{
|
|
for (int j1 = 0; j1 <= 9; j1++)
|
|
{
|
|
for (int i2 = 0; i2 < 24; i2++)
|
|
{
|
|
for (int j2 = 0; j2 < 24; j2++)
|
|
{
|
|
Stopwatch st = new Stopwatch();
|
|
st.Start();
|
|
// generate lat/lon from tile's midpoint
|
|
double lat = latbase + j0 * 10.0 + j1 * 1.0 + j2 * 1.0 / 24.0 + 0.5 / 24.0;
|
|
double lon = lonbase + i0 * 20.0 + i1 * 2.0 + i2 * 2.0 / 24.0 + 1.0 / 24.0;
|
|
// generate filename from lat/lon
|
|
string tileindex = MaidenheadLocator.LocFromLatLon(lat, lon, false, 3);
|
|
string filename = tileindex + ".loc";
|
|
// creating dir
|
|
string dir = Path.Combine(Properties.Settings.Default.DestDir, filename.Substring(0, 2), filename.Substring(2,2));
|
|
if (!File.Exists(Path.Combine(dir, filename)))
|
|
{
|
|
bool all_void = true;
|
|
tile = new ElevationTileDesignator();
|
|
tile.TileIndex = tileindex;
|
|
tile.Rows = (rows == 6000) ? rows / 50 / 24 : rows / 40 / 24;
|
|
tile.Columns = cols / 90 / 24 * 2;
|
|
short[,] b = new short[tile.Columns, tile.Rows];
|
|
for (int k = 0; k < tile.Columns; k++)
|
|
{
|
|
for (int l = 0; l < tile.Rows; l++)
|
|
{
|
|
br.BaseStream.Position = ((rows - 1 - j0 * 10 * 24 * tile.Rows - j1 * 24 * tile.Rows - j2 * tile.Rows - l) * cols + i0 * 10 * 24 * tile.Columns + i1 * 24 * tile.Columns + i2 * tile.Columns + k) * 2;
|
|
short e = br.ReadInt16();
|
|
if (e <= -500)
|
|
e = ElevationData.Database.ElvMissingFlag;
|
|
b[k, l] = e;
|
|
if ((e != ElevationData.Database.ElvMissingFlag) && (e < tile.MinElv))
|
|
{
|
|
tile.MinElv = e;
|
|
tile.MinLon = tile.BaseLon + k * tile.StepWidthLon;
|
|
tile.MinLat = tile.BaseLat + l * tile.StepWidthLat;
|
|
}
|
|
if ((e != ElevationData.Database.ElvMissingFlag) && (e > tile.MaxElv))
|
|
{
|
|
tile.MaxElv = e;
|
|
tile.MaxLon = tile.BaseLon + k * tile.StepWidthLon;
|
|
tile.MaxLat = tile.BaseLat + l * tile.StepWidthLat;
|
|
}
|
|
if (e != ElevationData.Database.ElvMissingFlag)
|
|
all_void = false;
|
|
}
|
|
}
|
|
tile.Elv = b;
|
|
tile.LastUpdated = DateTime.UtcNow;
|
|
if (!all_void)
|
|
{
|
|
// ElevationModel.Database.ElevationTileInsertOrUpdateIfNewer(tile);
|
|
// create dir if not exists
|
|
try
|
|
{
|
|
if (!Directory.Exists(dir))
|
|
Directory.CreateDirectory(dir);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
// write json file
|
|
ms = new MemoryStream();
|
|
using (StreamWriter sw = new StreamWriter(ms))
|
|
{
|
|
string json = tile.ToJSON();
|
|
sw.WriteLine(json);
|
|
sw.Flush();
|
|
ms.Position = 0;
|
|
File.WriteAllBytes(Path.Combine(dir, filename), ms.ToArray());
|
|
}
|
|
File.SetCreationTimeUtc(Path.Combine(dir, filename), tile.LastUpdated);
|
|
File.SetLastWriteTimeUtc(Path.Combine(dir, filename), tile.LastUpdated);
|
|
}
|
|
}
|
|
st.Stop();
|
|
tsl_Status.Text = "[" + Path.GetFileNameWithoutExtension(tilename) + ", " + current.ToString() + " of " + count.ToString() + "] Processing tile: " + filename + ", " + st.ElapsedMilliseconds.ToString() + "ms";
|
|
ss_Main.Refresh();
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Scan()
|
|
{
|
|
// string[] files = Directory.GetFiles(Properties.Settings.Default.SourceDir);
|
|
// foreach (string file in files)
|
|
// ProcessTile(file);
|
|
OpenFileDialog Dlg = new OpenFileDialog();
|
|
Dlg.DefaultExt = "*.loc";
|
|
Dlg.Multiselect = true;
|
|
Dlg.InitialDirectory = Properties.Settings.Default.SourceDir;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
int i = 1;
|
|
foreach (string file in Dlg.FileNames)
|
|
{
|
|
ProcessTile(file, i, Dlg.FileNames.Count());
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ZIP()
|
|
{
|
|
int i = 1;
|
|
char[] a = new char[2];
|
|
char[] b = new char[2];
|
|
for (a[0] = 'A'; a[0] <= 'R'; a[0]++)
|
|
{
|
|
for (a[1] = 'A'; a[1] <= 'R'; a[1]++)
|
|
{
|
|
for (b[0] = '0'; b[0] <= '9'; b[0]++)
|
|
{
|
|
for (b[1] = '0'; b[1] <= '9'; b[1]++)
|
|
{
|
|
Stopwatch st = new Stopwatch();
|
|
st.Start();
|
|
string dira = Path.Combine(Properties.Settings.Default.DestDir, new string(a), new string(b));
|
|
string dirb = Path.Combine(Properties.Settings.Default.DestDir, new string(a));
|
|
if (Directory.Exists(dira))
|
|
{
|
|
string[] files = Directory.GetFiles(dira, "*.loc");
|
|
if (files.Length > 0)
|
|
{
|
|
// create ZIP file and add all loc files
|
|
string zipfilename = Path.Combine(dirb, new string(a) + new string(b) + ".zip");
|
|
if (File.Exists(zipfilename))
|
|
File.Delete(zipfilename);
|
|
ZipFile zip = new ZipFile(zipfilename);
|
|
zip.AddFiles(files, "");
|
|
zip.Save();
|
|
// sleep 5s to ensure that file is written
|
|
Thread.Sleep(1000);
|
|
}
|
|
foreach (string file in files)
|
|
File.Delete(file);
|
|
Directory.Delete(dira);
|
|
}
|
|
|
|
st.Stop();
|
|
tsl_Status.Text = "Processing dir: " + dira + ", " + st.ElapsedMilliseconds.ToString() + "ms.";
|
|
Application.DoEvents();
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MainDlg_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private void btn_SourceDir_Click(object sender, EventArgs e)
|
|
{
|
|
FolderBrowserDialog Dlg = new FolderBrowserDialog();
|
|
Dlg.SelectedPath = Properties.Settings.Default.SourceDir;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Properties.Settings.Default.SourceDir = Dlg.SelectedPath;
|
|
}
|
|
}
|
|
|
|
private void btn_DestDir_Click(object sender, EventArgs e)
|
|
{
|
|
FolderBrowserDialog Dlg = new FolderBrowserDialog();
|
|
Dlg.SelectedPath = Properties.Settings.Default.DestDir;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Properties.Settings.Default.DestDir = Dlg.SelectedPath;
|
|
}
|
|
}
|
|
|
|
private void btn_Stop_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
private void btn_Picture_Click(object sender, EventArgs e)
|
|
{
|
|
Stopwatch st = new Stopwatch();
|
|
st.Start();
|
|
Bitmap bm = ElevationData.Database.DrawElevationBitmap(50, 0, 60, 20,3200, 3200, ELEVATIONMODEL.SRTM1);
|
|
bm.Save("Elevation.tif", System.Drawing.Imaging.ImageFormat.Tiff);
|
|
pb_Picture.Image = bm;
|
|
st.Stop();
|
|
tsl_Status.Text = "Drawing picture: " + st.ElapsedMilliseconds.ToString() + "ms.";
|
|
this.Refresh();
|
|
}
|
|
|
|
private void btn_ZIP_Click(object sender, EventArgs e)
|
|
{
|
|
ZIP();
|
|
}
|
|
|
|
public T GetFirstInstance<T>(string propertyName, string json)
|
|
{
|
|
using (var stringReader = new StringReader(json))
|
|
using (var jsonReader = new JsonTextReader(stringReader))
|
|
{
|
|
int level = 0;
|
|
|
|
while (jsonReader.Read())
|
|
{
|
|
switch (jsonReader.TokenType)
|
|
{
|
|
case JsonToken.PropertyName:
|
|
if (level != 1)
|
|
break;
|
|
if ((string)jsonReader.Value == propertyName)
|
|
{
|
|
jsonReader.Read();
|
|
|
|
return (T)jsonReader.Value;
|
|
}
|
|
break;
|
|
|
|
case JsonToken.StartArray:
|
|
case JsonToken.StartConstructor:
|
|
case JsonToken.StartObject:
|
|
level++;
|
|
break;
|
|
|
|
case JsonToken.EndArray:
|
|
case JsonToken.EndConstructor:
|
|
case JsonToken.EndObject:
|
|
level--;
|
|
break;
|
|
}
|
|
|
|
}
|
|
return default(T);
|
|
}
|
|
}
|
|
private void ScanDir(string dir)
|
|
{
|
|
tsl_Status.Text = "Scanning directory: " + dir;
|
|
this.Refresh();
|
|
Application.DoEvents();
|
|
string[] dirs = Directory.GetDirectories(dir);
|
|
foreach (string d in dirs)
|
|
ScanDir(d);
|
|
string[] files = Directory.GetFiles(dir, "*.loc");
|
|
foreach (string file in files)
|
|
{
|
|
try
|
|
{
|
|
DateTime lastupdated = File.GetCreationTimeUtc(file);
|
|
Tiles.Files.Add(Path.GetFileName(file), lastupdated);
|
|
/*
|
|
using (StreamReader sr = new StreamReader(File.OpenRead(file)))
|
|
{
|
|
string json = sr.ReadToEnd();
|
|
// ElevationTileDesignator tile = ElevationTileDesignator.FromJSON<ElevationTileDesignator>(json);
|
|
json = "{\"" + json.Remove(0, json.LastIndexOf("LastUpdated"));
|
|
lastupdated = GetFirstInstance<DateTime>("LastUpdated", json);
|
|
Tiles.Files.Add(Path.GetFileName(file), lastupdated);
|
|
}
|
|
*/
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ScanDirZIP(string dir)
|
|
{
|
|
tsl_Status.Text = "Scanning directory: " + dir;
|
|
this.Refresh();
|
|
Application.DoEvents();
|
|
string[] dirs = Directory.GetDirectories(dir);
|
|
foreach (string d in dirs)
|
|
ScanDirZIP(d);
|
|
string[] zipfiles = Directory.GetFiles(dir, "*.zip");
|
|
foreach (string zipfile in zipfiles)
|
|
{
|
|
ZipFile zip = new ZipFile(zipfile);
|
|
foreach (ZipEntry file in zip.Entries)
|
|
{
|
|
Tiles.Files.Add(Path.GetFileName(file.FileName), file.CreationTime.ToUniversalTime());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CAT()
|
|
{
|
|
Tiles.Files.Clear();
|
|
ScanDir(Properties.Settings.Default.DestDir);
|
|
tsl_Status.Text = "Scanned: " + Tiles.Files.Count + " files.";
|
|
this.Refresh();
|
|
string filename = Path.Combine(Properties.Settings.Default.DestDir, "files.cat");
|
|
using (StreamWriter sw = new StreamWriter(filename))
|
|
{
|
|
sw.WriteLine("// (D)igital (E)levation (Model) tile catalogue");
|
|
sw.WriteLine("// created " + DateTime.UtcNow.ToString("yyyy-MM-dd") + " (c) DL2ALF");
|
|
sw.WriteLine("// using elevation data from the GLOBE and SRTM (V3) projects, voids filled with the help of ASTER data");
|
|
sw.WriteLine("// GLOBE data homepage: https://www.ngdc.noaa.gov/mgg/topo/globe.html");
|
|
sw.WriteLine("// SRTM3 data homepage: https://lpdaac.usgs.gov/dataset_discovery/measures/measures_products_table/srtmgl3_v003");
|
|
sw.WriteLine("// SRTM1 data homepage: https://lpdaac.usgs.gov/dataset_discovery/measures/measures_products_table/srtmgl1_v003");
|
|
sw.WriteLine("// ASTER GDEM is a product of NASA and METI. See links above for details.");
|
|
sw.WriteLine();
|
|
foreach (KeyValuePair<string, DateTime> tile in Tiles.Files)
|
|
{
|
|
sw.WriteLine(tile.Key + ";" + tile.Value.ToString("yyyy-MM-dd HH:mm:ssZ", CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
string zipfilename = filename.Replace(".cat", ".zip");
|
|
if (File.Exists(zipfilename))
|
|
File.Delete(zipfilename);
|
|
ZipFile zip = new ZipFile(zipfilename);
|
|
zip.AddFile(filename, "");
|
|
zip.Save();
|
|
}
|
|
|
|
private void CATFromZIP()
|
|
{
|
|
Tiles.Files.Clear();
|
|
ScanDirZIP(Properties.Settings.Default.DestDir);
|
|
tsl_Status.Text = "Scanned: " + Tiles.Files.Count + " files.";
|
|
this.Refresh();
|
|
Application.DoEvents();
|
|
// string json = Tiles.ToJSON();
|
|
string filename = Path.Combine(Properties.Settings.Default.DestDir, "files.cat");
|
|
using (StreamWriter sw = new StreamWriter(filename))
|
|
{
|
|
sw.WriteLine("// (D)igital (E)levation (Model) tile catalogue");
|
|
sw.WriteLine("// created " + DateTime.UtcNow.ToString("yyyy-MM-dd") + " (c) DL2ALF");
|
|
sw.WriteLine("// using elevation data from the GLOBE and SRTM (V3) projects, voids filled with the help of ASTER data");
|
|
sw.WriteLine("// GLOBE data homepage: https://www.ngdc.noaa.gov/mgg/topo/globe.html");
|
|
sw.WriteLine("// SRTM3 data homepage: https://lpdaac.usgs.gov/dataset_discovery/measures/measures_products_table/srtmgl3_v003");
|
|
sw.WriteLine("// SRTM1 data homepage: https://lpdaac.usgs.gov/dataset_discovery/measures/measures_products_table/srtmgl1_v003");
|
|
sw.WriteLine("// ASTER GDEM is a product of NASA and METI. See links above for details.");
|
|
sw.WriteLine();
|
|
foreach (KeyValuePair<string, DateTime> tile in Tiles.Files)
|
|
{
|
|
sw.WriteLine(tile.Key + ";" + tile.Value.ToString("yyyy-MM-dd HH:mm:ssZ", CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
string zipfilename = filename.Replace(".cat", ".zip");
|
|
if (File.Exists(zipfilename))
|
|
File.Delete(zipfilename);
|
|
ZipFile zip = new ZipFile(zipfilename);
|
|
zip.AddFile(filename, "");
|
|
zip.Save();
|
|
}
|
|
|
|
private void btn_CAT_Click(object sender, EventArgs e)
|
|
{
|
|
CAT();
|
|
}
|
|
|
|
private void TestCAT()
|
|
{
|
|
// ElevationCatalogue cat = new ElevationCatalogue("http://www.airscout.eu/downloads/ElevationData/SRTM3", Application.StartupPath, 35, -15, 60, 30);
|
|
}
|
|
|
|
private void btn_TestCAT_Click(object sender, EventArgs e)
|
|
{
|
|
TestCAT();
|
|
}
|
|
|
|
private void btn_CATFromZIP_Click(object sender, EventArgs e)
|
|
{
|
|
CATFromZIP();
|
|
}
|
|
|
|
private void PictureFromTiles(string[] files, bool createTIFFromTiles = false)
|
|
{
|
|
Bitmap bm = null;
|
|
foreach (string file in files)
|
|
{
|
|
tsl_Status.Text = "Processing " + Path.GetFileName(file) + "...";
|
|
Application.DoEvents();
|
|
using (StreamReader sr = new StreamReader(File.OpenRead(file)))
|
|
{
|
|
string json = sr.ReadToEnd();
|
|
ElevationTileDesignator tile = ElevationTileDesignator.FromJSON<ElevationTileDesignator>(json);
|
|
// create bitmap if not created
|
|
if (bm == null)
|
|
{
|
|
bm = new Bitmap(tile.Columns * 24, tile.Rows * 24);
|
|
}
|
|
Bitmap bt = tile.ToBitmap();
|
|
if (createTIFFromTiles)
|
|
bt.Save(file.Replace(".loc",".tif"), System.Drawing.Imaging.ImageFormat.Tiff);
|
|
int col = (int)(tile.TileIndex[4] - 'A') * tile.Columns;
|
|
int row = (int)(tile.TileIndex[5] - 'A') * tile.Rows;
|
|
for (int i = 0; i < tile.Columns; i++)
|
|
{
|
|
for (int j = 0; j < tile.Rows; j++)
|
|
{
|
|
bm.SetPixel(col + i, bm.Height - row - bt.Height + j, bt.GetPixel(i, j));
|
|
}
|
|
}
|
|
pb_Picture.Image = bm;
|
|
}
|
|
}
|
|
if (bm != null)
|
|
bm.Save("ElevationTiles.tif", System.Drawing.Imaging.ImageFormat.Tiff);
|
|
}
|
|
|
|
private void btn_PictureFromTiles_Click(object sender, EventArgs e)
|
|
{
|
|
FolderBrowserDialog Dlg = new FolderBrowserDialog();
|
|
Dlg.SelectedPath = Properties.Settings.Default.DestDir;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string[] files = Directory.GetFiles(Dlg.SelectedPath, "*.loc");
|
|
}
|
|
}
|
|
|
|
private void ScanDirDelete(string dir)
|
|
{
|
|
tsl_Status.Text = "Scanning directory: " + dir;
|
|
this.Refresh();
|
|
string[] dirs = Directory.GetDirectories(dir);
|
|
foreach (string d in dirs)
|
|
ScanDirZIP(d);
|
|
string[] delfiles = Directory.GetFiles(dir, "*.*");
|
|
foreach (string delfile in delfiles)
|
|
{
|
|
try
|
|
{
|
|
File.Delete(delfile);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Delete()
|
|
{
|
|
FolderBrowserDialog Dlg = new FolderBrowserDialog();
|
|
Dlg.SelectedPath = Properties.Settings.Default.DestDir;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
ScanDirDelete(Dlg.SelectedPath);
|
|
}
|
|
}
|
|
|
|
private void btn_Delete_Click(object sender, EventArgs e)
|
|
{
|
|
Delete();
|
|
}
|
|
|
|
private void Say(string txt)
|
|
{
|
|
if (tsl_Status.Text != txt)
|
|
{
|
|
tsl_Status.Text = txt;
|
|
this.Refresh();
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
private void btn_Compare_Tile1_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFileDialog Dlg = new OpenFileDialog();
|
|
Dlg.CheckFileExists = true;
|
|
Dlg.Multiselect = true;
|
|
Dlg.Filter = "Elevation Files (*.hgt)|*.hgt|Zipped Elevation Files (*.zip)|*.zip";
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Files1.Clear();
|
|
if (Dlg.FileNames.Length > 1)
|
|
{
|
|
// multiple files selected
|
|
tb_Tile1.Text = string.Join(";", Dlg.FileNames);
|
|
}
|
|
else
|
|
{
|
|
// unzip if zip file selected
|
|
if (Path.GetExtension(Dlg.FileName) == ".zip")
|
|
{
|
|
// create ZIP file and add all loc files
|
|
ZipFile zip = new ZipFile(Dlg.FileName);
|
|
foreach (string filename in zip.EntryFileNames)
|
|
{
|
|
Files1.Add(Path.Combine(Path.GetTempPath(), "Files1", filename));
|
|
}
|
|
zip.ExtractAll(Path.Combine(Path.GetTempPath(), "Files1"), ExtractExistingFileAction.OverwriteSilently);
|
|
bool filemissing;
|
|
do
|
|
{
|
|
filemissing = false;
|
|
foreach (String filename in Files1)
|
|
{
|
|
if (!File.Exists(filename))
|
|
{
|
|
Application.DoEvents();
|
|
filemissing = true;
|
|
break;
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
}
|
|
while (filemissing);
|
|
}
|
|
else
|
|
{
|
|
tb_Tile1.Text = Dlg.FileName;
|
|
Files1.Add(Dlg.FileName);
|
|
}
|
|
}
|
|
}
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private void btn_Compare_Tile2_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFileDialog Dlg = new OpenFileDialog();
|
|
Dlg.CheckFileExists = true;
|
|
Dlg.Multiselect = true;
|
|
Dlg.Filter = "Elevation Files (*.hgt)|*.hgt|Zipped Elevation Files (*.zip)|*.zip";
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Files2.Clear();
|
|
if (Dlg.FileNames.Length > 1)
|
|
{
|
|
// multiple files selected
|
|
tb_Tile2.Text = string.Join(";", Dlg.FileNames);
|
|
}
|
|
else
|
|
{
|
|
// unzip if zip file selected
|
|
if (Path.GetExtension(Dlg.FileName) == ".zip")
|
|
{
|
|
// create ZIP file and add all loc files
|
|
ZipFile zip = new ZipFile(Dlg.FileName);
|
|
foreach (string filename in zip.EntryFileNames)
|
|
{
|
|
Files2.Add(Path.Combine(Path.GetTempPath(), "Files2", filename));
|
|
}
|
|
zip.ExtractAll(Path.Combine(Path.GetTempPath(), "Files2"), ExtractExistingFileAction.OverwriteSilently);
|
|
bool filemissing;
|
|
do
|
|
{
|
|
filemissing = false;
|
|
foreach (String filename in Files2)
|
|
{
|
|
if (!File.Exists(filename))
|
|
{
|
|
Application.DoEvents();
|
|
filemissing = true;
|
|
break;
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
}
|
|
while (filemissing);
|
|
}
|
|
else
|
|
{
|
|
tb_Tile2.Text = Dlg.FileName;
|
|
Files2.Add(Dlg.FileName);
|
|
}
|
|
}
|
|
}
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private string FindinFiles2(string filename1)
|
|
{
|
|
foreach(string filename2 in Files2)
|
|
{
|
|
if (Path.GetFileName(filename1) == Path.GetFileName(filename2))
|
|
return filename2;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public Bitmap DrawElevationBitmapHGT(string filename)
|
|
{
|
|
int minelv = 0;
|
|
int maxelv = 0;
|
|
long length = new System.IO.FileInfo(filename).Length / 2;
|
|
// calculate bitmap dimensions
|
|
// get the x/y ratio first
|
|
int width = (int)Math.Sqrt(length);
|
|
int height = width;
|
|
short[,] elv = new short[width,height];
|
|
long diff = 0;
|
|
long voids = 0;
|
|
long count = 0;
|
|
long sum = 0;
|
|
using (var filestream = File.Open(filename, FileMode.Open))
|
|
using (var binaryStream = new BinaryReader(filestream))
|
|
{
|
|
for (int i = 0; i < width; i++)
|
|
{
|
|
for (int j = 0; j < height; j++)
|
|
{
|
|
elv[i, j] = binaryStream.ReadInt16();
|
|
if (elv[i, j] != 0)
|
|
diff++;
|
|
if (elv[i, j] == -512)
|
|
voids++;
|
|
if (elv[i, j] < minelv)
|
|
minelv = elv[i, j];
|
|
if (elv[i, j] > maxelv)
|
|
maxelv = elv[i, j];
|
|
count++;
|
|
if (count % 100000 == 0)
|
|
Say("Processing " + count.ToString() + " of " + length.ToString() + " points");
|
|
}
|
|
}
|
|
}
|
|
long[] d = new long[maxelv - minelv + 1];
|
|
for (int i = 0; i < d.Length; i++)
|
|
d[i] = 0;
|
|
DEMColorPalette palette = new DEMColorPalette();
|
|
Bitmap bm = new Bitmap(width, height);
|
|
for (int i = 0; i < width; i++)
|
|
{
|
|
// System.Console.WriteLine(i);
|
|
for (int j = 0; j < height; j++)
|
|
{
|
|
double e = (double)(elv[i,j] - minelv) / (double)(maxelv - minelv) * 100.0;
|
|
if (e < 0)
|
|
e = 0;
|
|
if (e > 100)
|
|
e = 100;
|
|
// count occurence of difference in an array
|
|
d[elv[i,j] - minelv]++;
|
|
sum += elv[i, j];
|
|
bm.SetPixel(i, height - j - 1, palette.GetColor(e));
|
|
}
|
|
}
|
|
using (StreamWriter sw = new StreamWriter("ElevationDifference.csv"))
|
|
{
|
|
sw.WriteLine("Difference[m];Count");
|
|
for (int i = 0; i < d.Length; i++)
|
|
{
|
|
sw.WriteLine((i + minelv).ToString() + ";" + d[i].ToString());
|
|
}
|
|
}
|
|
lbl_Diff_Dimensions.Text = width.ToString() + "x" + height.ToString();
|
|
lbl_Diff_Total.Text = diff.ToString();
|
|
lbl_Diff_Voids.Text = voids.ToString();
|
|
lbl_Diff_Min.Text = minelv.ToString();
|
|
lbl_Diff_Max.Text = maxelv.ToString();
|
|
lbl_Diff_Mean.Text = (sum / length).ToString("F2");
|
|
return bm;
|
|
}
|
|
|
|
private string CompareFilesHGT(string filename1, string filename2)
|
|
{
|
|
string difffilename = Path.Combine(Application.StartupPath, Path.GetFileName(filename1).Replace(".hgt",".hgtdiff"));
|
|
long length1 = new System.IO.FileInfo(filename1).Length / 2;
|
|
long length2 = new System.IO.FileInfo(filename2).Length / 2;
|
|
if (length1 != length2)
|
|
{
|
|
MessageBox.Show("Cannot compare files with different length: " + filename1 + "<>" + filename2);
|
|
return "";
|
|
}
|
|
long l = 0;
|
|
long diff = 0;
|
|
// delete diff file
|
|
try
|
|
{
|
|
File.Delete(difffilename);
|
|
FileStream fs1 = File.OpenRead(filename1);
|
|
FileStream fs2 = File.OpenRead(filename2);
|
|
using (BinaryReader br1 = new BinaryReader(fs1))
|
|
{
|
|
using (BinaryReader br2 = new BinaryReader(fs2))
|
|
{
|
|
using (BinaryWriter bw = new BinaryWriter(File.Create(difffilename)))
|
|
{
|
|
while (br1.BaseStream.Position < br1.BaseStream.Length)
|
|
{
|
|
byte[] b1 = br1.ReadBytes(2);
|
|
byte[] b2 = br2.ReadBytes(2);
|
|
Array.Reverse(b1);
|
|
Array.Reverse(b2);
|
|
short e1 = BitConverter.ToInt16(b1, 0);
|
|
short e2 = BitConverter.ToInt16(b2, 0);
|
|
short e = ElevationData.Database.ElvMissingFlag;
|
|
if ((e1 >= -500) && (e2 >= -500))
|
|
{
|
|
e = (short)(e1 - e2);
|
|
if (e > 1000)
|
|
Console.WriteLine("Error at position:" + br1.BaseStream.Position.ToString("0X"));
|
|
if (e != 0)
|
|
diff++;
|
|
}
|
|
bw.Write(e);
|
|
if (l % 100000 == 0)
|
|
{
|
|
Say("Comparing point " + l.ToString() + " of " + length1.ToString() + ": " + diff.ToString() + " differences");
|
|
}
|
|
l++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.ToString());
|
|
}
|
|
|
|
return difffilename;
|
|
}
|
|
|
|
private void CompareFiles(string filename1, string filename2)
|
|
{
|
|
Stopwatch st = new Stopwatch();
|
|
st.Start();
|
|
if (Path.GetExtension(filename1) == ".hgt")
|
|
{
|
|
string difffilename = CompareFilesHGT(filename1, filename2);
|
|
tb_Diff.Text = difffilename;
|
|
Bitmap bm = DrawElevationBitmapHGT(difffilename);
|
|
pb_Picture.Image = bm;
|
|
bm.Save("ElevationDifference.tif", System.Drawing.Imaging.ImageFormat.Tiff);
|
|
pb_Picture.Image = bm;
|
|
}
|
|
st.Stop();
|
|
tsl_Status.Text = "Compare files: " + st.ElapsedMilliseconds.ToString() + "ms.";
|
|
this.Refresh();
|
|
}
|
|
|
|
private void btn_Compare_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (string filename1 in Files1)
|
|
{
|
|
string filename2 = FindinFiles2(filename1);
|
|
if (!String.IsNullOrEmpty(filename2))
|
|
{
|
|
CompareFiles(filename1, filename2);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void btn_ShowDiff_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFileDialog Dlg = new OpenFileDialog();
|
|
Dlg.CheckFileExists = true;
|
|
Dlg.Multiselect = false;
|
|
Dlg.Filter = "Elevation Difference Files (*.hgtdiff)|*.hgtdiff";
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
tb_Show_Diff.Text = Dlg.FileName;
|
|
Bitmap bm = DrawElevationBitmapHGT(tb_Show_Diff.Text);
|
|
pb_Diff.Image = bm;
|
|
}
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private void btn_PictureFromZIP_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFileDialog Dlg = new OpenFileDialog();
|
|
Dlg.CheckFileExists = true;
|
|
Dlg.Multiselect = false;
|
|
Dlg.Filter = "Zipped Elevation Files (*.zip)|*.zip";
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string[] delfiles = Directory.GetFiles(Path.GetTempPath(), "*.loc");
|
|
foreach (string file in delfiles)
|
|
{
|
|
try
|
|
{
|
|
File.Delete(file);
|
|
}
|
|
catch
|
|
{
|
|
// do nothing
|
|
}
|
|
}
|
|
// unzip if zip file selected
|
|
if (Path.GetExtension(Dlg.FileName) == ".zip")
|
|
{
|
|
// create ZIP file and add all loc files
|
|
ZipFile zip = new ZipFile(Dlg.FileName);
|
|
zip.ExtractAll(Path.GetTempPath(), ExtractExistingFileAction.OverwriteSilently);
|
|
bool filemissing;
|
|
do
|
|
{
|
|
filemissing = false;
|
|
foreach (String filename in Files1)
|
|
{
|
|
if (!File.Exists(filename))
|
|
{
|
|
Application.DoEvents();
|
|
filemissing = true;
|
|
break;
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
}
|
|
while (filemissing);
|
|
List<string> files = new List<string>();
|
|
foreach (string file in zip.EntryFileNames)
|
|
files.Add(Path.Combine(Path.GetTempPath(), file));
|
|
PictureFromTiles(files.ToArray());
|
|
}
|
|
else
|
|
{
|
|
tb_Tile1.Text = Dlg.FileName;
|
|
Files1.Add(Dlg.FileName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private short GetSRTM1Elevation(BinaryReader br, int x, int y)
|
|
{
|
|
int rows = 3601;
|
|
int cols = 3601;
|
|
long l = (x * cols + y) * 2;
|
|
br.BaseStream.Seek(l,0);
|
|
byte[] b = br.ReadBytes(2);
|
|
Array.Reverse(b);
|
|
short e = BitConverter.ToInt16(b, 0);
|
|
return e;
|
|
}
|
|
private void ConvertSRTM1ToSRTM3File(string srtm1file, string srtm3file)
|
|
{
|
|
Say("Processing " + srtm1file);
|
|
using (BinaryReader br = new BinaryReader(File.OpenRead(srtm1file)))
|
|
{
|
|
using (BinaryWriter bw = new BinaryWriter(File.Create(srtm3file)))
|
|
{
|
|
short e = 0;
|
|
for (int i = 0; i < 1200; i++)
|
|
{
|
|
for (int j = 0; j < 1200; j++)
|
|
{
|
|
e = 0;
|
|
for (int k = 0; k < 3; k++)
|
|
{
|
|
for (int l = 0; l < 3; l++)
|
|
{
|
|
short elv = GetSRTM1Elevation(br, i * 3 + k, j * 3 + l);
|
|
e += elv;
|
|
}
|
|
}
|
|
e = (short)(e / 9);
|
|
bw.BaseStream.WriteByte((byte)((e >> 8) & 0xFF));
|
|
bw.BaseStream.WriteByte((byte)(e & 0xFF));
|
|
}
|
|
// write point #1201
|
|
bw.BaseStream.WriteByte((byte)((e >> 8) & 0xFF));
|
|
bw.BaseStream.WriteByte((byte)(e & 0xFF));
|
|
}
|
|
for (int j = 0; j < 1201; j++)
|
|
{
|
|
e= GetSRTM1Elevation(br, 3600, j * 3);
|
|
bw.BaseStream.WriteByte((byte)((e >> 8) & 0xFF));
|
|
bw.BaseStream.WriteByte((byte)(e & 0xFF));
|
|
}
|
|
}
|
|
}
|
|
Say("Ready.");
|
|
}
|
|
|
|
private void btn_ConvertSRTM1ToSRTM3_Click(object sender, EventArgs e)
|
|
{
|
|
string[] files = Directory.GetFiles(Properties.Settings.Default.SourceDir, "*.hgt");
|
|
foreach (string srtm1file in files)
|
|
{
|
|
if (!IsSRTM1File(srtm1file))
|
|
continue;
|
|
string srtm3file = Path.Combine(Properties.Settings.Default.DestDir, Path.GetFileName(srtm1file));
|
|
ConvertSRTM1ToSRTM3File(srtm1file, srtm3file);
|
|
}
|
|
}
|
|
|
|
private void btn_Coverage_Click(object sender, EventArgs e)
|
|
{
|
|
CoverageDlg Dlg = new CoverageDlg();
|
|
Dlg.ShowDialog();
|
|
}
|
|
}
|
|
|
|
[System.ComponentModel.DesignerCategory("")]
|
|
public class DataTableSRTM3 : DataTable
|
|
{
|
|
public DataTableSRTM3()
|
|
: base()
|
|
{
|
|
// set table name
|
|
TableName = "SRTM3Tiles";
|
|
// create all specific columns
|
|
DataColumn FileIndex = this.Columns.Add("FileIndex", typeof(string));
|
|
DataColumn MinLat = this.Columns.Add("MinLat", typeof(double));
|
|
DataColumn MaxLat = this.Columns.Add("MaxLat", typeof(double));
|
|
DataColumn MinLon = this.Columns.Add("MinLon", typeof(double));
|
|
DataColumn MaxLon = this.Columns.Add("MaxLon", typeof(double));
|
|
DataColumn MinElv = this.Columns.Add("MinElv", typeof(int));
|
|
DataColumn MaxElv = this.Columns.Add("MaxElv", typeof(int));
|
|
DataColumn LastUpdated = this.Columns.Add("LastUpdated", typeof(string));
|
|
// create primary key
|
|
DataColumn[] keys = new DataColumn[1];
|
|
keys[0] = FileIndex;
|
|
this.PrimaryKey = keys;
|
|
}
|
|
|
|
}
|
|
|
|
}
|