/// <summary>
/// Called, when mouse/finger/pen click/touch map
/// </summary>
/// <param name="touchPoints">List of all touched points</param>
private bool OnTouchStart(List <Geometries.Point> touchPoints)
{
// Sanity check
if (touchPoints.Count == 0)
{
return(false);
}
// We have a new interaction with the screen, so stop all navigator animations
Navigator.StopRunningAnimation();
var args = new TouchedEventArgs(touchPoints);
TouchStarted?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
if (touchPoints.Count == 2)
{
(_previousCenter, _previousRadius, _previousAngle) = GetPinchValues(touchPoints);
_mode = TouchMode.Zooming;
_innerRotation = Viewport.Rotation;
}
else
{
_mode = TouchMode.Dragging;
_previousCenter = touchPoints.First();
}
return(true);
}
public void ZoomToBox(Geometries.Point beginPoint, Geometries.Point endPoint)
{
double x, y, resolution;
var width = Math.Abs(endPoint.X - beginPoint.X);
var height = Math.Abs(endPoint.Y - beginPoint.Y);
if (width <= 0)
{
return;
}
if (height <= 0)
{
return;
}
ZoomHelper.ZoomToBoudingbox(beginPoint.X, beginPoint.Y, endPoint.X, endPoint.Y, ActualWidth, out x, out y, out resolution);
resolution = ZoomHelper.ClipToExtremes(map.Resolutions, resolution);
viewport.Center = new Geometries.Point(x, y);
viewport.Resolution = resolution;
map.ViewChanged(true, viewport.Extent, viewport.Resolution);
OnViewChanged(false);
RefreshGraphics();
ClearBBoxDrawing();
}
void MapControl_PointerWheelChanged(object sender, PointerRoutedEventArgs e)
{
if (ZoomLocked)
{
return;
}
if (!viewInitialized)
{
return;
}
var currentPoint = e.GetCurrentPoint(this); //Needed for both MouseMove and MouseWheel event for mousewheel event
var mousePosition = new Geometries.Point(currentPoint.RawPosition.X, currentPoint.RawPosition.Y);
var newResolution = DetermineNewResolution(currentPoint.Properties.MouseWheelDelta, viewport.Resolution);
// 1) Temporarily center on the mouse position
viewport.Center = viewport.ScreenToWorld(mousePosition.X, mousePosition.Y);
// 2) Then zoom
viewport.Resolution = newResolution;
// 3) Then move the temporary center of the map back to the mouse position
viewport.Center = viewport.ScreenToWorld(
viewport.Width - mousePosition.X,
viewport.Height - mousePosition.Y);
e.Handled = true;
RefreshGraphics();
map.ViewChanged(true, viewport.Extent, viewport.Resolution);
OnViewChanged(true);
}
private void MapControlMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
#if !SILVERLIGHT
if (e.StylusDevice != null)
{
return;
}
#endif
if (IsInBoxZoomMode || ZoomToBoxMode)
{
ZoomToBoxMode = false;
Geometries.Point previous = Map.Viewport.ScreenToWorld(_previousMousePosition.X, _previousMousePosition.Y);
Geometries.Point current = Map.Viewport.ScreenToWorld(e.GetPosition(this).X, e.GetPosition(this).Y);
ZoomToBox(previous, current);
}
else
{
HandleFeatureInfo(e);
var eventArgs = GetMouseInfoEventArgs(e.GetPosition(this), MouseInfoUpLayers);
OnMouseInfoUp(eventArgs ?? new MouseInfoEventArgs());
}
_map.ViewChanged(true);
OnViewChanged(true);
_mouseDown = false;
_previousMousePosition = new Point();
ReleaseMouseCapture();
}
public static void Render(Graphics graphics, IGeometry feature, IStyle style, IViewport viewport)
{
var stream = ((IRaster)feature).Data;
stream.Position = 0;
var bitmap = new Bitmap(stream);
Geometries.Point min = viewport.WorldToScreen(new Geometries.Point(feature.GetBoundingBox().MinX, feature.GetBoundingBox().MinY));
Geometries.Point max = viewport.WorldToScreen(new Geometries.Point(feature.GetBoundingBox().MaxX, feature.GetBoundingBox().MaxY));
Rectangle destination = RoundToPixel(new RectangleF((float)min.X, (float)max.Y, (float)(max.X - min.X), (float)(min.Y - max.Y)));
graphics.DrawImage(bitmap,
destination,
0, 0, bitmap.Width, bitmap.Height,
GraphicsUnit.Pixel,
new ImageAttributes());
if (DeveloperTools.DeveloperMode)
{
var font = new System.Drawing.Font("Arial", 12);
var message = (GC.GetTotalMemory(true) / 1000).ToString(CultureInfo.InvariantCulture) + " KB";
graphics.DrawString(message, font, new SolidBrush(Color.Black), 10f, 10f);
}
bitmap.Dispose();
}
private Bitmap GeneratePartialBitmap(Geometries.Point center, XPosition xPos, YPosition yPos)
{
double x = center.X, y = center.Y;
switch (xPos)
{
case XPosition.Right:
x += m_Map.Envelope.Width;
break;
case XPosition.Left:
x -= m_Map.Envelope.Width;
break;
}
switch (yPos)
{
case YPosition.Top:
y += m_Map.Envelope.Height;
break;
case YPosition.Bottom:
y -= m_Map.Envelope.Height;
break;
}
m_Map.Center = new Geometries.Point(x, y);
return(m_Map.GetMap() as Bitmap);
}
/// <summary>
/// Called, when mouse/finger/pen click/touch map
/// </summary>
/// <param name="touchPoints">List of all touched points</param>
private bool OnTouchStart(List <Geometries.Point> touchPoints)
{
// Sanity check
if (touchPoints.Count == 0)
{
return(false);
}
var args = new TouchedEventArgs(touchPoints);
TouchStarted?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
if (touchPoints.Count == 2)
{
(_previousCenter, _previousRadius, _previousAngle) = GetPinchValues(touchPoints);
_mode = TouchMode.Zooming;
_innerRotation = Viewport.Rotation;
}
else
{
_mode = TouchMode.Dragging;
_previousCenter = touchPoints.First();
}
return(true);
}
#pragma warning restore 67
private void MapControl_PointerWheelChanged(object sender, PointerRoutedEventArgs e)
{
if (Map.ZoomLock)
{
return;
}
if (!Viewport.HasSize)
{
return;
}
var currentPoint = e.GetCurrentPoint(this);
//Needed for both MouseMove and MouseWheel event for mousewheel event
var mousePosition = new Geometries.Point(currentPoint.RawPosition.X, currentPoint.RawPosition.Y);
if (currentPoint.Properties.MouseWheelDelta > 0)
{
Navigator.ZoomIn(mousePosition);
}
else if (currentPoint.Properties.MouseWheelDelta < 0)
{
Navigator.ZoomOut(mousePosition);
}
e.Handled = true;
Refresh();
}
/// <summary>
/// Called, when mouse/finger/pen tapped on map 2 or more times
/// </summary>
/// <param name="screenPosition">First clicked/touched position on screen</param>
/// <param name="numOfTaps">Number of taps on map (2 is a double click/tap)</param>
/// <returns>True, if the event is handled</returns>
private bool OnDoubleTapped(Geometries.Point screenPosition, int numOfTaps)
{
var args = new TappedEventArgs(screenPosition, numOfTaps);
DoubleTap?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
var eventReturn = InvokeInfo(Map.Layers, Map.GetWidgetsOfMapAndLayers(), Viewport, screenPosition,
screenPosition, _renderer.SymbolCache, WidgetTouched, numOfTaps);
if (eventReturn != null)
{
if (!eventReturn.Handled)
{
// Double tap as zoom
return(OnZoomIn(screenPosition));
}
}
return(false);
}
public void ZoomToBox(Geometries.Point beginPoint, Geometries.Point endPoint)
{
var width = Math.Abs(endPoint.X - beginPoint.X);
var height = Math.Abs(endPoint.Y - beginPoint.Y);
if (width <= 0)
{
return;
}
if (height <= 0)
{
return;
}
ZoomHelper.ZoomToBoudingbox(
beginPoint.X, beginPoint.Y, endPoint.X, endPoint.Y,
Map.Viewport.Width, Map.Viewport.Height,
out var x, out var y, out var resolution);
resolution = ViewportLimiter.LimitResolution(resolution, _map.Viewport.Width, _map.Viewport.Height, _map.ZoomMode, _map.ZoomLimits,
_map.Resolutions, _map.Envelope);
_map.Viewport.Resolution = resolution;
_map.Viewport.Center = new Geometries.Point(x, y);
_map.RefreshData(true);
RefreshGraphics();
ClearBBoxDrawing();
}
public static CGRect ConvertPointBoundingBox(SymbolStyle symbolStyle, BoundingBox boundingBox, IViewport viewport)
{
var screenMin = viewport.WorldToScreen(boundingBox.Min);
var screenMax = viewport.WorldToScreen(boundingBox.Max);
//boundingBox.Offset = symbolStyle.SymbolOffset;
//var newMin = boundingBox.Min;
//var newMax = boundingBox.Max;
if (symbolStyle.SymbolOffset != null)
{
screenMin = new Geometries.Point(
screenMin.X - symbolStyle.SymbolOffset.X,
screenMin.Y - symbolStyle.SymbolOffset.Y);
screenMax = new Geometries.Point(
screenMax.X - symbolStyle.SymbolOffset.X,
screenMax.Y - symbolStyle.SymbolOffset.Y);
var w = viewport.ScreenToWorld(screenMin);
boundingBox.Offset(new Geometries.Point(w.X - boundingBox.MinX, w.Y - boundingBox.MinY));
screenMin = viewport.WorldToScreen(boundingBox.Min);
screenMax = viewport.WorldToScreen(boundingBox.Max);
}
var min = new Geometries.Point(screenMin.X - (32 / 2), screenMax.Y - (32 / 2)); //!!!
var max = new Geometries.Point((min.X + 32), (min.Y + 32)); //!!!
var frame = RoundToPixel(min, max);
//if(symbolStyle.SymbolOffset != null)
// frame.Offset ((float)symbolStyle.SymbolOffset.X, (float)symbolStyle.SymbolOffset.Y);
return frame;
}
/// <summary>
/// Called, when mouse/finger/pen hovers around
/// </summary>
/// <param name="screenPosition">Actual position of mouse/finger/pen</param>
private bool OnHovered(Geometries.Point screenPosition)
{
var args = new HoveredEventArgs(screenPosition);
Hovered?.Invoke(this, args);
return(args.Handled);
}
/// <summary>
/// Called, when mouse/finger/pen tapped long on map
/// </summary>
/// <param name="screenPosition">Clicked/touched position on screen</param>
/// <returns>True, if the event is handled</returns>
private bool OnLongTapped(Geometries.Point screenPosition)
{
var args = new TappedEventArgs(screenPosition, 1);
LongTap?.Invoke(this, args);
return(args.Handled);
}
public static void Pan(Viewport view, Point currentMap, Point previousMap)
{
Geometries.Point current = view.ScreenToWorld(currentMap.X, currentMap.Y);
Geometries.Point previous = view.ScreenToWorld(previousMap.X, previousMap.Y);
double diffX = previous.X - current.X;
double diffY = previous.Y - current.Y;
view.Center = new Geometries.Point(view.CenterX + diffX, view.CenterY + diffY);
}
public Geometries.Point GroundToImage(Geometries.Point groundPoint)
{
Geometries.Point imagePoint = new Geometries.Point();
imagePoint.X = inverseTransform[0] + inverseTransform[1] * groundPoint.X + inverseTransform[2] * groundPoint.Y;
imagePoint.Y = inverseTransform[3] + inverseTransform[4] * groundPoint.X + inverseTransform[5] * groundPoint.Y;
return(imagePoint);
}
public Geometries.Point ImageToGround(Geometries.Point imagePoint)
{
Geometries.Point groundPoint = new Geometries.Point();
groundPoint.X = transform[0] + transform[1] * imagePoint.X + transform[2] * imagePoint.Y;
groundPoint.Y = transform[3] + transform[4] * imagePoint.X + transform[5] * imagePoint.Y;
return(groundPoint);
}
private void WidgetTouched(IWidget widget, Geometries.Point screenPosition)
{
if (widget is Hyperlink hyperlink)
{
Task.Run(() => Launcher.LaunchUriAsync(new Uri(hyperlink.Url)));
}
widget.HandleWidgetTouched(screenPosition);
}
private void GetBounds(Geometries.Point p1, Geometries.Point p2,
out Geometries.Point lowerLeft, out Geometries.Point upperRight)
{
lowerLeft = new Geometries.Point(Math.Min(p1.X, p2.X), Math.Min(p1.Y, p2.Y));
upperRight = new Geometries.Point(Math.Max(p1.X, p2.X), Math.Max(p1.Y, p2.Y));
System.Diagnostics.Debug.WriteLine("p1: " + p1);
System.Diagnostics.Debug.WriteLine("p2: " + p2);
System.Diagnostics.Debug.WriteLine("lowerLeft: " + lowerLeft);
System.Diagnostics.Debug.WriteLine("upperRight: " + upperRight);
}
public static GeographicPosition ToGeographicPosition(this Geometries.Point c, int x, int y, int z, uint extent)
{
var size = extent * Math.Pow(2, z);
var x0 = extent * x;
var y0 = extent * y;
var y2 = 180 - (c.Y + y0) * 360 / size;
var lon = (c.X + x0) * 360 / size - 180;
var lat = 360 / Math.PI * Math.Atan(Math.Exp(y2 * Math.PI / 180)) - 90;
return(new GeographicPosition(lat, lon));
}
private static CGRect RoundToPixel(Geometries.Point min, Geometries.Point max)
{
// To get seamless aligning you need to round the
// corner coordinates to pixel. The new width and
// height will be a result of that.
var x = Math.Round(min.X);
var y = Math.Round(min.Y);
var width = Math.Round(max.X) - Math.Round(min.X);
var height = Math.Round(max.Y) - Math.Round(min.Y);
return(new CGRect((float)x, (float)y, (float)width, (float)height));
}
//end of windows phone support
private void PanAndZoom(Geometries.Point current, Geometries.Point previous, double deltaScale)
{
var diffX = previous.X - current.X;
var diffY = previous.Y - current.Y;
var newX = viewport.CenterX + diffX;
var newY = viewport.CenterY + diffY;
var zoomCorrectionX = (1 - deltaScale) * (current.X - viewport.CenterX);
var zoomCorrectionY = (1 - deltaScale) * (current.Y - viewport.CenterY);
viewport.Resolution = viewport.Resolution / deltaScale;
viewport.Center = new Geometries.Point(newX - zoomCorrectionX, newY - zoomCorrectionY);
}
/// <summary>
/// Called, when mouse/finger/pen tapped on map one time
/// </summary>
/// <param name="screenPosition">Clicked/touched position on screen</param>
private bool OnSingleTapped(Geometries.Point screenPosition)
{
var args = new TappedEventArgs(screenPosition, 1);
SingleTap?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
return(Map.InvokeInfo(screenPosition, screenPosition, _scale, _renderer.SymbolCache, WidgetTouched, 1));
}
void mapControl_ViewChanged(object sender, Windows.ViewChangedEventArgs e)
{
if (_first)
{
_first = false;
// sample: zoom to default area at startup
var beginPoint = new Geometries.Point(-4000000, 2000000);
var endPoint = new Geometries.Point(4000000, 11000000);
mapControl.ZoomToBox(beginPoint, endPoint);
mapControl.Refresh();
}
}
void mapControl_ViewChanged(object sender, Windows.ViewChangedEventArgs e)
{
if (_first)
{
_first = false;
// sample: zoom to default area at startup
var beginPoint = new Geometries.Point(-4000000, 2000000);
var endPoint = new Geometries.Point(4000000, 11000000);
mapControl.ZoomToBox(beginPoint, endPoint);
mapControl.Refresh();
}
}
public static UIElement RenderLabel(Geometries.Point position, LabelStyle labelStyle, IReadOnlyViewport viewport,
string labelText)
{
var screenPosition = viewport.WorldToScreen(position);
var windowsPosition = screenPosition.ToXaml();
// Set some defaults which should be configurable someday
const double witdhMargin = 3.0;
const double heightMargin = 0.0;
var textblock = new TextBlock
{
Text = labelText,
Foreground = new SolidColorBrush(labelStyle.ForeColor.ToXaml()),
FontFamily = new FontFamily(labelStyle.Font.FontFamily),
FontSize = labelStyle.Font.Size,
Margin = new Thickness(witdhMargin, heightMargin, witdhMargin, heightMargin),
};
// TODO: Halo is not supported by WPF, but we CAN do an outer glow-like effect...
if (labelStyle.Halo != null)
{
System.Windows.Media.Effects.DropShadowEffect haloEffect = new System.Windows.Media.Effects.DropShadowEffect();
haloEffect.ShadowDepth = 0;
haloEffect.Color = labelStyle.Halo.Color.ToXaml();
haloEffect.Opacity = haloEffect.Color.A / 255.0;
haloEffect.BlurRadius = labelStyle.Halo.Width * 2;
textblock.Effect = haloEffect;
}
var border = new Border
{
// TODO: We have no SymbolCache, so we get problems, if there is a bitmap as background
Background = labelStyle.BackColor.ToXaml(rotate: (float)viewport.Rotation),
CornerRadius = new CornerRadius(4),
Child = textblock,
Opacity = labelStyle.Opacity,
};
DetermineTextWidthAndHeightWpf(out var textWidth, out var textHeight, labelStyle, labelText);
var offsetX = labelStyle.Offset.IsRelative ? textWidth * labelStyle.Offset.X : labelStyle.Offset.X;
var offsetY = labelStyle.Offset.IsRelative ? textHeight * labelStyle.Offset.Y : labelStyle.Offset.Y;
border.SetValue(Canvas.LeftProperty, windowsPosition.X + offsetX
- (textWidth + 2 * witdhMargin) * (short)labelStyle.HorizontalAlignment * 0.5f);
border.SetValue(Canvas.TopProperty, windowsPosition.Y + offsetY
- (textHeight + 2 * heightMargin) * (short)labelStyle.VerticalAlignment * 0.5f);
return(border);
}
private void WidgetTouched(IWidget widget, Geometries.Point screenPosition)
{
if (widget is Hyperlink hyperlink)
{
global::Android.Net.Uri uri = global::Android.Net.Uri.Parse(hyperlink.Url);
Intent intent = new Intent(Intent.ActionView);
intent.SetData(uri);
Intent chooser = Intent.CreateChooser(intent, "Open with");
Context.StartActivity(chooser);
}
widget.HandleWidgetTouched(screenPosition);
}
/// <summary>
/// Called, when mouse/finger/pen anymore click/touch map
/// </summary>
/// <param name="touchPoints">List of all touched points</param>
/// <param name="releasedPoint">Released point, which was touched before</param>
private bool OnTouchEnd(List <Geometries.Point> touchPoints, Geometries.Point releasedPoint)
{
var args = new TouchedEventArgs(touchPoints);
TouchEnded?.Invoke(this, args);
// Last touch released
if (touchPoints.Count == 0)
{
_mode = TouchMode.None;
_map.RefreshData(_viewport.Extent, _viewport.Resolution, true);
}
return(args.Handled);
}
static void TestVariousGeometries()
{
WKTReader _wktReader = new WKTReader();
_wktReader.DefaultSRID = 4326;
IGeometry simplePoint = new Geometries.Point(1, 47)
{
SRID = 4326
};
IGeometry multiPoint = _wktReader.Read("MULTIPOINT((1 47),(1 46),(0 46),(0 47),(1 47))");
IGeometry lineString = _wktReader.Read("LINESTRING(1 47,1 46,0 46,0 47,1 47)");
IGeometry multiLineString = _wktReader.Read("MULTILINESTRING((0.516357421875 47.6415668949958,0.516357421875 47.34463879017405,0.977783203125 47.22539733216678,1.175537109375 47.463611506072866,0.516357421875 47.6415668949958),(0.764923095703125 47.86549372980948,0.951690673828125 47.82309640371982,1.220855712890625 47.79911736820551,1.089019775390625 47.69015026565801,1.256561279296875 47.656860648589))");
IGeometry simplePoly = _wktReader.Read("POLYGON((1 47,1 46,0 46,0 47,1 47))");
IGeometry polyWithHole = _wktReader.Read(@"
POLYGON(
(0.516357421875 47.6415668949958,0.516357421875 47.34463879017405,0.977783203125 47.22539733216678,1.175537109375 47.463611506072866,0.516357421875 47.6415668949958),
(0.630340576171875 47.54944962456812,0.630340576171875 47.49380564962583,0.729217529296875 47.482669772098674,0.731964111328125 47.53276262898896,0.630340576171875 47.54944962456812)
)");
IGeometry multiPolygon = _wktReader.Read(@"
MULTIPOLYGON (
((40 40, 20 45, 45 30, 40 40)),
((20 35, 45 20, 30 5, 10 10, 10 30, 20 35), (30 20, 20 25, 20 15, 30 20)),
((0.516357421875 47.6415668949958,0.516357421875 47.34463879017405,0.977783203125 47.22539733216678,1.175537109375 47.463611506072866,0.516357421875 47.6415668949958),(0.630340576171875 47.54944962456812,0.630340576171875 47.49380564962583,0.729217529296875 47.482669772098674,0.731964111328125 47.53276262898896,0.630340576171875 47.54944962456812))
)");
IGeometry geomCol = _wktReader.Read(@"
GEOMETRYCOLLECTION (
POLYGON((0.516357421875 47.6415668949958,0.516357421875 47.34463879017405,0.977783203125 47.22539733216678,1.175537109375 47.463611506072866,0.516357421875 47.6415668949958),(0.630340576171875 47.54944962456812,0.630340576171875 47.49380564962583,0.729217529296875 47.482669772098674,0.731964111328125 47.53276262898896,0.630340576171875 47.54944962456812)),
LINESTRING(0.764923095703125 47.86549372980948,0.951690673828125 47.82309640371982,1.220855712890625 47.79911736820551,1.089019775390625 47.69015026565801,1.256561279296875 47.656860648589),
POINT(0.767669677734375 47.817563762851776)
)");
SpatialTrace.Enable();
SpatialTrace.SetFillColor(Color.FromArgb(128, 0, 0, 255)); // Fill with blue
SpatialTrace.TraceGeometry(simplePoint, "simplePoint");
SpatialTrace.SetFillColor(Color.FromArgb(128, 255, 0, 0)); // Fill with red
SpatialTrace.TraceGeometry(multiPoint, "multiPoint");
SpatialTrace.ResetStyle();
SpatialTrace.TraceGeometry(lineString, "lineString");
SpatialTrace.TraceGeometry(multiLineString, "multiLineString");
SpatialTrace.TraceGeometry(simplePoly, "simplePoly");
SpatialTrace.TraceGeometry(polyWithHole, "polyWithHole");
SpatialTrace.TraceGeometry(multiPolygon, "multiPolygon");
SpatialTrace.TraceGeometry(geomCol, "geomCol");
//SpatialTrace.ShowDialog();
//SpatialTrace.Clear();
}
private void MapControl_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (_mousePosition == null)
{
return;
}
var newMousePosition = new Geometries.Point(e.X, e.Y);
MapTransformHelpers.Pan(Map.Viewport, newMousePosition, _mousePosition);
_mousePosition = newMousePosition;
ViewChanged(true);
Invalidate();
}
}
/// <summary>
/// Called, when mouse/finger/pen tapped on map one time
/// </summary>
/// <param name="screenPosition">Clicked/touched position on screen</param>
/// <returns>True, if the event is handled</returns>
private bool OnSingleTapped(Geometries.Point screenPosition)
{
var args = new TappedEventArgs(screenPosition, 1);
SingleTap?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
var infoToInvoke = InvokeInfo(screenPosition, screenPosition, 1);
OnInfo(infoToInvoke);
return(infoToInvoke?.Handled ?? false);
}
/// <summary>
/// Called, when map should zoom in
/// </summary>
/// <param name="screenPosition">Center of zoom in event</param>
private bool OnZoomIn(Geometries.Point screenPosition)
{
var args = new ZoomedEventArgs(screenPosition, ZoomDirection.ZoomIn);
Zoomed?.Invoke(this, args);
if (args.Handled)
{
return(true);
}
// TODO
// Perform standard behavior
return(true);
}
/// <summary>
/// Called, when mouse/finger/pen anymore click/touch map
/// </summary>
/// <param name="touchPoints">List of all touched points</param>
/// <param name="releasedPoint">Released point, which was touched before</param>
private bool OnTouchEnd(List <Geometries.Point> touchPoints, Geometries.Point releasedPoint)
{
var args = new TouchedEventArgs(touchPoints);
TouchEnded?.Invoke(this, args);
// Last touch released
if (touchPoints.Count == 0)
{
InvalidateCanvas();
_mode = TouchMode.None;
_map.ViewChanged(true);
}
return(args.Handled);
}
public static MemoryLayer CreateLayer()
{
var geodanAmsterdam = new Geometries.Point(122698, 483922);
var geodanDenBosch = new Geometries.Point(148949, 411446);
var imageStream = EmbeddedResourceLoader.Load("Images.location.png", typeof(GeodanOfficesSample));
var layer = new MemoryLayer
{
DataSource = new MemoryProvider(new[] {geodanAmsterdam, geodanDenBosch}),
Style = new SymbolStyle
{
BitmapId = BitmapRegistry.Instance.Register(imageStream),
SymbolOffset = new Offset {Y = 64},
SymbolScale = 0.25
},
CRS = "EPSG:28992",
Name = "Geodan Offices"
};
return layer;
}
private void GetBounds(Geometries.Point p1, Geometries.Point p2,
out Geometries.Point lowerLeft, out Geometries.Point upperRight)
{
lowerLeft = new Geometries.Point(Math.Min(p1.X, p2.X), Math.Min(p1.Y, p2.Y));
upperRight = new Geometries.Point(Math.Max(p1.X, p2.X), Math.Max(p1.Y, p2.Y));
System.Diagnostics.Debug.WriteLine("p1: " + p1);
System.Diagnostics.Debug.WriteLine("p2: " + p2);
System.Diagnostics.Debug.WriteLine("lowerLeft: " + lowerLeft);
System.Diagnostics.Debug.WriteLine("upperRight: " + upperRight);
}
public Geometries.Point GroundToImage(Geometries.Point groundPoint)
{
Geometries.Point imagePoint = new Geometries.Point();
imagePoint.X = inverseTransform[0] + inverseTransform[1] * groundPoint.X + inverseTransform[2] * groundPoint.Y;
imagePoint.Y = inverseTransform[3] + inverseTransform[4] * groundPoint.X + inverseTransform[5] * groundPoint.Y;
return imagePoint;
}
/// <summary>
/// Returns true if the element intersect the rectangle from the parent class
/// </summary>
/// <param name="rect">The rectangle to test must be in the virtual modeling coordinant plane</param>
/// <returns></returns>
public virtual bool elementInRectangle(Rectangle rect)
{
Geometries.IGeometry rectanglePoly;
if ((rect.Height == 0) && (rect.Width == 0))
{
rectanglePoly = new Geometries.Point(rect.X, rect.Y);
}
else if (rect.Width == 0)
{
Geometries.Point[] rectanglePoints = new Geometries.Point[2];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X, rect.Y + rect.Height);
rectanglePoly = new MapWindow.Geometries.LineString(rectanglePoints);
}
else if (rect.Height == 0)
{
Geometries.Point[] rectanglePoints = new Geometries.Point[2];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X + rect.Width, rect.Y);
rectanglePoly = new MapWindow.Geometries.LineString(rectanglePoints);
}
else
{
Geometries.Point[] rectanglePoints = new Geometries.Point[5];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X, rect.Y + rect.Height);
rectanglePoints[2] = new Geometries.Point(rect.X + rect.Width, rect.Y + rect.Height);
rectanglePoints[3] = new Geometries.Point(rect.X + rect.Width, rect.Y);
rectanglePoints[4] = new Geometries.Point(rect.X, rect.Y);
rectanglePoly = new Geometries.Polygon(new Geometries.LinearRing(rectanglePoints));
}
switch (Shape)
{
case ModelShapes.Rectangle:
return (rect.IntersectsWith(this.Rectangle));
case ModelShapes.Ellipse:
int b = Height / 2;
int a = Width / 2;
Geometries.Point[] ellipsePoints = new Geometries.Point[(4 * a) + 1];
for (int x = -a; x <= a; x++)
{
if (x == 0)
{
ellipsePoints[x + a] = new Geometries.Point(Location.X + x + a, Location.Y);
ellipsePoints[3 * a - x] = new Geometries.Point(Location.X + x + a, Location.Y + Height);
}
else
{
ellipsePoints[x + a] = new Geometries.Point(Location.X + x + a, Location.Y + b - System.Math.Sqrt(System.Math.Abs(((b * b * x * x) / (a * a)) - (b * b))));
ellipsePoints[3 * a - x] = new Geometries.Point(Location.X + x + a, Location.Y + b + System.Math.Sqrt(System.Math.Abs(((b * b * x * x) / (a * a)) - (b * b))));
}
}
Geometries.Polygon ellipsePoly = new Geometries.Polygon(new Geometries.LinearRing(ellipsePoints));
return (ellipsePoly.Intersects(rectanglePoly));
case ModelShapes.Triangle:
Geometries.Point[] trianglePoints = new Geometries.Point[4];
trianglePoints[0] = new Geometries.Point(Location.X, Location.Y);
trianglePoints[1] = new Geometries.Point(Location.X, Location.Y + Height);
trianglePoints[2] = new Geometries.Point(Location.X + Width - 5, Location.Y + ((this.Height - 5) / 2));
trianglePoints[3] = new Geometries.Point(Location.X, Location.Y);
Geometries.Polygon trianglePoly = new Geometries.Polygon(new Geometries.LinearRing(trianglePoints));
return (trianglePoly.Intersects(rectanglePoly));
default:
return false;
}
}
/// <summary>
/// Returns true if the element intersect the rectangle from the parent class
/// </summary>
/// <param name="rect">The rectangle to test must be in the virtual modeling coordinant plane</param>
/// <returns></returns>
public override bool elementInRectangle(Rectangle rect)
{
Geometries.IGeometry rectanglePoly;
if ((rect.Height == 0) && (rect.Width == 0))
{
rectanglePoly = new Geometries.Point(rect.X, rect.Y);
}
else if (rect.Width == 0)
{
Geometries.Point[] rectanglePoints = new Geometries.Point[2];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X, rect.Y + rect.Height);
rectanglePoly = new MapWindow.Geometries.LineString(rectanglePoints);
}
else if (rect.Height == 0)
{
Geometries.Point[] rectanglePoints = new Geometries.Point[2];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X + rect.Width, rect.Y);
rectanglePoly = new MapWindow.Geometries.LineString(rectanglePoints);
}
else
{
Geometries.Point[] rectanglePoints = new Geometries.Point[5];
rectanglePoints[0] = new Geometries.Point(rect.X, rect.Y);
rectanglePoints[1] = new Geometries.Point(rect.X, rect.Y + rect.Height);
rectanglePoints[2] = new Geometries.Point(rect.X + rect.Width, rect.Y + rect.Height);
rectanglePoints[3] = new Geometries.Point(rect.X + rect.Width, rect.Y);
rectanglePoints[4] = new Geometries.Point(rect.X, rect.Y);
rectanglePoly = new Geometries.Polygon(new Geometries.LinearRing(rectanglePoints));
}
if (Shape == ModelShapes.Arrow)
{
Geometries.Point[] arrowPoints = new Geometries.Point[_arrowPath.PointCount];
for(int i = 0; i < _arrowPath.PointCount; i++)
{
arrowPoints[i] = new Geometries.Point(_arrowPath.PathPoints[i].X + this.Location.X,_arrowPath.PathPoints[i].Y + this.Location.Y);
}
Geometries.LineString arrowLine = new MapWindow.Geometries.LineString(arrowPoints);
return (arrowLine.Intersects(rectanglePoly));
}
return false;
}
void MapControl_PointerWheelChanged(object sender, PointerRoutedEventArgs e)
{
if (ZoomLocked) return;
if (!_viewportInitialized) return;
var currentPoint = e.GetCurrentPoint(this); //Needed for both MouseMove and MouseWheel event for mousewheel event
var mousePosition = new Geometries.Point(currentPoint.RawPosition.X, currentPoint.RawPosition.Y);
var newResolution = DetermineNewResolution(currentPoint.Properties.MouseWheelDelta, Map.Viewport.Resolution);
// 1) Temporarily center on the mouse position
Map.Viewport.Center = Map.Viewport.ScreenToWorld(mousePosition.X, mousePosition.Y);
// 2) Then zoom
Map.Viewport.Resolution = newResolution;
// 3) Then move the temporary center of the map back to the mouse position
Map.Viewport.Center = Map.Viewport.ScreenToWorld(
Map.Viewport.Width - mousePosition.X,
Map.Viewport.Height - mousePosition.Y);
e.Handled = true;
_map.ViewChanged(true);
OnViewChanged(true);
}
private void MapControl_MouseDown(object sender, MouseEventArgs e)
{
_mousePosition = new Geometries.Point(e.X, e.Y);
}
private void MapControl_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (_mousePosition == null) return;
var newMousePosition = new Geometries.Point(e.X, e.Y);
MapTransformHelpers.Pan(Map.Viewport, newMousePosition, _mousePosition);
_mousePosition = newMousePosition;
ViewChanged(true);
Invalidate();
}
}
public Geometries.Point ImageToGround(Geometries.Point imagePoint)
{
Geometries.Point groundPoint = new Geometries.Point();
groundPoint.X = transform[0] + transform[1] * imagePoint.X + transform[2] * imagePoint.Y;
groundPoint.Y = transform[3] + transform[4] * imagePoint.X + transform[5] * imagePoint.Y;
return groundPoint;
}
