private static Driver GetTargetDatasetDriver(string path)
{
var driverName = GdalHelper.GetDriverName(path);
RegisterGdal();
return(Gdal.GetDriverByName(driverName));
}
private void SetDriver(string path)
{
using (var driver = gdalDataset.GetDriver())
{
if (!GdalHelper.IsCreateSupported(driver))
{
log.WarnFormat("Datasource is readonly: {0}", path);
return;
}
//cannot directly create dataset. check if dataset can be created by copying from another set
if (GdalHelper.IsCreateCopySupported(driver))
{
//TODO: fix this criteria
if (GetDatasetSize() < 1000000)
{
log.Debug("Using in-memory driver to facilitate writing to datasource");
//log.WarnFormat("Using in memory-driver with large dataset can yield unexpected results.");
using (var gdalDriver = Gdal.GetDriverByName("MEM"))
{
var oldGdalDataSet = gdalDataset;
gdalDataset = gdalDriver.CreateCopy(path, gdalDataset, 0, new string[] { }, null, null);
oldGdalDataSet.Dispose();
}
}
}
}
}
private void Functions_CollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
if (!AutoOpen())
{
return;
}
if ((e.Action == NotifyCollectionChangeAction.Add || e.Action == NotifyCollectionChangeAction.Replace) &&
e.Item is IRegularGridCoverage)
{
var grid = (IRegularGridCoverage)e.Item;
var driverName = GdalHelper.GetDriverName(path);
RegisterGdal();
using (var gdalDriver = Gdal.GetDriverByName(driverName))
{
var gdalType = GdalHelper.GetGdalDataType(gdalDriver, grid.Components[0].ValueType);
var gdalvariableValue = GdalHelper.GetVariableForDataType(gdalType);// TODO: strange logic, use supported GDAL types here (as .NET types) instead
var type = gdalvariableValue.ValueType;
if (type != grid.Components[0].ValueType)
{
throw new InvalidOperationException(string.Format("Value type {0} is not supported by GDAL driver", grid.Components[0].ValueType));
}
}
}
}
private void SetDriver(string path)
{
using (var driver = gdalDataset.GetDriver())
{
if (GdalHelper.IsCreateCopyOnlySupported(driver))
{
log.WarnFormat("Datasource is readonly: {0}", path);
return;
}
//cannot directly create dataset. check if dataset can be created by copying from another set
if (GdalHelper.IsCreateCopySupported(driver))
{
if (gdalDataset.RasterCount > 1000)
{
log.WarnFormat("Using in memory-driver with large dataset can yield unexpected results.");
}
log.WarnFormat("Using in memory-driver with large dataset can yield unexpected results.");
}
else
{
using (var gdalDriver = Gdal.GetDriverByName("MEM"))
{
var oldGdalDataSet = gdalDataset;
gdalDataset = gdalDriver.CreateCopy(path, gdalDataset, 0, new string[] { }, null, null);
oldGdalDataSet.Dispose();
}
}
}
}
public virtual IEnvelope GetExtents()
{
if (!AutoOpen())
{
return(emptyEnvelope);
}
return(GdalHelper.GetExtents(gdalDataset));
}
private static void CheckAndFixHeaders(string path)
{
if (path.EndsWith(".bil", StringComparison.OrdinalIgnoreCase))
{
GdalHelper.CheckBilHdrFileForPixelTypeField(path);
}
if (path.EndsWith(".asc", StringComparison.OrdinalIgnoreCase))
{
GdalHelper.CheckAndFixAscHeader(path);
}
}
private void FillBitmap <T>(Bitmap bitmap, BitmapData bitmapData, Dataset dataset, int xOff, int yOff, int width, int height,
int imageWidth, int imageHeight, int targetPixelSpace, int lineSpace, string legendFilename)
{
T[] values = GdalHelper.GetValuesForBand <T>(dataset, 1, xOff, yOff, width, height, imageWidth, imageHeight);
var gdalRasterLayer = layer as GdalRasterLayer;
if (gdalRasterLayer == null)
{
throw new Exception("Trying to draw a GdalRasterLayer, while we got another type of layer!");
}
FillBitmapPixels <T>(values, bitmapData, targetPixelSpace, imageWidth, imageHeight);
}
private void CopyCurrentDatasetFromAddedCoverage(GdalFunctionStore gdalFunctionStore, Driver gdalDriver)
{
gdalDataset = gdalDriver.CreateCopy(path, gdalFunctionStore.gdalDataset, 0, new string[] { }, null, "Copy");
//substitute driver by in-memory driver in case driver is read-only
if (GdalHelper.IsCreateCopyOnlySupported(gdalDriver))
{
using (var inMemoryDriver = Gdal.GetDriverByName("MEM"))
{
var oldGdalDataSet = gdalDataset;
//create in-memory dataset with a copy of the original data.
gdalDataset = inMemoryDriver.CreateCopy(path, gdalFunctionStore.gdalDataset, 0, new string[] { },
null, null);
oldGdalDataSet.Dispose();
}
}
}
private static void WriteGdalDatasetToFile(string path, Dataset gdalDataset)
{
log.Debug("Recreating file and copying data from in-memory datasource.");
Driver targetDatasetDriver = GetTargetDatasetDriver(path);
using (targetDatasetDriver)
{
if (GdalHelper.IsCreateCopySupported(targetDatasetDriver))
{
targetDatasetDriver.CreateCopy(path, gdalDataset, 0, new string[] { }, null, null)
.Dispose();
}
}
GC.Collect();
}
private void SubstituteDriverByInMemIfReadonly(IRegularGridCoverage addedCoverage, Driver gdalDriver)
{
var canCreate = gdalDriver.GetMetadataItem("DCAP_CREATE", null) == "YES";
//cannot create use mem driver.
if (!canCreate)
{
using (var inMemoryDriver = Gdal.GetDriverByName("MEM"))
{
DataType dataType =
GdalHelper.GetGdalDataType(inMemoryDriver, addedCoverage.Components[0].ValueType);
if (dataType.Equals(DataType.GDT_Unknown))
{
throw new NotSupportedException(
String.Format("The datatype {0} cannot be saved to this kind of file: {1}",
addedCoverage.Components[0].ValueType, System.IO.Path.GetExtension(path)));
}
gdalDataset = inMemoryDriver.Create(path, addedCoverage.SizeX, addedCoverage.SizeY,
addedCoverage.Components.Count, dataType,
new string[] { });
}
}
else
{
DataType dataType =
GdalHelper.GetGdalDataType(gdalDriver, addedCoverage.Components[0].ValueType);
if (dataType.Equals(DataType.GDT_Unknown))
{
throw new NotSupportedException(
String.Format("The datatype {0} cannot be saved to this kind of file: {1}",
addedCoverage.Components[0].ValueType, System.IO.Path.GetExtension(path)));
}
gdalDataset = gdalDriver.Create(path, addedCoverage.SizeX, addedCoverage.SizeY,
addedCoverage.Components.Count, dataType,
new string[] { });
}
}
private static Dataset GetOutputDataset <T>(Dataset gdalDataset, Driver gdalDriver, Driver targetDatasetDriver, IRegularGridCoverage gridCoverage, int rasterBandIndex, RasterBoundaries rasterBoundaries, T[] values)
{
Dataset outputDataset = gdalDataset;
if (targetDatasetDriver.ShortName == "PCRaster")
{
// Convert the in mem dataset to a pc rasterBoundaries compatible one...
Type valueType = gridCoverage.Components[0].ValueType;
DataType dataType =
GdalHelper.GetGdalDataType(targetDatasetDriver, valueType);
outputDataset = gdalDriver.Create(gridCoverage.Name, gdalDataset.RasterXSize,
gdalDataset.RasterYSize,
gridCoverage.Components.Count, dataType, new string[] { });
GdalHelper.SetValuesForBand(outputDataset, rasterBandIndex, rasterBoundaries.StartX, rasterBoundaries.StartY, rasterBoundaries.WidthX, rasterBoundaries.WidthY, values);
}
return(outputDataset);
}
private void SetGdalValues <T>(int componentIndex, T[] values, params IVariableFilter[] variableFilters)
{
var rasterBoundaries = GetRasterBoundaries(variableFilters);
var rasterBandIndex = componentIndex + 1; //1 based index
GdalHelper.SetValuesForBand(gdalDataset, rasterBandIndex, rasterBoundaries.StartX, rasterBoundaries.StartY, rasterBoundaries.WidthX, rasterBoundaries.WidthY, values);
gdalDataset.FlushCache();
//update dataset on filesystem by copying in-memory dataset
var inMemoryDriver = gdalDataset.GetDriver();
if (!GdalHelper.IsInMemoryDriver(inMemoryDriver))
{
return;
}
Driver targetDatasetDriver = GetTargetDatasetDriver(path);
Dataset outputDataset = GetOutputDataset(gdalDataset, inMemoryDriver, targetDatasetDriver, Functions.OfType <IRegularGridCoverage>().FirstOrDefault(), rasterBandIndex, rasterBoundaries, values);
WriteGdalDatasetToFile(path, outputDataset);
}
private static IEnumerable <IVariable> GetDataSetComponentVariables(Dataset gdalDataset)
{
IList <IVariable> components = new List <IVariable>();
for (var i = 1; i <= gdalDataset.RasterCount; i++)
{
using (var band = gdalDataset.GetRasterBand(i))
{
var dataType = band.DataType;
var componentVariableName = "Raster" + i;
var componentVariable = GdalHelper.GetVariableForDataType(dataType);
componentVariable.Name = componentVariableName;
int hasNoDataValue;
double noDataValue;
band.GetNoDataValue(out noDataValue, out hasNoDataValue);
//ToDo check this logic versus specs of hdr definition for bil files.
if (noDataValue < 0 && (dataType == DataType.GDT_UInt32 || dataType == DataType.GDT_UInt16))
{
noDataValue = Math.Abs(noDataValue);
log.DebugFormat("Nodata value changed from a negative to a positive value");
}
if (hasNoDataValue > 0)
{
componentVariable.NoDataValues = new[] { noDataValue };
}
componentVariable.FixedSize = gdalDataset.RasterXSize * gdalDataset.RasterYSize;
components.Add(componentVariable);
}
}
return(components);
}
private static IRegularGridCoverage CreateRegularGridCoverage(Dataset dataset)
{
var gridName = System.IO.Path.GetFileNameWithoutExtension(dataset.GetFileList()[0]);
IRegularGridCoverage grid = new RegularGridCoverage {
Name = gridName
};
grid.X.FixedSize = dataset.RasterXSize;
grid.Y.FixedSize = dataset.RasterYSize;
//set Grid geometry
var geometryFactory = new GeometryFactory(); // TODO: add CRS!
var extents = GdalHelper.GetExtents(dataset);
grid.Geometry = geometryFactory.ToGeometry(extents);
// replace grid components by the components found in GDAL dataset
grid.Components.Clear();
var gridComponents = GetDataSetComponentVariables(dataset);
grid.Components.AddRange(gridComponents);
return(grid);
}
/// <summary>
/// Use store to copy values from function to datasource and connect store to function.
/// </summary>
/// <param name="function"></param>
private void AddFunction(IFunction function)
{
if (!(function is IRegularGridCoverage))
{
return;
}
if (state == GdalState.Initializing)
{
return;
}
var addedCoverage = (IRegularGridCoverage)function;
xValues = addedCoverage.X.Values;
yValues = addedCoverage.Y.Values;
//Close(); //clean up resources used by current dataset if any.
var driverName = GdalHelper.GetDriverName(path);
using (Driver gdalDriver = Gdal.GetDriverByName(driverName))
{
VerifyDriverIsValid(gdalDriver);
if (addedCoverage.Store is GdalFunctionStore)
{
//CopyCurrentDatasetFromAddedCoverage((GdalFunctionStore)addedCoverage.Store, gdalDriver);
var store = (GdalFunctionStore)addedCoverage.Store;
CopyCurrentDatasetFromAddedCoverage(store, gdalDriver);
return;
}
//verify if all components are of the same type
VerifyComponentTypesAreSame(addedCoverage);
//substitute driver by in-memory driver in case driver is read-only
SubstituteDriverByInMemIfReadonly(addedCoverage, gdalDriver);
if (gdalDataset == null)
{
throw new IOException(String.Format("Cannot open file: {0}", path));
}
{
var transform = new RegularGridGeoTransform(addedCoverage.Origin.X,
addedCoverage.Origin.Y + addedCoverage.DeltaY * addedCoverage.SizeY,
addedCoverage.DeltaX,
addedCoverage.DeltaY);
//todo check: lowerleft corner or upperleft corner. (currently using upperleft corner as reference point)
gdalDataset.SetGeoTransform(transform.TransForm);
// add agruments
functions.Add(addedCoverage.X);
functions.Add(addedCoverage.Y);
//copy components to this store
for (int i = 0; i < addedCoverage.Components.Count; i++)
{
IMultiDimensionalArray componentValues = addedCoverage.Components[i].Values;
functions.Add(addedCoverage.Components[i]);
addedCoverage.Components[i].SetValues(componentValues);
}
gdalDataset.FlushCache();
}
if (gdalDataset == null)
{
log.ErrorFormat("No GdalDataset available to write/read {0}.", path);
}
}
}
private IMultiDimensionalArray <T> GetGdalValues <T>(int componentIndex, params IVariableFilter[] variableFilters) where T : IComparable
{
bool scale = false;
int startX = 0, startY = 0, widthX = Grid.SizeX, widthY = Grid.SizeY;
int rasterBandIndex = componentIndex + 1; //1 based index
var sizeX = Grid.SizeX;
var sizeY = Grid.SizeY;
if (variableFilters.Length > 0)
{
foreach (IVariableFilter filter in variableFilters)
{
if (filter is VariableAggregationFilter)
{
var sampleFilter = filter as VariableAggregationFilter;
if (sampleFilter.Variable == Grid.X)
{
startX = sampleFilter.MinIndex;
widthX = sampleFilter.Count;
sizeX = sampleFilter.MaxIndex - sampleFilter.MinIndex + 1;
}
if (sampleFilter.Variable == Grid.Y)
{
startY = Grid.SizeY - sampleFilter.MaxIndex - 1;
widthY = sampleFilter.Count;
sizeY = sampleFilter.MaxIndex - sampleFilter.MinIndex + 1;
}
scale = true;
continue;
}
if (filter is IVariableValueFilter)
{
var variableValueFilter = filter as IVariableValueFilter;
if (variableValueFilter.Values.Count > 1)
{
throw new NotSupportedException(
"Multiple values for VariableValueFilter not supported by GDalFunctionStore");
}
if (filter.Variable == Grid.X)
{
startX = Grid.X.Values.IndexOf(variableValueFilter.Values[0]);
widthX = 1;
}
if (filter.Variable == Grid.Y)
{
//origin of our system is lower left corner, origin of gdal is upper left corner.
startY = Grid.SizeY - Grid.Y.Values.IndexOf(variableValueFilter.Values[0]) - 1;
widthY = 1;
}
continue;
}
if (filter is VariableIndexRangesFilter)
{
var rangesFilter = ((VariableIndexRangesFilter)filter);
if (filter.Variable == Grid.X)
{
startX = rangesFilter.IndexRanges[0].First;
widthX = rangesFilter.IndexRanges[0].Second - startX + 1;
}
if (filter.Variable == Grid.Y)
{
// rangesFilter.IndexRanges[0].First;
startY = Grid.SizeY - rangesFilter.IndexRanges[0].Second - 1;
widthY = Grid.SizeY - startY - rangesFilter.IndexRanges[0].First;
}
}
if (filter is VariableIndexRangeFilter)
{
var variableIndexRangeFilter = filter as VariableIndexRangeFilter;
if (filter.Variable == Grid.X)
{
startX = variableIndexRangeFilter.MinIndex;
widthX = 1 + variableIndexRangeFilter.MaxIndex - variableIndexRangeFilter.MinIndex;
}
if (filter.Variable == Grid.Y)
{
startY = Grid.SizeY - variableIndexRangeFilter.MaxIndex - 1;
widthY = Grid.SizeY - startY - variableIndexRangeFilter.MinIndex;
}
continue;
}
}
}
//create a generic MDA of [xSize,ySize] with values of dataset.
T[] values;
if (scale)
{
values = GdalHelper.GetValuesForBand <T>(gdalDataset, rasterBandIndex, startX, startY, sizeX, sizeY, widthX, widthY);
}
else
{
values = GdalHelper.GetValuesForBand <T>(gdalDataset, rasterBandIndex, startX, startY, widthX, widthY);
}
IMultiDimensionalArray <T> array = (MultiDimensionalArray <T>)TypeUtils.CreateGeneric(
typeof(MultiDimensionalArray <>),
typeof(T), true, true,
Grid.Components[componentIndex].
DefaultValue,
values, new[] { widthX, widthY }
);
((MultiDimensionalArray <T>)array).Owner = Grid.Components[componentIndex];
return(array);
}
public virtual IEnvelope GetExtents()
{
return(GdalHelper.GetExtents(gdalDataset));
}
