public void GetFilteredValuesFrom2DFunction()
{
var x = new Variable <int>();
var y = new Variable <int>();
var z = new Variable <double> {
Arguments = { x, y }
};
z[0, 0] = 1.0;
z[0, 1] = 2.0;
z[1, 0] = 3.0;
z[1, 1] = 4.0;
var xFilter = new VariableValueFilter <int>(x, 0);
var yFilter = new VariableValueFilter <int>(y, 1);
var values = z.GetValues(xFilter, yFilter);
values.Count
.Should("query values using 2 filters").Be.EqualTo(1);
values[0]
.Should("query values using 2 filters").Be.EqualTo(2.0);
}
private static FilterDefinition <VariableValue> BuildFindKeyFilter(
VariableValueFilter filter)
{
FilterDefinition <VariableValue> dbFilter = Filter.Eq(x => x.Key.VariableId, filter.Id);
if (filter.EnvironmentId.HasValue)
{
dbFilter &= Filter
.EqOrNull(x => x.Key.EnvironmentId, filter.EnvironmentId.Value);
}
if (filter.ApplicationId.HasValue)
{
dbFilter &= Filter
.EqOrNull(x => x.Key.ApplicationId, filter.ApplicationId.Value);
}
if (filter.PartId.HasValue)
{
dbFilter &= Filter
.EqOrNull(x => x.Key.PartId, filter.PartId.Value);
}
return(dbFilter);
}
public void ConstructorPreconditions()
{
var variable = new Variable <int>();
try
{
var t = new VariableValueFilter <int>(variable, new int[] {});
Assert.Fail("ArgumentOutOfRangeException Should be thrown");
}
catch (Exception e)
{
Assert.AreEqual(typeof(ArgumentOutOfRangeException), e.GetType());
Assert.AreEqual("Cannot be empty\r\nParameter name: values", e.Message);
}
try
{
var t = new VariableValueFilter <double>(variable, new[] { 1.1 });
Assert.Fail("ArgumentOutOfRangeException Should be thrown");
}
catch (Exception e)
{
Assert.AreEqual(typeof(ArgumentOutOfRangeException), e.GetType());
Assert.AreEqual("Invalid value type\r\nParameter name: values", e.Message);
}
}
public void Extrapolation()
{
var argument = new Variable <int>("x")
{
Values = { 0, 10, 20 }
};
argument.InterpolationType = InterpolationType.Constant;
argument.ExtrapolationType = ExtrapolationType.Constant;
var component = new Variable <int>("y")
{
Values = { 3, 4, 5 }
};
var component2 = new Variable <int>("yy")
{
Values = { 6, 7, 8 }
};
var function = new Function()
{
Arguments = { argument }, Components = { component, component2 }
};
var xFilter = new VariableValueFilter <int>(argument, 40);
var valueY = function.Components[0].Evaluate <int>(xFilter);
var valueYY = function.Components[1].Evaluate <int>(xFilter);
Assert.AreEqual(5, valueY);
Assert.AreEqual(8, valueYY);
}
private void ReplaceTimeFilter(DateTime time, IVariableFilter[] filters)
{
var timeFilter = (IVariableValueFilter)filters.FirstOrDefault(f => f is IVariableValueFilter && f.Variable == Time);
var timeFilterIndex = filters.ToList().IndexOf(timeFilter);
filters[timeFilterIndex] = new VariableValueFilter <DateTime>(Time, time);
}
public TimeArgumentNavigatable(VariableValueFilter<DateTime> filter)
{
if (filter == null)
{
throw new InvalidOperationException("Filter should not be null");
}
this.filter = filter;
filter.Variable.ValuesChanged += VariableValuesChanged;
}
public async Task <IEnumerable <VariableValue> > GetValuesAsync(
VariableValueFilter filter,
bool decrypt,
CancellationToken cancellationToken)
{
Variable variable =
await _variableStore.GetByIdAsync(filter.Id, cancellationToken);
return(await GetValuesAsync(variable, filter, decrypt, cancellationToken));
}
public TimeArgumentNavigatable(VariableValueFilter <DateTime> filter)
{
if (filter == null)
{
throw new InvalidOperationException("Filter should not be null");
}
this.filter = filter;
filter.Variable.ValuesChanged += VariableValuesChanged;
}
public async Task <IEnumerable <VariableValue> > GetByFilterAsync(
VariableValueFilter filter,
CancellationToken cancellationToken)
{
FilterDefinition <VariableValue> dbFilter = BuildFindKeyFilter(filter);
IAsyncCursor <VariableValue> cursor = await _dbContext.VariableValues.FindAsync(
dbFilter,
options : null,
cancellationToken);
return(await cursor.ToListAsync(cancellationToken));
}
public void Interpolation()
{
var argument = new Variable<int>("x") { Values = { 0, 10, 20 } };
argument.InterpolationType = InterpolationType.Constant;
var component = new Variable<int>("y") { Values = { 3, 4, 5 } };
var component2 = new Variable<int>("yy") { Values = { 6, 7, 8 } };
var function = new Function() { Arguments = { argument }, Components = { component, component2 } };
var xFilter = new VariableValueFilter<int>(argument, 15);
var valueY = function.Components[0].Evaluate<int>(xFilter);
var valueYY = function.Components[1].Evaluate<int>(xFilter);
Assert.AreEqual(4, valueY);
Assert.AreEqual(7, valueYY);
}
public void WriteSlicesUsingTimeFilterShouldBeTheSameAsUsingIndexFilter()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network
};
var locations = new[] { new NetworkLocation(network.Branches[0], 0.0),
new NetworkLocation(network.Branches[0], 100.0),
new NetworkLocation(network.Branches[1], 100.0) };
networkCoverage.SetLocations(locations);
networkCoverage.Locations.FixedSize = locations.Length;
var networkCoverage2 = new NetworkCoverage("test", true)
{
Network = network
};
networkCoverage2.SetLocations(locations);
networkCoverage2.Locations.FixedSize = locations.Length;
// set 1000 values using time filters in coverage 1 and 2
var startTime = new DateTime(2000, 1, 1);
for (int i = 0; i < 1000; i++)
{
IEnumerable <double> values = new[] { 1.0, 2.0, 3.0 }.Select(d => d * i);
DateTime currentTime = startTime.AddMinutes(i);
//set values for coverage 1 using value filter
networkCoverage.Time.AddValues(new[] { currentTime });
var timeValueFilter = new VariableValueFilter <DateTime>(networkCoverage.Time, currentTime);
networkCoverage.SetValues(values, timeValueFilter);
//set values for coverage 2 using index filter
networkCoverage2.Time.AddValues(new[] { currentTime });
var timeIndexFilter = new VariableIndexRangeFilter(networkCoverage2.Time, i);
networkCoverage2.SetValues(values, timeIndexFilter);
}
Assert.AreEqual(networkCoverage.Components[0].Values, networkCoverage2.Components[0].Values);
}
public async Task <IEnumerable <VariableValue> > GetValuesAsync(
Variable variable,
VariableValueFilter filter,
bool decrypt,
CancellationToken cancellationToken)
{
IEnumerable <VariableValue> values = await _variableValueStore.GetByFilterAsync(
filter,
cancellationToken);
if (variable.IsSecret && decrypt)
{
values = await values
.ToAsyncEnumerable()
.SelectAwait(async value => value with
{
Value = await _cryptoProvider.DecryptAsync(
value.Value,
value.Encryption !,
cancellationToken)
})
public void MultiRasterBandTest()
{
string fileName = rasterDataPath + "4band.tif";
var functionStore = new GdalFunctionStore {
Path = fileName
};
functionStore.Open();
var grid = (IRegularGridCoverage)functionStore.Functions.First(f => f is IRegularGridCoverage);
//RasterBands to Components should be one to one. Tif -> 4 bands (values per ARGB channel)
Assert.AreEqual(4, grid.Components.Count);
var xFilter = new VariableValueFilter <double>(grid.X, grid.X.Values[9]);
var yFilter = new VariableValueFilter <double>(grid.Y, grid.Y.Values[9]);
var c1 = grid.Components[0].GetValues(xFilter, yFilter)[0];
var c2 = grid.Components[1].GetValues(xFilter, yFilter)[0];
var c3 = grid.Components[2].GetValues(xFilter, yFilter)[0];
var c4 = grid.Components[3].GetValues(xFilter, yFilter)[0];
Assert.AreEqual(255, c1);
Assert.AreEqual(255, c2);
Assert.AreEqual(255, c3);
Assert.AreEqual(255, c4);
// F = (value)(x,y) components - arguments
/*
* F........ grid coverage is a vector function
* value.... grid contains n band variables (components)
* x........ grid contains 2 variables for x and y
* y
*/
Assert.AreEqual(functionStore.Functions.Count, 7,
"store should contain 1 function for grid coverage, variable for 1st grid component and variables for x and y arguments");
}
public void GetFilteredValuesFrom2DFunction()
{
var x = new Variable<int>();
var y = new Variable<int>();
var z = new Variable<double> { Arguments = { x, y } };
z[0, 0] = 1.0;
z[0, 1] = 2.0;
z[1, 0] = 3.0;
z[1, 1] = 4.0;
var xFilter = new VariableValueFilter<int>(x, 0);
var yFilter = new VariableValueFilter<int>(y, 1);
var values = z.GetValues(xFilter, yFilter);
values.Count
.Should("query values using 2 filters").Be.EqualTo(1);
values[0]
.Should("query values using 2 filters").Be.EqualTo(2.0);
}
public void WriteSlicesUsingTimeFilterShouldBeTheSameAsUsingIndexFilter()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
var locations = new[] { new NetworkLocation(network.Branches[0], 0.0),
new NetworkLocation(network.Branches[0], 100.0),
new NetworkLocation(network.Branches[1], 100.0) };
networkCoverage.SetLocations(locations);
networkCoverage.Locations.FixedSize = locations.Length;
var networkCoverage2 = new NetworkCoverage("test", true) { Network = network };
networkCoverage2.SetLocations(locations);
networkCoverage2.Locations.FixedSize = locations.Length;
// set 1000 values using time filters in coverage 1 and 2
var startTime = new DateTime(2000, 1, 1);
for (int i = 0; i < 1000;i++ )
{
IEnumerable<double> values = new[] { 1.0, 2.0, 3.0 }.Select(d => d * i);
DateTime currentTime = startTime.AddMinutes(i);
//set values for coverage 1 using value filter
networkCoverage.Time.AddValues(new[] { currentTime });
var timeValueFilter = new VariableValueFilter<DateTime>(networkCoverage.Time, currentTime);
networkCoverage.SetValues(values,timeValueFilter);
//set values for coverage 2 using index filter
networkCoverage2.Time.AddValues(new[] { currentTime });
var timeIndexFilter = new VariableIndexRangeFilter(networkCoverage2.Time, i);
networkCoverage2.SetValues(values, timeIndexFilter);
}
Assert.AreEqual(networkCoverage.Components[0].Values,networkCoverage2.Components[0].Values);
}
public void MultiRasterBandTest()
{
string fileName = rasterDataPath + "4band.tif";
var functionStore = new GdalFunctionStore {Path = fileName};
functionStore.Open();
var grid = (IRegularGridCoverage) functionStore.Functions.First(f => f is IRegularGridCoverage);
//RasterBands to Components should be one to one. Tif -> 4 bands (values per ARGB channel)
Assert.AreEqual(4, grid.Components.Count);
var xFilter = new VariableValueFilter<double>(grid.X, grid.X.Values[9]);
var yFilter = new VariableValueFilter<double>(grid.Y, grid.Y.Values[9]);
var c1 = grid.Components[0].GetValues(xFilter, yFilter)[0];
var c2 = grid.Components[1].GetValues(xFilter, yFilter)[0];
var c3 = grid.Components[2].GetValues(xFilter, yFilter)[0];
var c4 = grid.Components[3].GetValues(xFilter, yFilter)[0];
Assert.AreEqual(255, c1);
Assert.AreEqual(255, c2);
Assert.AreEqual(255, c3);
Assert.AreEqual(255, c4);
// F = (value)(x,y) components - arguments
/*
* F........ grid coverage is a vector function
* value.... grid contains n band variables (components)
* x........ grid contains 2 variables for x and y
* y
*/
Assert.AreEqual(functionStore.Functions.Count, 7,
"store should contain 1 function for grid coverage, variable for 1st grid component and variables for x and y arguments");
}
public void ConstructorPreconditions()
{
var variable = new Variable<int>();
try
{
var t = new VariableValueFilter<int>(variable, new int[] {});
Assert.Fail("ArgumentOutOfRangeException Should be thrown");
}
catch (Exception e)
{
Assert.AreEqual(typeof(ArgumentOutOfRangeException), e.GetType());
Assert.AreEqual("Cannot be empty\r\nParameter name: values", e.Message);
}
try
{
var t = new VariableValueFilter<double>(variable, new[] { 1.1 });
Assert.Fail("ArgumentOutOfRangeException Should be thrown");
}
catch (Exception e)
{
Assert.AreEqual(typeof(ArgumentOutOfRangeException), e.GetType());
Assert.AreEqual("Invalid value type\r\nParameter name: values", e.Message);
}
}
