private static ITheme CreateDefaultGradientTheme(string columnName, Tuple <double, double> tuple)
{
double minValue = tuple.value1;
double maxValue = tuple.value2;
string attribute = columnName;
int numberOfClasses = 10;
// use polygon for grids so style will be shown nicely in dialog
var defaultStyle = new VectorStyle {
GeometryType = typeof(IPolygon)
};
var blend = new ColorBlend(new Color[] { Color.Black, Color.White }, new float[] { 0, 1 });
int size = (int)defaultStyle.SymbolScale;
GradientTheme gradientTheme = ThemeFactory.CreateGradientTheme(attribute, defaultStyle,
blend,
(float)Convert.ChangeType(minValue, typeof(float)),
(float)Convert.ChangeType(maxValue, typeof(float)),
size,
size,
false,
false);
return(gradientTheme);
}
private void UpdateTheme()
{
// If there was no theme attached to the layer yet, generate a default theme
if (featureCoverage == null || featureCoverage.Features == null || featureCoverage.Features.Count == 0)
{
return;
}
Style.GeometryType = GetFeatureGeometryType(featureCoverage.Features[0] as IFeature);
// Values to base the theme on
//List<IVariableFilter> filters = new List<IVariableFilter>();
if (Coverage.Time != null)
{
if (CurrentTime == null && Coverage.Time.Values.Count != 0)
{
CurrentTime = Coverage.Time.Values[0];
}
//filters.Add(new VariableValueFilter(featureCoverage.Time, CurrentTime));
}
IMultiDimensionalArray <double> values = featureCoverage.GetValues <double>();
if (null == values)
{
return;
}
// NOTE: we're getting all values here!
var featureValues = new List <double>(values.Where(v => !double.IsNaN(v)));
if (0 == featureValues.Count)
{
log.Error("Unable to generate default theme; no values available");
return;
//throw new ArgumentException();
}
featureValues.Sort();
double minValue = featureValues.Min();
double maxValue = featureValues.Max();
if (minValue == maxValue)
{
// Only a single value, so no gradient theme needed/wanted: create a 'blue' single feature theme
Theme = ThemeFactory.CreateSingleFeatureTheme(Style.GeometryType, Color.Blue, 10);
}
else
{
// Create 'green to blue' gradient theme
Theme = ThemeFactory.CreateGradientTheme(Coverage.Components[0].Name, Style,
new ColorBlend(new Color[] { Color.Green, Color.Blue },
new float[] { 0f, 1f }),
(float)minValue, (float)maxValue, 1, 1, false, true);
}
}
public void LayersWithThemeGroupShareMinMax()
{
var table = new FeatureDataTable();
table.Columns.Add("Id", typeof(int));
table.Columns.Add("X", typeof(double));
table.Columns.Add("Y", typeof(double));
table.Columns.Add("Value", typeof(double));
AddRow(table, new object[] { 0, 5.0, 5.0, 0.0 });
AddRow(table, new object[] { 1, 10.0, 10.0, 10.0 });
var dataSource = new DataTablePoint(table, "Id", "X", "Y");
var table2 = new FeatureDataTable();
table2.Columns.Add("Id", typeof(int));
table2.Columns.Add("X", typeof(double));
table2.Columns.Add("Y", typeof(double));
table2.Columns.Add("Value", typeof(double));
AddRow(table2, new object[] { 0, 5.0, 2.0, 0.0 });
AddRow(table2, new object[] { 1, 10.0, 4.0, 10.0 });
AddRow(table2, new object[] { 2, 7.0, 10.0, 20.0 });
var dataSource2 = new DataTablePoint(table2, "Id", "X", "Y");
var basicTheme = ThemeFactory.CreateGradientTheme("Value", null, ColorBlend.Rainbow7, 0.0, 5.0, 3, 3, false, true, 3);
var layer = new VectorLayer {
AutoUpdateThemeOnDataSourceChanged = true, ThemeGroup = "group1", DataSource = dataSource, Theme = basicTheme
};
var layer2 = new VectorLayer {
AutoUpdateThemeOnDataSourceChanged = true, ThemeGroup = "group1", DataSource = dataSource2, Theme = basicTheme
};
var map = new Map();
map.Layers.Add(layer);
Assert.AreEqual(10.0, ((GradientTheme)layer.Theme).Max); // refresh on add
map.Layers.Add(layer2);
Assert.AreEqual(20.0, ((GradientTheme)layer.Theme).Max); // both to max of the group
Assert.AreEqual(20.0, ((GradientTheme)layer2.Theme).Max);
map.Layers.Remove(layer2);
Assert.AreEqual(10.0, ((GradientTheme)layer.Theme).Max); // refresh on remove
}
protected override void CreateDefaultTheme()
{
// If there was no theme attached to the layer yet, generate a default theme
if (Theme != null)
{
return;
}
//looks like min/max should suffice
var minMaxValue = GetMinMaxValue();
if (minMaxValue != null && minMaxValue.First != double.MaxValue && minMaxValue.Second != double.MaxValue)
{
const int numberOfClasses = 12;
Theme = ThemeFactory.CreateGradientTheme(Coverage.Components[0].Name, Style,
ColorBlend.Rainbow7,
(float)minMaxValue.First, (float)minMaxValue.Second,
12, 25, false, false, numberOfClasses);
}
AutoUpdateThemeOnDataSourceChanged = true;
}
protected static ITheme GenerateDefaultTheme(string name, IList noDataValues, object minValue, object maxValue)
{
double min = Convert.ToDouble(minValue);
double max = Convert.ToDouble(maxValue);
if (double.IsInfinity(min) || double.IsNaN(min))
{
log.Debug("Nan or infinity is invalid as minvalue for theme. Changed it to lowest possible value");
min = double.MinValue;
}
if (double.IsInfinity(max) || double.IsNaN(max))
{
log.Debug("Nan or infinity is invalid as maxvalue for theme. Changed it to highest possible value");
max = double.MaxValue;
}
var theme = ThemeFactory.CreateGradientTheme(name, null, Thematics.ColorBlend.GreenToBlue, min, max, 1, 1, false, true);
theme.NoDataValues = noDataValues;
return(theme);
}
public void ClonePerformanceTest()
{
var table = new FeatureDataTable();
table.Columns.Add("Id", typeof(int));
table.Columns.Add("X", typeof(double));
table.Columns.Add("Y", typeof(double));
table.Columns.Add("Value", typeof(double));
AddRow(table, new object[] { 0, 5.0, 5.0, 0.0 });
AddRow(table, new object[] { 1, 10.0, 10.0, 10.0 });
var dataSource = new DataTablePoint(table, "Id", "X", "Y");
var basicTheme = ThemeFactory.CreateGradientTheme("Value", null, ColorBlend.Rainbow7, 0.0, 5.0, 3, 3, false, true, 8);
var layer = new VectorLayer
{
AutoUpdateThemeOnDataSourceChanged = true,
Theme = basicTheme,
DataSource = dataSource
};
TestHelper.AssertIsFasterThan(230, () => layer.Clone());
}
protected override void CreateDefaultTheme()
{
// If there was no theme attached to the layer yet, generate a default theme
if (Theme != null)
{
return;
}
//looks like min/max should suffice
var minMaxValue = GetMinMaxValue();
if (minMaxValue != null)
{
var attributeName = ((INetworkCoverage)Coverage).SegmentGenerationMethod == SegmentGenerationMethod.SegmentPerLocation
? Coverage.Components[0].Name
: "Chainage";
Theme = ThemeFactory.CreateGradientTheme(attributeName, Style, ColorBlend.Rainbow7,
(float)minMaxValue.First, (float)minMaxValue.Second,
10, 25, false, false, 12);
}
AutoUpdateThemeOnDataSourceChanged = true;
}
public void GradientThemeScaleToWithColorBlends()
{
var blend = new ColorBlend(new[] { Color.Black, Color.White }, new[] { 0f, 1f });
var theme = ThemeFactory.CreateGradientTheme("", null, blend, 0.0, 5.0, 3, 3, false, true, 3);
AssertColor(Color.Black, theme.GetFillColor(-1.0));
AssertColor(Color.Black, theme.GetFillColor(0.0));
AssertColor(Color.FromArgb(255, 64, 64, 64), theme.GetFillColor(1.25));
AssertColor(Color.FromArgb(255, 128, 128, 128), theme.GetFillColor(2.5));
AssertColor(Color.FromArgb(255, 191, 191, 191), theme.GetFillColor(3.75));
AssertColor(Color.White, theme.GetFillColor(5.0));
AssertColor(Color.White, theme.GetFillColor(6.0));
theme.ScaleTo(-2.0, 1.0);
AssertColor(Color.Black, theme.GetFillColor(-3.0));
AssertColor(Color.Black, theme.GetFillColor(-2.0));
AssertColor(Color.FromArgb(255, 64, 64, 64), theme.GetFillColor(-1.25));
AssertColor(Color.FromArgb(255, 128, 128, 128), theme.GetFillColor(-0.5));
AssertColor(Color.FromArgb(255, 191, 191, 191), theme.GetFillColor(0.25));
AssertColor(Color.White, theme.GetFillColor(1.0));
AssertColor(Color.White, theme.GetFillColor(2.0));
}
private void UpdateTheme()
{
// If there was no theme attached to the layer yet, generate a default theme
if (featureCoverage == null || featureCoverage.Features == null || featureCoverage.Features.Count == 0)
{
return;
}
Style.GeometryType = GetFeatureGeometryType(featureCoverage.Features[0]);
// Values to base the theme on
if (Coverage.Time != null)
{
if (CurrentTime == null && Coverage.Time.Values.Count != 0)
{
CurrentTime = Coverage.Time.Values[0];
}
}
IMultiDimensionalArray <double> values = featureCoverage.GetValues <double>();
if (null == values)
{
return;
}
// NOTE: we're getting all values here!
var featureValues = new List <double>(values.Where(v => !double.IsNaN(v) && !double.IsInfinity(v)));
if (0 == featureValues.Count)
{
Log.Error("Unable to generate default theme; no values available");
return;
}
featureValues.Sort();
double minValue = featureValues.Min();
double maxValue = featureValues.Max();
if (base.Theme == null)
{
// Create default Theme
if (minValue == maxValue)
{
// Only a single value, so no gradient theme needed/wanted: create a 'blue' single feature theme
Theme = ThemeFactory.CreateSingleFeatureTheme(Style.GeometryType, Color.Blue, 10);
}
else
{
// Create 'green to blue' gradient theme
Theme = ThemeFactory.CreateGradientTheme(Coverage.Components[0].Name, Style,
new ColorBlend(new[] { Color.Green, Color.Blue },
new[] { 0f, 1f }),
(float)minValue, (float)maxValue, 1, 1, false, true);
}
}
else
{
if (AutoUpdateThemeOnDataSourceChanged)
{
Theme.ScaleTo(minValue, maxValue);
}
}
}
private void CreateDefaultTheme()
{
// If there was no theme attached to the layer yet, generate a default theme
if (Theme != null || networkCoverage == null || networkCoverage.Locations == null)
{
return;
}
//looks like min/max should suffice
IList <double> values = GetAllValues();
if (null == values)
{
return;
}
var minValue = networkCoverage.DefaultValue; // ???
var maxValue = minValue;
// NOTE: we should be getting al the values here!
var featureValues = new List <double>(values);
if (0 != featureValues.Count)
{
featureValues.Sort();
minValue = featureValues[0];
maxValue = featureValues[featureValues.Count - 1];
}
if (minValue == maxValue)
{
// Only a single value, so no gradient theme needed/wanted: create a 'blue' single feature theme
if (networkCoverage.SegmentGenerationMethod != SegmentGenerationMethod.None)
{
SegmentLayer.Theme = ThemeFactory.CreateSingleFeatureTheme(SegmentLayer.Style.GeometryType,
Color.PaleTurquoise, 6);
}
LocationLayer.Theme = ThemeFactory.CreateSingleFeatureTheme(LocationLayer.Style.GeometryType, Color.Blue, 10);
}
else
{
int numberOfClasses = 12;
if (networkCoverage.SegmentGenerationMethod != SegmentGenerationMethod.None)
{
// Create flashy gradient theme
if (NetworkCoverage.SegmentGenerationMethod == SegmentGenerationMethod.SegmentPerLocation)
{
SegmentLayer.Theme = ThemeFactory.CreateGradientTheme(Coverage.Components[0].Name, SegmentLayer.Style,
ColorBlend.Rainbow7,
(float)minValue, (float)maxValue,
10, 25, false,
false, numberOfClasses);
}
else
{
SegmentLayer.Theme = ThemeFactory.CreateGradientTheme("Offset", SegmentLayer.Style,
ColorBlend.Rainbow7,
(float)minValue, (float)maxValue,
10, 25, false,
false, numberOfClasses);
}
}
LocationLayer.Theme = ThemeFactory.CreateGradientTheme(Coverage.Components[0].Name, LocationLayer.Style,
ColorBlend.Rainbow7,
(float)minValue, (float)maxValue,
12, 25, false, false, numberOfClasses);
}
}
public void GradientThemeRescaledAsExpected()
{
var featureCoverage = new FeatureCoverage();
featureCoverage.Arguments.Add(new Variable <IFeature>());
featureCoverage.Components.Add(new Variable <double>());
var branches = CreateNBranchesNetwork(5);
featureCoverage.Features = new EventedList <IFeature>(branches);
double variableValue = 0.0;
var expectedColors = new Dictionary <IFeature, Color>(5);
double minvalue = 1.0;
double maxvalue = 3.0;
foreach (var branch in branches)
{
featureCoverage[branch] = variableValue;
int grayscaleValue = variableValue <= minvalue
? 0
: variableValue >= maxvalue
? 255
: Convert.ToInt32(255 * (variableValue - minvalue) / (maxvalue - minvalue));
expectedColors[branch] = Color.FromArgb(255, grayscaleValue, grayscaleValue, grayscaleValue);
variableValue += 1;
}
var theme = ThemeFactory.CreateGradientTheme("", null, new ColorBlend(new[] { Color.Black, Color.White },
new[] { 0f, 1f }), minvalue, maxvalue, 3, 3, false, true,
3);
var fcLayer = new FeatureCoverageLayer
{
AutoUpdateThemeOnDataSourceChanged = false,
Coverage = featureCoverage,
Theme = theme
};
foreach (var branch in branches)
{
AssertColor(expectedColors[branch], fcLayer.Theme.GetFillColor((double)featureCoverage[branch]));
}
fcLayer.Theme.ScaleTo(0.0, 2.0);
var min = ((GradientTheme)fcLayer.Theme).Min;
var max = ((GradientTheme)fcLayer.Theme).Max;
Assert.AreEqual(0.0, min);
Assert.AreEqual(2.0, max);
foreach (var branch in branches)
{
variableValue = (double)featureCoverage[branch];
int greyScaleValue = variableValue <= min
? 0
: variableValue >= max
? 255
: Convert.ToInt32(255 * (variableValue - min) / (max - min));
AssertColor(Color.FromArgb(255, greyScaleValue, greyScaleValue, greyScaleValue), fcLayer.Theme.GetFillColor(variableValue));
}
}
