/// <summary>
/// Calculates the number of grid cells that will be generated.
/// If no bounding box is specified in gridSpecification,
/// the sweden extent will be used.
/// </summary>
/// <param name="gridSpecification">The grid specification.</param>
/// <returns>The number of grid cells that will be generated.</returns>
public long CalculateNumberOfGridCells(GridSpecification gridSpecification)
{
if (gridSpecification.GridCellSize <= 0)
{
throw new ArgumentException("GridCellSize must be greater than 0.");
}
IBoundingBox boundingBox = gridSpecification.BoundingBox;
if (boundingBox == null)
{
boundingBox = SwedenExtentManager.GetSwedenExtentBoundingBox(gridSpecification.GridCoordinateSystem.ToCoordinateSystem());
}
double xMin, yMin, xMax, yMax;
int cellSize = gridSpecification.GridCellSize;
xMin = Math.Floor(boundingBox.Min.X / cellSize) * cellSize;
xMax = Math.Ceiling(boundingBox.Max.X / cellSize) * cellSize;
yMin = Math.Floor(boundingBox.Min.Y / cellSize) * cellSize;
yMax = Math.Ceiling(boundingBox.Max.Y / cellSize) * cellSize;
long count = (long)(((xMax - xMin) / cellSize) * ((yMax - yMin) / cellSize));
return(count);
}
public IList <IGridCellSpeciesObservationCount> GetSpeciesObservationGridCellResultFromWebService(IUserContext userContext, MySettings mySettings)
{
var speciesObservationSearchCriteriaManager = new SpeciesObservationSearchCriteriaManager(userContext);
SpeciesObservationSearchCriteria searchCriteria = speciesObservationSearchCriteriaManager.CreateSearchCriteria(mySettings);
ICoordinateSystem coordinateSystem = new CoordinateSystem();
coordinateSystem.Id = CoordinateSystemId.GoogleMercator;
GridStatisticsSetting gridStatisticsSetting = mySettings.Calculation.GridStatistics;
IGridSpecification gridSpecification = new GridSpecification();
if (gridStatisticsSetting.CoordinateSystemId.HasValue)
{
gridSpecification.GridCoordinateSystem = (GridCoordinateSystem)gridStatisticsSetting.CoordinateSystemId;
}
else
{
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM;
}
if (gridStatisticsSetting.GridSize.HasValue)
{
gridSpecification.GridCellSize = gridStatisticsSetting.GridSize.Value;
gridSpecification.IsGridCellSizeSpecified = true;
}
IList <IGridCellSpeciesObservationCount> gridCellObservations = CoreData.AnalysisManager.GetGridSpeciesObservationCounts(userContext, searchCriteria, gridSpecification, coordinateSystem);
// Add result to cache
return(gridCellObservations);
}
/// <summary>
/// Calculates the combined grid result.
/// </summary>
/// <param name="calculationCoordinateSystemId">The calculation coordinate system id.</param>
/// <param name="gridCellSize">Size of the grid cell.</param>
/// <param name="wfsLayerId">The WFS layer id.</param>
/// <returns>Combined grid cell statistics.</returns>
public CombinedGridStatisticsResult CalculateCombinedGridResult(int calculationCoordinateSystemId, int gridCellSize, int wfsLayerId)
{
GridSpecification gridSpecification = new GridSpecification();
CoordinateSystem displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem;
gridSpecification.GridCoordinateSystem = (GridCoordinateSystem)calculationCoordinateSystemId;
gridSpecification.GridCellSize = gridCellSize;
gridSpecification.IsGridCellSizeSpecified = true;
gridSpecification.GridCellGeometryType = GridCellGeometryType.Polygon;
if (MySettings.Filter.Spatial.IsActive)
{
// Create bounding box from spatial filter
ObservableCollection <DataPolygon> polygons = MySettings.Filter.Spatial.Polygons;
if (polygons.Count > 0)
{
BoundingBox boundingBox = polygons.GetBoundingBox();
CoordinateSystem toCoordinateSystem = CoordinateSystemHelper.GetCoordinateSystemFromGridCoordinateSystem(gridSpecification.GridCoordinateSystem);
IPolygon convertedBoundingBoxPolygon = GisTools.CoordinateConversionManager.GetConvertedBoundingBox(boundingBox, MySettings.Filter.Spatial.PolygonsCoordinateSystem, toCoordinateSystem);
BoundingBox convertedBoundingBox = convertedBoundingBoxPolygon.GetBoundingBox();
gridSpecification.BoundingBox = convertedBoundingBox;
}
}
WfsLayerSetting wfsLayer = SessionHandler.MySettings.DataProvider.MapLayers.WfsLayers.FirstOrDefault(l => l.Id == wfsLayerId);
string featuresUrl = "";
string featureCollectionJson = null;
if (wfsLayer.IsFile)
{
featureCollectionJson = JObject.FromObject(MySettingsManager.GetMapDataFeatureCollection(UserContext, wfsLayer.GeometryName, gridSpecification.GridCoordinateSystem.GetCoordinateSystemId())).ToString();
}
else
{
if (string.IsNullOrEmpty(wfsLayer.Filter))
{
featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}",
wfsLayer.ServerUrl, wfsLayer.TypeName);
}
else
{
featuresUrl =
string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&filter={2}",
wfsLayer.ServerUrl, wfsLayer.TypeName, wfsLayer.Filter);
}
}
var speciesObservationSearchCriteriaManager = new SpeciesObservationSearchCriteriaManager(UserContext);
SpeciesObservationSearchCriteria searchCriteria = speciesObservationSearchCriteriaManager.CreateSearchCriteria(MySettings);
IList <IGridCellCombinedStatistics> gridCells = CoreData.AnalysisManager.GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(UserContext, gridSpecification, searchCriteria, null, featuresUrl, featureCollectionJson, displayCoordinateSystem);
if (MySettings.Calculation.GridStatistics.GenerateAllGridCells)
{
gridCells = AddEmptyGridCells(gridCells, gridSpecification, displayCoordinateSystem);
gridCells = RemoveGridCellsOutsideBounds(gridCells, gridSpecification);
}
gridCells = gridCells.OrderBy(x => x.Identifier).ToList();
return(CombinedGridStatisticsResult.Create(
(CoordinateSystemId)calculationCoordinateSystemId, displayCoordinateSystem.Id, gridCellSize, gridCells));
}
public void CalculateNumberOfGridCells_GridCellSizeIsZero_ArgumentExceptionIsThrown()
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = 0;
GridCellManager gridCellManager = new GridCellManager();
gridCellManager.CalculateNumberOfGridCells(gridSpecification);
}
public void GenerateGrid_GridCellSizeIsZero_ArgumentExceptionIsThrown()
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = 0;
GridCellManager gridCellManager = new GridCellManager();
gridCellManager.GenerateGrid(gridSpecification, new CoordinateSystem(CoordinateSystemId.GoogleMercator));
}
/// <summary>
/// Generates grid cells according to the gridSpecification.
/// </summary>
/// <param name="gridSpecification">The grid specification.</param>
/// <param name="displayCoordinateSystem">The display coordinate system.</param>
/// <returns>A list of grid cells according to the grid specification.</returns>
public List <GridCellBase> GenerateGrid(GridSpecification gridSpecification, ICoordinateSystem displayCoordinateSystem)
{
if (gridSpecification.GridCellSize <= 0)
{
throw new ArgumentException("GridCellSize must be greater than 0.");
}
List <GridCellBase> gridCells = new List <GridCellBase>();
IBoundingBox boundingBox = gridSpecification.BoundingBox;
if (boundingBox == null)
{
boundingBox = SwedenExtentManager.GetSwedenExtentBoundingBox(gridSpecification.GridCoordinateSystem.ToCoordinateSystem());
}
double xMin, yMin, xMax, yMax;
int cellSize;
cellSize = gridSpecification.GridCellSize;
xMin = Math.Floor(boundingBox.Min.X / cellSize) * cellSize;
xMax = Math.Ceiling(boundingBox.Max.X / cellSize) * cellSize;
yMin = Math.Floor(boundingBox.Min.Y / cellSize) * cellSize;
yMax = Math.Ceiling(boundingBox.Max.Y / cellSize) * cellSize;
ICoordinateSystem fromCoordinateSystem = gridSpecification.GridCoordinateSystem.ToCoordinateSystem();
ICoordinateSystem toCoordinateSystem = displayCoordinateSystem;
// The last grid cell may exceed the boundary box.
while (xMin < xMax)
{
// The last grid cell may exceed the boundary box.
while (yMin < yMax)
{
GridCellBase gridCell = new GridCellBase();
gridCell.GridCoordinateSystem = gridSpecification.GridCoordinateSystem;
gridCell.GridCellSize = gridSpecification.GridCellSize;
gridCell.OrginalGridCellBoundingBox = new BoundingBox();
gridCell.OrginalGridCellBoundingBox.Min = new Point(xMin, yMin);
gridCell.OrginalGridCellBoundingBox.Max = new Point(xMin + cellSize, yMin + cellSize);
gridCell.OrginalGridCellCentreCoordinate = new Point(Math.Floor(xMin / cellSize) * cellSize + cellSize * 0.5, Math.Floor(yMin / cellSize) * cellSize + cellSize * 0.5);
gridCell.GridCellBoundingBox = GisTools.CoordinateConversionManager.GetConvertedBoundingBox(gridCell.OrginalGridCellBoundingBox, fromCoordinateSystem, toCoordinateSystem);
gridCell.CoordinateSystem = displayCoordinateSystem;
gridCell.GridCellCentreCoordinate = GisTools.CoordinateConversionManager.GetConvertedPoint(gridCell.OrginalGridCellCentreCoordinate, fromCoordinateSystem, toCoordinateSystem);
gridCells.Add(gridCell);
yMin = yMin + cellSize;
}
xMin = xMin + cellSize;
yMin = Math.Floor(boundingBox.Min.Y / cellSize) * cellSize;
}
return(gridCells);
}
/// <summary>
/// Calculates the species observation grid.
/// </summary>
/// <param name="taxonIds">The taxon ids.</param>
/// <param name="gridCoordinateSystem">The grid coordinate system.</param>
/// <returns>List of grid cells data.</returns>
public IList <IGridCellSpeciesObservationCount> CalculateSpeciesObservationGrid(List <int> taxonIds, GridCoordinateSystem?gridCoordinateSystem)
{
var speciesObservationSearchCriteriaManager = new SpeciesObservationSearchCriteriaManager(UserContext);
SpeciesObservationSearchCriteria searchCriteria = speciesObservationSearchCriteriaManager.CreateSearchCriteria(MySettings);
searchCriteria.TaxonIds = taxonIds;
CoordinateSystem displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem;
//CoordinateSystem displayCoordinateSystem = new CoordinateSystem(MapSettings.CoordinateSystemId); // todo - såhär borde det se ut
GridStatisticsSetting gridStatisticsSetting = MySettings.Calculation.GridStatistics;
GridSpecification gridSpecification = new GridSpecification();
if (gridCoordinateSystem.HasValue)
{
gridSpecification.GridCoordinateSystem = gridCoordinateSystem.Value;
}
else
{
if (gridStatisticsSetting.CoordinateSystemId.HasValue)
{
gridSpecification.GridCoordinateSystem = (GridCoordinateSystem)gridStatisticsSetting.CoordinateSystemId;
}
else
{
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM;
}
}
if (gridStatisticsSetting.GridSize.HasValue)
{
gridSpecification.GridCellSize = gridStatisticsSetting.GridSize.Value;
gridSpecification.IsGridCellSizeSpecified = true;
}
gridSpecification.GridCellGeometryType = GridCellGeometryType.Polygon;
// todo - implement check that the number of possible grid cells aren't too large.
// todo - perhaps this check should be in the service
////long numberOfGridCellsThatWillBeGenerated = GisTools.GridCellManager.CalculateNumberOfGridCells(gridSpecification, searchCriteria.Polygons, searchCriteria.RegionGuids);
////if (numberOfGridCellsThatWillBeGenerated > MAX_NUMBER_OF_GRID_CELLS)
////{
//// throw new ArgumentException(string.Format("The cell size is too small, which would have resulted in possibly {0} grid cells. The limit lies at {1}.", numberOfGridCellsThatWillBeGenerated, MAX_NUMBER_OF_GRID_CELLS));
////}
var gridCellObservations = CoreData.AnalysisManager.GetGridSpeciesObservationCounts(UserContext, searchCriteria, gridSpecification, displayCoordinateSystem);
if (MySettings.Calculation.GridStatistics.GenerateAllGridCells)
{
gridCellObservations = AddEmptyGridCells(gridCellObservations, gridSpecification, displayCoordinateSystem);
gridCellObservations = RemoveGridCellsOutsideBounds(gridCellObservations, gridSpecification);
}
gridCellObservations = gridCellObservations.OrderBy(x => x.Identifier).ToList();
return(gridCellObservations);
}
public void CalculateNumberOfGridCells_BoundingBoxIsNotSpecified_SwedenExtentIsUsedAsBoundingBox()
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = 10000;
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM;
GridCellManager gridCellManager = new GridCellManager();
long calculatedNumberOfGridCells = gridCellManager.CalculateNumberOfGridCells(gridSpecification);
gridSpecification.BoundingBox = SwedenExtentManager.GetSwedenExtentBoundingBox(new CoordinateSystem(CoordinateSystemId.SWEREF99_TM));
long calculatedNumberOfGridCellsWithBbox = gridCellManager.CalculateNumberOfGridCells(gridSpecification);
Assert.AreEqual(calculatedNumberOfGridCellsWithBbox, calculatedNumberOfGridCells);
}
public WfsStatisticsGridResult CalculateGridResult(IUserContext userContext, int coordinateSystemId, int gridSize, int wfsLayerId)
{
var requestedGridCoordinateSystem = (GridCoordinateSystem)coordinateSystemId;
var gridSpecification = new GridSpecification
{
GridCoordinateSystem = requestedGridCoordinateSystem,
GridCellSize = gridSize,
IsGridCellSizeSpecified = true,
GridCellGeometryType = GridCellGeometryType.Polygon
};
if (MySettings.Filter.Spatial.IsActive)
{
// Create bounding box from spatial filter
var polygons = MySettings.Filter.Spatial.Polygons;
if (polygons.Count > 0)
{
var boundingBox = polygons.GetBoundingBox();
var toCoordinateSystem = CoordinateSystemHelper.GetCoordinateSystemFromGridCoordinateSystem(gridSpecification.GridCoordinateSystem);
var convertedBoundingBoxPolygon = GisTools.CoordinateConversionManager.GetConvertedBoundingBox(boundingBox, MySettings.Filter.Spatial.PolygonsCoordinateSystem, toCoordinateSystem);
gridSpecification.BoundingBox = convertedBoundingBoxPolygon.GetBoundingBox();
}
}
var displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem;
var wfsLayer = SessionHandler.MySettings.DataProvider.MapLayers.WfsLayers.FirstOrDefault(l => l.Id == wfsLayerId);
string featuresUrl = null;
string featureCollectionJson = null;
if (wfsLayer.IsFile)
{
featureCollectionJson = JObject.FromObject(MySettingsManager.GetMapDataFeatureCollection(userContext, wfsLayer.GeometryName, requestedGridCoordinateSystem.GetCoordinateSystemId())).ToString();
}
else
{
if (string.IsNullOrEmpty(wfsLayer.Filter))
{
featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}", wfsLayer.ServerUrl, wfsLayer.TypeName);
}
else
{
featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&filter={2}", wfsLayer.ServerUrl, wfsLayer.TypeName, wfsLayer.Filter);
}
}
var list = CoreData.AnalysisManager.GetGridFeatureStatistics(UserContext, null, featuresUrl, featureCollectionJson, gridSpecification, displayCoordinateSystem);
return(WfsStatisticsGridResult.Create(list));
}
public void GenerateGridCellsAndCalculateNumberOfGridCells_SwedenExtent_GridCellsCountAndCalculatedNumberOfGridCellsShouldBeEqual()
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = 10000;
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM;
gridSpecification.BoundingBox = SwedenExtentManager.GetSwedenExtentBoundingBox(new CoordinateSystem(CoordinateSystemId.SWEREF99_TM));
CoordinateSystem displayCoordinateSystem = new CoordinateSystem(CoordinateSystemId.GoogleMercator);
GridCellManager gridCellManager = new GridCellManager();
List <GridCellBase> gridCells = gridCellManager.GenerateGrid(gridSpecification, displayCoordinateSystem);
long calculatedNumberOfGridCells = gridCellManager.CalculateNumberOfGridCells(gridSpecification);
Assert.AreEqual(gridCells.Count, calculatedNumberOfGridCells);
}
private List <GridCellBase> CreateGridCells(int gridCellSize, BoundingBox boundingBox, GridCoordinateSystem gridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM, CoordinateSystemId displayCoordinateSystemId = CoordinateSystemId.GoogleMercator)
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = gridCellSize;
gridSpecification.GridCoordinateSystem = gridCoordinateSystem;
gridSpecification.BoundingBox = boundingBox;
CoordinateSystem displayCoordinateSystem = new CoordinateSystem(displayCoordinateSystemId);
GridCellManager gridCellManager = new GridCellManager();
List <GridCellBase> gridCells = gridCellManager.GenerateGrid(gridSpecification, displayCoordinateSystem);
long calculatedNumberOfGridCells = gridCellManager.CalculateNumberOfGridCells(gridSpecification);
Assert.AreEqual(gridCells.Count, calculatedNumberOfGridCells);
return(gridCells);
}
public void GenerateGridCellsAndCalculateNumberOfGridCells_CustomBoundingBox_GridCellsCountAndCalculatedNumberOfGridCellsShouldBeEqual()
{
GridSpecification gridSpecification = new GridSpecification();
gridSpecification.GridCellSize = 25000;
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.GoogleMercator;
gridSpecification.BoundingBox = new BoundingBox();
gridSpecification.BoundingBox.Min = new Point(0, 0);
gridSpecification.BoundingBox.Max = new Point(100000, 50000);
CoordinateSystem displayCoordinateSystem = new CoordinateSystem(CoordinateSystemId.GoogleMercator);
GridCellManager gridCellManager = new GridCellManager();
List <GridCellBase> gridCells = gridCellManager.GenerateGrid(gridSpecification, displayCoordinateSystem);
long calculatedNumberOfGridCells = gridCellManager.CalculateNumberOfGridCells(gridSpecification);
Assert.AreEqual(gridCells.Count, calculatedNumberOfGridCells);
}
/// <summary>
/// Calculates the species observation grid.
/// </summary>
/// <param name="taxonIds">The taxon ids.</param>
/// <param name="gridCoordinateSystem">The grid coordinate system.</param>
/// <param name="bottom"></param>
/// <param name="left"></param>
/// <param name="right"></param>
/// <param name="top"></param>
/// <param name="zoom"></param>
/// <param name="gridSize"></param>
/// <returns>List of grid cells data.</returns>
public IList <IGridCellSpeciesObservationCount> CalculateSpeciesObservationGrid(List <int> taxonIds, GridCoordinateSystem?gridCoordinateSystem, double bottom, double left, double right, double top, int zoom, int?gridSize)
{
var speciesObservationSearchCriteriaManager = new SpeciesObservationSearchCriteriaManager(UserContext);
SpeciesObservationSearchCriteria searchCriteria = speciesObservationSearchCriteriaManager.CreateSearchCriteria(MySettings);
// remove spatial filter?
searchCriteria.Polygons = null;
searchCriteria.RegionGuids = null;
searchCriteria.TaxonIds = taxonIds;
CoordinateSystem displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem;
GridStatisticsSetting gridStatisticsSetting = MySettings.Calculation.GridStatistics;
GridSpecification gridSpecification = new GridSpecification();
if (gridCoordinateSystem.HasValue)
{
gridSpecification.GridCoordinateSystem = gridCoordinateSystem.Value;
}
else
{
if (gridStatisticsSetting.CoordinateSystemId.HasValue)
{
gridSpecification.GridCoordinateSystem = (GridCoordinateSystem)gridStatisticsSetting.CoordinateSystemId;
}
else
{
gridSpecification.GridCoordinateSystem = GridCoordinateSystem.SWEREF99_TM;
}
}
gridSpecification.GridCellSize = gridSize.HasValue ? gridSize.Value : ZoomMappings[zoom];
gridSpecification.IsGridCellSizeSpecified = true;
gridSpecification.GridCellGeometryType = GridCellGeometryType.Polygon;
searchCriteria.Polygons = new List <IPolygon>();
searchCriteria.Polygons.Add(GetPolygon(bottom, left, right, top));
IList <IGridCellSpeciesObservationCount> gridCellObservations = CoreData.AnalysisManager.GetGridSpeciesObservationCounts(UserContext, searchCriteria, gridSpecification, displayCoordinateSystem);
gridCellObservations = gridCellObservations.OrderBy(x => x.Identifier).ToList();
return(gridCellObservations);
}
private IList <IGridCellSpeciesObservationCount> AddEmptyGridCells(IList <IGridCellSpeciesObservationCount> gridCellObservations, GridSpecification gridSpecification, ICoordinateSystem displayCoordinateSystem)
{
long numberOfGridCellsThatWillBeGenerated = GisTools.GridCellManager.CalculateNumberOfGridCells(gridSpecification);
if (numberOfGridCellsThatWillBeGenerated > MAX_NUMBER_OF_GRID_CELLS)
{
throw new ArgumentException(string.Format("The cell size is too small, which would have resulted in the {0} grid cells. The limit lies at {1}.", numberOfGridCellsThatWillBeGenerated, MAX_NUMBER_OF_GRID_CELLS));
}
if (gridSpecification.BoundingBox == null)
{
gridSpecification.BoundingBox = SwedenExtentManager.GetSwedenExtentBoundingBox(gridSpecification.GridCoordinateSystem.ToCoordinateSystem());
}
List <GridCellBase> allGridCells = GisTools.GridCellManager.GenerateGrid(gridSpecification, displayCoordinateSystem);
List <IGridCellBase> dataGridCells = gridCellObservations.Cast <IGridCellBase>().ToList();
List <IGridCellBase> missingGridCells = GisTools.GridCellManager.GetMissingGridCells(allGridCells.Cast <IGridCellBase>().ToList(), dataGridCells);
foreach (IGridCellBase missingGridCell in missingGridCells)
{
GridCellSpeciesObservationCount gridCellSpeciesObservationCount = new GridCellSpeciesObservationCount();
gridCellSpeciesObservationCount.ObservationCount = 0;
missingGridCell.CopyPropertiesTo(gridCellSpeciesObservationCount);
gridCellObservations.Add(gridCellSpeciesObservationCount);
}
return(gridCellObservations);
}
/// <summary>
/// Removes the grid cells outside grid bounds.
/// </summary>
/// <param name="gridCellObservations">The grid cell observations.</param>
/// <param name="gridSpecification">The grid specification.</param>
/// <returns>A list with all <paramref name="gridCellObservations"/> except the ones outside the grid bounds.</returns>
private List <IGridCellSpeciesObservationCount> RemoveGridCellsOutsideBounds(IList <IGridCellSpeciesObservationCount> gridCellObservations, GridSpecification gridSpecification)
{
List <IGridCellSpeciesObservationCount> result = new List <IGridCellSpeciesObservationCount>();
IBoundingBox boundingBox = gridSpecification.BoundingBox;
int cellSize = gridSpecification.GridCellSize;
double xMin = Math.Floor(boundingBox.Min.X / cellSize) * cellSize;
double xMax = Math.Ceiling(boundingBox.Max.X / cellSize) * cellSize;
double yMin = Math.Floor(boundingBox.Min.Y / cellSize) * cellSize;
double yMax = Math.Ceiling(boundingBox.Max.Y / cellSize) * cellSize;
foreach (IGridCellSpeciesObservationCount gridCell in gridCellObservations)
{
if (gridCell.OrginalGridCellBoundingBox.Min.X >= xMin &&
gridCell.OrginalGridCellBoundingBox.Min.Y >= yMin &&
gridCell.OrginalGridCellBoundingBox.Max.X <= xMax &&
gridCell.OrginalGridCellBoundingBox.Max.Y <= yMax)
{
result.Add(gridCell);
}
}
return(result);
}
/// <summary>
/// Calculates the number of gridcells
/// </summary>
/// <param name="gridSpecification"></param>
/// <param name="polygons"></param>
/// <param name="regionGuids"></param>
/// <returns></returns>
public long CalculateNumberOfGridCells(GridSpecification gridSpecification, List <IPolygon> polygons, List <string> regionGuids)
{
throw new NotImplementedException();
}
