private static Tuple <double, double> GetMaxMinFromGridFile(IRegularGridCoverage grid)
{
Tuple <double, double> tuple = new Tuple <double, double>();
IList <double> values;
if (grid.Components[0].ValueType == typeof(double))
{
values = grid.GetValues <double>();
}
else //convert
{
values = new List <double>();
var nonConvertedValues = grid.GetValues();
foreach (var obj in nonConvertedValues)
{
values.Add(Convert.ToDouble(obj));
}
}
double maxValue = double.MinValue;
double secondMaxValue = double.MinValue;
double minValue = double.MaxValue;
double secondMinValue = double.MaxValue;
// we need to filter out any non-data values. So we look at two most extreme values
// on either side, assuming that only one value (but perhaps one for positive and
// one for negative) is used for non-data. We do this by looking at the difference
// between the maximum found and the second maximum found, and comparing this to the
// difference between the second maximum and the second minimum.
foreach (double value in values)
{
maxValue = Math.Max(maxValue, value);
minValue = Math.Min(minValue, value);
}
foreach (double value in values)
{
if (value < maxValue)
{
secondMaxValue = Math.Max(secondMaxValue, value);
}
if (value > minValue)
{
secondMinValue = Math.Min(secondMinValue, value);
}
}
tuple.value1 = (Math.Abs(minValue - secondMinValue) > Math.Abs(secondMaxValue - secondMinValue))
?
secondMinValue
: minValue;
tuple.value2 = (Math.Abs(maxValue - secondMaxValue) > Math.Abs(secondMaxValue - secondMinValue))
?
secondMaxValue
: maxValue;
return(tuple);
}
public void CheckEnvelope()
{
string filePath = @"..\..\..\..\data\RasterData\Schematisatie.bil";
GdalFunctionStore store = new GdalFunctionStore
{
Path = Path.GetFullPath(filePath)
};
IRegularGridCoverage regularGridCoverage = store.Grid;
Assert.IsNotNull(store);
//check wether geometry has been updated in the right manner.
Assert.AreEqual(0, regularGridCoverage.Geometry.Envelope.EnvelopeInternal.MinX, 0.1);
Assert.AreEqual(60, regularGridCoverage.Geometry.Envelope.EnvelopeInternal.MaxX, 0.1);
Assert.AreEqual(0, regularGridCoverage.Geometry.Envelope.EnvelopeInternal.MinY, 0.1);
Assert.AreEqual(60, regularGridCoverage.Geometry.Envelope.EnvelopeInternal.MaxY, 0.1);
Assert.AreEqual(3, regularGridCoverage.SizeY);
Assert.AreEqual(3, regularGridCoverage.SizeX);
Assert.AreEqual(20.0, regularGridCoverage.DeltaX, 0.1);
Assert.AreEqual(-20.0, regularGridCoverage.DeltaY, 0.1);
//check wether lower left corner lies at (0, 0)
Assert.AreEqual(0.0, regularGridCoverage.Origin.X, 0.1);
Assert.AreEqual(60.0, regularGridCoverage.Origin.Y, 0.1);
}
public void ReadBinaryRasterFile()
{
string fileName = RasterDataPath + "SchematisatieInt.bil";
var rasterLayer = new RegularGridCoverageLayer();
var rasterFeatureProvider = new GdalFeatureProvider {
Path = fileName
};
rasterFeatureProvider.Open();
IRegularGridCoverage grid = rasterFeatureProvider.Grid;
IList <int> values = grid.GetValues <int>();
Assert.AreEqual(9, values.Count);
IList <int> values2 = grid.GetValues <int>(
new VariableValueFilter <double>(grid.X, grid.X.Values[0]),
new VariableValueFilter <double>(grid.Y, grid.Y.Values[0])
);
Assert.AreEqual(1, values2.Count);
Assert.AreEqual(7, values2[0]);
//rasterLayer.CustomRenderers.Add(new RegularGridCoverageRenderer()); // add optimized custom gdal renderer
rasterLayer.DataSource = rasterFeatureProvider;
IRegularGridCoverage regularGridCoverage = rasterFeatureProvider.Grid;
}
public void RenderBilFileAsCoverage()
{
var map = new Map(new Size(400, 200))
{
Name = "map1"
};
string fileName = RasterDataPath + "SchematisatieInt.bil";
var rasterLayer = new RegularGridCoverageLayer();
var rasterFeatureProvider = new GdalFeatureProvider {
Path = fileName
};
rasterLayer.CustomRenderers.Add(new RegularGridCoverageRenderer(rasterLayer));
// add optimized custom gdal renderer
rasterLayer.DataSource = rasterFeatureProvider;
map.Layers.Add(rasterLayer);
IRegularGridCoverage grid = rasterFeatureProvider.Grid;
IList <int> values = grid.GetValues <int>();
Assert.AreEqual(9, values.Count);
MapTestHelper.Show(map);
}
public void GenerateThemeForBilFileWithoutLegendFile()
{
const string fileName = @"..\..\..\..\..\test-data\DeltaShell\DeltaShell.Plugins.SharpMapGis.Tests\RasterData\SchematisatieUInt.bil";
RegularGridCoverageLayer rasterLayer = new RegularGridCoverageLayer();
GdalFeatureProvider rasterFeatureProvider = new GdalFeatureProvider {
Path = fileName
};
rasterFeatureProvider.Open();
rasterLayer.DataSource = rasterFeatureProvider;
IRegularGridCoverage grid = rasterLayer.Grid;
ITheme theme = DemisMapControlLegendHelper.ConvertLegendToTheme(fileName, "value", grid);
Assert.IsTrue(((GradientTheme)theme).Max == 9.0);
Assert.IsTrue(((GradientTheme)theme).Min == 1.0);
Assert.IsInstanceOfType(typeof(GradientTheme), theme);
foreach (IThemeItem themeItem in theme.ThemeItems)
{
Assert.IsInstanceOfType(typeof(GradientThemeItem), themeItem);
Assert.IsInstanceOfType(typeof(VectorStyle), themeItem.Style);
}
}
public void CreateNewRasterLayer()
{
// read source grid
string filePath = RasterDataPath + "Schematisatie.bil";
var sourceProvider = new GdalFeatureProvider {
Path = filePath
};
IRegularGridCoverage sourceGrid = sourceProvider.Grid;
// create a new grid
//const string targetFilePath = @"..\..\..\..\data\RasterData\SchematisatieTest.asc";
const string targetFilePath = "GdalProviderTest.CreateNewRasterLayer.asc";
var targetProvider = new GdalFeatureProvider();
targetProvider.CreateNew(targetFilePath);
Assert.AreEqual(0, targetProvider.Features.Count);
targetProvider.Features.Add(sourceGrid);
// provider will write a source grid into .asc file and will add a new grid
Assert.AreEqual(1, targetProvider.Features.Count);
Assert.AreEqual(sourceGrid.SizeX, targetProvider.Grid.SizeX);
Assert.AreEqual(sourceGrid.SizeY, targetProvider.Grid.SizeY);
Assert.AreEqual(sourceGrid.DeltaX, targetProvider.Grid.DeltaX);
Assert.AreEqual(sourceGrid.DeltaY, targetProvider.Grid.DeltaY);
Assert.IsTrue(sourceGrid.X.Values.SequenceEqual(targetProvider.Grid.X.Values));
Assert.IsTrue(sourceGrid.GetValues <float>().SequenceEqual(targetProvider.Grid.GetValues <float>()));
}
public void TimeDependentGridGetTimeSeriesAtUnKnownLocation()
{
DateTime time1;
DateTime time2;
IRegularGridCoverage grid2D = CreatePressureTimeDependentRegularGridCoverage(out time1, out time2);
grid2D.GetTimeSeries(new Coordinate(75.0, 75.0));
}
/// <summary>
/// Fills gridvalues function with profiledata based on profileline over the grid
/// </summary>
/// <param name="function"></param>
/// <param name="grid"></param>
/// <param name="polyline"></param>
public static void UpdateGridValues(Function function, IRegularGridCoverage grid, ILineString polyline)
{
function.Clear();
double offset = 0;
double step = polyline.Length / 100;
foreach (ICoordinate coordinate in GetGridProfileCoordinates(polyline, step))
{
function[offset] = grid.Evaluate(coordinate);
offset += step;
}
}
/// <summary>
/// Fills gridvalues function with profiledata based on profileline over the grid
/// </summary>
/// <param name="function"></param>
/// <param name="grid"></param>
/// <param name="polyline"></param>
public static void UpdateGridValues(Function function, IRegularGridCoverage grid, ILineString polyline)
{
function.Clear();
double offset = 0;
double step = polyline.Length / 100;
foreach (ICoordinate coordinate in GetGridProfileCoordinates(polyline, step))
{
function[offset] = grid.Evaluate(coordinate);
offset += step;
}
}
public void TimeDependentGrid2D()
{
DateTime time1;
DateTime time2;
IRegularGridCoverage grid2D = CreatePressureTimeDependentRegularGridCoverage(out time1, out time2);
Assert.IsTrue(grid2D.Time.Values.SequenceEqual(new[] { time1, time2 }));
// time values are added last. internal array is 1,2,3,4,5,6,10,20,30,40,50,60
Assert.AreEqual(10.0, grid2D.GetValues <double>()[6]);
Assert.AreEqual(2.0, grid2D.GetValues <double>()[1]);
Assert.AreEqual(12, grid2D.GetValues <double>().Count);
}
public void TimeDependentGridGetTimeSeriesAtKnownLocation()
{
DateTime time1;
DateTime time2;
IRegularGridCoverage grid2D = CreatePressureTimeDependentRegularGridCoverage(out time1, out time2);
var timeSeries = grid2D.GetTimeSeries(new Coordinate(100.0, 100.0));
Assert.AreEqual(1, timeSeries.Arguments.Count);
Assert.AreEqual(1, timeSeries.Components.Count);
var values = timeSeries.GetValues();
Assert.AreEqual(2, values.Count);
Assert.AreEqual(6.0, values[0]);
Assert.AreEqual(60.0, values[1]);
}
private static Bitmap GenerateBitmap(IRegularGridCoverageLayer gridLayer, IRegularGridCoverage grid,
PixelFormat pixelFormat, IVariableFilter[] filters, int xWidth, int yWidth)
{
/*var xWidth =
* ((VariableIndexRangesFilter) filters[0]).IndexRanges[0].Second-((VariableIndexRangesFilter) filters[0]).
* IndexRanges[0].First +1;
* var yWidth = ((VariableIndexRangesFilter)filters[1]).IndexRanges[0].Second - ((VariableIndexRangesFilter)filters[1]).
* IndexRanges[0].First+1;*/
var bitmap = new Bitmap(xWidth, yWidth, pixelFormat);
if (grid.Components[0].ValueType == typeof(double))
{
FillBitmap <double>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else if (grid.Components[0].ValueType == typeof(float))
{
FillBitmap <float>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else if (grid.Components[0].ValueType == typeof(int))
{
FillBitmap <int>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else if (grid.Components[0].ValueType == typeof(short))
{
FillBitmap <short>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else if (grid.Components[0].ValueType == typeof(UInt32))
{
FillBitmap <UInt32>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else if (grid.Components[0].ValueType == typeof(Byte))
{
//todo hack: in case source file is tiff it has its own color
//return bitmap;
FillBitmap <Byte>(gridLayer, grid, bitmap, pixelFormat, filters);
}
else
{
log.WarnFormat("Cant render type: " + grid.Components[0].ValueType);
}
return(bitmap);
}
/// <summary>
/// Defines the gridProfile function
/// </summary>
/// <param name="grid"></param>
/// <param name="polyline"></param>
public static Function GetGridValues(IRegularGridCoverage grid, ILineString polyline)
{
Function function = new Function {Name = grid.Name};
if (grid.Time != null)
{
grid.Name += " (" + grid.Time + ")";
}
function.Arguments.Add(new Variable<double>("offset"));
function.Components.Add( (IVariable) TypeUtils.CreateGeneric(typeof (Variable<>), grid.Components[0].ValueType, new object[] {"value"}));
function.Components[0].NoDataValues = grid.Components[0].NoDataValues;
if (null == polyline)
{
return function;
}
UpdateGridValues(function, grid, polyline);
return function;
}
public RegularGridCoverage(IRegularGridCoverage grid)
{
if (grid.Components.Count > 1)
{
throw new NotImplementedException("Copy constructor not implemented for grids with more than one component");
}
if (grid.Components[0].NoDataValues.Count > 1)
{
throw new NotImplementedException("Copy constructor not implemented for component with multiple nodata values");
}
Name = grid.Name;
var y = new Variable <double>("y", grid.SizeY)
{
InterpolationType = InterpolationType.Constant
};
y.Attributes[StandardName] = StandardNameY;
Arguments.Add(y);
var x = new Variable <double>("x", grid.SizeX)
{
InterpolationType = InterpolationType.Constant
};
x.Attributes[StandardName] = StandardNameX;
Arguments.Add(x);
IVariable variable = grid.Components[0].Clone();
//clear arguments because they will be added when the component is added to the function
variable.Arguments.Clear();
Components.Add(variable);
CollectionChanged += RegularGridCoverage_CollectionChanged;
ValuesChanged += RegularGridCoverage_ValuesChanged;
IsTimeDependent = grid.IsTimeDependent;
// update sizes of the arguments
Resize(grid.SizeX, grid.SizeY, grid.DeltaX, grid.DeltaY, new Coordinate(grid.Origin.X, grid.Origin.Y));
}
public void GenerateThemeForCategorialBilFileWithLegendFile()
{
const string fileName = @"..\..\..\..\..\test-data\DeltaShell\DeltaShell.Plugins.SharpMapGis.Tests\RasterData\bodem.bil";
var rasterLayer = new RegularGridCoverageLayer();
var rasterFeatureProvider = new GdalFeatureProvider {
Path = fileName
};
rasterLayer.DataSource = rasterFeatureProvider;
IRegularGridCoverage grid = rasterLayer.Grid;
ITheme theme = DemisMapControlLegendHelper.ConvertLegendToTheme(fileName, "value", grid);
ICollection colors = new List <string>(new string[]
{
"0000FF",
"00FFFF",
"00FF00",
"FFFF00",
"FF0000"
});
ICollection values = new List <double>(new double[] { 1, 2, 3, 4, 5 });
Assert.IsInstanceOfType(typeof(CategorialTheme), theme);
foreach (IThemeItem themeItem in theme.ThemeItems)
{
Assert.IsInstanceOfType(typeof(CategorialThemeItem), themeItem);
Assert.IsInstanceOfType(typeof(VectorStyle), themeItem.Style);
double value = Convert.ToDouble(((CategorialThemeItem)themeItem).Value);
Assert.Contains(value, values);
((List <double>)values).Remove(value);
string color = FromColorToBGRString(((SolidBrush)((VectorStyle)themeItem.Style).Fill).Color);
Assert.Contains(color, colors);
((List <string>)colors).Remove(color);
}
Assert.IsTrue(colors.Count == 0);
Assert.IsTrue(values.Count == 0);
}
public void GetCoordinatesInCoverageWithOffset()
{
IRegularGridCoverage grid2D = CreatePressureCoverage(1000.0, 0.0);
IRegularGridCoverageCell regularGridCoverageCell = grid2D.GetRegularGridCoverageCellAtPosition(1000.0, 0.0);
Assert.AreEqual(1000.0, regularGridCoverageCell.X);
Assert.AreEqual(0.0, regularGridCoverageCell.Y);
regularGridCoverageCell = grid2D.GetRegularGridCoverageCellAtPosition(1050.0, 25.0);
Assert.AreEqual(1000.0, regularGridCoverageCell.X);
Assert.AreEqual(0.0, regularGridCoverageCell.Y);
regularGridCoverageCell = grid2D.GetRegularGridCoverageCellAtPosition(1150.0, 25.0);
Assert.AreEqual(1100.0, regularGridCoverageCell.X);
Assert.AreEqual(0.0, regularGridCoverageCell.Y);
regularGridCoverageCell = grid2D.GetRegularGridCoverageCellAtPosition(1199.0, 99.0);
Assert.AreEqual(1100.0, regularGridCoverageCell.X);
Assert.AreEqual(50.0, regularGridCoverageCell.Y);
}
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[] { });
}
}
/// <summary>
/// Defines the gridProfile function
/// </summary>
/// <param name="grid"></param>
/// <param name="polyline"></param>
public static Function GetGridValues(IRegularGridCoverage grid, ILineString polyline)
{
Function function = new Function {
Name = grid.Name
};
if (grid.Time != null)
{
grid.Name += " (" + grid.Time + ")";
}
function.Arguments.Add(new Variable <double>("offset"));
function.Components.Add((IVariable)TypeUtils.CreateGeneric(typeof(Variable <>), grid.Components[0].ValueType, new object[] { "value" }));
function.Components[0].NoDataValues = grid.Components[0].NoDataValues;
if (null == polyline)
{
return(function);
}
UpdateGridValues(function, grid, polyline);
return(function);
}
public void Initialization()
{
IRegularGridCoverage grid2D = CreatePressureCoverage(0.0, 0.0);
Assert.AreEqual(2, grid2D.Arguments.Count);
Assert.AreEqual("y", grid2D.Arguments[0].Name);
Assert.AreEqual("x", grid2D.Arguments[1].Name);
Assert.IsInstanceOfType(typeof(IPolygon), grid2D.Geometry);
Assert.AreEqual(grid2D.SizeX, grid2D.X.Values.Count, "number of X argument values");
Assert.AreEqual(grid2D.SizeY, grid2D.Y.Values.Count, "number of Y argument values");
//obtain values for all x and for y=50.0 (second row.
var values = grid2D.GetValues(new VariableValueFilter <double>(grid2D.Y, new[] { 50.0 }));
Assert.IsTrue(((IEnumerable <double>)values).SequenceEqual(new[] { 3.0, 4.0 }));
//obtain values for all x and for y=100.0 (third row.)
values = grid2D.GetValues(new VariableValueFilter <double>(grid2D.Y, new[] { 100.0 }));
Assert.IsTrue(((IEnumerable <double>)values).SequenceEqual(new[] { 5.0, 6.0 }));
}
/// <summary>
/// Convert a DemisMapControl legend (.leg) file to an ITheme
/// </summary>
/// <remarks>
/// returns null if legend file is not found
/// </remarks>
/// <param name="fileName">The name of the legfile or bil-/bsq-/bipfile</param>
/// <returns>instance of ITheme</returns>
public static ITheme ConvertLegendToTheme(string fileName, string columnName, IRegularGridCoverage grid)
{
string legendFileNameBase = null;
string legendFileName = null;
bool fileIsLegend = false;
if (Path.GetExtension(fileName.ToLower()).Equals(".bil") ||
Path.GetExtension(fileName.ToLower()).Equals(".bip") ||
Path.GetExtension(fileName.ToLower()).Equals(".bsq"))
{
string pathName = Path.GetDirectoryName(fileName);
string baseName = Path.GetFileNameWithoutExtension(fileName);
legendFileNameBase = Path.Combine(pathName, baseName);
}
else
{
fileIsLegend = true;
legendFileName = fileName;
}
if (legendFileNameBase != null)
{
foreach (string name in
new string[]
{
legendFileNameBase + ".leg",
legendFileNameBase + ".Leg",
legendFileNameBase + ".LEG"
})
{
if (File.Exists(name))
{
legendFileName = name;
break;
}
}
}
Legend legend;
if (legendFileName == null || (legend = ReadLegend(legendFileName)) == null)
{
if (fileIsLegend || grid == null)
{
return(null);
}
return(CreateDefaultGradientTheme(columnName, GetMaxMinFromGridFile(grid)));
}
legend.columnName = columnName;
Ranges <double> doubleRanges = null;
Ranges <int> intRanges = null;
if (legend.doubles)
{
doubleRanges = ParseRanges <double>(legend);
}
else
{
intRanges = ParseRanges <int>(legend);
}
ITheme newTheme;
if (intRanges != null && intRanges.IsClassification)
{
newTheme = CreateCategorialTheme(legend, intRanges);
}
else if (legend.doubles)
{
newTheme = CreateQuantityTheme <double>(legend, doubleRanges);
}
else
{
newTheme = CreateQuantityTheme <int>(legend, intRanges);
}
return(newTheme);
}
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);
}
/// <summary>
/// Sony NS @ 2013-08-06
/// </summary>
/// <param name="worldPos"></param>
/// <param name="limit"></param>
/// <param name="outLayer"></param>
/// <param name="condition"></param>
/// <returns></returns>
public IFeature FindNearestFeature(ICoordinate worldPos, float limit, out ILayer outLayer, Func <ILayer, bool> condition)
{
IFeature nearestFeature = null;
outLayer = null;
// Since we are only interested in one geometry object start with the topmost trackersLayer and stop
// searching the lower layers when an object is found.
// Sony NS @ 2013-08-06, order list ILayer Desc, karena untuk layer-layer symbol diload paling terakhir
foreach (ILayer mapLayer in Map.GetAllVisibleLayers(true).Reverse())
{
if (mapLayer is DiscreteGridPointCoverageLayer)
{
try
{
var curvilinearGridLayer = (DiscreteGridPointCoverageLayer)mapLayer;
var coverage = (IDiscreteGridPointCoverage)curvilinearGridLayer.Coverage;
var nearestFeatures = coverage.GetFeatures(worldPos.X, worldPos.Y, limit);
if (nearestFeatures != null)
{
if (!curvilinearGridLayer.ShowFaces)
{
nearestFeatures = nearestFeatures.Where(f => !(f is IGridFace));
}
if (!curvilinearGridLayer.ShowVertices)
{
nearestFeatures = nearestFeatures.Where(f => !(f is IGridVertex));
}
}
nearestFeature = nearestFeatures.FirstOrDefault();
outLayer = curvilinearGridLayer;
}
catch (Exception)
{
// GetCoordinateAtPosition will throw exception if x, y is not within the coverage
}
}
if (mapLayer is VectorLayer)
{
var vectorLayer = mapLayer as VectorLayer;
IEnvelope envelope;
float localLimit = limit;
if ((!vectorLayer.IsSelectable) || ((null != condition) && (!condition(vectorLayer))))
{
continue;
}
// Adjust the marge limit for Layers with a symbol style and if the size of the symbol exceeds
// the minimum limit. Ignore layers with custom renderers
if ((vectorLayer.Style.Symbol != null) && (0 == vectorLayer.CustomRenderers.Count))
{
ICoordinate size = MapHelper.ImageToWorld(MapControl.Map,
vectorLayer.Style.Symbol.Width,
vectorLayer.Style.Symbol.Height);
if ((size.X > localLimit) || (size.Y > localLimit))
{
envelope = MapHelper.GetEnvelope(worldPos, size.X, size.Y);
localLimit = (float)Math.Max(envelope.Width, envelope.Height);
}
else
{
envelope = GetEnvelope(worldPos, localLimit);
}
}
else
{
envelope = GetEnvelope(worldPos, localLimit);
}
IFeatureProvider featureProvider = vectorLayer.DataSource;
if (null != featureProvider)
{
// Get features in the envelope
IList objectsAt;
if (vectorLayer.CustomRenderers.Count > 0)
{
objectsAt = vectorLayer.CustomRenderers[0].GetFeatures(envelope, vectorLayer);
}
else
{
objectsAt = featureProvider.GetFeatures(envelope);
}
// Mousedown at new position
if (null != objectsAt)
{
IFeature feature = null;
if (objectsAt.Count == 1)
{
feature = objectsAt.OfType <IFeature>().First();
}
else if (objectsAt.Count > 1)
{
double localDistance;
feature = FindNearestFeature(vectorLayer, objectsAt, worldPos, localLimit, out localDistance);
}
if (null != feature)
{
nearestFeature = feature;
outLayer = vectorLayer;
break;
}
}
}
}
else if (mapLayer is IRegularGridCoverageLayer)
{
try
{
IRegularGridCoverageLayer regularGridCoverageLayer = (IRegularGridCoverageLayer)mapLayer;
IRegularGridCoverage regularGridCoverage = (IRegularGridCoverage)regularGridCoverageLayer.Coverage;
nearestFeature = regularGridCoverage.GetRegularGridCoverageCellAtPosition(worldPos.X, worldPos.Y);
outLayer = regularGridCoverageLayer;
}
catch (Exception)
{
// GetCoordinateAtPosition will throw exception if x, y is not within the coverage
}
}
}
return(nearestFeature);
}
protected static void FillBitmap <T>(IRegularGridCoverageLayer gridLayer, IRegularGridCoverage gridCoverage,
Bitmap bitmap, PixelFormat pixelFormat, IVariableFilter[] filters)
where T : IComparable, IComparable <T>
{
// HACK: free memory before getting large block
GC.Collect(1, GCCollectionMode.Optimized);
T[] gridValues = gridCoverage.Components[0].GetValues <T>(filters).ToArray();
var imageWidth = bitmap.Width;
var imageHeight = bitmap.Height;
Trace.Assert(imageHeight * imageWidth == gridValues.Count());
//flip upside down
for (int k = 0; k < imageWidth; k++)
{
for (int j = 0; j < imageHeight / 2; j++)
{
T swap1 = gridValues[k + j * imageWidth];
T swap2 = gridValues[(imageHeight - 1 - j) * imageWidth + k];
gridValues[k + j * imageWidth] = swap2;
gridValues[(imageHeight - 1 - j) * imageWidth + k] = swap1;
}
}
if (gridLayer.Theme == null)
{
object minValue = gridCoverage.Components[0].MinValue;
object maxValue = gridCoverage.Components[0].MaxValue;
gridLayer.Theme = GenerateDefaultTheme(gridCoverage.Components[0].Name,
gridCoverage.Components[0].NoDataValues, minValue, maxValue);
}
// Add NoDataValues from grid coverage if it was unspecified:
var theme = gridLayer.Theme as Theme;
if (theme != null && theme.NoDataValues == null)
{
theme.NoDataValues = gridCoverage.Components[0].NoDataValues;
}
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, imageWidth, imageHeight),
ImageLockMode.ReadWrite, pixelFormat);
try
{
unsafe
{
// use a pointer to get direct access to the bits in the bitmap.
// this is faster and removes the need to copy values from
// unmanaged to managed memory and vice versa.
IntPtr array = bitmapData.Scan0;
int * pByte = (int *)array.ToPointer();
int bytes = bitmapData.Width * bitmapData.Height;
((Theme)gridLayer.Theme).GetFillColors(pByte, bytes, (T[])gridValues);
}
}
catch (Exception e)
{
throw e;
}
finally
{
if (bitmapData != null)
{
bitmap.UnlockBits(bitmapData);
// force a collect to reclaim large allocated arrays that have survived the first generations
GC.Collect(1, GCCollectionMode.Optimized);
}
}
}
public void GenerateThemeForQuantityBilFileWithLegendFile()
{
const string fileName = @"..\..\..\..\..\test-data\DeltaShell\DeltaShell.Plugins.SharpMapGis.Tests\RasterData\FloatValues.bil";
RegularGridCoverageLayer rasterLayer = new RegularGridCoverageLayer();
GdalFeatureProvider rasterFeatureProvider = new GdalFeatureProvider {
Path = fileName
};
rasterLayer.DataSource = rasterFeatureProvider;
IRegularGridCoverage grid = rasterLayer.Grid;
ITheme theme = DemisMapControlLegendHelper.ConvertLegendToTheme(fileName, "value", grid);
ICollection colors = new List <string>(new string[]
{
"000000",
"E1E1FE",
"DCD9FE",
"D6D0FE",
"D0C8FF",
"CBC0FF",
"C09EFF",
"B57BFF",
"A959FF",
"9E36FF",
"9314FF"
});
ICollection values = new List <double>(new double[]
{
-16.9996604919434,
-13.5799999237061,
-10.1499996185303,
-6.73000001907349,
-3.29999995231628,
.119999997317791,
3.54999995231628,
6.96999979019165,
10.3900003433228,
13.8199996948242,
17.2399997711182
});
Assert.IsInstanceOfType(typeof(QuantityTheme), theme);
foreach (IThemeItem themeItem in theme.ThemeItems)
{
Assert.IsInstanceOfType(typeof(QuantityThemeItem), themeItem);
Assert.IsInstanceOfType(typeof(VectorStyle), themeItem.Style);
double value = ((QuantityThemeItem)themeItem).Interval.Max;
Assert.Contains(value, values);
((List <double>)values).Remove(value);
string color = FromColorToBGRString(((SolidBrush)((VectorStyle)themeItem.Style).Fill).Color);
Assert.Contains(color, colors);
((List <string>)colors).Remove(color);
}
Assert.IsTrue(colors.Count == 0);
Assert.IsTrue(values.Count == 0);
}
public void GetCoordinateOutsideAfterWithOffset()
{
IRegularGridCoverage grid2D = CreatePressureCoverage(1000.0, 0.0);
grid2D.GetRegularGridCoverageCellAtPosition(1200.0, 100.0);
}
public void GetCoordinateOutsideBefore()
{
IRegularGridCoverage grid2D = CreatePressureCoverage(0.0, 0.0);
grid2D.GetRegularGridCoverageCellAtPosition(-10.0, 200.0);
}
public IFeature FindNearestFeature(ICoordinate worldPos, float limit, out ILayer outLayer,
Func <ILayer, bool> condition)
{
IFeature nearestFeature = null;
outLayer = null;
// Since we are only interested in one geometry object start with the topmost trackersLayer and stop
// searching the lower layers when an object is found.
foreach (ILayer mapLayer in MapHelper.GetAllMapLayers(Map.Layers, false))
{
if (mapLayer is VectorLayer)
{
var vectorLayer = mapLayer as VectorLayer;
IEnvelope envelope;
float localLimit = limit;
if ((!vectorLayer.IsSelectable) || ((null != condition) && (!condition(vectorLayer))))
{
continue;
}
// Adjust the marge limit for Layers with a symbol style and if the size of the symbol exceeds
// the minimum limit. Ignore layers with custom renderers
if ((vectorLayer.Style.Symbol != null) && (0 == vectorLayer.CustomRenderers.Count))
{
ICoordinate size = MapControlHelper.ImageToWorld(MapControl.Map, vectorLayer.Style.Symbol.Width,
vectorLayer.Style.Symbol.Height);
if ((size.X > localLimit) || (size.Y > localLimit))
{
envelope = MapControlHelper.GetEnvelope(worldPos, size.X, size.Y);
localLimit = (float)Math.Max(envelope.Width, envelope.Height);
}
else
{
envelope = GetEnvelope(worldPos, localLimit);
}
}
else
{
envelope = GetEnvelope(worldPos, localLimit);
}
IFeatureProvider featureProvider = vectorLayer.DataSource;
if (null != featureProvider)
{
// Get features in the envelope
IList objectsAt;
if (vectorLayer.CustomRenderers.Count > 0)
{
objectsAt = vectorLayer.CustomRenderers[0].GetFeatures(envelope, vectorLayer);
}
else
{
objectsAt = featureProvider.GetFeatures(envelope);
}
// Mousedown at new position
if ((null != objectsAt) && (objectsAt.Count > 0))
{
double localDistance;
IFeature feature = FindNearestFeature(vectorLayer, objectsAt, worldPos, localLimit,
out localDistance);
if (null != feature)
{
nearestFeature = feature;
outLayer = vectorLayer;
break;
}
}
}
}
else if (mapLayer is IRegularGridCoverageLayer)
{
try
{
IRegularGridCoverageLayer regularGridCoverageLayer = (IRegularGridCoverageLayer)mapLayer;
IRegularGridCoverage regularGridCoverage = (IRegularGridCoverage)regularGridCoverageLayer.Coverage;
nearestFeature = regularGridCoverage.GetRegularGridCoverageCellAtPosition(worldPos.X, worldPos.Y);
outLayer = regularGridCoverageLayer;
}
catch (Exception)
{
// GetCoordinateAtPosition will throw exception if x, y is not within the coverage
}
}
}
return(nearestFeature);
}
