private void FireStartPointSet(MapPointSet pointset)
{
if (PointSetModelStarted != null)
{
PointSetModelStarted(pointset);
}
}
private void FireEndPointSet(MapPointSet pointset)
{
if (PointSetModelCompleted != null)
{
PointSetModelCompleted(pointset);
}
}
private void FirePointSetProgressMessage(MapPointSet points, string message, double?percentComplete)
{
if (PointSetModelProgress != null)
{
PointSetModelProgress(points, message, percentComplete);
}
}
private void PlotPointSet(MapPointSet points)
{
var map = PluginManager.Instance.GetMap();
if (map != null)
{
map.Show();
map.PlotPoints(points);
}
}
void processor_PointSetModelStarted(MapPointSet obj)
{
lvwRichness.InvokeIfRequired(() => {
var vm = ViewModelForModel(obj);
if (vm != null)
{
vm.Status = "Running...";
}
});
}
public void PlotPoints(MapPointSet points)
{
if (_map != null && _map.IsVisible)
{
var mapControl = _map.Control as MapControl;
if (mapControl != null)
{
mapControl.PlotPoints(points);
}
}
}
void processor_PointSetModelCompleted(MapPointSet obj)
{
var vm = ViewModelForModel(obj);
if (vm != null)
{
lvwRichness.InvokeIfRequired(() => {
vm.Status = string.Format("Done.");
});
}
}
private SpeciesRichnessPointSetViewModel ViewModelForModel(MapPointSet model)
{
var viewmodels = lvwRichness.ItemsSource as ObservableCollection <SpeciesRichnessPointSetViewModel>;
if (viewmodels != null)
{
var selected = viewmodels.FirstOrDefault((m) => {
return(m.Name == model.Name);
});
return(selected);
}
return(null);
}
void processor_PointSetModelProgress(MapPointSet pointSet, string message, double?percent)
{
var vm = ViewModelForModel(pointSet);
if (vm != null)
{
lvwRichness.InvokeIfRequired(() => {
if (percent.HasValue)
{
vm.Status = string.Format("{0}%", (int)percent.Value);
}
else
{
vm.Status = string.Format("-");
}
});
}
}
void tvw_Drop(object sender, DragEventArgs e)
{
var pinnable = e.Data.GetData(PinnableObject.DRAG_FORMAT_NAME) as PinnableObject;
e.Effects = DragDropEffects.None;
if (pinnable != null)
{
var pointGenerator = PluginManager.Instance.FindAdaptorForPinnable <IMapPointSetGenerator>(pinnable);
if (pointGenerator != null)
{
using (new OverrideCursor(Cursors.Wait)) {
MapPointSet points = pointGenerator.GeneratePoints(false);
if (points != null)
{
AddPointSet(points);
}
}
}
}
}
private void AddPointSet(MapPointSet set)
{
var viewModel = new PointSetViewModel(set);
_model.Add(viewModel);
var killlist = new List <PointViewModel>();
foreach (MapPoint p in set)
{
var childVM = new PointViewModel(p);
childVM.Parent = viewModel;
viewModel.Children.Add(childVM);
if (p.Latitude == 0 && p.Longitude == 0)
{
killlist.Add(childVM);
}
}
foreach (PointViewModel p in killlist)
{
viewModel.RemovePoint(p);
}
}
public static Image GetSymbolForPointSet(MapPointSet set)
{
return GetSymbol(set.PointShape, set.Size, set.PointColor, set.DrawOutline, set.OutlineColor);
}
private void RemovePoint(PointViewModel point, MapPointSet set)
{
}
public void PlotPoints(MapPointSet points)
{
if (_map != null && _map.IsVisible) {
var mapControl = _map.Control as MapControl;
if (mapControl != null) {
mapControl.PlotPoints(points);
}
}
}
public GridLayer RunSpeciesRichness()
{
// First load each of the layers...
IsCancelled = false;
var layers = new List <GridLayer>();
foreach (string filename in LayerFiles)
{
ProgressMessage("Loading environmental layer {0}...", filename);
layers.Add(new GridLayer(filename));
}
// Now for each point set, run the model...
var resultLayers = new List <GridLayer>();
Model.ProgressObserver = this;
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running models...");
}
var first = layers[0];
int setIndex = 0;
foreach (SpeciesRichnessPointSetViewModel pointset in MapPointSets)
{
_currentPointSet = pointset.Model;
var percent = ((double)setIndex / (double)MapPointSets.Count()) * 100.0;
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running model on pointset " + pointset.Name, percent);
}
FireStartPointSet(pointset.Model);
var list = new List <MapPointSet>();
list.Add(pointset.Model);
var modelLayer = Model.RunModel(layers, list);
if (modelLayer != null)
{
if (RetainLayers)
{
pointset.Filename = string.Format("{0}{1}_{2}.grd", TempFileManager.GetTemporaryFolder(), SystemUtils.StripIllegalFilenameChars(pointset.Name), setIndex);
modelLayer.SaveToGRDFile(pointset.Filename);
}
resultLayers.Add(modelLayer);
}
if (IsCancelled)
{
return(null);
}
FireEndPointSet(pointset.Model);
setIndex++;
}
var target = new GridLayer(first.Width, first.Height)
{
DeltaLatitude = first.DeltaLatitude, DeltaLongitude = first.DeltaLongitude, Flags = first.Flags, Latitude0 = first.Latitude0, Longitude0 = first.Longitude0, NoValueMarker = 0
};
target.SetAllCells(0);
foreach (GridLayer result in resultLayers)
{
for (int y = 0; y < target.Height; ++y)
{
var lat = target.Latitude0 + (y * target.DeltaLatitude); // Work out Lat. of this cell.
for (int x = 0; x < target.Width; ++x)
{
var lon = target.Longitude0 + (x * target.DeltaLongitude); // Work out Long. of this cell.
var fVal = result.GetValueAt(lat, lon, result.NoValueMarker);
if (fVal == result.NoValueMarker)
{
target.SetCellValue(x, y, target.NoValueMarker);
}
else
{
if (fVal > CutOff)
{
var currentVal = target.GetCellValue(x, y);
target.SetCellValue(x, y, currentVal + 1);
}
}
}
}
}
return(target);
}
