/// <summary>
/// Run the intersection shapefile test
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
internal static bool RunIntersectionShapefileTest(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
theForm.Progress(string.Empty, 0, "-----------------------The intersection shapefile test has started.");
// Read text file:
var lines = Helper.ReadTextfile(textfileLocation);
// Get every first line and second line:
for (var i = 0; i < lines.Count; i = i + 2)
{
if (i + 1 > lines.Count)
{
theForm.Error(string.Empty, "Input file is incorrect.");
break;
}
if (!IntersectShapefile(lines[i], lines[i + 1], theForm))
{
numErrors++;
}
Thread.Sleep(1000);
}
theForm.Progress(
string.Empty,
100,
string.Format("The intersection shapefile test has finished. {0} tests went wrong", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Open the grid.
/// </summary>
/// <param name="gridFilename">
/// The grid filename.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The <see cref="Grid"/>.
/// </returns>
internal static Grid OpenGrid(string gridFilename, Form1 theForm)
{
if (!File.Exists(gridFilename))
{
theForm.Error(string.Empty, "Cannot find the file: " + gridFilename);
return(null);
}
var grid = new Grid {
GlobalCallback = theForm
};
theForm.Progress(string.Empty, 0, "Start opening " + Path.GetFileName(gridFilename));
if (!grid.Open(gridFilename, GridDataType.UnknownDataType, false))
{
var msg = string.Format("Error opening grid: {0}", grid.ErrorMsg[grid.LastErrorCode]);
Debug.WriteLine(msg);
theForm.Error(string.Empty, msg);
return(null);
}
// Log some characteristics:
theForm.Progress(string.Empty, 100, "Number of bands: " + grid.NumBands);
return(grid);
}
/// <summary>
/// Run the Filemanager Grid open test
/// </summary>
/// <param name="textfileLocation">
/// The location of the text file.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
public static bool RunGridOpenTest(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
// Open text file:
if (!File.Exists(textfileLocation))
{
throw new FileNotFoundException("Cannot find text file.", textfileLocation);
}
theForm.Progress(string.Empty, 0, "-----------------------The Filemanager Grid open tests have started." + Environment.NewLine);
// Read text file:
var lines = Helper.ReadTextfile(textfileLocation);
foreach (var line in lines)
{
if (!GridOpenTest(line, theForm))
{
numErrors++;
}
// Wait a second to show something:
Application.DoEvents();
Thread.Sleep(1000);
}
theForm.Progress(
string.Empty,
100,
string.Format("The Filemanager Grid open tests have finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Drop PostGIS database.
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// Tru on success.
/// </returns>
internal static bool RunPostGisDropDatabase(string textfileLocation, Form1 theForm)
{
theForm.Progress(
"-----------------------The drop of a PostGIS database has started." + Environment.NewLine);
var numErrors = RunNonExecuteQuery(textfileLocation, theForm);
theForm.Progress(string.Format("The postGIS drop database test has finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Run the Dissolve shapefile test
/// </summary>
/// <param name="textfileLocation">
/// The location of the text file.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool RunDissolveShapefileTest(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
// Open text file:
if (!File.Exists(textfileLocation))
{
throw new FileNotFoundException("Cannot find text file.", textfileLocation);
}
theForm.Progress(string.Empty, 0, "-----------------------The GEOS Dissolve tests have started.");
// Read text file:
var lines = Helper.ReadTextfile(textfileLocation);
// Get every first line and second line:
for (var i = 0; i < lines.Count; i = i + 2)
{
if (i + 1 > lines.Count)
{
theForm.Error(string.Empty, "Input file is incorrect. Not enough lines");
break;
}
int fieldIndex;
if (!int.TryParse(lines[i + 1], out fieldIndex))
{
theForm.Error(string.Empty, "Input file is incorrect. Can't find field index value");
break;
}
if (!DissolveShapefile(lines[i], fieldIndex, theForm))
{
numErrors++;
}
// Wait a second to show something:
Application.DoEvents();
Thread.Sleep(1000);
}
theForm.Progress(
string.Empty,
100,
string.Format("The GEOS Dissolve tests have finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Test setting PostGIS privileges.
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
internal static bool RunPostGisPostGisPrivileges(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
theForm.Progress(
"-----------------------The setting of the grants and privileges has started." + Environment.NewLine);
// Read testfile:
string connectionString;
List <string> queryList;
if (!ReadTextfile(textfileLocation, out connectionString, out queryList))
{
throw new Exception("Cannot read text file");
}
// Connect to data source:
var ds = new OgrDatasource {
GlobalCallback = theForm
};
if (!ds.Open(connectionString))
{
throw new Exception("Failed to open datasource: " + ds.GdalLastErrorMsg);
}
// Get every first and second line:
foreach (var query in queryList)
{
string errorMsg;
if (!ds.ExecuteSQL(query, out errorMsg))
{
theForm.WriteError(string.Format("Error executing query [{0}]: {1}", query, errorMsg));
numErrors++;
}
}
// Close database connection:
ds.Close();
theForm.Progress(
string.Format("The setting of the grants and privileges test has finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Open the filename as a shapefile
/// </summary>
/// <param name="shapefilename">
/// The gridFilename.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The shapefile object
/// </returns>
internal static Shapefile OpenShapefile(string shapefilename, Form1 theForm)
{
if (!File.Exists(shapefilename))
{
theForm.Error(string.Empty, "Cannot find the file: " + shapefilename);
return(null);
}
var sf = new Shapefile {
GlobalCallback = theForm
};
theForm.Progress(string.Empty, 0, "Start opening " + Path.GetFileName(shapefilename));
if (!sf.Open(shapefilename, theForm))
{
var msg = string.Format("Error opening shapefile: {0}", sf.ErrorMsg[sf.LastErrorCode]);
Debug.WriteLine(msg);
theForm.Error(string.Empty, msg);
return(null);
}
// Log some characteristics:
theForm.Progress(string.Empty, 100, "Number of shapes: " + sf.NumShapes);
theForm.Progress(string.Empty, 100, "Number of fields: " + sf.NumFields);
theForm.Progress(string.Empty, 100, "Type: " + sf.ShapefileType);
theForm.Progress(string.Empty, 100, "Projection: " + sf.GeoProjection.ExportToProj4());
theForm.Progress(string.Empty, 100, "Has spatial index: " + sf.HasSpatialIndex);
return(sf);
}
/// <summary>
/// Open the shapefile and load it as an layer.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="theForm">
/// The form with the callback implementation.
/// </param>
/// <param name="clearLayers">
/// Clear the layers.
/// </param>
/// <returns>
/// The layer handle
/// </returns>
internal static int OpenShapefileAsLayer(string filename, Form1 theForm, bool clearLayers)
{
var hndl = -1;
var sf = OpenShapefile(filename, theForm);
if (sf != null)
{
if (clearLayers)
{
Map.RemoveAllLayers();
Application.DoEvents();
// Set projection of map using the grid projection:
if (!sf.GeoProjection.IsEmpty)
{
// Set the projection of the shapefile to the map:
Map.GeoProjection = sf.GeoProjection.Clone();
}
}
hndl = Map.AddLayer(sf, true);
theForm.Progress(string.Empty, 100, "The shapefile is of type " + sf.ShapefileType);
var msg = string.Format(
"The shapefile its projection: {0} ({1})",
sf.GeoProjection.Name,
sf.GeoProjection.GeogCSName);
theForm.Progress(msg);
theForm.Progress(string.Empty, 100, "Done opening " + Path.GetFileName(filename));
}
else
{
theForm.Error(string.Empty, "Cannot load shapefile");
}
return(hndl);
}
/// <summary>
/// Run the WKT - shapefile conversion test
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool RunWktShapefileTest(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
theForm.Progress(string.Format(
"{0}-----------------------{0}The WKT - shapefile conversion test has started.",
Environment.NewLine));
// Read text file:
var lines = Helper.ReadTextfile(textfileLocation);
foreach (var line in lines)
{
var shapeIndex = 0; // if needed change this method to read this value from the input text file
var wkt = ConvertToWkt(line, shapeIndex, theForm);
if (wkt != null)
{
theForm.Progress(string.Empty, 100, wkt);
if (!ConvertFromWkt(line, shapeIndex, wkt, theForm))
{
numErrors++;
}
}
else
{
numErrors++;
}
theForm.Progress(string.Empty, 100, " ");
Thread.Sleep(1000);
}
theForm.Progress(string.Format("The WKT - shapefile conversion test has finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Run non execute query, like create database and drop database
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The number of errors
/// </returns>
private static int RunNonExecuteQuery(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
// Read testfile:
string connectionString;
List <string> queryList;
if (!ReadTextfile(textfileLocation, out connectionString, out queryList))
{
throw new Exception("Cannot read text file");
}
// Connect to data source:
var ds = new OgrDatasource {
GlobalCallback = theForm
};
if (!ds.Open(connectionString))
{
throw new Exception("Failed to open datasource: " + ds.GdalLastErrorMsg);
}
// Get queries:
foreach (var query in queryList)
{
string errorMsg;
if (ds.ExecuteSQL(query, out errorMsg))
{
theForm.Progress("Executed query: " + query);
continue;
}
if (ds.GdalLastErrorMsg.Contains("cannot run inside a transaction block"))
{
errorMsg += " You're probably using a too old version of GDAL v2, please update.";
}
theForm.WriteError(string.Format("Error executing query [{0}]: {1}", query, errorMsg));
numErrors++;
}
// Close database connection:
ds.Close();
return(numErrors);
}
/// <summary>
/// Convert WKT to shape and test result
/// </summary>
/// <param name="shapefilename">
/// The shapefilename.
/// </param>
/// <param name="shapeIndex">
/// The shape index.
/// </param>
/// <param name="wkt">
/// The wkt.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
private static bool ConvertFromWkt(string shapefilename, int shapeIndex, string wkt, Form1 theForm)
{
// Convert the WKT
var shapeWkt = new Shape();
if (!shapeWkt.ImportFromWKT(wkt))
{
theForm.Error(
string.Empty,
"ImportFromWKT was unsuccessful: " + shapeWkt.ErrorMsg[shapeWkt.LastErrorCode]);
return(false);
}
// Check with the original shape if it is still the same:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (Helper.AreShapesDifferent(sf.Shape[shapeIndex], shapeWkt, theForm))
{
theForm.Progress(string.Empty, 100, "The two shapes are identical.");
}
return(true);
}
/// <summary>
/// Dissolve the shapefile
/// </summary>
/// <param name="shapefilename">
/// The shapefilename.
/// </param>
/// <param name="fieldIndex">
/// The field index.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool DissolveShapefile(string shapefilename, int fieldIndex, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(shapefilename, theForm))
{
return(false);
}
// Open the sf:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (sf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var globalSettings = new GlobalSettings();
globalSettings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start dissolving " + Path.GetFileName(shapefilename));
var dissolvedSf = sf.Dissolve(fieldIndex, false);
// Do some checks:
if (!Helper.CheckShapefile(sf, dissolvedSf, globalSettings.GdalLastErrorMsg, theForm))
{
return(false);
}
// The resulting shapefile has only 1 field:
Helper.ColorShapes(ref dissolvedSf, 0, tkMapColor.BlueViolet, tkMapColor.Wheat, true);
// Save result:
var newFilename = shapefilename.Replace(".shp", "-dissolved.shp");
Helper.DeleteShapefile(newFilename);
dissolvedSf.SaveAs(newFilename, theForm);
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
// Load the files:
MyAxMap.Clear();
if (MyAxMap.AddLayer(dissolvedSf, true) == -1)
{
theForm.Error(string.Empty, "Cannot open dissolved shapefiles");
return(false);
}
sf.DefaultDrawingOptions.FillVisible = false;
// MyAxMap.AddLayer(sf, true);
// Wait to show the map:
Application.DoEvents();
var msg = string.Format(
"The dissolved shapefile now has {0} shapes instead of {1} and has {2} rows",
dissolvedSf.NumShapes,
sf.NumShapes,
dissolvedSf.Table.NumRows);
theForm.Progress(msg);
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
}
theForm.Progress(string.Empty, 100, "The Dissolve shapefile test has finished");
return(true);
}
/// <summary>
/// Import shapefiles into the PostGIS database
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
internal static bool RunPostGisImportSf(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
Map = Fileformats.Map;
Map.RemoveAllLayers();
Map.Projection = tkMapProjection.PROJECTION_WGS84;
Application.DoEvents();
theForm.Progress("----------------------- Importing of shapefiles has started." + Environment.NewLine);
// Read testfile:
string connectionString;
List <string> shapefileList;
if (!ReadTextfile(textfileLocation, out connectionString, out shapefileList))
{
throw new Exception("Cannot read text file");
}
// Connect to data source:
var ds = new OgrDatasource {
GlobalCallback = theForm
};
if (!ds.Open(connectionString))
{
throw new Exception("Failed to open datasource: " + ds.GdalLastErrorMsg);
}
// Get queries:
foreach (var shapefileLocation in shapefileList)
{
var layerName = Path.GetFileNameWithoutExtension(shapefileLocation);
if (!File.Exists(shapefileLocation))
{
theForm.WriteError(shapefileLocation + " does not exists. Skipping");
continue;
}
// Open shapefile:
theForm.Progress(string.Format("Reading {0} shapefile", layerName));
var fm = new FileManager();
var sf = fm.OpenShapefile(shapefileLocation, theForm);
theForm.Progress(string.Format("Importing {0} shapefile", layerName));
if (!ds.ImportShapefile(sf, layerName, "OVERWRITE=YES", tkShapeValidationMode.NoValidation))
{
var errorMsg = fm.ErrorMsg[fm.LastErrorCode];
// let's check GDAL error as well
var gs = new GlobalSettings();
errorMsg += " GDAL error message: " + gs.GdalLastErrorMsg;
theForm.WriteError(
string.Format("Error importing shapefile [{0}]: {1}", shapefileLocation, errorMsg));
numErrors++;
}
else
{
// Read layer and add to map:
theForm.Progress(string.Format("Reading {0} layer from db", layerName));
var handle = Map.AddLayerFromDatabase(connectionString, layerName, true);
if (handle == -1)
{
theForm.WriteError("Failed to open database layer: " + layerName);
numErrors++;
}
Application.DoEvents();
}
// Close shapefile:
sf.Close();
}
// Close database connection:
ds.Close();
theForm.Progress(string.Format("Importing of shapefiles test has finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Run the open postGIS layers test.
/// </summary>
/// <param name="textfileLocation">
/// The textfile location.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool RunOpenPostGisLayers(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
Map = Fileformats.Map;
Map.RemoveAllLayers();
// TODO: How to switch between these two:
// Map.Projection = tkMapProjection.PROJECTION_WGS84;
Map.GrabProjectionFromData = true;
var gs = new GlobalSettings();
theForm.Progress("OgrLayerMaxFeatureCount: " + gs.OgrLayerMaxFeatureCount);
Application.DoEvents();
theForm.Progress("----------------------- Opening PostGIS layers has started." + Environment.NewLine);
// Read testfile:
string connectionString;
List <string> layersList;
if (!ReadTextfile(textfileLocation, out connectionString, out layersList))
{
throw new Exception("Cannot read text file");
}
// Connect to data source:
var ds = new OgrDatasource {
GlobalCallback = theForm
};
if (!ds.Open(connectionString))
{
throw new Exception("Failed to open datasource: " + ds.GdalLastErrorMsg);
}
// Get queries:
foreach (var layerName in layersList)
{
var layer = ds.GetLayerByName(layerName, true);
if (layer == null)
{
continue;
}
layer.MaxFeatureCount = 10000;
layer.GlobalCallback = theForm;
theForm.Progress("Opening " + layerName);
var handle = Map.AddLayer(layer, true);
if (handle == -1)
{
theForm.WriteError("Failed to add database layer " + layerName + " to the map.");
numErrors++;
}
Application.DoEvents();
}
// Close database connection:
ds.Close();
theForm.Progress(string.Format("Opening PostGIS layers test has finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Open the grid and load it as an layer.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="theForm">
/// The form with the callback implementation.
/// </param>
/// <param name="clearLayers">
/// Clear the layers.
/// </param>
/// <returns>
/// The layer handle
/// </returns>
internal static int OpenGridAsLayer(string filename, Form1 theForm, bool clearLayers)
{
if (!File.Exists(filename))
{
theForm.Error(string.Empty, "Cannot find the file: " + filename);
return(-1);
}
var hndl = -1;
try
{
var settings = new GlobalSettings();
var grd = new Grid {
GlobalCallback = theForm
};
settings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start opening " + Path.GetFileName(filename));
if (!grd.Open(filename, GridDataType.UnknownDataType, false, GridFileType.UseExtension, theForm))
{
var msg = string.Format(
"Error opening grid: {0}{1}",
grd.ErrorMsg[grd.LastErrorCode],
Environment.NewLine);
if (settings.GdalLastErrorMsg != string.Empty)
{
msg += "GDAL Error: " + settings.GdalLastErrorMsg;
}
Debug.WriteLine(msg);
theForm.Error(string.Empty, msg);
}
else
{
if (clearLayers)
{
Map.RemoveAllLayers();
Application.DoEvents();
// Set projection of map using the grid projection:
if (!grd.Header.GeoProjection.IsEmpty)
{
Map.GeoProjection.CopyFrom(grd.Header.GeoProjection);
}
}
// Log projection:
theForm.Progress(string.Empty, 100, "Projection: " + grd.Header.GeoProjection.ExportToProj4());
theForm.Progress(string.Empty, 100, "Number of bands: " + grd.NumBands);
theForm.Progress(string.Empty, 100, "NoData value: " + grd.Header.NodataValue);
hndl = Map.AddLayer(grd, true);
// The Grid objects are added to the Map control as Image layers. Once the Grid has been added,
// the user is free to Close the Grid because that object is not actually referenced by the map:
grd.Close();
theForm.Progress(string.Empty, 100, "Done opening " + Path.GetFileName(filename));
}
}
catch (SEHException sehException)
{
theForm.Error(string.Empty, "SEHException in OpenGridAsLayer: " + sehException.Message);
}
return(hndl);
}
/// <summary>
/// Run the intersect shapefile test
/// </summary>
/// <param name="shapefilename">
/// The shapefile name
/// </param>
/// <param name="overlayFilename">
/// The name of the overlay shapefile
/// </param>
/// <param name="theForm">
/// The the form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool IntersectShapefile(string shapefilename, string overlayFilename, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(shapefilename, theForm))
{
return(false);
}
if (!Helper.CheckShapefileLocation(overlayFilename, theForm))
{
return(false);
}
// Open the sf:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (sf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var overlaySf = Fileformats.OpenShapefile(overlayFilename, theForm);
if (overlaySf == null)
{
theForm.Error(string.Empty, "Opening overlay shapefile was unsuccessful");
return(false);
}
var globalSettings = new GlobalSettings();
globalSettings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start intersecting " + Path.GetFileName(shapefilename));
// var intersectedSf = sf.Union(false, overlaySf, false);
// With SHP_NULLSHAPE the most obvious type will be used:
var intersectedSf = sf.GetIntersection(false, overlaySf, false, ShpfileType.SHP_NULLSHAPE, theForm);
// Do some checks:)
if (!Helper.CheckShapefile(sf, intersectedSf, globalSettings.GdalLastErrorMsg, theForm))
{
return(false);
}
theForm.Progress("Coloring the resulting shapefile.");
Helper.ColorShapes(ref intersectedSf, 0, tkMapColor.BlueViolet, tkMapColor.DarkRed, true);
// Save result:
var newFilename = overlayFilename.Replace(".shp", "-intersected.shp");
Helper.DeleteShapefile(newFilename);
intersectedSf.SaveAs(newFilename, theForm);
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
// Load the files:
MyAxMap.RemoveAllLayers();
if (MyAxMap.AddLayer(intersectedSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the intersected shapefile to the map");
return(false);
}
// Wait to show the map:
Application.DoEvents();
// MyAxMap.AddLayer(overlaySf, true);
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
}
return(true);
}
/// <summary>
/// Run the Single Sided Buffer test
/// </summary>
/// <param name="textfileLocation">
/// The location of the text file.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
internal static bool RunSingleSidedBuffer(string textfileLocation, Form1 theForm)
{
var numErrors = 0;
// Open text file:
if (!File.Exists(textfileLocation))
{
throw new FileNotFoundException("Cannot find text file.", textfileLocation);
}
theForm.Progress(string.Empty, 0, "-----------------------The GEOS Single Sided Buffer tests have started.");
// Read text file:
var lines = Helper.ReadTextfile(textfileLocation);
// Create shapefile:
var bufferSf = new Shapefile {
GlobalCallback = theForm
};
bufferSf.CreateNewWithShapeID(string.Empty, ShpfileType.SHP_POLYGON);
var lineSf = new Shapefile {
GlobalCallback = theForm
};
lineSf.CreateNewWithShapeID(string.Empty, ShpfileType.SHP_POLYLINE);
// Get every first line and second line:
for (var i = 0; i < lines.Count; i = i + 2)
{
if (i + 1 > lines.Count)
{
theForm.Error(string.Empty, "Input file is incorrect.");
numErrors++;
break;
}
double distance;
if (!double.TryParse(lines[i + 1], NumberStyles.Number, CultureInfo.InvariantCulture, out distance))
{
theForm.Error(string.Empty, "Could not parse distance");
numErrors++;
continue;
}
// Convert line (wkt) to shapefile:
var shapeWkt = new Shape();
if (!shapeWkt.ImportFromWKT(lines[i]))
{
theForm.Error(
string.Empty,
"ImportFromWKT was unsuccessful: " + shapeWkt.ErrorMsg[shapeWkt.LastErrorCode]);
numErrors++;
}
// Create a single sided buffer:
var shapeBuffer = shapeWkt.BufferWithParams(distance, 30, true, tkBufferCap.bcFLAT);
// Add shapes to sf:
bufferSf.EditAddShape(shapeBuffer);
lineSf.EditAddShape(shapeWkt);
}
// Add sf to map:
var utils = new Utils {
GlobalCallback = theForm
};
bufferSf.DefaultDrawingOptions.FillVisible = true;
bufferSf.DefaultDrawingOptions.LineColor = utils.ColorByName(tkMapColor.Black);
if (MyAxMap.AddLayer(bufferSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the single-sided buffer to the map");
return(false);
}
lineSf.DefaultDrawingOptions.LineColor = utils.ColorByName(tkMapColor.OrangeRed);
lineSf.DefaultDrawingOptions.LineWidth = 2;
if (MyAxMap.AddLayer(lineSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the input shapefile to the map");
return(false);
}
// Wait a second to show something:
Application.DoEvents();
Thread.Sleep(1000);
theForm.Progress(string.Format("The GEOS Single Sided Buffer tests have finished, with {0} errors", numErrors));
return(numErrors == 0);
}
/// <summary>
/// Open the image and load it as an layer.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="theForm">
/// The form with the callback implementation.
/// </param>
/// <param name="clearLayers">
/// Clear the layers.
/// </param>
/// <returns>
/// The layer handle
/// </returns>
internal static int OpenImageAsLayer(string filename, Form1 theForm, bool clearLayers)
{
if (!File.Exists(filename))
{
theForm.Error(string.Empty, "Cannot find the file: " + filename);
return(-1);
}
var hndl = -1;
try
{
// Track GDAL Errors:
var settings = new GlobalSettings();
var img = new Image {
GlobalCallback = theForm
};
settings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start opening " + Path.GetFileName(filename));
if (!img.Open(filename, ImageType.USE_FILE_EXTENSION, false, null))
{
var msg = string.Format(
"Error opening image: {0}{1}",
img.ErrorMsg[img.LastErrorCode],
Environment.NewLine);
if (settings.GdalLastErrorMsg != string.Empty)
{
msg += "GDAL Error: " + settings.GdalLastErrorMsg;
}
Debug.WriteLine(msg);
theForm.Error(string.Empty, msg);
}
else
{
// Without overviews this decreases the performance too much:
if (img.NumOverviews > 1)
{
theForm.Progress(string.Empty, 100, "Opening the image with high quality interpolation mode.");
img.UpsamplingMode = tkInterpolationMode.imHighQualityBilinear;
img.DownsamplingMode = tkInterpolationMode.imBilinear;
}
if (clearLayers)
{
Map.RemoveAllLayers();
Application.DoEvents();
}
// Log characteristics:
theForm.Progress(string.Empty, 100, "projection: " + img.GetProjection());
theForm.Progress(string.Empty, 100, "Number bands: " + img.NoBands);
theForm.Progress(string.Empty, 100, "Number overviews: " + img.NumOverviews);
theForm.Progress(string.Empty, 100, "Use transparency?: " + img.UseTransparencyColor);
theForm.Progress(string.Empty, 100, "Transparency Color: " + img.TransparencyColor);
hndl = Map.AddLayer(img, true);
theForm.Progress(string.Empty, 100, "Done opening " + Path.GetFileName(filename));
}
}
catch (SEHException sehException)
{
theForm.Error(string.Empty, "SEHException in OpenImageAsLayer: " + sehException.Message);
}
return(hndl);
}
/// <summary>
/// The simplify shapefile.
/// </summary>
/// <param name="shapefilename">
/// The shapefilename.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private static bool SimplifyShapefile(string shapefilename, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(shapefilename, theForm))
{
return(false);
}
// Open the sf:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (sf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var globalSettings = new GlobalSettings();
globalSettings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start simplifying " + Path.GetFileName(shapefilename));
// Make the tolerance depending on the projection.
var tolerance = 10d;
if (sf.GeoProjection.IsGeographic)
{
tolerance = 0.1;
}
var simplifiedSf = sf.SimplifyLines(tolerance, false);
// Do some checks:
if (!Helper.CheckShapefile(sf, simplifiedSf, globalSettings.GdalLastErrorMsg, theForm))
{
return(false);
}
// give the resulting lines a good width and color:
var utils = new Utils {
GlobalCallback = theForm
};
simplifiedSf.DefaultDrawingOptions.LineWidth = 2;
simplifiedSf.DefaultDrawingOptions.LineColor = utils.ColorByName(tkMapColor.OrangeRed);
simplifiedSf.DefaultDrawingOptions.LineStipple = tkDashStyle.dsSolid;
// Save result:
var newFilename = shapefilename.Replace(".shp", "-simplified.shp");
Helper.DeleteShapefile(newFilename);
simplifiedSf.SaveAs(newFilename, theForm);
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
// Load the files:
MyAxMap.Clear();
if (MyAxMap.AddLayer(simplifiedSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the simplified shapefile to the map");
return(false);
}
Fileformats.OpenShapefileAsLayer(shapefilename, theForm, false);
// Wait to show the map:
Application.DoEvents();
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
}
return(true);
}
/// <summary>
/// Get the closest point
/// </summary>
/// <param name="inputShapefile">
/// The input shapefile.
/// </param>
/// <param name="searchShapefile">
/// The search shapefile.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
private static bool ClosestPoint(string inputShapefile, string searchShapefile, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(inputShapefile, theForm))
{
return(false);
}
if (!Helper.CheckShapefileLocation(searchShapefile, theForm))
{
return(false);
}
// Open the sf:
var inputSf = Fileformats.OpenShapefile(inputShapefile, theForm);
if (inputSf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var searchSf = Fileformats.OpenShapefile(searchShapefile, theForm);
if (searchSf == null)
{
theForm.Error(string.Empty, "Opening search shapefile was unsuccessful");
return(false);
}
// Create resulting shapefile:
var linksSf = new Shapefile {
GlobalCallback = theForm
};
linksSf.CreateNew(string.Empty, ShpfileType.SHP_POLYLINE);
var fieldIndex = linksSf.EditAddField("FoundId", FieldType.INTEGER_FIELD, 0, 0);
// Get a random shape
var index = new Random().Next(inputSf.NumShapes - 1);
var randomInputShape = inputSf.Shape[index];
// Select the shape:
var utils = new Utils {
GlobalCallback = theForm
};
inputSf.SelectionColor = utils.ColorByName(tkMapColor.Yellow);
inputSf.ShapeSelected[index] = true;
// Load the files:
MyAxMap.RemoveAllLayers();
MyAxMap.AddLayer(searchSf, true);
MyAxMap.AddLayer(inputSf, true);
// To store the lenght and index:
var minLength = double.MaxValue;
var closestIndex = -1;
// Search around the location until at least on shape is found.
// To optimize searching make sure a spatial index is used:
if (!searchSf.HasSpatialIndex)
{
searchSf.CreateSpatialIndex(searchSf.Filename);
}
searchSf.UseSpatialIndex = true;
// create start search box:
var searchExtent = randomInputShape.Extents;
// Make the start tolerance depending on the projection:
var tolerance = 2D;
if (searchSf.GeoProjection.IsGeographic)
{
tolerance = 0.01;
}
var foundShapeId = -1;
object results = null;
// Search in increasing circles:
var notFound = true;
// TODO: Add continious loop prevention
while (notFound)
{
if (searchSf.SelectShapes(searchExtent, tolerance, SelectMode.INTERSECTION, ref results))
{
var shapeIds = results as int[];
// Use the first one:
if (shapeIds != null)
{
foreach (var shapeId in shapeIds)
{
foundShapeId = shapeId;
// When the shapes intersect you get wrong values:
var intersects = randomInputShape.Intersects(searchSf.Shape[foundShapeId]);
if (intersects)
{
continue;
}
// stop searching:
notFound = false;
break;
}
}
}
// increase tolerance:
tolerance = tolerance + tolerance;
}
if (foundShapeId == -1)
{
theForm.Error(string.Empty, "Error! Could not find any shapes");
return(false);
}
// Select the found shape:
searchSf.SelectionColor = utils.ColorByName(tkMapColor.Red);
searchSf.ShapeSelected[foundShapeId] = true;
var link = randomInputShape.ClosestPoints(searchSf.Shape[foundShapeId]);
if (link != null && link.numPoints > 1)
{
if (link.IsValid)
{
var shapeId = linksSf.EditAddShape(link);
linksSf.EditCellValue(fieldIndex, shapeId, foundShapeId);
if (minLength > link.Length)
{
minLength = link.Length;
closestIndex = foundShapeId;
}
}
else
{
theForm.Error(string.Empty, "Found link line is invalid: " + link.IsValidReason);
return(false);
}
}
else
{
theForm.Error(string.Empty, "pointShp.ClosestPoints() could not find anything");
return(false);
}
linksSf.DefaultDrawingOptions.LineColor = utils.ColorByName(tkMapColor.Black);
linksSf.DefaultDrawingOptions.LineWidth = 2;
MyAxMap.AddLayer(linksSf, true);
linksSf.GenerateLabels(fieldIndex, tkLabelPositioning.lpMiddleSegment);
linksSf.Labels.OffsetX = 10;
linksSf.Labels.OffsetY = 10;
MyAxMap.ZoomToMaxExtents();
// Wait to show the map:
Application.DoEvents();
theForm.Progress(
string.Format(
"The closest shape is {0}, has a value of {1} and a length of {2}",
closestIndex,
searchSf.CellValue[0, closestIndex],
minLength));
// Save result:
var newFilename = inputSf.Filename.Replace(".shp", "-Closest.shp");
Helper.DeleteShapefile(newFilename);
if (!linksSf.SaveAs(newFilename, theForm))
{
return(false);
}
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
return(false);
}
return(true);
}
/// <summary>
/// Clip the shapefile
/// </summary>
/// <param name="shapefilename">
/// The shapefile name
/// </param>
/// <param name="overlayFilename">
/// The name of the overlay shapefile
/// </param>
/// <param name="theForm">
/// The form
/// </param>
/// <returns>
/// True on success
/// </returns>
private static bool ClipShapefile(string shapefilename, string overlayFilename, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(shapefilename, theForm))
{
return(false);
}
if (!Helper.CheckShapefileLocation(overlayFilename, theForm))
{
return(false);
}
// Open the sf:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (sf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var overlaySf = Fileformats.OpenShapefile(overlayFilename, theForm);
if (overlaySf == null)
{
theForm.Error(string.Empty, "Opening overlay shapefile was unsuccessful");
return(false);
}
theForm.Progress(string.Format(
"Clipping {0} ({1}) with {2} ({3})",
Path.GetFileName(shapefilename),
sf.ShapefileType,
Path.GetFileName(overlayFilename),
overlaySf.ShapefileType));
var globalSettings = new GlobalSettings();
globalSettings.ResetGdalError();
theForm.Progress(string.Empty, 0, "Start clipping " + Path.GetFileName(shapefilename));
// selecting only part of overlay, then the check about the varying
// number of shapes in input/output will work
var max = Math.Max(overlaySf.NumShapes / 2, 1);
for (var i = 0; i < max; i++)
{
overlaySf.ShapeSelected[i] = true;
}
var clippedSf = sf.Clip(false, overlaySf, true);
// Do some checks:
if (!Helper.CheckShapefile(sf, clippedSf, globalSettings.GdalLastErrorMsg, theForm))
{
return(false);
}
Helper.ColorShapes(ref clippedSf, 0, tkMapColor.DarkRed, tkMapColor.LightSeaGreen, true);
// Count the resulting shapes it should be higher than the input shapefile.
var numClippedSf = clippedSf.NumShapes;
var numInputSf = sf.NumShapes;
// Reset map:
MyAxMap.Clear();
if (numClippedSf == numInputSf)
{
// Nothing was clipped
theForm.Error(
string.Empty,
"The resulting shapefile has the same number of shapes as the input shapefile. Either the input files are incorrect or the clipping function doesn't behaves as expected.");
MyAxMap.AddLayer(sf, true);
MyAxMap.AddLayer(overlaySf, true);
// Wait to show the map:
Application.DoEvents();
return(false);
}
// Save result:
if (overlayFilename != null)
{
var newFilename = shapefilename.Replace(
".shp",
string.Format("-{0}", Path.GetFileName(overlayFilename).Replace(".shp", "-clipped.shp")));
Helper.DeleteShapefile(newFilename);
clippedSf.SaveAs(newFilename, theForm);
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
// Load the files:
Fileformats.OpenShapefileAsLayer(overlayFilename, theForm, false);
if (MyAxMap.AddLayer(clippedSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the clipped shapefile to the map");
return(false);
}
// Wait to show the map:
Application.DoEvents();
}
else
{
return(false);
}
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
}
theForm.Progress(string.Empty, 100, "This clipping has finished.");
return(true);
}
/// <summary>
/// Buffer the shapefile
/// </summary>
/// <param name="shapefilename">
/// The shapefilename.
/// </param>
/// <param name="theForm">
/// The form.
/// </param>
/// <returns>
/// True on success
/// </returns>
private static bool BufferShapefile(string shapefilename, Form1 theForm)
{
try
{
// Check inputs:
if (!Helper.CheckShapefileLocation(shapefilename, theForm))
{
return(false);
}
// Open the sf:
var sf = Fileformats.OpenShapefile(shapefilename, theForm);
if (sf == null)
{
theForm.Error(string.Empty, "Opening input shapefile was unsuccessful");
return(false);
}
var globalSettings = new GlobalSettings();
globalSettings.ResetGdalError();
theForm.Progress(string.Empty, 100, "Start buffering " + Path.GetFileName(shapefilename));
// Make the distance depending on the projection.
var distance = 1000.0;
if (sf.GeoProjection.IsGeographic)
{
distance = 0.1;
}
var bufferedSf = sf.BufferByDistance(distance, 16, false, false);
// Do some checks:
if (!Helper.CheckShapefile(sf, bufferedSf, globalSettings.GdalLastErrorMsg, theForm))
{
return(false);
}
Helper.ColorShapes(ref bufferedSf, 0, tkMapColor.LightBlue, tkMapColor.LightYellow, true);
// Save result:
var newFilename = shapefilename.Replace(".shp", "-buffered.shp");
Helper.DeleteShapefile(newFilename);
bufferedSf.SaveAs(newFilename, theForm);
theForm.Progress(string.Empty, 100, "The resulting shapefile has been saved as " + newFilename);
// Load the files:
MyAxMap.Clear();
Fileformats.OpenShapefileAsLayer(shapefilename, theForm, true);
bufferedSf.DefaultDrawingOptions.FillVisible = false;
if (MyAxMap.AddLayer(bufferedSf, true) == -1)
{
theForm.Error(string.Empty, "Could not add the buffered shapefile to the map");
return(false);
}
// Wait to show the map:
Application.DoEvents();
}
catch (Exception exception)
{
theForm.Error(string.Empty, "Exception: " + exception.Message);
}
return(true);
}