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)); }