private void Start()
{
gameManager = FindObjectOfType <GameManager>();
foesManager = FindObjectOfType <FoesManager>();
parameters = gameManager.parameters;
tilesReferences = parameters.tilesReferences;
}
public MapElementActions(SinglePlayerMenuActions parent, MapParameters parameters)
{
this.parent = parent;
this.parameters = parameters;
Initialize();
}
/// <summary>
/// Gets a map tile with spatial filter boundaries drawn on it
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="filterPolygons">List of filter polygons</param>
/// <param name="boundaryType">Type of filter boundary which determines the color</param>
/// <returns>A bitmap</returns>
public byte[] GetFilterBoundaryBitmap(MapParameters parameters, List <List <WGSPoint> > filterPolygons, FilterBoundaryType boundaryType)
{
byte[] geofenceImage = null;
if (filterPolygons != null && filterPolygons.Any())
{
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
foreach (var polygonPoints in filterPolygons)
{
if (polygonPoints != null && polygonPoints.Any())
{
int color = 0;
switch (boundaryType)
{
case FilterBoundaryType.Alignment:
color = DEFAULT_ALIGNMENT_BOUNDARY_COLOR;
break;
case FilterBoundaryType.Design:
color = DEFAULT_DESIGN_BOUNDARY_COLOR;
break;
default:
color = DEFAULT_CUSTOM_BOUNDARY_COLOR;
break;
}
DrawGeofence(parameters, bitmap, $"{boundaryType} Filter Boundary", polygonPoints, color, true);
}
}
geofenceImage = bitmap.BitmapToByteArray();
}
}
return(geofenceImage);
}
private void Start()
{
random = new Random(gameManager.seed);
mapGenerator = gameManager.mapGenerator;
grid = gameManager.grid;
parameters = gameManager.parameters;
}
/// <summary>
/// Gets a map tile with the project boundary drawn on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="project">The project to draw the boundary for</param>
/// <returns>A bitmap</returns>
public byte[] GetProjectBitmap(MapParameters parameters, ProjectData project)
{
log.LogInformation($"GetProjectBitmap: project {project.ProjectUID}");
const int PROJECT_BOUNDARY_COLOR = 0x0080FF; //Note: packed is abgr order
const int STROKE_TRANSPARENCY = 0x73; //0.45 of FF
Rgba32 PROJECT_BOUNDARY_RGBA = new Rgba32((uint)((STROKE_TRANSPARENCY << 24) | PROJECT_BOUNDARY_COLOR));
const int PROJECT_OUTLINE_WIDTH = 4;
byte[] projectImage = null;
if (project != null)
{
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
var projectPoints = project.ProjectGeofenceWKT.GeometryToPoints();
PointF[] pixelPoints = TileServiceUtils.LatLngToPixelOffset(projectPoints, parameters.pixelTopLeft, parameters.numTiles);
bitmap.Mutate(ctx => ctx.DrawPolygon(PROJECT_BOUNDARY_RGBA, PROJECT_OUTLINE_WIDTH, pixelPoints));
projectImage = bitmap.BitmapToByteArray();
}
}
return(projectImage);
}
[InlineData(4096, 4096, false, 4096, 4096, 1.5269, 1.1341, -1.4009, 1.1341)]//tile larger than bbox
public void TestZeroAreaBoundingBoxes(int tileWidth, int tileHeight, bool addMargin, int expectedWidth, int expectedHeight,
double expectedMinLat, double expectedMinLng, double expectedMaxLat, double expectedMaxLng)
{
var minLat = 0.63137; //36.175°
var minLng = -2.00748; //-115.020°
var maxLat = 0.63137; //36.178°
var maxLng = -2.00748; //-115.018°
MapBoundingBox bbox = new MapBoundingBox
{
minLat = minLat,
minLng = minLng,
maxLat = maxLat,
maxLng = maxLng
};
var service = new BoundingBoxService(loggerFactory);
//numTiles = 1048576 for Z10
MapParameters parameters = new MapParameters
{
bbox = bbox,
numTiles = 1048576,
zoomLevel = 10,
mapWidth = tileWidth,
mapHeight = tileHeight,
addMargin = addMargin
};
service.AdjustBoundingBoxToFit(parameters);
parameters.mapWidth.Should().Be(expectedWidth);
parameters.mapHeight.Should().Be(expectedHeight);
parameters.bbox.minLat.Should().BeApproximately(expectedMinLat, 0.0001);
parameters.bbox.minLng.Should().BeApproximately(expectedMinLng, 0.0001);
parameters.bbox.maxLat.Should().BeApproximately(expectedMaxLat, 0.0001);
parameters.bbox.maxLng.Should().BeApproximately(expectedMaxLng, 0.0001);
}
public SvcAppSPGlymaSession(GlymaSessionConfiguration configuration)
{
_configuration = configuration;
_sessionId = Guid.Empty;
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
public SvcAppSPGlymaSession(GlymaSessionConfiguration configuration)
{
_configuration = configuration;
_sessionId = Guid.Empty;
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
// Start is called before the first frame update
void Start()
{
attackingFoes = new List <Transform>();
mapDrawer = FindObjectOfType <MapDrawer>();
gameManager = FindObjectOfType <GameManager>();
parameters = gameManager.parameters;
}
public WebAppSPGlymaSession(string callingUrl)
{
_callingUrl = callingUrl;
_sessionId = Guid.Empty;
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
public SvcAppSPGlymaSession(GlymaSessionConfiguration configuration, Guid sessionId)
{
_configuration = configuration;
_sessionId = sessionId;
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
public SvcAppSPGlymaSession(GlymaSessionConfiguration configuration, Guid sessionId)
{
_configuration = configuration;
_sessionId = sessionId;
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
public WebAppSPGlymaSession(string callingUrl, Guid sessionId)
{
_callingUrl = callingUrl;
_sessionId = sessionId;
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
public void Init(MapParameters mapParameters)
{
if (mapParameters == null || !mapParameters.Set)
{
return;
}
InitMode = mapParameters.InitMode;
StartPoint = DatabaseService.GetInstance().GetPoint(mapParameters.StartId);
EndPoint = DatabaseService.GetInstance().GetPoint(mapParameters.EndId);
}
public WebAppSPGlymaSession(string callingUrl, Guid?domainId, Guid?rootMapId, params IRight[] requiredRights)
{
_callingUrl = callingUrl;
_sessionId = Guid.Empty;
if (!IsAuthorised(domainId, rootMapId, requiredRights))
{
throw new UnauthorizedAccessException("This user does not have the required privileges for this task.");
}
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
/// <summary>
/// Gets a map tile with the geoJson boundary drawn on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="points">The points from the geoJson</param>
/// <returns></returns>
public byte[] GetGeoJsonBitmap(MapParameters parameters, List <WGSPoint> points)
{
byte[] geofenceImage = null;
if (points != null && points.Any())
{
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
DrawGeofence(parameters, bitmap, "Geofence GeoJson", points, GEOJSON_BOUNDARY_COLOR, true);
geofenceImage = bitmap.BitmapToByteArray();
}
}
return(geofenceImage);
}
/// <summary>
/// Gets a map tile with geofences drawn on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="sites">List of geofences for the customer</param>
/// <returns>A bitmap</returns>
private byte[] GetGeofencesBitmap(MapParameters parameters, IEnumerable <GeofenceData> sites, bool isSites)
{
log.LogInformation("GetGeofencesBitmap");
const int DEFAULT_SITE_COLOR = 0x0055FF;
byte[] sitesImage = null;
if (sites != null && sites.Any())
{
// Exclude sites that are too small to be displayed in the current viewport.
double viewPortArea = Math.Abs(parameters.bbox.minLatDegrees - parameters.bbox.maxLatDegrees) * Math.Abs(parameters.bbox.minLngDegrees - parameters.bbox.maxLngDegrees);
double minArea = viewPortArea / 10000;
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
foreach (var site in sites)
{
log.LogDebug($"GetGeofencesBitmap examining site {site.GeofenceUID}");
//Old geofences may not have AreaSqMeters set.
if (site.AreaSqMeters > 0 && site.AreaSqMeters < minArea)
{
log.LogDebug($"GetGeofencesBitmap excluding site {site.GeofenceUID} due to area");
continue;
}
var sitePoints = site.GeometryWKT.GeometryToPoints().ToList();
//Exclude site if outside bbox
bool outside = TileServiceUtils.Outside(parameters.bbox, sitePoints);
if (outside)
{
log.LogDebug($"GetGeofencesBitmap excluding site {site.GeofenceUID} outside bbox");
}
else
{
int siteColor = site.FillColor > 0 ? site.FillColor : (isSites ? DEFAULT_SITE_COLOR : DEFAULT_CUSTOM_BOUNDARY_COLOR);
bool transparent = isSites ? site.IsTransparent : true;
DrawGeofence(parameters, bitmap, site.GeofenceUID.ToString(), sitePoints, siteColor, transparent);
}
}
sitesImage = bitmap.BitmapToByteArray();
}
}
return(sitesImage);
}
/// <summary>
/// Gets a map tile with load/dump locations drawn on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="loadDumpLocations">List of Load/Dump locations</param>
/// <returns>A bitmap</returns>
public byte[] GetLoadDumpBitmap(MapParameters parameters, List <LoadDumpLocation> loadDumpLocations)
{
log.LogInformation($"GetLoadDumpBitmap");
//Note: packed is abgr order
const uint LOAD_COLOR = 0xFF008F01; //Green 0x018F00
const uint DUMP_COLOR = 0xFFFF3304; //Blue 0x0433FF
Rgba32 LOAD_RGBA = new Rgba32(LOAD_COLOR);
Rgba32 DUMP_RGBA = new Rgba32(DUMP_COLOR);
var loadPen = new Pen <Rgba32>(LOAD_RGBA, 1);
var dumpPen = new Pen <Rgba32>(DUMP_RGBA, 1);
byte[] loadDumpImage = null;
if (loadDumpLocations != null && loadDumpLocations.Any())
{
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
IEnumerable <WGSPoint> loads = loadDumpLocations
.Select(x => new WGSPoint(x.loadLatitude.LatDegreesToRadians(), x.loadLongitude.LonDegreesToRadians())).ToList();
PointF[] pixelPoints = TileServiceUtils.LatLngToPixelOffset(loads, parameters.pixelTopLeft, parameters.numTiles);
foreach (var p in pixelPoints)
{
//Coloring one pixel doesn't show up well therefore do rectangle of 4 pixels
var x = (int)p.X;
var y = (int)p.Y;
var rect = new RectangleF(x, y, 2, 2);
bitmap.Mutate(ctx => ctx.Draw(loadPen, rect));
//bitmap[(int) p.X, (int) p.Y] = LOAD_RGBA;
}
IEnumerable <WGSPoint> dumps = loadDumpLocations
.Select(x => new WGSPoint(x.dumpLatitude.LatDegreesToRadians(), x.dumpLongitude.LonDegreesToRadians())).ToList();
pixelPoints = TileServiceUtils.LatLngToPixelOffset(dumps, parameters.pixelTopLeft, parameters.numTiles);
foreach (var p in pixelPoints)
{
var x = (int)p.X;
var y = (int)p.Y;
var rect = new RectangleF(x, y, 2, 2);
bitmap.Mutate(ctx => ctx.Draw(dumpPen, rect));
//bitmap[(int) p.X, (int) p.Y] = DUMP_RGBA;
}
loadDumpImage = bitmap.BitmapToByteArray();
}
}
return(loadDumpImage);
}
private void WebMapOpen_Click(object sender, RoutedEventArgs e)
{
string mapId = ((Button)sender)?.Tag?.ToString();
if (string.IsNullOrWhiteSpace(mapId))
{
return; //TODO: Log this
}
var parameters = new MapParameters()
{
MapId = mapId
};
this.Frame.Navigate(typeof(MapViewer), parameters);
}
/// <summary>
/// Generates a randomized Map object based on the map generator's properties.
/// </summary>
public static Map GenerateMap(MapParameters mapParams)
{
if (mapParams == null)
{
throw new System.ArgumentNullException("mapParams");
}
return(MapBuilder
.InitializeRandomMap(mapParams.Length, mapParams.Width, mapParams.InitialDensity, mapParams.Seed)
.Smooth()
.RemoveSmallFloorRegions(mapParams.MinFloorSize)
.ExpandRegions(mapParams.FloorExpansion)
.ConnectFloors(tunnelRadius: BASE_TUNNEL_RADIUS + mapParams.FloorExpansion)
.SmoothOnlyWalls()
.RemoveSmallWallRegions(mapParams.MinWallSize)
.ApplyBorder(mapParams.BorderSize));
}
public void OverlayTilesReturnsTileForEmptyList()
{
var mapParameters = new MapParameters {
mapWidth = 4, mapHeight = 4
};
var result = TileServiceUtils.OverlayTiles(mapParameters, new Dictionary <TileOverlayType, byte[]>());
byte[] expectedResult = null;
using (Image <Rgba32> bitmap = new Image <Rgba32>(mapParameters.mapWidth, mapParameters.mapHeight))
{
expectedResult = bitmap.BitmapToByteArray();
}
for (int i = 0; i < expectedResult.Length; i++)
{
Assert.Equal(expectedResult[i], result[i]);
}
}
public Grid(MapParameters parameters, MapGenerator generator)
{
this.parameters = parameters;
mapGenerator = generator;
nodes = new GridNode[parameters.mapSizeX - 1, parameters.mapSizeY - 1];
for (int x = 0; x < parameters.mapSizeX - 1; x++)
{
float nodePosX = (x * parameters.cellSize.x) + parameters.cellSize.x;
for (int y = 0; y < parameters.mapSizeY - 1; y++)
{
float nodePosY = (y * parameters.cellSize.y) + parameters.cellSize.y;
nodes[x, y] = new GridNode(x, y, nodePosX, nodePosY);
}
}
}
// Start is called before the first frame update
public MapGenerator(MapParameters parameters)
{
this.parameters = parameters;
// Init the map array
cells = new Cell[parameters.mapSizeX, parameters.mapSizeY];
for (int x = 0; x < parameters.mapSizeX; x++)
{
float cellPosX = (x * parameters.cellSize.x) + (parameters.cellSize.x / 2);
for (int y = 0; y < parameters.mapSizeY; y++)
{
float cellPosY = (y * parameters.cellSize.y) + (parameters.cellSize.y / 2);
cells[x, y] = new Cell(x, y, cellPosX, cellPosY);
}
}
}
private async void OpenMapArea_Click(object sender, RoutedEventArgs e)
{
string areaId = ((Button)sender)?.Tag?.ToString();
if (string.IsNullOrWhiteSpace(areaId))
{
return; //TODO: Log this
}
var area = this.ViewModel.MapAreasRaw.FirstOrDefault(m => m.Id == areaId);
var path = MapAreaManager.GetOfflineMapPath(areaId);
MobileMapPackage offlineMapPackage = await MobileMapPackage.OpenAsync(path);
var parameters = new MapParameters()
{
Map = offlineMapPackage.Maps.FirstOrDefault()
};
this.Frame.Navigate(typeof(MapViewer), parameters);
}
private void TryZoomIn(MapParameters parameters, out int requiredWidth, out int requiredHeight, out Point pixelMin, out Point pixelMax)
{
pixelMin = TileServiceUtils.LatLngToPixel(parameters.bbox.minLat, parameters.bbox.minLng, parameters.numTiles);
pixelMax = TileServiceUtils.LatLngToPixel(parameters.bbox.maxLat, parameters.bbox.maxLng, parameters.numTiles);
requiredWidth = (int)Math.Abs(pixelMax.x - pixelMin.x);
requiredHeight = (int)Math.Abs(pixelMax.y - pixelMin.y);
//See if we can zoom in - occurs when the requested tile size is much larger than the bbox
var zoomedWidth = requiredWidth;
var zoomedHeight = requiredHeight;
int zoomLevel = parameters.zoomLevel;
Point zoomedPixelMin = pixelMin;
Point zoomedPixelMax = pixelMax;
long numTiles = parameters.numTiles;
//allow a 15% margin extra otherwise if the tile is only a few pixels bigger than the calculated zoom
//we use the smaller zoom level and end up with lots of space around the data.
//AdjustBoundingBoxToFit handles the bigger size.
var mapWidth = parameters.mapWidth * 1.15;
var mapHeight = parameters.mapHeight * 1.15;
while (zoomedWidth < mapWidth && zoomedHeight < mapHeight && zoomLevel < MAX_ZOOM_LEVEL)
{
parameters.zoomLevel = zoomLevel;
parameters.numTiles = numTiles;
requiredWidth = zoomedWidth;
requiredHeight = zoomedHeight;
pixelMin = zoomedPixelMin;
pixelMax = zoomedPixelMax;
zoomLevel++;
numTiles = TileServiceUtils.NumberOfTiles(zoomLevel);
zoomedPixelMin = TileServiceUtils.LatLngToPixel(parameters.bbox.minLat, parameters.bbox.minLng, numTiles);
zoomedPixelMax = TileServiceUtils.LatLngToPixel(parameters.bbox.maxLat, parameters.bbox.maxLng, numTiles);
zoomedWidth = (int)Math.Abs(zoomedPixelMax.x - zoomedPixelMin.x);
zoomedHeight = (int)Math.Abs(zoomedPixelMax.y - zoomedPixelMin.y);
}
}
private void DrawGeofence(MapParameters parameters, Image <Rgba32> bitmap, string uid, IEnumerable <WGSPoint> points, int color, bool isTransparent)
{
const byte FILL_TRANSPARENCY = 0x40; //0.25 of FF
const byte STROKE_TRANSPARENCY = 0x73; //0.45 of FF
const int SITE_OUTLINE_WIDTH = 2;
log.LogDebug($"DrawGeofence drawing site or boundary {uid}");
var red = (byte)((color & 0xFF0000) >> 16);
var green = (byte)((color & 0x00FF00) >> 8);
var blue = (byte)(color & 0x0000FF);
PointF[] pixelPoints = TileServiceUtils.LatLngToPixelOffset(points, parameters.pixelTopLeft, parameters.numTiles);
if (!isTransparent)
{
var fillColor = new Rgba32(red, green, blue, FILL_TRANSPARENCY);
bitmap.Mutate(ctx => ctx.FillPolygon(fillColor, pixelPoints));
}
var lineColor = new Rgba32(red, green, blue, STROKE_TRANSPARENCY);
bitmap.Mutate(ctx => ctx.DrawPolygon(lineColor, SITE_OUTLINE_WIDTH, pixelPoints));
}
/// <summary>
/// Overlays the collection of tiles on top of each other and returns a single tile
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="tileList">The list of tiles to overlay</param>
/// <returns>A single bitmap of the overlayed tiles</returns>
public static byte[] OverlayTiles(MapParameters parameters, IDictionary <TileOverlayType, byte[]> tileList)
{
//Order for overlays:
List <TileOverlayType> orderedOverlayTypes = new List <TileOverlayType>
{
TileOverlayType.BaseMap, TileOverlayType.ProjectBoundary, TileOverlayType.Geofences, TileOverlayType.GeofenceBoundary,
TileOverlayType.ProductionData, TileOverlayType.LoadDumpData,
TileOverlayType.FilterCustomBoundary, TileOverlayType.FilterDesignBoundary, TileOverlayType.FilterAlignmentBoundary,
TileOverlayType.CutFillDesignBoundary, TileOverlayType.DxfLinework, TileOverlayType.Alignments
};
//Make an orderd list
List <byte[]> overlays = new List <byte[]>();
foreach (var overLayType in orderedOverlayTypes)
{
if (tileList.ContainsKey(overLayType))
{
overlays.Add(tileList[overLayType]);
}
}
return(OverlayTiles(parameters, overlays));
}
/// <summary>
/// Overlays the collection of tiles on top of each other and returns a single tile
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="tileList">The list of tiles to overlay</param>
/// <returns>A single bitmap of the overlayed tiles</returns>
public static byte[] OverlayTiles(MapParameters parameters, IEnumerable <byte[]> tileList)
{
byte[] overlayData = null;
//Overlay the tiles. Return an empty tile if none to overlay.
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
foreach (byte[] tileData in tileList)
{
if (tileData != null && tileData.Length > 0)
{
using (var tileStream = new MemoryStream(tileData))
{
var image = Image.Load <Rgba32>(tileStream);
bitmap.Mutate(ctx => ctx.DrawImage(image, 1f));
}
}
}
overlayData = bitmap.BitmapToByteArray();
}
return(overlayData);
}
public WebAppSPGlymaSession(string callingUrl, Guid sessionId, bool isParameter, MapParameter domainParameter, MapParameter rootMapParameter, params IRight[] requiredRights)
{
_callingUrl = callingUrl;
_sessionId = sessionId;
IRight[] heightenedRightRequirement = requiredRights;
Guid?domainId = null;
Guid?rootMapId = null;
if (rootMapParameter == null || rootMapParameter.IsDelayed)
{
/// If they passed through a delayed rootmap ID parameter, they are going to have to be a Glyma Map Manager at the very minimum to finish this transaction.
heightenedRightRequirement = new IRight[] { SPGlymaRightFactory.Instance.RootMapCreateRight };
}
else
{
rootMapId = rootMapParameter.Value;
}
if (domainParameter == null || domainParameter.IsDelayed)
{
/// If they passed through a delayed domain ID parameter, they are going to have to be a Glyma Project Manager at the very minimum to finish this transaction.
heightenedRightRequirement = new IRight[] { SPGlymaRightFactory.Instance.ProjectCreateRight };
}
else
{
domainId = domainParameter.Value;
}
if (!IsAuthorised(domainId, rootMapId, heightenedRightRequirement))
{
throw new UnauthorizedAccessException("This user does not have the required privileges for this task.");
}
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
/// <summary>
/// Gets a map tile with alignment center lines drawn on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="projectId">Legacy project ID</param>
/// <param name="alignmentPointsList">Points for the project's alignment files</param>
/// <returns>A bitmap</returns>
public byte[] GetAlignmentsBitmap(MapParameters parameters, long projectId, List <List <WGSPoint> > alignmentPointsList)
{
log.LogInformation($"GetAlignmentsBitmap: project {projectId}");
byte[] alignmentsImage = null;
if (alignmentPointsList != null && alignmentPointsList.Any())
{
using (Image <Rgba32> bitmap = new Image <Rgba32>(parameters.mapWidth, parameters.mapHeight))
{
foreach (var alignmentPoints in alignmentPointsList)
{
if (alignmentPoints != null && alignmentPoints.Any())
{
PointF[] pixelPoints = TileServiceUtils.LatLngToPixelOffset(alignmentPoints, parameters.pixelTopLeft, parameters.numTiles);
bitmap.Mutate(ctx => ctx.DrawLines(Rgba32.Red, 1, pixelPoints));
}
}
alignmentsImage = bitmap.BitmapToByteArray();
}
}
return(alignmentsImage);
}
public WebAppSPGlymaSession(string callingUrl, bool isParameter, MapParameter domainParameter, MapParameter rootMapParameter, params IRight[] requiredRights)
{
_callingUrl = callingUrl;
_sessionId = Guid.Empty;
IRight[] heightenedRightRequirement = requiredRights;
Guid? domainId = null;
Guid? rootMapId = null;
if (rootMapParameter == null || rootMapParameter.IsDelayed)
{
/// If they passed through a delayed rootmap ID parameter, they are going to have to be a Glyma Map Manager at the very minimum to finish this transaction.
heightenedRightRequirement = new IRight[] { SPGlymaRightFactory.Instance.RootMapCreateRight };
}
else
{
rootMapId = rootMapParameter.Value;
}
if (domainParameter == null || domainParameter.IsDelayed)
{
/// If they passed through a delayed domain ID parameter, they are going to have to be a Glyma Project Manager at the very minimum to finish this transaction.
heightenedRightRequirement = new IRight[] { SPGlymaRightFactory.Instance.ProjectCreateRight };
}
else
{
domainId = domainParameter.Value;
}
if (!IsAuthorised(domainId, rootMapId, heightenedRightRequirement))
{
throw new UnauthorizedAccessException("This user does not have the required privileges for this task.");
}
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
public void SetContent(MapParameters parameters)
{
if (!parameters.IsFolder())
{
ScenarioName.Content = parameters.Basic.scenario_name;
PlayersValue.Content = parameters.Basic.players_value;
MapSize.Content = parameters.Basic.width_size.ToString() + 'x' + parameters.Basic.height_size.ToString();
VictoryConditions.Content = parameters.Basic.victory_conditions;
DefeatConditions.Content = parameters.Basic.defeat_conditions;
}
else
{
string name = Path.GetFileName(parameters.Basic.scenario_name);
if (name == Settings.Default.MAPS_DIRECTORY_NAME)
{
ScenarioName.Content = "...";
}
else
{
ScenarioName.Content = name;
}
}
}
/// <summary>
/// Gets a map tile with DXF linework on it.
/// </summary>
/// <param name="parameters">Map parameters such as bounding box, tile size, zoom level etc.</param>
/// <param name="dxfFiles">The list of DXF files to overlay tiles for</param>
/// <returns>A bitmap</returns>
public async Task <byte[]> GetDxfBitmap(MapParameters parameters, IEnumerable <FileData> dxfFiles)
{
log.LogInformation("GetDxfBitmap");
byte[] overlayData = null;
if (dxfFiles != null && dxfFiles.Any())
{
List <byte[]> tileList = new List <byte[]>();
foreach (var dxfFile in dxfFiles)
{
if (dxfFile.ImportedFileType == ImportedFileType.Linework)
{
tileList.Add(await JoinDxfTiles(parameters, dxfFile));
}
}
log.LogDebug("Overlaying DXF bitmaps");
overlayData = TileServiceUtils.OverlayTiles(parameters, tileList);
}
return(overlayData);
}
public UpdateRelationship(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
public UpdateMetadata(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
public UpdateDescriptor(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
public WebAppSPGlymaSession(string callingUrl, Guid sessionId, Guid? domainId, Guid? rootMapId, params IRight[] requiredRights)
{
_callingUrl = callingUrl;
_sessionId = sessionId;
if (!IsAuthorised(domainId, rootMapId, requiredRights))
{
throw new UnauthorizedAccessException("This user does not have the required privileges for this task.");
}
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
public WebAppSPGlymaSession(string callingUrl)
{
_callingUrl = callingUrl;
_sessionId = Guid.Empty;
_session = new MapSession(this);
_parameters = new MapParameters(this);
}
public WebAppSPGlymaSession(string callingUrl, Guid sessionId)
{
_callingUrl = callingUrl;
_sessionId = sessionId;
_session = new MapSession(this, _sessionId);
_parameters = new MapParameters(this);
}
internal CreateDescriptor(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
public DeleteNode(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
public UpdateNode(MapParameters sessionMapParameters)
{
SessionMapParameters = sessionMapParameters;
}
