/// <summary>
/// Gets the name of the coordinate system.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system identifier.</param>
/// <returns>The name of the coordinate system.</returns>
public static string GetCoordinateSystemName(this CoordinateSystemId coordinateSystemId)
{
switch (coordinateSystemId)
{
case CoordinateSystemId.GoogleMercator:
return("Google Mercator");
case CoordinateSystemId.SWEREF99:
return("SWEREF 99");
case CoordinateSystemId.SWEREF99_TM:
return("SWEREF 99");
case CoordinateSystemId.WGS84:
return("WGS 84");
case CoordinateSystemId.Rt90_25_gon_v:
return("RT 90");
case CoordinateSystemId.None:
return("None");
default:
throw new ArgumentException(string.Format("CoordinateSystemId: {0} doesn't exist.", coordinateSystemId));
}
}
/// <summary>
/// Creates a Grid statistics result object.
/// </summary>
/// <param name="calculationCoordinateSystemId">The calculation coordinate system id.</param>
/// <param name="displayCoordinateSystemId">The display coordinate system id.</param>
/// <param name="gridCellSize">Size of the grid cell.</param>
/// <param name="cells">Grid statistics cell list returned from web service.</param>
/// <returns></returns>
public static CombinedGridStatisticsResult Create(
CoordinateSystemId calculationCoordinateSystemId,
CoordinateSystemId displayCoordinateSystemId,
int gridCellSize,
IList <IGridCellCombinedStatistics> cells)
{
var model = new CombinedGridStatisticsResult();
model.Cells = new List <CombinedGridStatisticsCellResult>();
model.CalculationCoordinateSystemId = (int)displayCoordinateSystemId;
model.CalculationCoordinateSystemName = CoordinateSystemHelper.GetCoordinateSystemName(calculationCoordinateSystemId);
model.DisplayCoordinateSystemId = (int)calculationCoordinateSystemId;
model.DisplayCoordinateSystemName = CoordinateSystemHelper.GetCoordinateSystemName(displayCoordinateSystemId);
model.GridCellSize = gridCellSize;
if (cells == null || cells.Count == 0)
{
return(model);
}
//model.GridCellSize = cells[0].GridCellSize;
//model.GridCellCoordinateSystemId = (int)cells[0].GridCoordinateSystem;
//model.GridCellCoordinateSystem = cells[0].GridCoordinateSystem.ToString();
foreach (IGridCellCombinedStatistics gridCell in cells)
{
model.Cells.Add(CombinedGridStatisticsCellResult.Create(gridCell));
}
return(model);
}
public string GetSpeciesObservationsAsGeoJson(CoordinateSystemId displayCoordinateSystem)
{
var data = CalculateSpeciesObservations(displayCoordinateSystem);
var model = SpeciesObservationsGeoJsonModel.CreateResult(data.SpeciesObservationList);
return(JsonConvert.SerializeObject(model.Points, JsonHelper.GetDefaultJsonSerializerSettings()));
}
public static IGeometry ReProject(this IGeometry geometry, CoordinateSystemId fromCoordinateSystem, CoordinateSystemId toCoordinateSystem)
{
if (geometry == null || fromCoordinateSystem == toCoordinateSystem)
{
return(geometry);
}
var factory = new CoordinateTransformationFactory();
var fromSystem = CoordinateSystemWktReader.Parse(fromCoordinateSystem.GetWkt()) as ICoordinateSystem;
var toSystem = CoordinateSystemWktReader.Parse(toCoordinateSystem.GetWkt()) as ICoordinateSystem;
var transformator = factory.CreateFromCoordinateSystems(fromSystem, toSystem);
switch (geometry.GeometryType)
{
case "MultiPolygon":
return(((IMultiPolygon)geometry).ReProject(transformator));
case "Polygon":
return(((IPolygon)geometry).ReProject(transformator));
case "LinearRing":
return(((ILinearRing)geometry).ReProject(transformator));
case "Point":
return(((IPoint)geometry).ReProject(transformator));
}
return(null);
}
/// <summary>
/// Get WKT for specified Coordinate system id
/// </summary>
/// <param name="coordinateSystemId"></param>
/// <param name="ownWkt">WKT to return if coordinate system id equals None</param>
/// <returns></returns>
public static string GetWkt(this CoordinateSystemId coordinateSystemId, string ownWkt = null)
{
switch (coordinateSystemId)
{
case CoordinateSystemId.None:
return(ownWkt);
case CoordinateSystemId.GoogleMercator:
return(Settings.Default.GoogleMercator_WKT);
case CoordinateSystemId.Rt90_25_gon_v:
return(Settings.Default.Rt90_25_gon_v_WKT);
case CoordinateSystemId.SWEREF99:
// SWEREF99 is mapped to SWEREF99_TM in order to
// support old definition of the enum.
// This should be changed in the future when
// SWEREF99 no longer is used in its old meaning.
case CoordinateSystemId.SWEREF99_TM:
return(Settings.Default.SWEREF99_TM_WKT);
case CoordinateSystemId.WGS84:
return(Settings.Default.WGS84_WKT);
default:
throw new ArgumentException("Not handled coordinate system id " + coordinateSystemId);
}
}
/// <summary>
/// Gets the Srid for the specified coordinate system.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system id.</param>
/// <returns>The Srid.</returns>
public static int Srid(this CoordinateSystemId coordinateSystemId)
{
switch (coordinateSystemId)
{
case CoordinateSystemId.GoogleMercator:
return(900913);
case CoordinateSystemId.Rt90_25_gon_v:
return(3021);
case CoordinateSystemId.SWEREF99:
// SWEREF99 is mapped to SWEREF99_TM in order to
// support old definition of the enum.
// This should be changed in the future when
// SWEREF99 no longer is used in its old meaning.
case CoordinateSystemId.SWEREF99_TM:
return(3006);
case CoordinateSystemId.WGS84:
return(4326);
case CoordinateSystemId.None:
return(0);
default:
throw new ArgumentException(coordinateSystemId + " is not handled");
}
}
/// <summary>
/// Gets the EOO header.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system identifier.</param>
/// <returns>EOO header.</returns>
public string GetEooHeader(CoordinateSystemId coordinateSystemId)
{
const string eooHeaderTemplate = "EOO (km2, {0})";
var coordinateSystemName = coordinateSystemId.GetCoordinateSystemName();
return(string.Format(eooHeaderTemplate, coordinateSystemName));
}
/// <summary>
/// Converts the webPoint from the coordinate system given by the coordinateSystemId to all the coordinate systems listed in the <see cref="CoordinateSystemId"/> enumeration.
/// The results are stored in the property WebPoints' dictionary
/// </summary>
/// <param name="webPoint"></param>
/// <param name="coordinateSystemId"></param>
private void ConvertCoordinates(WebPoint webPoint, CoordinateSystemId coordinateSystemId)
{
WebPoints = null;
WebPoints = new Dictionary <CoordinateSystemId, WebPoint>();
var fromWebCoordinateSystem = new WebCoordinateSystem {
Id = coordinateSystemId
};
foreach (CoordinateSystemId csid in Enum.GetValues(typeof(CoordinateSystemId)))
{
// following coordinate systems is not used and can be skipped
if (csid == CoordinateSystemId.None)
{
continue;
}
//// if (csid == CoordinateSystemId.GoogleMercator) continue;
//// todo: remove this when there is support in ProjNet to convert to LAEA
//// http://projnet.codeplex.com/
//// if (csid == CoordinateSystemId.ETRS89_LAEA) continue;
//// end
WebPoints.Add(csid, WebServiceData.CoordinateConversionManager.GetConvertedPoint(webPoint, fromWebCoordinateSystem, new WebCoordinateSystem {
Id = csid
}));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GridStatisticsOnSpeciesObservationCountExcelXlsx"/> class.
/// </summary>
/// <param name="currentUser">Current user context</param>
/// <param name="coordinateSystem">The coordinate system.</param>
/// <param name="addSettings">True if settings sheet should be included</param>
/// <param name="addProvenance">True if provenance sheet should be included.</param>
public GridStatisticsOnSpeciesObservationCountExcelXlsx(IUserContext currentUser, CoordinateSystemId coordinateSystem, bool addSettings, bool addProvenance)
{
IsColumnHeaderBackgroundUsed = true;
base.currentUser = currentUser;
CoordinateSystem = coordinateSystem;
base.addSettings = addSettings;
base.addProvenance = addProvenance;
}
/// <summary>
/// Updates the coordinate system.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system identifier.</param>
/// <param name="returnUrl">The return URL.</param>
/// <returns>A redirection to <paramref name="returnUrl"/>.</returns>
public RedirectResult UpdateCoordinateSystem(CoordinateSystemId coordinateSystemId, string returnUrl)
{
var viewManager = new MapSettingsViewManager(GetCurrentUser(), SessionHandler.MySettings);
viewManager.UpdateCurrentCoordinateSystem(coordinateSystemId);
SessionHandler.UserMessages.Add(new UserMessage(Resources.Resource.PresentationMapSettingsUpdated));
return(Redirect(returnUrl));
}
protected CoordinateSystem GetCoordinateSystem(CoordinateSystemId coordinateSystemId = CoordinateSystemId.WGS84)
{
CoordinateSystem coordinateSystem = new CoordinateSystem();
coordinateSystem.Id = coordinateSystemId;
coordinateSystem.WKT = "None";
return(coordinateSystem);
}
/// <summary>
/// Method that generates an Excel (XML/XLSX) file with species observations.
/// </summary>
/// <param name="addSettings"></param>
/// <param name="addProvenance"></param>
/// <param name="presentationCoordinateSystem">Coordinate system to use.</param>
/// <param name="columnsSet">Which columns set to use.</param>
/// <param name="columnsHeadersType">Columns headers type to use.</param>
/// <returns>An Excel file of the type XML or XLSX.</returns>
public FileResult SpeciesObservationsAsExcel(
bool?addSettings,
bool?addProvenance,
int?presentationCoordinateSystem,
int?columnsSet,
int?columnsHeadersType)
{
MemoryStream returnStream;
string fileName;
addSettings = addSettings.GetValueOrDefault(true);
addProvenance = addProvenance.GetValueOrDefault(false);
CoordinateSystemId coordinateSystemId = GetCoordinateSystemIdFromArgument(
presentationCoordinateSystem,
SessionHandler.MySettings.Presentation.Map.DownloadCoordinateSystemId);
SpeciesObservationTableColumnsSetId speciesObservationTableColumnsSetId =
GetSpeciesObservationTableColumnsSetIdFromArgument(
columnsSet,
SessionHandler.MySettings.Presentation.Table.SpeciesObservationTable.SpeciesObservationTableColumnsSetId);
bool useLabelAsColumnHeader = GetUselabelAsColumnHeaderFromArgument(
columnsHeadersType,
SessionHandler.MySettings.Presentation.Table.SpeciesObservationTable.UseLabelAsColumnHeader);
if (SessionHandler.MySettings.Presentation.FileFormat.ExcelFileSettings.IsSettingsDefault())
{
SpeciesObservationsExcelXlsx file = FileExportManager.GetSpeciesObservationsAsExcelXlsx(
GetCurrentUser(),
addSettings.Value,
addProvenance.Value,
coordinateSystemId,
speciesObservationTableColumnsSetId,
useLabelAsColumnHeader);
returnStream = file.ToStream();
fileName = CreateXlsxExcelFileName("SpeciesObservations");
}
else
{
SpeciesObservationsExcelXml file =
FileExportManager.GetSpeciesObservationsAsExcelXml(
GetCurrentUser(),
addSettings.Value,
addProvenance.Value,
coordinateSystemId,
speciesObservationTableColumnsSetId,
useLabelAsColumnHeader);
returnStream = file.ToStream();
fileName = CreateXmlExcelFileName("SpeciesObservations");
}
SetServerDone();
return(File(returnStream, XlsxExcelFileMimeType, fileName));
}
/// <summary>
/// Creates the search criteria based on filter settings.
/// </summary>
/// <param name="mySettings">
/// The my settings object.
/// </param>
/// <returns>
/// The <see cref="SpeciesObservationSearchCriteria"/>.
/// </returns>
public SpeciesObservationSearchCriteria CreateSearchCriteria(
MySettings.MySettings mySettings,
CoordinateSystemId coordinateSystemId)
{
return(CreateSearchCriteria(
mySettings,
new CoordinateSystem {
Id = coordinateSystemId
}));
}
/// <summary>
/// Adds the headers.
/// </summary>
/// <param name="worksheet">The worksheet.</param>
private void AddHeaders(ExcelWorksheet worksheet)
{
CoordinateSystemId coordinateSystemId = (CoordinateSystemId)SessionHandler.MySettings.Calculation.GridStatistics.CoordinateSystemId.Value;
worksheet.Cells[HeadersRowIndex, TaxonIdColumnIndex].Value = Resource.LabelTaxonId;
worksheet.Cells[HeadersRowIndex, ScientificNameColumnIndex].Value = Resource.TaxonSharedScientificName;
worksheet.Cells[HeadersRowIndex, SwedishNameColumnIndex].Value = Resource.TaxonSharedSwedishName;
worksheet.Cells[HeadersRowIndex, AooColumnIndex].Value = aooEooExcelFormatter.GetAooHeader(coordinateSystemId);
worksheet.Cells[HeadersRowIndex, EooColumnIndex].Value = aooEooExcelFormatter.GetEooHeader(coordinateSystemId);
}
public List <Dictionary <ViewTableField, string> > GetTableResult(
CoordinateSystemId coordinateSystemId,
SpeciesObservationTableColumnsSetId speciesObservationTableColumnsSetId)
{
SpeciesObservationsData speciesObservationsData = GetSpeciesObservations(coordinateSystemId);
var viewManager = new SpeciesObservationTableViewManager(UserContext, MySettings);
ViewTableViewModel viewModel = viewManager.CreateViewTableViewModel(speciesObservationTableColumnsSetId);
var speciesObservationDataManager = new SpeciesObservationDataManager(UserContext, MySettings);
List <Dictionary <ViewTableField, string> > dicResult = speciesObservationDataManager.GetObservationsListDictionary(speciesObservationsData.SpeciesObservationViewModels, viewModel.TableFields);
return(dicResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="SpeciesObservationsExcelXlsx" /> class.
/// </summary>
/// <param name="currentUser">Current user context.</param>
/// <param name="addSettings">True if settings sheet should be included</param>
/// <param name="addProvenance">True if provenance sheet should be included.</param>
/// <param name="coordinateSystemId">Coordinate system</param>
/// <param name="speciesObservationTableColumnsSetId">The table columns set to use.</param>
/// <param name="useLabelAsColumnHeader">Use label as column header.</param>
public SpeciesObservationsExcelXlsx(
IUserContext currentUser,
bool addSettings,
bool addProvenance,
CoordinateSystemId coordinateSystemId,
SpeciesObservationTableColumnsSetId speciesObservationTableColumnsSetId,
bool useLabelAsColumnHeader)
{
IsColumnHeaderBackgroundUsed = true;
base.currentUser = currentUser;
base.addSettings = addSettings;
base.addProvenance = addProvenance;
this.coordinateSystemId = coordinateSystemId;
this.speciesObservationTableColumnsSetId = speciesObservationTableColumnsSetId;
this.useLabelAsColumnHeader = useLabelAsColumnHeader;
}
/// <summary>
/// Creates an xlsx excel file with species observations data.
/// </summary>
/// <param name="currentUser">Current user context</param>
/// <param name="addSettings">True if settings sheet should be included</param>
/// <param name="addProvenance">True if provenance sheet should be included.</param>
/// <param name="coordinateSystemId">Coordinate system to use.</param>
/// <param name="speciesObservationTableColumnsSetId">The table columns set to use.</param>
/// <param name="useLabelAsColumnHeader">Use label as column header.</param>
/// <returns>
/// The xlsx Excel file.
/// </returns>
public static SpeciesObservationsExcelXlsx GetSpeciesObservationsAsExcelXlsx(
IUserContext currentUser,
bool addSettings,
bool addProvenance,
CoordinateSystemId coordinateSystemId,
SpeciesObservationTableColumnsSetId speciesObservationTableColumnsSetId,
bool useLabelAsColumnHeader)
{
return(new SpeciesObservationsExcelXlsx(
currentUser,
addSettings,
addProvenance,
coordinateSystemId,
speciesObservationTableColumnsSetId,
useLabelAsColumnHeader));
}
public void GridStatisticsSettingsSummaryPropertyTest()
{
using (ShimsContext.Create())
{
// First we must login
LoginTestUser();
IUserContext user = SessionHandler.UserContext;
SessionHandler.MySettings.Calculation.GridStatistics = new GridStatisticsSetting();
// Created from SessionHandler.MySettings.Calculation.SummaryStatistics
GridStatisticsSettingSummary settingSummary = new GridStatisticsSettingSummary();
//************ Check all settings at startup as designed *************************
//These setting is active at startup
Assert.IsTrue(settingSummary.HasActiveSettings);
Assert.IsTrue(settingSummary.HasSettings);
Assert.IsTrue(settingSummary.IsActive);
Assert.IsTrue(settingSummary.HasSettingsSummary);
Assert.IsTrue(settingSummary.Identifier == MySettingsSummaryItemIdentifier.CalculationGridStatistics);
// Verify HardCodedData // TODO why hardcoded???
Assert.IsTrue(settingSummary.PageInfo.Controller.Equals("Calculation"));
Assert.IsTrue(settingSummary.PageInfo.Action.Equals("GridStatistics"));
Assert.IsTrue(settingSummary.SettingsSummaryWidth == 350);
Assert.IsTrue(settingSummary.Title.Equals(Resources.Resource.StateButtonCalculationGridStatistics));
GridStatisticsViewModel model = settingSummary.GetSettingsSummaryModel(user);
//Check defaults
Assert.IsTrue(model.CalculateNumberOfObservations);
Assert.IsTrue(model.CalculateNumberOfTaxa);
CoordinateSystemId enumDisplayStatus = ((CoordinateSystemId)model.CoordinateSystemId);
string stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.SWEREF99.ToString()));
Assert.IsTrue(model.GridSize == 10000);
Assert.IsTrue(model.CoordinateSystems.Count > 0);
Assert.IsTrue(model.IsSettingsDefault);
//************ Check all settings at startup as designed *************************
//These setting is active at startup
Assert.IsTrue(settingSummary.HasActiveSettings);
Assert.IsTrue(settingSummary.HasSettings);
Assert.IsTrue(settingSummary.IsActive);
Assert.IsTrue(settingSummary.HasSettingsSummary);
Assert.IsTrue(settingSummary.Identifier == MySettingsSummaryItemIdentifier.CalculationGridStatistics);
}
}
public SpeciesObservationsData CalculateSpeciesObservations(CoordinateSystemId displayCoordinateSystemId)
{
var displayCoordinateSystem = new CoordinateSystem(displayCoordinateSystemId);
var searchCriteriaManager = new SpeciesObservationSearchCriteriaManager(UserContext);
var searchCriteria = searchCriteriaManager.CreateSearchCriteria(MySettings, displayCoordinateSystem);
if (UserContext.CurrentRole.IsNull() && UserContext.CurrentRoles.Count > 0)
{
UserContext.CurrentRole = UserContext.CurrentRoles[0];
}
var speciesObservationList = CoreData.SpeciesObservationManager.GetSpeciesObservations(UserContext, searchCriteria, displayCoordinateSystem);
var fieldDescriptionViewManager = new SpeciesObservationFieldDescriptionViewManager(UserContext, MySettings);
var fieldDescriptionsViewModel = fieldDescriptionViewManager.CreateSpeciesObservationFieldDescriptionsViewModel();
var speciesObservationsData = new SpeciesObservationsData(speciesObservationList, fieldDescriptionsViewModel);
return(speciesObservationsData);
}
/// <summary>
/// Gets the coordinate system identifier from argument.
/// </summary>
/// <param name="presentationCoordinateSystem">The presentation coordinate system.</param>
/// <param name="defaultCoordinateSystemId">Default coordinate system id.</param>
/// <returns>The presentation coordinate system specified as argument if it's valid; otherwise the default coordinate system id.</returns>
private CoordinateSystemId GetCoordinateSystemIdFromArgument(int?presentationCoordinateSystem, CoordinateSystemId defaultCoordinateSystemId)
{
CoordinateSystemId coordinateSystemId;
if (presentationCoordinateSystem.HasValue)
{
if (!presentationCoordinateSystem.Value.TryParseEnum(out coordinateSystemId))
{
coordinateSystemId = defaultCoordinateSystemId;
}
}
else
{
coordinateSystemId = defaultCoordinateSystemId;
}
return(coordinateSystemId);
}
/// <summary>
/// Gets the grid maps coordinate systems.
/// </summary>
/// <returns>A list with available grid maps coordinate systems.</returns>
public static List <CoordinateSystemViewModel> GetGridMapsCoordinateSystems()
{
CoordinateSystemId coordinateSystemId = CoordinateSystemId.SWEREF99_TM;
if (SessionHandler.MySettings.Calculation.GridStatistics.CoordinateSystemId.HasValue)
{
try
{
coordinateSystemId =
(CoordinateSystemId)SessionHandler.MySettings.Calculation.GridStatistics.CoordinateSystemId.Value;
}
catch (Exception)
{
}
}
return(GetGridMapsCoordinateSystems(coordinateSystemId));
}
/// <summary>
/// Gets the EPSG code for the coordinate system.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system id.</param>
/// <returns>The EPSG code.</returns>
public static string EpsgCode(this CoordinateSystemId coordinateSystemId)
{
return(string.Format("EPSG:{0}", coordinateSystemId.Srid()));
}
/// <summary>
/// Constructor of an excel xml file with grid statistics on species counts.
/// </summary>
/// <param name="currentUser">Current user context</param>
/// <param name="coordinateSystem">Coordinate system of the transformated coordinates.</param>
/// <param name="addSettings">True if settings sheet should be included</param>
/// <param name="addProvenance">True if provenance sheet should be included.</param>
public GridStatisticsOnSpeciesCountExcelXml(IUserContext currentUser, CoordinateSystemId coordinateSystem, bool addSettings, bool addProvenance)
: base()
{
var resultCalculator = new TaxonGridCalculator(currentUser, SessionHandler.MySettings);
var data = resultCalculator.GetTaxonGridResultFromCacheIfAvailableOrElseCalculate();
_xmlBuilder = new StringBuilder();
//Add file definitions and basic format settings
_xmlBuilder.AppendLine(base.GetInitialSection());
//Specify column and row counts
_xmlBuilder.AppendLine(base.GetColumnInitialSection(8, data.Cells.Count));
////_xmlBuilder.AppendLine(base.getColumnInitialSection(10, data.Cells.Count));
//Specify column widths
_xmlBuilder.AppendLine(base.GetColumnWidthLine(200));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(100));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(60));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(150));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(150));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
////_xmlBuilder.AppendLine(base.getColumnWidthLine(170));
////_xmlBuilder.AppendLine(base.getColumnWidthLine(170));
//Add row with column headers
_xmlBuilder.AppendLine(base.GetRowStart());
_xmlBuilder.AppendLine(base.GetColumnNameRowLine("Id"));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(Resource.GridStatisticsTaxaCount));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(Resource.GridStatisticsObservationCount));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate X ({0})", data.GridCellCoordinateSystem)));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate Y ({0})", data.GridCellCoordinateSystem)));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate X ({0})", coordinateSystem.ToString())));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate Y ({0})", coordinateSystem.ToString())));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine("Grid cell width (metres)"));
////_xmlBuilder.AppendLine(base.getColumnNameRowLine("long"));
////_xmlBuilder.AppendLine(base.getColumnNameRowLine("lat"));
_xmlBuilder.AppendLine(base.GetRowEnd());
//Data values
foreach (TaxonGridCellResult row in data.Cells)
{
_xmlBuilder.AppendLine(base.GetRowStart());
_xmlBuilder.AppendLine(base.GetDataRowLine("String", row.Identifier));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.SpeciesCount.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.ObservationCount.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.OriginalCentreCoordinateX.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.OriginalCentreCoordinateY.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.CentreCoordinateX.ToString(base.GetApprotiateGlobalization())));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.CentreCoordinateY.ToString(base.GetApprotiateGlobalization())));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", data.GridCellSize.ToString()));
////Point convertedPoint = GisTools.CoordinateConversionManager.GetConvertedPoint(
//// new Point(row.CentreCoordinateX, row.CentreCoordinateY),
//// new CoordinateSystem(CoordinateSystemId.GoogleMercator),
//// new CoordinateSystem(CoordinateSystemId.WGS84));
////_xmlBuilder.AppendLine(base.getDataRowLine("Number", convertedPoint.X.ToString(CultureInfo.InvariantCulture.NumberFormat)));
////_xmlBuilder.AppendLine(base.getDataRowLine("Number", convertedPoint.Y.ToString(CultureInfo.InvariantCulture.NumberFormat)));
_xmlBuilder.AppendLine(base.GetRowEnd());
}
// Add final section of the xml document.
_xmlBuilder.AppendLine(GetFinalSection(GetAditionalSheets(currentUser, addSettings, addProvenance)));
}
/// <summary>
/// Create a .geotiff raster image from a geo json
/// </summary>
/// <param name="geoJson">Geojson string</param>
/// <param name="coordinateSystem">Current coordinate system</param>
/// <param name="filePathTiff">Path where the .geotiff file will be created</param>
/// <param name="pixelsX">Tiff image width in pixels (mandatory if not pixelSize is passed)</param>
/// <param name="pixelsY">Tiff image height in pixels (mandatory if not pixelSize is passed)</param>
/// <param name="pixelSize">How many meters should each pixel represent (mandatory if not width and height in pixels are passed)</param>
/// <param name="attribute">Optional attribute to get value from. If not passed 255 will be used for all shapes</param>
/// <param name="dataType">Attribute data type, default byte</param>
public static byte[] CreateTiffFile(string geoJson, CoordinateSystemId coordinateSystem, string filePathTiff, int pixelsX = 0, int pixelsY = 0, int pixelSize = 0, string attribute = null, Data.DataType dataType = Data.DataType.Byte)
{
if ((pixelsX == 0 || pixelsY == 0) && pixelSize == 0)
{
throw new Exception("You have to state image size in pixels or pixel size");
}
geoJson = geoJson.ReplaceSwedishChars();
attribute = attribute.ReplaceSwedishChars();
//Create a temporary file name
filePathTiff = Path.Combine(filePathTiff, Guid.NewGuid().ToString() + ".tif");
try
{
//Register the vector drivers
Ogr.RegisterAll();
//Reading the vector data
var dataSource = Ogr.Open(geoJson, 0);
var layer = dataSource.GetLayerByIndex(0);
var envelope = new Envelope();
layer.GetExtent(envelope, 1);
double pixelSizeX = pixelSize;
double pixelSizeY = pixelSize;
//Calculate diff between min and max
var xDiff = envelope.MaxX - envelope.MinX;
var yDiff = envelope.MaxY - envelope.MinY;
//Calculate raster size in pixels if pixel size is passed
if ((pixelsX == 0 || pixelsY == 0))
{
var sumDiff = xDiff + yDiff;
//Calculate ratio %
var xRatio = xDiff / sumDiff;
var yRatio = yDiff / sumDiff;
//Calculate pixels width and height
pixelsX = (int)(xRatio * pixelSize);
pixelsY = (int)(yRatio * pixelSize);
}
//Calculate pixel size
pixelSizeX = xDiff / pixelsX;
pixelSizeY = yDiff / pixelsY;
//Register the raster drivers
Gdal.AllRegister();
//Check if output raster exists & delete (optional)
if (File.Exists(filePathTiff))
{
File.Delete(filePathTiff);
}
//Create new tiff
var outputDriver = Gdal.GetDriverByName("GTiff");
var dt = DataType.GDT_Byte;
switch (dataType)
{
case Data.DataType.Float32:
dt = DataType.GDT_Float32;
break;
case Data.DataType.Float64:
dt = DataType.GDT_Float64;
break;
case Data.DataType.Int32:
dt = DataType.GDT_Int32;
break;
}
using (var createDataset = outputDriver.Create(filePathTiff, pixelsX, pixelsY, 1, dt, null))
{
//Extrac srs from input feature
string inputShapeSrs;
var spatialRefrence = layer.GetSpatialRef();
spatialRefrence.ExportToWkt(out inputShapeSrs);
//Assign input feature srs to outpur raster
createDataset.SetProjection(inputShapeSrs);
//Geotransform
var argin = new[] { envelope.MinX, pixelSizeX, 0, envelope.MaxY, 0, -pixelSizeY };
createDataset.SetGeoTransform(argin);
// Define pixel_size and NoData value of new raster
const double noDataValue = 0;
//Set no data
var band = createDataset.GetRasterBand(1);
band.SetNoDataValue(noDataValue);
//close tiff
createDataset.FlushCache();
}
//Feature to raster rasterize layer options
//No of bands (1)
var bandlist = new[] { 1 };
//Values to be burn on raster when no attribute name is passed
var burnValues = new[] { 255.0 };
using (var outputDataset = Gdal.Open(filePathTiff, Access.GA_Update))
{
string[] rasterizeOptions = attribute == null ? null : new[] { "ALL_TOUCHED=TRUE", string.Format("ATTRIBUTE={0}", attribute) };
Gdal.RasterizeLayer(outputDataset, 1, bandlist, layer, IntPtr.Zero, IntPtr.Zero, 1, burnValues, rasterizeOptions, ProgressFunc, "Raster conversion");
}
return(File.ReadAllBytes(filePathTiff));
}
finally
{
if (File.Exists(filePathTiff))
{
File.Delete(filePathTiff);
}
}
}
/// <summary>
/// Updates the current coordinate system.
/// </summary>
/// <param name="coordinateSystemId">The coordinate system identifier.</param>
public void UpdateCurrentCoordinateSystem(CoordinateSystemId coordinateSystemId)
{
MapSettings.PresentationCoordinateSystemId = coordinateSystemId;
}
/// <summary>
/// Tries to finds the coordinate system crs property used.
/// </summary>
/// <param name="featureCollection">The feature collection.</param>
/// <returns>The coordinate system used. If no crs was found, the coordinate system Id property is set to None.</returns>
public CoordinateSystem FindCoordinateSystem(FeatureCollection featureCollection)
{
CoordinateSystemId coordinateSystemId = FindCoordinateSystemId(featureCollection);
return(new CoordinateSystem(coordinateSystemId));
}
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);
}
/// <summary>
/// Constructor of an excel xml file with grid statistics on species observation counts.
/// </summary>
/// <param name="currentUser">Current user context.</param>
/// <param name="coordinateSystem">Coordinate system of the transformated coordinates.</param>
/// <param name="addSettings">True if settings sheet should be included</param>
/// <param name="addProvenance">True if provenance sheet should be included.</param>
public GridStatisticsOnSpeciesObservationCountExcelXml(IUserContext currentUser, CoordinateSystemId coordinateSystem, bool addSettings, bool addProvenance)
: base()
{
var resultCalculator = new SpeciesObservationGridCalculator(currentUser, SessionHandler.MySettings);
var data = resultCalculator.GetSpeciesObservationGridResultFromCacheIfAvailableOrElseCalculate();
_xmlBuilder = new StringBuilder();
//Add file definitions and basic format settings
_xmlBuilder.AppendLine(base.GetInitialSection());
//Specify column and row counts
_xmlBuilder.AppendLine(base.GetColumnInitialSection(7, data.Cells.Count));
//Specify column widths
_xmlBuilder.AppendLine(base.GetColumnWidthLine(200));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(90));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(150));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(150));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
_xmlBuilder.AppendLine(base.GetColumnWidthLine(170));
//Add row with column headers
_xmlBuilder.AppendLine(base.GetRowStart());
_xmlBuilder.AppendLine(base.GetColumnNameRowLine("Id"));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(Resource.GridStatisticsObservationCount));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate X ({0})", data.GridCellCoordinateSystem)));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate Y ({0})", data.GridCellCoordinateSystem)));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate X ({0})", coordinateSystem.ToString())));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine(String.Format("Centre coordinate Y ({0})", coordinateSystem.ToString())));
_xmlBuilder.AppendLine(base.GetColumnNameRowLine("Grid cell width (metres)"));
_xmlBuilder.AppendLine(base.GetRowEnd());
//Data values
foreach (SpeciesObservationGridCellResult row in data.Cells)
{
_xmlBuilder.AppendLine(base.GetRowStart());
_xmlBuilder.AppendLine(base.GetDataRowLine("String", row.Identifier));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.ObservationCount.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.OriginalCentreCoordinateX.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.OriginalCentreCoordinateY.ToString()));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.CentreCoordinateX.ToString(base.GetApprotiateGlobalization())));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", row.CentreCoordinateY.ToString(base.GetApprotiateGlobalization())));
_xmlBuilder.AppendLine(base.GetDataRowLine("Number", data.GridCellSize.ToString()));
_xmlBuilder.AppendLine(base.GetRowEnd());
}
// Add final section of the xml document.
_xmlBuilder.AppendLine(GetFinalSection(GetAditionalSheets(currentUser, addSettings, addProvenance)));
}
/// <summary>
/// Initializes a new instance of the <see cref="SpeciesAOOEOOExcelXml"/> class.
/// </summary>
/// <param name="currentUser">The current user.</param>
/// <param name="data">The data.</param>
/// <param name="addSettings">if set to <c>true</c> settings report should be added.</param>
/// <param name="addProvenance">if set to <c>true</c> provenance report should be added.</param>
/// <param name="aooEooExcelFormatter">The aoo eoo excel formatter.</param>
public SpeciesAOOEOOExcelXml(
IUserContext currentUser,
Tuple <int, string, string, string, string>[] data,
bool addSettings,
bool addProvenance,
IAooEooExcelFormatter aooEooExcelFormatter)
: base()
{
_xmlBuilder = new StringBuilder();
// Add file definitions and basic format settings
_xmlBuilder.AppendLine(GetInitialSection());
// Specify column and row counts
CoordinateSystemId coordinateSystemId = (CoordinateSystemId)SessionHandler.MySettings.Calculation.GridStatistics.CoordinateSystemId.Value;
List <string> columns = new List <string>();
columns.Add(Resource.LabelTaxonId);
columns.Add(Resource.TaxonSharedScientificName);
columns.Add(Resource.TaxonSharedSwedishName);
columns.Add(aooEooExcelFormatter.GetAooHeader(coordinateSystemId));
columns.Add(aooEooExcelFormatter.GetEooHeader(coordinateSystemId));
_xmlBuilder.AppendLine(GetColumnInitialSection(columns.Count, data.Length));
// Specify column widths
foreach (var column in columns)
{
_xmlBuilder.AppendLine(GetColumnWidthLine(100));
}
// Add row with column headers
_xmlBuilder.AppendLine(GetRowStart());
foreach (string column in columns)
{
_xmlBuilder.AppendLine(GetColumnNameRowLine(column));
}
_xmlBuilder.AppendLine(GetRowEnd());
// Data values
foreach (var taxon in data)
{
_xmlBuilder.AppendLine(GetRowStart());
_xmlBuilder.AppendLine(GetDataRowLine("Number", taxon.Item1.ToString(CultureInfo.InvariantCulture)));
_xmlBuilder.AppendLine(GetDataRowLine("String", taxon.Item2));
_xmlBuilder.AppendLine(GetDataRowLine("String", taxon.Item3));
long result;
if (aooEooExcelFormatter.TryConvertKm2StringToNumber(taxon.Item4, out result))
{
_xmlBuilder.AppendLine(GetDataRowLine("Number", result.ToString(CultureInfo.InvariantCulture)));
}
else
{
_xmlBuilder.AppendLine(GetDataRowLine("String", ""));
}
if (aooEooExcelFormatter.TryConvertKm2StringToNumber(taxon.Item5, out result))
{
_xmlBuilder.AppendLine(GetDataRowLine("Number", result.ToString(CultureInfo.InvariantCulture)));
}
else
{
_xmlBuilder.AppendLine(GetDataRowLine("String", ""));
}
_xmlBuilder.AppendLine(GetRowEnd());
}
_xmlBuilder.AppendLine(GetFinalSection(GetAditionalSheets(currentUser, addSettings, addProvenance)));
}
public void GridStatisticsSettingPropertyTest()
{
GridStatisticsSetting setting = new GridStatisticsSetting();
setting.ResultCacheNeedsRefresh = false;
//************ Check all settings at startup as designed *************************
//These setting is active at startup
Assert.IsTrue(setting.HasActiveSettings);
Assert.IsTrue(setting.HasSettings);
Assert.IsTrue(setting.IsActive);
Assert.IsTrue(setting.CalculateNumberOfObservations);
Assert.IsTrue(setting.CalculateNumberOfTaxa);
CoordinateSystemId enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
string stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.SWEREF99.ToString()));
Assert.IsTrue(setting.GridSize == 10000);
// This setting is default at start up, cash needs to be updated
Assert.IsTrue(setting.IsSettingsDefault());
Assert.IsFalse(setting.ResultCacheNeedsRefresh);
//************ Update settings and test *************************
setting.CalculateNumberOfObservations = false;
setting.CoordinateSystemId = 2;
setting.GridSize = 20000;
Assert.IsTrue(setting.HasActiveSettings);
Assert.IsTrue(setting.HasSettings);
// These setting is active at startup
Assert.IsTrue(setting.IsActive);
Assert.IsFalse(setting.CalculateNumberOfObservations);
Assert.IsTrue(setting.CalculateNumberOfTaxa);
enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.Rt90_25_gon_v.ToString()));
Assert.IsTrue(setting.GridSize == 20000);
// This setting is default at start up
Assert.IsFalse(setting.IsSettingsDefault());
Assert.IsTrue(setting.ResultCacheNeedsRefresh);
// Set default values and check again
setting.ResetSettings();
Assert.IsTrue(setting.HasActiveSettings);
Assert.IsTrue(setting.HasSettings);
Assert.IsTrue(setting.IsActive);
Assert.IsTrue(setting.CalculateNumberOfObservations);
Assert.IsTrue(setting.CalculateNumberOfTaxa);
Assert.IsTrue(setting.IsSettingsDefault());
Assert.IsTrue(setting.ResultCacheNeedsRefresh);
enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.SWEREF99.ToString()));
Assert.IsTrue(setting.GridSize == 10000);
// Now we change CalculateNumberOfSpeciesfromObsData setting
setting.CalculateNumberOfTaxa = false;
setting.GridSize = 50000;
Assert.IsTrue(setting.HasActiveSettings);
Assert.IsTrue(setting.HasSettings);
// These setting is active at startup
Assert.IsTrue(setting.IsActive);
Assert.IsTrue(setting.CalculateNumberOfObservations);
Assert.IsFalse(setting.CalculateNumberOfTaxa);
enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.SWEREF99.ToString()));
Assert.IsTrue(setting.GridSize == 50000);
// This setting is not default and cash needs to be updated
Assert.IsFalse(setting.IsSettingsDefault());
Assert.IsTrue(setting.ResultCacheNeedsRefresh);
// Set default values
setting.ResetSettings();
// Now we change CalculateNumberOfSpeciesfromObsData and CalculateNumberOfObservationsfromObsData setting
setting.CalculateNumberOfObservations = false;
setting.CalculateNumberOfTaxa = false;
setting.GridSize = 0;
setting.CoordinateSystemId = 0;
// TODO GridStatistics settings are always true
//Assert.IsFalse(setting.HasActiveSettings);
//Assert.IsFalse(setting.HasSettings);
//// These setting is active at startup
//Assert.IsTrue(setting.IsActive);
Assert.IsFalse(setting.CalculateNumberOfObservations);
Assert.IsFalse(setting.CalculateNumberOfTaxa);
enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.None.ToString()));
Assert.IsTrue(setting.GridSize == 0);
// This setting is not default and cash needs to be updated
Assert.IsFalse(setting.IsSettingsDefault());
Assert.IsTrue(setting.ResultCacheNeedsRefresh);
// Set default values
setting.ResetSettings();
//Set this setting not to be active
setting.IsActive = false;
Assert.IsFalse(setting.HasActiveSettings);
Assert.IsTrue(setting.HasSettings);
// These setting is active at startup
Assert.IsFalse(setting.IsActive);
Assert.IsTrue(setting.CalculateNumberOfObservations);
Assert.IsTrue(setting.CalculateNumberOfTaxa);
enumDisplayStatus = ((CoordinateSystemId)setting.CoordinateSystemId);
stringValue = enumDisplayStatus.ToString();
Assert.IsTrue(stringValue.Equals(CoordinateSystemId.SWEREF99.ToString()));
Assert.IsTrue(setting.GridSize == 10000);
// This setting is default at start up and no cash needs to be updated
Assert.IsTrue(setting.IsSettingsDefault());
Assert.IsTrue(setting.ResultCacheNeedsRefresh);
setting = new GridStatisticsSetting();
setting.ResultCacheNeedsRefresh = false;
//Set alreday existing value and check that cash in not needed to be updated
setting.CalculateNumberOfTaxa = true;
Assert.IsTrue(setting.IsSettingsDefault());
// TODO not required to always update cash ...Assert.IsFalse(setting.ResultCacheNeedsRefresh);
}
