public void GetValuesWithAggregationFilter()
{
// nRows 2566
// nCols 1843
// upper left corner of map
// ULXMAP 124854.28
// ULYMAP 523505.38
// stepsize (m) for both dimensions
// Xdim 20
// Ydim 20
string path = rasterDataPath + "Bodem.bil";
var functionStore = new GdalFunctionStore {
Path = path
};
functionStore.Open();
//grid.GetValues()
var grid = functionStore.Grid;
//create filter for x and y to set xmin, xmax, ymin and ymax (VariableValueRangesFilter<>)
var xFilter = new VariableAggregationFilter(grid.X, 18, 0, 1782);
var yFilter = new VariableAggregationFilter(grid.Y, 25, 0, 2475);
//get values between 130000-132000 and 526000-528000
var values = grid.GetValues(xFilter, yFilter);
//check count
Assert.AreEqual(10000, values.Count);
}
private int GetSourceIndex(VariableAggregationFilter filter, int index)
{
int sourceIndex = filter.MinIndex + index * filter.StepSize;
sourceIndex = Math.Min(sourceIndex, filter.MaxIndex);
return(sourceIndex);
}
/// <summary>
/// Returns filters containing variables which exist in the store.
/// If variable in the filter is filtered - use parent vararible.
/// </summary>
/// <param name="filters"></param>
/// <returns></returns>
private IVariableFilter[] GetFiltersInParent(IEnumerable <IVariableFilter> filters)
{
if (filters.Count() == 0 && Filters.Count == 0)
{
return(new IVariableFilter[0]);
}
var allFilters = new List <IVariableFilter>();
//convert variableValuefilter to parent..some assumptions here refactor to a more decorated architecture
foreach (IVariableFilter filter in filters)
{
//TODO : refactor to a base class or something
if ((filter is IVariableValueFilter) && (filter.Variable.Parent != null))
{
var valueFilter = (filter as IVariableValueFilter);
var parentVariable = (IVariable)(valueFilter.Variable.Parent);
allFilters.Add(parentVariable.CreateValuesFilter(valueFilter.Values));
}
else if ((filter is VariableIndexRangesFilter) && (filter.Variable.Parent != null))
{
//this assumen indexes in the parent are the same..
VariableIndexRangesFilter indexFilter = (filter as VariableIndexRangesFilter);
allFilters.Add(new VariableIndexRangesFilter((IVariable)(indexFilter.Variable.Parent),
indexFilter.IndexRanges));
}
else if ((filter is VariableAggregationFilter) && (filter.Variable.Parent != null))
{
//this assumen indexes in the parent are the same..
VariableAggregationFilter aggregationFilter = (filter as VariableAggregationFilter);
VariableAggregationFilter clone = (VariableAggregationFilter)aggregationFilter.Clone();
clone.Variable = (IVariable)filter.Variable.Parent;
allFilters.Add(clone);
}
else
{
allFilters.Add(filter);
}
}
if (Filters.Count != 0)
{
allFilters = Filters.Concat(allFilters).ToList();
}
List <IVariableFilter> uniqueFilters = CombineCompatibleFilters(allFilters);
if (uniqueFilters.OfType <IVariableValueFilter>().Any(f => f.Values.Count == 0))
{
throw new InvalidOperationException("Variable value filters should have values!");
}
return(uniqueFilters.ToArray());
}
public void AggregateOneDimension()
{
//two dimensional function aggregation on x variable
Function f = new Function();
var x = new Variable <int>("x");
var y = new Variable <int>("x");
f.Arguments.Add(x);
f.Arguments.Add(y);
//step through x 0,5,10,...100..selecting 21 values from 0 to 100 ranging 101 values
var xFilter = new VariableAggregationFilter(x, 5, 0, 100);
FilteredArrayInfo info = new FilteredArrayInfo(f, new[] { xFilter });
Assert.AreEqual(new[] { 0, -1 }, info.Origin);
Assert.AreEqual(new[] { 21, -1 }, info.Shape);
Assert.AreEqual(new[] { 101, -1 }, info.Size);
Assert.AreEqual(new[] { 5, -1 }, info.Stride);
}
public void SelectTwoDimensional()
{
IFunction f = new Function();
var x = new Variable <int>("x");
var y = new Variable <int>("x");
f.Arguments.Add(x);
f.Arguments.Add(y);
//step through x 0,5,10,...100..selecting 21 values from 0 to 100 ranging 101 values
var xFilter = new VariableAggregationFilter(x, 5, 0, 100);
//step through y 10,12,14..20..selecting 6 values from 10 to 20 ranging 11
var yFilter = new VariableAggregationFilter(y, 2, 10, 20);
FilteredArrayInfo info = new FilteredArrayInfo(f, new[] { xFilter, yFilter });
Assert.AreEqual(new[] { 0, 10 }, info.Origin);
Assert.AreEqual(new[] { 21, 6 }, info.Shape);
Assert.AreEqual(new[] { 101, 11 }, info.Size);
Assert.AreEqual(new[] { 5, 2 }, info.Stride);
}
public void SampleSize()
{
IVariable <int> x = new Variable <int>();
int stepSize = 1;
int startIndex = 0;
int endIndex = 0;
var filter = new VariableAggregationFilter(x, stepSize, startIndex, endIndex);
Assert.AreEqual(1, filter.Count);
stepSize = 2;
startIndex = 0;
endIndex = 3;
filter = new VariableAggregationFilter(x, stepSize, startIndex, endIndex);
Assert.AreEqual(2, filter.Count);
stepSize = 2;
startIndex = 0;
endIndex = 4;
filter = new VariableAggregationFilter(x, stepSize, startIndex, endIndex);
Assert.AreEqual(3, filter.Count);
}
/// <summary>
/// Renders feature on a given map.
/// </summary>
/// <param name="feature">Feature to render</param>
/// <param name="g">Graphics object to be used as a target for rendering</param>
/// <param name="layer">Layer where feature belongs to</param>
/// <returns>When rendering succeds - returns true, otherwise false</returns>
public virtual bool Render(IFeature feature, Graphics g, ILayer layer)
{
if (null == RegularGridCoverageLayer)
{
throw new Exception("RegularGridCoverageRenderer needs reference to RegularGridCoverageLayer");
}
var gridLayer = RegularGridCoverageLayer;
var grid = gridLayer.RenderedCoverage;
IEnvelope mapExtents = layer.Map.Envelope;
// IEnvelope gridExtents = grid.Geometry.EnvelopeInternal;
//do not render invalid grid
if (grid.SizeX == 0 || grid.SizeY == 0)
{
return(false);
}
//create filters for x, y to only obtain necessary data from functionstore.
// var xFilter = new VariableValueRangesFilter<double>(grid.X, new[] { new Pair<double, double>(layer.Map.Envelope.MinX,layer.Map.Envelope.MaxX) });
// var yFilter = new VariableValueRangesFilter<double>(grid.Y, new[] { new Pair<double, double>(layer.Map.Envelope.MinY, layer.Map.Envelope.MaxY) });
IMultiDimensionalArray <double> xValues = grid.X.Values;
var indexMinX = FindNearest(xValues, layer.Map.Envelope.MinX);
var indexMaxX = FindNearest(xValues, layer.Map.Envelope.MaxX);
IMultiDimensionalArray <double> yValues = grid.Y.Values;
var indexMinY = FindNearest(yValues, layer.Map.Envelope.MinY);
var indexMaxY = FindNearest(yValues, layer.Map.Envelope.MaxY);
if (indexMaxX == indexMinX || indexMaxY == indexMinY)
{
return(true); //nothing to render.
}
/*
* var xWidth = xFilter.IndexRanges[0].Second - xFilter.IndexRanges[0].First + 1;
* var yWidth = yFilter.IndexRanges[0].Second - yFilter.IndexRanges[0].First + 1;
*/
const PixelFormat pixelFormat = PixelFormat.Format32bppArgb;
var gridMinX = xValues[indexMinX];
var gridMaxX = xValues[indexMaxX] + grid.DeltaX;
var gridMinY = yValues[indexMinY];
var gridMaxY = yValues[indexMaxY] + grid.DeltaY;
//height and offset for the rasterlayer
var targetOffsetX = (int)((gridMinX - mapExtents.MinX) / layer.Map.PixelWidth);
var targetOffsetY = (int)((mapExtents.MaxY - gridMaxY) / layer.Map.PixelHeight);
var targetWidth = (int)((gridMaxX - gridMinX) / layer.Map.PixelWidth);
var targetHeight = (int)((gridMaxY - gridMinY) / layer.Map.PixelHeight);
if (targetHeight == 0 || targetWidth == 0)
{
return(true);
}
//in case there is just one pixel stepsize should be 1
var stepsizeX = Math.Max((indexMaxX - indexMinX) / targetWidth, 1);
var stepsizeY = Math.Max((indexMaxY - indexMinY) / targetHeight, 1);
/*
* var xFilter = new VariableAggregationFilter(grid.Components[0].Arguments.Where(a=>a.Name==grid.X.Name).FirstOrDefault(), stepsizeX, indexMinX, indexMaxX);
* var yFilter = new VariableAggregationFilter(grid.Components[0].Arguments.Where(a=>a.Name==grid.Y.Name).FirstOrDefault(), stepsizeY, indexMinY, indexMaxY);
*
*/
var xFilter = new VariableAggregationFilter(grid.X, stepsizeX, indexMinX, indexMaxX);
var yFilter = new VariableAggregationFilter(grid.Y, stepsizeY, indexMinY, indexMaxY);
log.DebugFormat("x: {0},{1},{2}; y: {3},{4},{5}", stepsizeX, indexMinX, indexMaxX, stepsizeY, indexMinY, indexMaxY);
// TODO: Commented out as temporary fix. Bitmap is not be cleared any more, results in as of revision 19658 by Genna
// Fix ensures coverage is updated properly and no strange rescaling effects when zooming or dragging a part of the coverage outside the viewport
// occur because bitmapCache is never cleared.
// However, the fix might incur performance issues because bitmapCache is always refreshed on Render call
//if (null == bitmapCache)
//{
var filters = grid.Filters.ToList();
filters.Add(xFilter);
filters.Add(yFilter);
bitmapCache = GenerateBitmap(gridLayer, grid, pixelFormat, filters.ToArray(),
xFilter.Count, yFilter.Count);
//}
/*
* int targetOffsetX = (int)((gridExtents.MinX - mapExtents.MinX) / layer.Map.PixelWidth);
* int targetOffsetY = (int)((mapExtents.MaxY - gridExtents.MaxY) / layer.Map.PixelHeight);
*
* int targetWidth = (int)(gridExtents.Width / layer.Map.PixelWidth);
* int targetHeight = (int)(gridExtents.Height / layer.Map.PixelHeight);
*/
var srcRectangle = new Rectangle(0, 0, bitmapCache.Width, bitmapCache.Height);
var targetRectangle = new Rectangle(targetOffsetX, targetOffsetY, targetWidth, targetHeight);
g.SetClip(targetRectangle);
g.PixelOffsetMode = PixelOffsetMode.Half;
g.InterpolationMode = InterpolationMode.NearestNeighbor;
g.DrawImage(bitmapCache, targetRectangle, srcRectangle, GraphicsUnit.Pixel);
g.ResetClip();
return(false);
}
/// <summary>
/// Renders feature on a given map.
/// </summary>
/// <param name="feature">Feature to render</param>
/// <param name="g">Graphics object to be used as a target for rendering</param>
/// <param name="layer">Layer where feature belongs to</param>
/// <returns>When rendering succeds - returns true, otherwise false</returns>
public virtual bool Render(IFeature feature, Graphics g, ILayer layer)
{
if (null == RegularGridCoverageLayer)
{
throw new Exception("RegularGridCoverageRenderer needs reference to RegularGridCoverageLayer");
}
var gridLayer = RegularGridCoverageLayer;
var grid = (IRegularGridCoverage)feature;
//do not render invalid grid
if (grid.SizeX == 0 || grid.SizeY == 0)
{
log.ErrorFormat("The following grid could not be rendered: '{0}'", grid.Name);
return(false);
}
IEnvelope mapExtents = layer.Map.Envelope;
// IEnvelope gridExtents = grid.Geometry.EnvelopeInternal;
//create filters for x, y to only obtain necessary data from functionstore.
// var xFilter = new VariableValueRangesFilter<double>(grid.X, new[] { new Pair<double, double>(layer.Map.Envelope.MinX,layer.Map.Envelope.MaxX) });
// var yFilter = new VariableValueRangesFilter<double>(grid.Y, new[] { new Pair<double, double>(layer.Map.Envelope.MinY, layer.Map.Envelope.MaxY) });
IMultiDimensionalArray <double> xValues = grid.X.Values;
var indexMinX = FindNearest(xValues, layer.Map.Envelope.MinX);
var indexMaxX = FindNearest(xValues, layer.Map.Envelope.MaxX);
IMultiDimensionalArray <double> yValues = grid.Y.Values;
var indexMinY = FindNearest(yValues, layer.Map.Envelope.MinY);
var indexMaxY = FindNearest(yValues, layer.Map.Envelope.MaxY);
if (indexMaxX == indexMinX || indexMaxY == indexMinY)
{
return(true); //nothing to render.
}
/*
* var xWidth = xFilter.IndexRanges[0].Second - xFilter.IndexRanges[0].First + 1;
* var yWidth = yFilter.IndexRanges[0].Second - yFilter.IndexRanges[0].First + 1;
*/
const PixelFormat pixelFormat = PixelFormat.Format32bppRgb;
var gridMinX = xValues[indexMinX];
var gridMaxX = xValues[indexMaxX] + grid.DeltaX;
var gridMinY = yValues[indexMinY];
var gridMaxY = yValues[indexMaxY] + grid.DeltaY;
//height and offset for the rasterlayer
var targetOffsetX = (int)((gridMinX - mapExtents.MinX) / layer.Map.PixelWidth);
var targetOffsetY = (int)((mapExtents.MaxY - gridMaxY) / layer.Map.PixelHeight);
var targetWidth = (int)((gridMaxX - gridMinX) / layer.Map.PixelWidth);
var targetHeight = (int)((gridMaxY - gridMinY) / layer.Map.PixelHeight);
if (targetHeight == 0 || targetWidth == 0)
{
return(true);
}
//in case there is just one pixel stepsize should be 1
var stepsizeX = Math.Max((indexMaxX - indexMinX) / targetWidth, 1);
var stepsizeY = Math.Max((indexMaxY - indexMinY) / targetHeight, 1);
/*
* var xFilter = new VariableAggregationFilter(grid.Components[0].Arguments.Where(a=>a.Name==grid.X.Name).FirstOrDefault(), stepsizeX, indexMinX, indexMaxX);
* var yFilter = new VariableAggregationFilter(grid.Components[0].Arguments.Where(a=>a.Name==grid.Y.Name).FirstOrDefault(), stepsizeY, indexMinY, indexMaxY);
*
*/
var xFilter = new VariableAggregationFilter(grid.X, stepsizeX, indexMinX, indexMaxX);
var yFilter = new VariableAggregationFilter(grid.Y, stepsizeY, indexMinY, indexMaxY);
log.DebugFormat("x: {0},{1},{2}; y: {3},{4},{5}", stepsizeX, indexMinX, indexMaxX, stepsizeY, indexMinY, indexMaxY);
if (null == bitmapCache)
{
var filters = grid.Filters.ToList();
var coverageLayer = (RegularGridCoverageLayer)layer;
if (coverageLayer.TimeSelectionStart != null)
{
filters.Add(new VariableValueFilter <DateTime>(grid.Time, coverageLayer.TimeSelectionStart.Value));
}
filters.Add(xFilter);
filters.Add(yFilter);
bitmapCache = GenerateBitmap(gridLayer, grid, pixelFormat, filters.ToArray(),
xFilter.Count, yFilter.Count);
}
/*
* int targetOffsetX = (int)((gridExtents.MinX - mapExtents.MinX) / layer.Map.PixelWidth);
* int targetOffsetY = (int)((mapExtents.MaxY - gridExtents.MaxY) / layer.Map.PixelHeight);
*
* int targetWidth = (int)(gridExtents.Width / layer.Map.PixelWidth);
* int targetHeight = (int)(gridExtents.Height / layer.Map.PixelHeight);
*/
var srcRectangle = new Rectangle(0, 0, bitmapCache.Width, bitmapCache.Height);
var targetRectangle = new Rectangle(targetOffsetX, targetOffsetY, targetWidth, targetHeight);
g.SetClip(targetRectangle);
g.PixelOffsetMode = PixelOffsetMode.Half;
g.InterpolationMode = InterpolationMode.NearestNeighbor;
g.DrawImage(bitmapCache, targetRectangle, srcRectangle, GraphicsUnit.Pixel);
g.ResetClip();
// clear memory claimed by MD arrays to avoid out of memory exception
xValues = null;
yValues = null;
GC.Collect();
return(false);
}
