public static void RefreshAfterClone(IFeatureCoverage featureCoverage,
IEnumerable <IFeature> featuresSuperSetBefore,
IEnumerable <IFeature> featuresSuperSetAfter)
{
var featuresBefore = featuresSuperSetBefore.ToList();
var featuresAfter = featuresSuperSetAfter.ToList();
if (featuresBefore.Count != featuresAfter.Count)
{
throw new ArgumentException("Non matching feature count before / after");
}
ObjectHelper.RefreshItemsInList(featureCoverage.Features, featuresBefore, featuresAfter);
var featuresMDA = featureCoverage.FeatureVariable.Values;
var wasStored = featuresMDA.IsAutoSorted;
var wasReadOnly = featuresMDA.IsReadOnly;
featuresMDA.IsAutoSorted = false;
featuresMDA.IsReadOnly = false; //we just do a replace, so ignore read-only is safe (right?)
try
{
ObjectHelper.RefreshItemsInList(featuresMDA, featuresBefore, featuresAfter);
}
finally
{
featuresMDA.IsAutoSorted = wasStored;
featuresMDA.IsReadOnly = wasReadOnly;
}
}
public void FilterCoverage()
{
IList <SimpleFeature> features = new List <SimpleFeature>();
features.Add(new SimpleFeature(0, new Point(0, 0)));
features.Add(new SimpleFeature(1, new Point(1, 1)));
features.Add(new SimpleFeature(2, new Point(2, 2)));
FeatureCoverage coverage = new FeatureCoverage();
coverage.Components.Add(new Variable <double>("value"));
IVariable timeVariable = new Variable <DateTime>("time");
coverage.Arguments.Add(timeVariable);
coverage.Arguments.Add(new Variable <SimpleFeature>("feature"));
coverage.Features = new EventedList <IFeature>(features.Cast <IFeature>());
// set values of feature a variable
coverage.FeatureVariable.SetValues(features);
DateTime time1 = DateTime.Now;
coverage[time1] = new double[] { 1.0, 2.0, 3.0 };
DateTime time2 = time1.AddDays(1);
coverage[time2] = new[] { 10.0, 20.0, 30.0 };
Assert.AreEqual(6, coverage.Components[0].Values.Count);
//filter the created coverage
IFeatureCoverage filteredCoverage = coverage.FilterAsFeatureCoverage(new VariableValueFilter <DateTime>(timeVariable, time2));
//should not change the original!
Assert.AreEqual(6, coverage.Components[0].Values.Count);
Assert.AreEqual(coverage.Features.Count, filteredCoverage.Features.Count);
Assert.AreEqual(3, filteredCoverage.Components[0].Values.Count);
}
/// <summary>
/// Renders all features on the currently visible part of the map, using the values from the feature coverage.
/// </summary>
/// <param name="feature">The coverage to render.</param>
/// <param name="g">Graphics object to be used as a target for rendering.</param>
/// <param name="layer">Layer where coverage belongs to.</param>
/// <returns>When rendering succeds returns true, otherwise false.</returns>
public bool Render(IFeature feature, Graphics g, ILayer layer)
{
// Use the FeatureCoverage function to get the coverage values
var coverageLayer = (FeatureCoverageLayer)layer;
IFeatureCoverage coverage = coverageLayer.FeatureCoverage;
Map map = coverageLayer.Map;
// No theme? No rendering! (This should be set in the FeatureCoverageLayer class' set_Features.)
if (coverageLayer.Theme == null)
{
return(false);
}
// What features to render?
IList featuresToRender;
IFeature[] coverageFeatures;
double[] values;
lock (coverage.Store) // makes sure that features don't change before we get values
{
featuresToRender = coverageLayer.DataSource.GetFeatures(map.Envelope).Cast <IFeature>().ToArray();
if (featuresToRender.Count <= 0)
{
// No features in the envelope, so no rendering required.
return(true);
}
coverageFeatures = coverage.FeatureVariable.Values.Cast <IFeature>().ToArray();
values = coverage.Components[0].Values.Cast <double>().ToArray();
}
for (var i = 0; i < coverageFeatures.Length; i++)
{
var featureToRender = coverageFeatures[i];
if (!featuresToRender.Contains(featureToRender))
{
continue;
}
// Use the GetStyle with the retrieved value
var style = coverageLayer.Theme.GetStyle(values[i]) as VectorStyle;
if (style != null)
{
// Draw background of all line-outlines first
if (feature.Geometry is ILineString)
{
if (style.Enabled && style.EnableOutline)
{
VectorRenderingHelper.DrawLineString(g, featureToRender.Geometry as ILineString, style.Outline, map);
}
}
else if (feature.Geometry is IMultiLineString)
{
if (style.Enabled && style.EnableOutline)
{
VectorRenderingHelper.DrawMultiLineString(g, featureToRender.Geometry as IMultiLineString,
style.Outline, map);
}
}
// Draw actual geometry
VectorRenderingHelper.RenderGeometry(g, map, featureToRender.Geometry, style, VectorLayer.DefaultPointSymbol,
coverageLayer.ClippingEnabled);
}
else
{
throw new ArgumentException("No style could be gotten from the theme; the feature cannot be rendered.");
}
}
return(true);
}
