public override VectorElement BuildClusterElement(MapPos pos, VectorElementVector elements)
{
BalloonPopupStyle style = balloonPopupStyleBuilder.BuildStyle();
var popup = new BalloonPopup(pos, style, elements.Count.ToString(), "");
return popup;
}
public void ShowRoute(MapPos startPos, MapPos stopPos)
{
// Run routing in background
System.Threading.Tasks.Task.Run(() =>
{
long time = DateTime.Now.Millisecond;
RoutingResult result = Routing.GetResult(startPos, stopPos);
// Update response in UI thread
InvokeOnMainThread(() =>
{
if (result == null)
{
Alert("Routing failed");
return;
}
Alert(Routing.GetMessage(result, time, DateTime.Now.Millisecond));
Color darkGray = new Carto.Graphics.Color(50, 50, 50, 255);
Routing.Show(result, darkGray);
});
});
}
// Map View manipulation handlers
public override void OnMapClicked(MapClickInfo mapClickInfo)
{
if (mapClickInfo.ClickType == ClickType.ClickTypeLong)
{
MapPos clickPos = mapClickInfo.ClickPos;
if (startPos == null)
{
// Set start, or start again
startPos = clickPos;
if (StartPositionClicked != null) {
StartPositionClicked(new object(), new RouteMapEventArgs { ClickPosition = clickPos });
}
}
else if (stopPos == null)
{
// Set stop and calculate
stopPos = clickPos;
if (StartPositionClicked != null)
{
StopPositionClicked(new object(), new RouteMapEventArgs {
ClickPosition = clickPos,
StartPosition = startPos,
StopPosition = stopPos
});
}
// Restart to force new route next time
startPos = null;
stopPos = null;
}
}
}
public static async void AddMarkerToPosition(this MapView map, MapPos position)
{
await ThreadPool.RunAsync(delegate
{
// Initialize a local vector data source
Projection projection = map.Options.BaseProjection;
LocalVectorDataSource datasource = new LocalVectorDataSource(projection);
// Initialize a vector layer with the previous data source
VectorLayer layer = new VectorLayer(datasource);
// Add layer to map
map.Layers.Add(layer);
MarkerStyleBuilder builder = new MarkerStyleBuilder();
builder.Size = 15;
builder.Color = new Carto.Graphics.Color(0, 255, 0, 255);
MarkerStyle style = builder.BuildStyle();
// Create marker and add it to the source
Marker marker = new Marker(position, style);
datasource.Add(marker);
});
}
/// <summary>
/// Calculates the screen position corresponding to a map position, using the current view parameters.
/// </summary>
/// <param name="mapPos">The map position in base projection coordinate system.</param>
/// <returns>The calculated screen position. Can be off-screen.</returns>
public ScreenPos MapToScreen(MapPos mapPos)
{
return(_baseMapView.MapToScreen(mapPos));
}
/// <summary>
/// Zooms the view relative to the current zoom value. Positive values zoom in, negative values zoom out.
/// The new calculated zoom value will be clamped to the range of [0 .. 24] and to the range set by Options::setZoomRange.
///
/// Zooming is done towards the specified target position, keeping it at the same location on the screen.
///
/// If durationSeconds > 0 the zooming operation will be animated over time. If the previous zooming animation has not
/// finished by the time this method is called, it will be stopped.
/// </summary>
/// <param name="deltaZoom">The delta zoom value.</param>
/// <param name="targetPos">The zooming target position in the coordinate system of the base projection.</param>
/// <param name="durationSeconds">The duration in which the zooming operation will be completed in seconds.</param>
public void SetRelativeZoom(float deltaZoom, MapPos targetPos, float durationSeconds)
{
_baseMapView.Zoom(deltaZoom, targetPos, durationSeconds);
}
/// <summary>
/// Rotates the view relative to the current rotation value. Positive values rotate clockwise, negative values counterclockwise.
/// The new calculated rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable
/// is set to false.
///
/// Rotating is done around the specified target position, keeping it at the same location on the screen.
///
/// If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not
/// finished by the time this method is called, it will be stopped.
/// </summary>
/// <param name="deltaAngle">The delta angle value in degrees.</param>
/// <param name="targetPos">The zooming target position in the coordinate system of the base projection.</param>
/// <param name="durationSeconds">The duration in which the zooming operation will be completed in seconds.</param>
public void Rotate(float deltaAngle, MapPos targetPos, float durationSeconds)
{
_baseMapView.Rotate(deltaAngle, targetPos, durationSeconds);
}
public void AddTurret(Turret turret, MapPos position, ProjectileManager projectiles)
{
Turrets.Add(new TurretInstance(turret, position, LevelDesc, projectiles));
}
void OnPermissionGranted()
{
if (!MapView.FocusPos.Equals(position))
{
position = MapView.FocusPos;
number++;
Android.Graphics.Bitmap image = BitmapUtils.CreateAndroidBitmapFromBitmap(bitmap);
string folder = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
string filename = number + ".png";
string path = Path.Combine(folder, filename);
string message = null;
try
{
using (var stream = new FileStream(path, FileMode.Create))
{
image.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, stream);
}
}
catch (Exception e)
{
message = e.Message;
}
Share(path);
if (message == null)
{
Alert("Great success! Screenshot saved to: " + path);
}
else {
Alert("Error! " + message);
}
}
}
public void SetStopMarker(MapPos pos)
{
stopMarker.SetPos(pos);
stopMarker.Visible = true;
}
public void CreateRoutePoint(MapPos pos, RoutingInstruction instruction, LocalVectorDataSource source)
{
MarkerStyle style = instructionUp;
string str = "";
switch (instruction.Action)
{
case RoutingAction.RoutingActionHeadOn:
str = "head on";
break;
case RoutingAction.RoutingActionFinish:
str = "finish";
break;
case RoutingAction.RoutingActionTurnLeft:
style = instructionLeft;
str = "turn left";
break;
case RoutingAction.RoutingActionTurnRight:
style = instructionRight;
str = "turn right";
break;
case RoutingAction.RoutingActionUturn:
str = "u turn";
break;
case RoutingAction.RoutingActionNoTurn:
case RoutingAction.RoutingActionGoStraight:
//style = instructionUp;
//str = "continue";
break;
case RoutingAction.RoutingActionReachViaLocation:
style = instructionUp;
str = "stopover";
break;
case RoutingAction.RoutingActionEnterAgainstAllowedDirection:
str = "enter against allowed direction";
break;
case RoutingAction.RoutingActionLeaveAgainstAllowedDirection:
break;
case RoutingAction.RoutingActionEnterRoundabout:
str = "enter roundabout";
break;
case RoutingAction.RoutingActionStayOnRoundabout:
str = "stay on roundabout";
break;
case RoutingAction.RoutingActionLeaveRoundabout:
str = "leave roundabout";
break;
case RoutingAction.RoutingActionStartAtEndOfStreet:
str = "start at end of street";
break;
}
if (str != "")
{
Marker marker = new Marker(pos, style);
BalloonPopup popup2 = new BalloonPopup(marker, balloonBuilder.BuildStyle(), str, "");
source.Add(popup2);
source.Add(marker);
}
}
int CheckCastleSpot(Game game, Player player, MapPos position, int intelligence)
{
var map = game.Map;
int treeCount = map.FindInArea(position, 5, FindTree, 1).Count;
int stoneCount = map.FindInArea(position, 5, FindStone, 1).Count;
int fishCount = map.FindInArea(position, 7, FindFish, 1).Count;
int mountainCountNear = map.FindInArea(position, 3, FindMountain, 0).Count;
int mountainCountFar = map.FindInArea(position, 9, FindMountain, 4).Count;
int desertCount = map.FindInArea(position, 6, FindDesert, 0).Count;
int waterCount = map.FindInArea(position, 6, FindWater, 0).Count;
int numLargeSpots = 3;
int numSmallSpots = 3;
int keepDistanceToEnemies = 30 - (aggressivity / 2) * 10;
if (player.InitialSupplies < 5)
{
// we need coal and iron close enough when starting with low supplies
var minerals = map.FindInArea(position, 9, FindMineral, 1).Select(m => (KeyValuePair <Map.Minerals, uint>)m);
int ironCount = minerals.Where(m => m.Key == Map.Minerals.Iron).Select(m => (int)m.Value).Sum();
int coalCount = minerals.Where(m => m.Key == Map.Minerals.Coal).Select(m => (int)m.Value).Sum();
if (ironCount == 0 || coalCount == 0)
{
return(-1);
}
}
else // good amount of starting resources
{
if (map.Size > 5)
{
if (treeCount < 12 || stoneCount < 6)
{
return(-1);
}
}
else if (map.Size == 5)
{
if (treeCount < 9 || stoneCount < 5)
{
return(-1);
}
}
else if (map.Size == 4)
{
if (treeCount < 7 || stoneCount < 4)
{
return(-1);
}
}
}
// if we tried too often we will only assure that there is a bit of trees and stones
if (numTries >= 25 + map.Size * 5)
{
if (treeCount < 5 || stoneCount < 2)
{
return(-1);
}
if (numTries < 500) // after 500 tries, just place it somewhere
{
if (mountainCountNear > 7) // too close to mountain
{
return(-1);
}
if (desertCount > 6) // too much desert
{
return(-1);
}
if (waterCount > 8) // too much water
{
return(-1);
}
if (player.InitialSupplies < 3) // with 3 or more we have 1 iron ore and 1 coal
{
if (fishCount == 0 || stoneCount < 2 || treeCount < 5)
{
return(-1);
}
}
numLargeSpots = 2; // the toolmaker can be build when we have expanded the land
if (numTries >= 80 && player.InitialSupplies > 4)
{
numLargeSpots = 1; // we need to expand the territory to build the sawmill
}
if (game.Map.Size < 5)
{
// in small maps we no longer force enemy distance after many tries
if (numTries >= 120)
{
keepDistanceToEnemies = 0;
}
else if (numTries >= 80)
{
keepDistanceToEnemies = 15;
}
}
else if (numTries >= 200) // if tried very long we will have mercy in any case
{
keepDistanceToEnemies = 0;
}
}
}
else
{
if (mountainCountNear > 4) // too close to mountain
{
return(-1);
}
if (desertCount > 3) // too much desert
{
return(-1);
}
if (desertCount + waterCount + mountainCountNear + mountainCountFar > 10) // too much desert/water/mountain
{
return(-1);
}
var minerals = map.FindInArea(position, 9, FindMineral, 1).Select(m => (KeyValuePair <Map.Minerals, uint>)m);
int stoneOreCount = minerals.Where(m => m.Key == Map.Minerals.Stone).Select(m => (int)m.Value).Sum();
int goldCount = minerals.Where(m => m.Key == Map.Minerals.Gold).Select(m => (int)m.Value).Sum();
int ironCount = minerals.Where(m => m.Key == Map.Minerals.Iron).Select(m => (int)m.Value).Sum();
int coalCount = minerals.Where(m => m.Key == Map.Minerals.Coal).Select(m => (int)m.Value).Sum();
if (player.InitialSupplies < 5)
{
if (treeCount < 8 || stoneCount < 4 || fishCount < 1 || ironCount == 0 || coalCount == 0)
{
return(-1);
}
}
// low intelligence will treat half the mountains as the right mineral without checking
int halfMountainCount = (mountainCountNear + mountainCountFar) / 2;
int minConstructionCount = 3 + intelligence / 10 + Math.Max(buildingFocus, constructionMaterialFocus) * 5;
if (treeCount + stoneCount + Math.Max(halfMountainCount, stoneOreCount) < minConstructionCount)
{
return(-1);
}
int minFishCount = foodFocus * 5 + (player.InitialSupplies < 5 ? 1 : 0);
if (fishCount < minFishCount)
{
return(-1);
}
int minSteelCount = Math.Max(steelFocus, militaryFocus / 2) * 2;
int steelOreCount = (intelligence < 20) ? Math.Max(halfMountainCount, ironCount + coalCount) : ironCount + coalCount;
if (steelOreCount < minSteelCount)
{
return(-1);
}
int minGoldCount = goldFocus / 2;
int goldOreCount = (intelligence < 20) ? Math.Max(halfMountainCount, goldCount) : ironCount + coalCount;
if (goldCount < minGoldCount)
{
return(-1);
}
}
if (keepDistanceToEnemies > 0 && numTries < 1000)
{
for (uint i = 0; i < game.PlayerCount; ++i)
{
var enemy = game.GetPlayer(i);
if (enemy == player || !enemy.HasCastle)
{
continue;
}
int distance = Math.Min(Math.Abs(game.Map.DistanceX(position, enemy.CastlePosition)), Math.Abs(game.Map.DistanceY(position, enemy.CastlePosition)));
if (distance < keepDistanceToEnemies)
{
return(-1);
}
}
}
// check if we can build at least: lumberjack, stonecutter, sawmill, toolmaker and one hut
// -> 3 small and 2 large buildings
// but we check the castle too, so 3 large buildings
int numSmall = 0;
int numLarge = 0;
List <uint> largeSpots = new List <uint>();
for (int i = 0; i < 100; ++i)
{
uint checkPosition = map.PositionAddSpirally(position, (uint)i);
if (game.CanBuildLarge(checkPosition))
{
++numSmall;
++numLarge;
largeSpots.Add(checkPosition);
}
else if (game.CanBuildSmall(checkPosition))
{
++numSmall;
}
// TODO: What if a building would block another building spot.
if (numLarge >= numLargeSpots && (numSmall - numLargeSpots) >= numSmallSpots)
{
return((int)largeSpots[0]);
}
}
return(-1);
}
static Point GetPoint(Projection projection, MapPos position, Color color)
{
PointStyleBuilder pointStyleBuilder = new PointStyleBuilder();
pointStyleBuilder.Color = color;
pointStyleBuilder.Size = 16;
return new Point(projection.FromWgs84(position), pointStyleBuilder.BuildStyle());
}
static Marker GetMarker(Projection projection, MapPos position, Bitmap image)
{
//TODO
//Bitmap androidMarkerBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.marker);
//com.carto.graphics.Bitmap markerBitmap = BitmapUtils.createBitmapFromAndroidBitmap(androidMarkerBitmap);
// Create marker style
MarkerStyleBuilder builder = new MarkerStyleBuilder();
builder.Bitmap = image;
builder.Size = 30;
MarkerStyle style = builder.BuildStyle();
// Create and return marker
return new Marker(projection.FromWgs84(position), style);
}
bool FindMountainWithFlag(Map map, MapPos position)
{
return(FindMountain(map, position, true));
}
public DirectionCycleCCW(Direction start, MapPos length)
: base(start, length)
{
}
public static void AnimateZoomTo(this MapView map, MapPos position)
{
position = map.Options.BaseProjection.FromWgs84(new MapPos(24.650415, 59.428773));
map.SetFocusPos(position, 2);
map.Zoom = 14;
}
/// <summary>
/// Extract column from MapPos.
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
public uint PositionColumn(MapPos position)
{
return(position & ColumnMask);
}
public RoutingResult GetResult(MapPos startPos, MapPos stopPos)
{
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(BaseProjection, poses);
return Service.CalculateRoute(request);
}
/// <summary>
/// Extract row from MapPos.
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
public uint PositionRow(MapPos position)
{
return((position >> RowShift) & RowMask);
}
public void CreateRoutePoint(MapPos pos, RoutingInstruction instruction, LocalVectorDataSource source)
{
MarkerStyle style = instructionUp;
string str = "";
switch (instruction.Action)
{
case RoutingAction.RoutingActionHeadOn:
str = "head on";
break;
case RoutingAction.RoutingActionFinish:
str = "finish";
break;
case RoutingAction.RoutingActionTurnLeft:
style = instructionLeft;
str = "turn left";
break;
case RoutingAction.RoutingActionTurnRight:
style = instructionRight;
str = "turn right";
break;
case RoutingAction.RoutingActionUturn:
str = "u turn";
break;
case RoutingAction.RoutingActionNoTurn:
case RoutingAction.RoutingActionGoStraight:
//style = instructionUp;
//str = "continue";
break;
case RoutingAction.RoutingActionReachViaLocation:
style = instructionUp;
str = "stopover";
break;
case RoutingAction.RoutingActionEnterAgainstAllowedDirection:
str = "enter against allowed direction";
break;
case RoutingAction.RoutingActionLeaveAgainstAllowedDirection:
break;
case RoutingAction.RoutingActionEnterRoundabout:
str = "enter roundabout";
break;
case RoutingAction.RoutingActionStayOnRoundabout:
str = "stay on roundabout";
break;
case RoutingAction.RoutingActionLeaveRoundabout:
str = "leave roundabout";
break;
case RoutingAction.RoutingActionStartAtEndOfStreet:
str = "start at end of street";
break;
}
if (str != "")
{
Marker marker = new Marker(pos, style);
BalloonPopup popup2 = new BalloonPopup(marker, balloonBuilder.BuildStyle(), str, "");
source.Add(popup2);
source.Add(marker);
}
}
/// <summary>
/// Addition of two map positions.
/// </summary>
/// <param name="position"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public MapPos PositionAdd(MapPos position, int x, int y)
{
return(Position((uint)((int)Columns + (int)PositionColumn(position) + x) & ColumnMask, (uint)((int)Rows + (int)PositionRow(position) + y) & RowMask));
}
private static void ThreeZoneIntercalibration(string [] args, ref SySal.DAQSystem.Scanning.IntercalibrationInfo intercal, bool rewrite)
{
int i, n;
int MinMatches = Convert.ToInt32(args[11]);
SySal.Processing.QuickMapping.QuickMapper QMap = new SySal.Processing.QuickMapping.QuickMapper();
SySal.Processing.QuickMapping.Configuration C = (SySal.Processing.QuickMapping.Configuration)QMap.Config;
C.PosTol = Convert.ToDouble(args[8], System.Globalization.CultureInfo.InvariantCulture);
C.SlopeTol = Convert.ToDouble(args[9], System.Globalization.CultureInfo.InvariantCulture);
QMap.Config = C;
double ZProj = Convert.ToDouble(args[7], System.Globalization.CultureInfo.InvariantCulture);
double maxoffset = Convert.ToDouble(args[10], System.Globalization.CultureInfo.InvariantCulture);
MapPos [] mappositions = new MapPos[3];
SySal.Scanning.Plate.IO.OPERA.LinkedZone [] savezones = new SySal.Scanning.Plate.IO.OPERA.LinkedZone[3];
for (n = 0; n < 3; n++)
{
SySal.Scanning.Plate.IO.OPERA.LinkedZone reflz = (SySal.Scanning.Plate.IO.OPERA.LinkedZone)SySal.OperaPersistence.Restore(args[1 + n * 2], typeof(SySal.Scanning.Plate.IO.OPERA.LinkedZone));
SySal.Tracking.MIPEmulsionTrackInfo [] refzone = new SySal.Tracking.MIPEmulsionTrackInfo[reflz.Length];
for (i = 0; i < refzone.Length; i++)
{
refzone[i] = reflz[i].Info;
}
reflz = null;
SySal.Scanning.Plate.IO.OPERA.LinkedZone caliblz = (SySal.Scanning.Plate.IO.OPERA.LinkedZone)SySal.OperaPersistence.Restore(args[2 + n * 2], typeof(SySal.Scanning.Plate.IO.OPERA.LinkedZone));
if (rewrite)
{
savezones[n] = caliblz;
}
SySal.Tracking.MIPEmulsionTrackInfo [] calibzone = new SySal.Tracking.MIPEmulsionTrackInfo[caliblz.Length];
for (i = 0; i < calibzone.Length; i++)
{
calibzone[i] = caliblz[i].Info;
}
caliblz = null;
GC.Collect();
Console.Write("Zone #" + n.ToString() + " ");
SySal.Scanning.PostProcessing.PatternMatching.TrackPair [] pairs = QMap.Match(refzone, calibzone, ZProj, maxoffset, maxoffset);
if (pairs.Length < MinMatches)
{
Console.Error.WriteLine("Too few matching tracks: " + MinMatches.ToString() + " required, " + pairs.Length + " obtained. Aborting.");
return;
}
Console.WriteLine("Matches: " + pairs.Length);
mappositions[n].SetFromPairs(pairs);
mappositions[n].X -= intercal.RX;
mappositions[n].Y -= intercal.RY;
}
double x20 = mappositions[2].X - mappositions[0].X;
double x10 = mappositions[1].X - mappositions[0].X;
double y20 = mappositions[2].Y - mappositions[0].Y;
double y10 = mappositions[1].Y - mappositions[0].Y;
double det = 1.0 / (x10 * y20 - x20 * y10);
double u20 = mappositions[2].DX - mappositions[0].DX;
double v20 = mappositions[2].DY - mappositions[0].DY;
double u10 = mappositions[1].DX - mappositions[0].DX;
double v10 = mappositions[1].DY - mappositions[0].DY;
intercal.MXX = (u10 * y20 - u20 * y10) * det;
intercal.MXY = (u20 * x10 - u10 * x20) * det;
intercal.MYX = (v10 * y20 - v20 * y10) * det;
intercal.MYY = (v20 * x10 - v10 * x20) * det;
intercal.TX = mappositions[0].DX - intercal.MXX * mappositions[0].X - intercal.MXY * mappositions[0].Y;
intercal.TY = mappositions[0].DY - intercal.MYX * mappositions[0].X - intercal.MYY * mappositions[0].Y;
intercal.MXX += 1.0;
intercal.MYY += 1.0;
CheckIntercalibration(intercal);
if (rewrite)
{
MyTransformation.Transformation = intercal;
for (n = 0; n < 3; n++)
{
SySal.OperaPersistence.Persist(args[2 + n * 2], new LinkedZone(savezones[n]));
}
}
}
/// <summary>
/// Addition of two map positions.
/// </summary>
/// <param name="position"></param>
/// <param name="offset"></param>
/// <returns></returns>
public MapPos PositionAdd(MapPos position, MapPos offset)
{
return(Position((PositionColumn(position) + PositionColumn(offset)) & ColumnMask,
(PositionRow(position) + PositionRow(offset)) & RowMask));
}
/// <summary>
/// Sets the new absolute focus position. The new focus position is expected to be in
/// the coordinate system of the base projection. The new focus position will be clamped to
/// the world bounds and to the bounds set by Options::setPanBounds.
///
/// If durationSeconds > 0 the panning operation will be animated over time. If the previous panning animation has not
/// finished by the time this method is called, it will be stopped.
/// </summary>
/// <param name="pos">The new focus point position in base coordinate system.</param>
/// <param name="durationSeconds">The duration in which the tilting operation will be completed in seconds.</param>
public void SetFocusPos(MapPos pos, float durationSeconds)
{
_baseMapView.SetFocusPos(pos, durationSeconds);
}
/// <summary>
/// Shortest signed distance between map positions.
/// </summary>
/// <param name="position1"></param>
/// <param name="position2"></param>
/// <returns></returns>
public int DistanceX(MapPos position1, MapPos position2)
{
return((int)Columns / 2 - (int)(((int)Columns / 2 + (int)PositionColumn(position1) - (int)PositionColumn(position2)) & ColumnMask));
}
/// <summary>
/// Sets the new absolute rotation value. 0 means look north, 90 means west, -90 means east and 180 means south.
/// The rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable
/// is set to false.
///
/// Rotating is done around the specified target position, keeping it at the same location on the screen.
///
/// If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not
/// finished by the time this method is called, it will be stopped.
/// </summary>
/// <param name="angle">The new absolute rotation angle value in degrees.</param>
/// <param name="targetPos">The zooming target position in the coordinate system of the base projection.</param>
/// <param name="durationSeconds">The duration in which the zooming operation will be completed in seconds.</param>
public void SetMapRotation(float angle, MapPos targetPos, float durationSeconds)
{
_baseMapView.SetRotation(angle, targetPos, durationSeconds);
}
public int DistanceY(MapPos position1, MapPos position2)
{
return((int)Rows / 2 - (int)(((int)Rows / 2 + (int)PositionRow(position1) - (int)PositionRow(position2)) & RowMask));
}
/// <summary>
/// Sets the new absolute zoom value. The minimum zoom value is 0, which means absolutely zoomed out and the maximum
/// zoom value is 24. The zoom value can be further constrained by the Options::setZoomRange method. Values
/// exceeding these ranges will be clamped.
///
/// Zooming is done towards the specified target position, keeping it at the same location on the screen.
///
/// If durationSeconds > 0, the zooming operation will be animated over time. If the previous zooming animation has not
/// finished by the time this method is called, it will be stopped.
/// </summary>
/// <param name="zoom">The new absolute zoom value.</param>
/// <param name="targetPos">The zooming target position in the coordinate system of the base projection.</param>
/// <param name="durationSeconds">The duration in which the zooming operation will be completed in seconds.</param>
public void SetZoom(float zoom, MapPos targetPos, float durationSeconds)
{
_baseMapView.SetZoom(zoom, targetPos, durationSeconds);
}
/// <summary>
/// Movement of map position according to directions.
/// </summary>
/// <param name="position"></param>
/// <param name="direction"></param>
/// <returns></returns>
public MapPos Move(MapPos position, Direction direction)
{
return(PositionAdd(position, directions[(int)direction]));
}
bool FindMountain(Map map, MapPos position)
{
return(FindMountain(map, position, false));
}
public MapPos MoveRight(MapPos position)
{
return(Move(position, Direction.Right));
}
public static void ShowResult(this LocalVectorDataSource source, MapView map, GeocodingResult result, string title, string description, bool goToPosition)
{
source.Clear();
var builder = new BalloonPopupStyleBuilder();
builder.LeftMargins = new BalloonPopupMargins(0, 0, 0, 0);
builder.TitleMargins = new BalloonPopupMargins(6, 3, 6, 3);
builder.CornerRadius = 5;
// Make sure this label is shown on top of all other labels
builder.PlacementPriority = 10;
FeatureCollection collection = result.FeatureCollection;
int count = collection.FeatureCount;
MapPos position = new MapPos();
Geometry geometry;
for (int i = 0; i < count; i++)
{
geometry = collection.GetFeature(i).Geometry;
var color = new Carto.Graphics.Color(0, 100, 200, 150);
var pointBuilder = new PointStyleBuilder();
pointBuilder.Color = color;
var lineBuilder = new LineStyleBuilder();
lineBuilder.Color = color;
var polygonBuilder = new PolygonStyleBuilder();
polygonBuilder.Color = color;
VectorElement element = null;
if (geometry is PointGeometry)
{
element = new Point(geometry as PointGeometry, pointBuilder.BuildStyle());
}
else if (geometry is LineGeometry)
{
element = new Line(geometry as LineGeometry, lineBuilder.BuildStyle());
}
else if (geometry is PolygonGeometry)
{
element = new Polygon(geometry as PolygonGeometry, polygonBuilder.BuildStyle());
}
else if (geometry is MultiGeometry)
{
var collectionBuilder = new GeometryCollectionStyleBuilder();
collectionBuilder.PointStyle = pointBuilder.BuildStyle();
collectionBuilder.LineStyle = lineBuilder.BuildStyle();
collectionBuilder.PolygonStyle = polygonBuilder.BuildStyle();
element = new GeometryCollection(geometry as MultiGeometry, collectionBuilder.BuildStyle());
}
if (element != null)
{
position = geometry.CenterPos;
source.Add(element);
}
}
if (goToPosition)
{
map.SetFocusPos(position, 1.0f);
map.SetZoom(16, 1.0f);
}
var popup = new BalloonPopup(position, builder.BuildStyle(), title, description);
source.Add(popup);
}
public MapPos MoveDown(MapPos position)
{
return(Move(position, Direction.Down));
}
public static long CreateIndex(MapPos position, Direction direction)
{
return((((long)direction) << 32) | position);
}
public MapPos MoveLeft(MapPos position)
{
return(Move(position, Direction.Left));
}
public void SetStopMarker(MapPos pos)
{
stopMarker.SetPos(pos);
stopMarker.Visible = true;
}
public MapPos MoveUp(MapPos position)
{
return(Move(position, Direction.Up));
}
public void SetStartMarker(MapPos startPos)
{
routeDataSource.Clear();
stopMarker.Visible = false;
startMarker.SetPos(startPos);
startMarker.Visible = true;
}
public MapPos MoveRightN(MapPos position, int count)
{
return(PositionAdd(position, (MapPos)(directions[(int)Direction.Right] * count)));
}
// Creates a line from GraphHopper response
protected Line CreatePolyline(MapPos start, MapPos end, RoutingResult result, Color darkGray)
{
LineStyleBuilder lineStyleBuilder = new LineStyleBuilder();
lineStyleBuilder.Color = darkGray;
lineStyleBuilder.Width = 12;
return new Line(result.Points, lineStyleBuilder.BuildStyle());
}
public MapPos MoveDownN(MapPos position, int count)
{
return(PositionAdd(position, (MapPos)(directions[(int)Direction.Down] * count)));
}
public override void SetCenter(MapPos mapPos)
{
mapView.SetFocusPos(mapView.Options.BaseProjection.FromWgs84(mapPos), 1.0f);
}
public void ZoomTo(MapPos position)
{
MapView.FocusPos = MapView.Options.BaseProjection.FromWgs84(position);
MapView.SetZoom(12, 2);
}
