/// <summary> /// Rotate the specified rotation. /// </summary> /// <param name="rotation">Rotation.</param> private void Rotate(UIRotationGestureRecognizer rotation) { RectangleF rect = this.Frame; if (this.MapAllowTilt && rect.Width > 0) { this.StopCurrentAnimation(); if (rotation.State == UIGestureRecognizerState.Ended) { this.NotifyMovementByInvoke();; _mapViewBefore = null; } else if (rotation.State == UIGestureRecognizerState.Began) { _mapViewBefore = this.CreateView(rect); } else { //_mapViewBefore = this.CreateView (_rect); View2D rotatedView = _mapViewBefore.RotateAroundCenter((Radian)rotation.Rotation); _mapTilt = (float)((Degree)rotatedView.Rectangle.Angle).Value; PointF2D sceneCenter = rotatedView.Rectangle.Center; _mapCenter = this.Map.Projection.ToGeoCoordinates( sceneCenter[0], sceneCenter[1]); this.NotifyMovementByInvoke(); } } }
/// <summary> /// Called when the map reports it has changed. /// </summary> void MapChanged() { try { if (!_renderingSuspended) { // rendering is not suspended! // notify map layout of changes. if (this.SurfaceWidth > 0 && this.SurfaceHeight > 0) { // create the current view. View2D view = this.CreateView(); // notify listener. if (view != null) { // only notify listener if there is a view. _listener.NotifyChange(view, this.MapZoom); } } _previouslyRenderedView = null; _previouslyChangedView = null; } } catch (Exception ex) { OsmSharp.Logging.Log.TraceEvent("MapViewSurface", TraceEventType.Critical, string.Format("An unhandled exception occured:{0}", ex.ToString())); } }
/// <summary> /// Creates a view. /// </summary> /// <returns></returns> public View2D CreateView() { try { if (this.Map != null && this.Map.Projection != null && this.MapCenter != null) { // only create a view when a map is set and a valid mapcenter is present. float height = this.SurfaceHeight / _bufferFactor; float width = this.SurfaceWidth / _bufferFactor; // calculate the center/zoom in scene coordinates. var sceneCenter = this.Map.Projection.ToPixel(this.MapCenter.Latitude, this.MapCenter.Longitude); var sceneZoomFactor = (float)this.Map.Projection.ToZoomFactor(this.MapZoom); // create the view for this control. return(View2D.CreateFrom((float)sceneCenter[0], (float)sceneCenter[1], width, height, sceneZoomFactor, _invertX, _invertY, this.MapTilt)); } } catch (Exception ex) { OsmSharp.Logging.Log.TraceEvent("MapViewSurface.CreateView()", TraceEventType.Critical, string.Format("An unhandled exception occured:{0}", ex.ToString())); } return(null); }
/// <summary> /// Returns the size in pixels. /// </summary> /// <param name="target"></param> /// <param name="view"></param> /// <param name="sizeInPixels"></param> /// <returns></returns> protected override double FromPixels(Target2DWrapper <GraphicsDevice> target, View2D view, double sizeInPixels) { double scaleX = target.Width / view.Width; return(sizeInPixels / scaleX); }
/// <summary> /// Returns all objects in this scene that are visible for the given parameters. /// </summary> /// <param name="zoomFactor"></param> /// <param name="view"></param> /// <returns></returns> public override IEnumerable <Primitive2D> Get(float zoomFactor, View2D view) { return(_primitives.Where((primitive) => { return primitive.IsVisibleIn(view, zoomFactor); })); }
/// <summary> /// Returns all objects visible for the given parameters. /// </summary> /// <param name="view"></param> /// <param name="zoomFactor"></param> /// <returns></returns> public IEnumerable <Primitive2D> Get(View2D view, float zoomFactor) { ISpatialIndexReadonly <Primitive2D> sceneAtZoom = _rTrees[0]; // find the part of this scene containing the objects for the requested zoom. for (int idx = 1; idx < _zoomFactors.Length; idx++) { if (zoomFactor <= _zoomFactors[idx]) { sceneAtZoom = _rTrees[idx]; } else { break; } } if (sceneAtZoom != null) { var primitives = new SortedSet <Primitive2D>(LayerComparer.GetInstance()); foreach (var primitive in sceneAtZoom.Get(view.OuterBox)) { primitives.Add(primitive); } return(primitives); } return(new List <Primitive2D>()); }
/// <summary> /// Draws the view within the specified rectangle. /// </summary> /// <param name="rect">Rect.</param> public override void Draw(System.Drawing.RectangleF rect) { _rect = rect; base.Draw(rect); lock (_bufferSynchronisation) { // recreate the view. View2D view = this.CreateView(this.Frame); float zoomFactor = (float)this.Map.Projection.ToZoomFactor(this.MapZoom); // call the canvas renderer. CGContext context = UIGraphics.GetCurrentContext(); if (context != null) { context.InterpolationQuality = CGInterpolationQuality.None; context.SetShouldAntialias(false); context.SetBlendMode(CGBlendMode.Copy); context.SetAlpha(1); long afterViewChanged = DateTime.Now.Ticks; CGContextRenderer renderer = new CGContextRenderer(1); renderer.Render( new CGContextWrapper(context, this.Frame), view, zoomFactor, new Primitive2D[] { _onScreenBuffer }); long afterRendering = DateTime.Now.Ticks; } } }
public void View2DTestCreateFromXYDifference() { double x, y; var view = View2D.CreateFrom(0, 0, 400, 200, 1, false, false); // test result. Assert.AreEqual(view.LeftTop[0], -200); Assert.AreEqual(view.RightTop[0], 200); Assert.AreEqual(view.RightBottom[1], -100); Assert.AreEqual(view.RightTop[1], 100); Assert.IsTrue(view.Contains(0, 0)); var fromMatrix = view.CreateFromViewPort(2000, 1000); // var topLeft = view.FromViewPort(2000, 1000, 0, 0); fromMatrix.Apply(0, 0, out x, out y); Assert.AreEqual(x, -200); Assert.AreEqual(y, -100); // var bottomRight = view.FromViewPort(2000, 1000, 2000, 1000); fromMatrix.Apply(2000, 1000, out x, out y); Assert.AreEqual(x, 200); Assert.AreEqual(y, 100); var toMatrix = view.CreateToViewPort(2000, 1000); // var viewTopLeft = view.ToViewPort(2000, 1000, view.LeftTop[0], view.RightTop[1]); toMatrix.Apply(view.LeftTop[0], view.RightTop[1], out x, out y); Assert.AreEqual(0, x); Assert.AreEqual(1000, y); // var viewBottomRight = view.ToViewPort(2000, 1000, view.RightBottom[0], view.RightBottom[1]); toMatrix.Apply(view.RightBottom[0], view.RightBottom[1], out x, out y); Assert.AreEqual(2000, x); Assert.AreEqual(0, y); }
/// <summary> /// Returns all primitives from this layer visible for the given parameters. /// </summary> /// <param name="zoomFactor"></param> /// <param name="view"></param> /// <returns></returns> protected internal override IEnumerable <Primitive2D> Get(float zoomFactor, View2D view) { var primitives = new List <Primitive2D>(); lock (_cache) { foreach (var tile in _cache) { if (tile.Value.IsVisibleIn(view, zoomFactor)) { Image2D temp; var minZoom = _projection.ToZoomFactor(tile.Key.Zoom - _zoomMinOffset); var maxZoom = _projection.ToZoomFactor(tile.Key.Zoom + (1 - _zoomMinOffset)); if (zoomFactor < maxZoom && zoomFactor > minZoom) { _cache.TryGet(tile.Key, out temp); primitives.Add(tile.Value); } } } } primitives.Sort(this); return(primitives); }
/// <summary> /// Notifies that there was movement. /// </summary> private void NotifyMovement() { //// invalidate the current view. //this.Invalidate(); // notify map layout of changes. if (this.Width > 0 && this.Height > 0) { // create the view. View2D view = _renderer.Create(this.Width, this.Height, this.Map, (float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, false, true); _mapView.NotifyMapChange(this.Width, this.Height, view, this.Map.Projection); this.SetOrtho(view); //// build the layers list. //var layers = new List<ILayer>(); //for (int layerIdx = 0; layerIdx < this.Map.LayerCount; layerIdx++) //{ // // get the layer. // layers.Add(this.Map[layerIdx]); //} //_renderer.Render(_target, // layers, // view); } }
/// <summary> /// Sets the map view. /// </summary> /// <param name="center">Center.</param> /// <param name="mapTilt">Map tilt.</param> /// <param name="mapZoom">Map zoom.</param> public void SetMapView(GeoCoordinate center, Degree mapTilt, float mapZoom) { //this.MapCenter = center; if (this.Width == 0 || this.MapBoundingBox == null) { _mapCenter = center; } else { _mapCenter = this.Map.EnsureViewWithinBoundingBox(center, this.MapBoundingBox, this.CurrentView); } //this.MapTilt = mapTilt; _mapTilt = mapTilt; //this.MapZoom = mapZoom; if (mapZoom > this.MapMaxZoomLevel) { _mapZoomLevel = this.MapMaxZoomLevel; } else if (mapZoom < this.MapMinZoomLevel) { _mapZoomLevel = this.MapMinZoomLevel; } else { _mapZoomLevel = mapZoom; } _previouslyRenderedView = null; _previouslyChangedView = null; (this.Context as Activity).RunOnUiThread(NotifyMovement); }
public Bitmap Render(int x, int y, int zoom, double width, int tileSize) { const double magicMaster = 9105.7453358554949742220244056229; var zoomRate = (float)(magicMaster * width); int tiles = 1 << zoom; double tileGeoWidth = width / tiles; double movex = tiles == 1 ? 0 : tileGeoWidth * (tiles / 2 - x) - tileGeoWidth / 2; double movey = tiles == 1 ? 0 : tileGeoWidth * (tiles / 2 - y) - tileGeoWidth / 2; var center = new GeoCoordinate(movey, -movex); double baseZoomFactor = 100f * ((double)tileSize / zoomRate); float zoomFactor = Convert.ToSingle(baseZoomFactor * tiles); var image = new Bitmap(tileSize, tileSize); Graphics target = Graphics.FromImage(image); target.SmoothingMode = SmoothingMode.HighQuality; target.PixelOffsetMode = PixelOffsetMode.HighQuality; target.CompositingQuality = CompositingQuality.HighQuality; target.InterpolationMode = InterpolationMode.HighQualityBicubic; target.FillRectangle(Brushes.Red, 0, 0, tileSize, tileSize); View2D visibleView = Renderer.Create(tileSize, tileSize, Map, zoomFactor, center, false, true); Map.ViewChanged(zoomFactor, center, visibleView, visibleView); Renderer.Render(target, Map, visibleView, visibleView, zoomFactor); target.Dispose(); return(image); }
/// <summary> /// Notifies change. /// </summary> public void TriggerRendering(bool force) { // notify map layout of changes. if (this.Width > 0 && this.Height > 0) { // create the view. View2D view = _renderer.Create(this.Width, this.Height, this.Map, (float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, false, true); // notify the map that the view has changed. this.Map.ViewChanged((float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, view); _mapView.NotifyMapChange(this.Width, this.Height, view, this.Map.Projection); this.SetOrtho(view); // build the layers list. var layers = new List <Layer>(); for (int layerIdx = 0; layerIdx < this.Map.LayerCount; layerIdx++) { // get the layer. layers.Add(this.Map[layerIdx]); } _renderer.Render(_target, layers, view, (float)this.Map.Projection.ToZoomFactor(this.MapZoom)); } }
/// <summary> /// Draws the view within the specified rectangle. /// </summary> /// <param name="rect">Rect.</param> public override void Draw(System.Drawing.RectangleF rect) { _rect = rect; base.Draw(rect); lock (_cachedScene) { // recreate the view. //View2D view = this.CreateView (_rect); View2D view = this.CreateView(this.Frame); // call the canvas renderer. CGContext context = UIGraphics.GetCurrentContext(); if (context != null) { context.InterpolationQuality = CGInterpolationQuality.None; context.SetShouldAntialias(false); context.SetBlendMode(CGBlendMode.Copy); context.SetAlpha(1); long afterViewChanged = DateTime.Now.Ticks; CGContextRenderer renderer = new CGContextRenderer(1); // renderer.Render (new CGContextWrapper (context, _rect), // _cachedScene, view); renderer.Render(new CGContextWrapper(context, this.Frame), _cachedScene, view); long afterRendering = DateTime.Now.Ticks; } } }
/// <summary> /// Builds the scene. /// </summary> /// <param name="map"></param> /// <param name="zoomFactor"></param> /// <param name="center"></param> /// <param name="view"></param> private void BuildScene(Map map, float zoomFactor, GeoCoordinate center, View2D view) { // build the boundingbox. var viewBox = view.OuterBox; var box = new GeoCoordinateBox(map.Projection.ToGeoCoordinates(viewBox.Min [0], viewBox.Min [1]), map.Projection.ToGeoCoordinates(viewBox.Max [0], viewBox.Max [1])); var zoomLevel = (int)map.Projection.ToZoomLevel(zoomFactor); if (_lastBox != null && _lastBox.Contains(box) && zoomLevel == _lastZoom) { return; } _lastBox = box; _lastZoom = zoomLevel; // reset the scene. if (_scene2DSimple == null) { _scene2DSimple = new Scene2DSimple(); } _scene2DSimple.Clear(); // get from the index. this.Scene.BackColor = SimpleColor.FromKnownColor(KnownColor.White).Value; lock (_sync) { _index.Get(_scene2DSimple, view, zoomFactor); } }
/// <summary> /// Zoom to the given makers list. /// </summary> /// <param name="marker"></param> public void ZoomToMarkers(List <MapMarker> markers, double percentage) { // float height = _rect.Height; // float width = _rect.Width; float width = this.Frame.Width; float height = this.Frame.Height; RectangleF rect = this.Frame; if (width > 0) { PointF2D[] points = new PointF2D[markers.Count]; for (int idx = 0; idx < markers.Count; idx++) { points[idx] = new PointF2D(this.Map.Projection.ToPixel(markers[idx].Location)); } View2D view = this.CreateView(rect); // View2D view = this.CreateView(this.Frame); View2D fittedView = view.Fit(points, percentage); float zoom = (float)this.Map.Projection.ToZoomLevel(fittedView.CalculateZoom( width, height)); GeoCoordinate center = this.Map.Projection.ToGeoCoordinates( fittedView.Center[0], fittedView.Center[1]); _mapCenter = center; this.MapZoom = zoom; this.Change(false); } }
/// <summary> /// Called when the tap gesture recognizer detects a double tap. /// </summary> /// <param name="tap">Tap.</param> private void DoubleTap(UITapGestureRecognizer tap) { //RectangleF2D rect = _rect; RectangleF rect = this.Frame; if (rect.Width > 0 && rect.Height > 0) { this.StopCurrentAnimation(); View2D view = this.CreateView(rect); PointF location = tap.LocationInView(this); double[] sceneCoordinates = view.FromViewPort(rect.Width, rect.Height, location.X, location.Y); GeoCoordinate geoLocation = this.Map.Projection.ToGeoCoordinates(sceneCoordinates [0], sceneCoordinates [1]); if (this.DoubleMapTapEvent != null) { this.DoubleMapTapEvent(geoLocation); } else { // minimum zoom. float tapRequestZoom = (float)System.Math.Max(_mapZoom + 1, 19); _doubleTapAnimator.Start(geoLocation, tapRequestZoom, new TimeSpan(0, 0, 1)); } } }
/// <summary> /// Notifies the map change. /// </summary> /// <param name="pixelsWidth">Pixels width.</param> /// <param name="pixelsHeight">Pixels height.</param> /// <param name="view">View.</param> /// <param name="projection">Projection.</param> public void NotifyMapChange(double pixelsWidth, double pixelsHeight, View2D view, IProjection projection) { this.NotifyOnBeforeSetLayout(); lock (_markers) { if (_markers != null) { foreach (var marker in _markers) { this.NotifyMapChangeToControl(pixelsWidth, pixelsHeight, view, projection, marker); } } } lock (_controls) { if (_controls != null) { foreach (var control in _controls) { this.NotifyMapChangeToControl(pixelsWidth, pixelsHeight, view, projection, control); } } } this.NotifyOnAfterSetLayout(); }
/// <summary> /// A way for the surface to complain that it is invalid. /// </summary> public override void Invalidate() { lock (this) { _latestTriggeredView = null; } }
/// <summary> /// Transforms the target using the specified view. /// </summary> /// <param name="target"></param> /// <param name="view">View.</param> protected override void Transform(Target2DWrapper <CGContextWrapper> target, View2D view) { _view = view; _target = target; _scaleX = (float)(target.Width / view.Width); }
/// <summary> /// Fills the given simple scene with objects inside the given view and for the given zoomFactor. /// </summary> /// <param name="scene"></param> /// <param name="view"></param> /// <param name="zoomFactor"></param> public void Get(Scene2DSimple scene, View2D view, float zoomFactor) { // check what is in the non-simplified scene. IScene2DPrimitivesSource simpleSource = this.GetNonSimplifiedStream(); simpleSource.Get(scene, view, zoomFactor); // check what index this zoomfactor is for. int idx = this.SearchForScene(zoomFactor); if (idx >= 0) { // the index was found. if (!_loadedScenes.TryGetValue(idx, out simpleSource)) { // the scene was not found. long position = _index.SceneIndexes[idx]; _stream.Seek(position, SeekOrigin.Begin); LimitedStream stream = new LimitedStream(_stream); //Scene2DRTreeSerializer serializer = new Scene2DRTreeSerializer(true); //simpleSource = new Scene2DPrimitivesSource(serializer.Deserialize(stream)); OsmSharp.UI.Renderer.Scene.Storage.Styled.Scene2DStyledSerializer serializer = new Styled.Scene2DStyledSerializer(); simpleSource = serializer.Deserialize(stream, true); _loadedScenes.Add(idx, simpleSource); } simpleSource.Get(scene, view, zoomFactor); OsmSharp.Logging.Log.TraceEvent("Scene2DLayeredSource", System.Diagnostics.TraceEventType.Verbose, string.Format("Deserialized from scene at zoom {0} and idx {1}.", zoomFactor, idx)); } }
/// <summary> /// Raises the mousemove event. /// </summary> /// <param name="e"></param> protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); var currentCoordinates = new double[] { e.X, e.Y }; if (this.MapAllowPan && e.Button == MouseButtons.Left && _draggingCoordinates != null) { var delta = new double[] { _draggingCoordinates[0] - currentCoordinates[0], (_draggingCoordinates[1] - currentCoordinates[1]) }; var newCenter = new double[] { this.Width / 2.0f + delta[0], this.Height / 2.0f + delta[1] }; this.MapCenter = _oldCenter; View2D view = _renderer.Create(this.Width, this.Height, this.Map, (float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, false, true); double x, y; var fromMatrix = view.CreateFromViewPort(this.Width, this.Height); fromMatrix.Apply(newCenter[0], newCenter[1], out x, out y); // project to new center. this.MapCenter = this.Map.Projection.ToGeoCoordinates(x, y); // notify the map. this.QueueNotifyMapViewChanged(); } this.RaiseOnMapMouseMove(e); }
/// <summary> /// Sets the layout. /// </summary> /// <param name="pixelsWidth">Pixels width.</param> /// <param name="pixelsHeight">Pixels height.</param> /// <param name="view">View.</param> /// <param name="projection">Projection.</param> internal bool SetLayout(double pixelsWidth, double pixelsHeight, View2D view, IProjection projection) { double[] projected = projection.ToPixel(this.Location); double[] locationPixel = view.ToViewPort(pixelsWidth, pixelsHeight, projected[0], projected[1]); // set the new location depending on the size of the image and the alignment parameter. double leftMargin = locationPixel[0]; double topMargin = locationPixel[1]; leftMargin = locationPixel[0] - (this.LayoutParameters as FrameLayout.LayoutParams).Width / 2.0; switch (_alignment) { case MapMarkerAlignmentType.Center: topMargin = locationPixel[1] - (this.LayoutParameters as FrameLayout.LayoutParams).Height / 2.0; break; case MapMarkerAlignmentType.CenterTop: break; case MapMarkerAlignmentType.CenterBottom: topMargin = locationPixel[1] - (this.LayoutParameters as FrameLayout.LayoutParams).Height; break; } (this.LayoutParameters as FrameLayout.LayoutParams).LeftMargin = (int)leftMargin; (this.LayoutParameters as FrameLayout.LayoutParams).TopMargin = (int)topMargin; return(true); }
/// <summary> /// Triggers rendering. /// </summary> public void TriggerRendering(bool force) { if (this.SurfaceWidth == 0) { // nothing to render yet! return; } // create the view that would be use for rendering. View2D view = _cacheRenderer.Create((int)(this.SurfaceWidth * _extra), (int)(this.SurfaceHeight * _extra), this.Map, (float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, _invertX, _invertY, this.MapTilt); // ... and compare to the previous rendered view. if (!force && _previouslyRenderedView != null && view.Equals(_previouslyRenderedView)) { return; } _previouslyRenderedView = view; // end existing rendering thread. if (_renderingThread != null && _renderingThread.IsAlive) { if (_cacheRenderer.IsRunning) { this.Map.ViewChangedCancel(); _cacheRenderer.CancelAndWait(); } } // start new rendering thread. _renderingThread = new Thread(new ThreadStart(Render)); _renderingThread.Start(); }
/// <summary> /// Notifies that there was movement. /// </summary> private void NotifyMovement() { try { // invalidate the current view. this.Invalidate(); // notify map layout of changes. if (this.SurfaceWidth > 0 && this.SurfaceHeight > 0) { // create the current view. View2D view = this.CreateView(); // notify map change to reposition markers. _mapView.NotifyMapChange(this.SurfaceWidth, this.SurfaceHeight, view, this.Map.Projection); // notify listener. _listener.NotifyChange(view, this.MapZoom); } } catch (Exception ex) { OsmSharp.Logging.Log.TraceEvent("MapViewSurface", TraceEventType.Critical, string.Format("An unhandled exception occured:{0}", ex.ToString())); } }
/// <summary> /// Raises the draw event. /// </summary> /// <param name="canvas">Canvas.</param> protected override void OnDraw(global::Android.Graphics.Canvas canvas) { base.OnDraw(canvas); // set the height/width. if (_surfaceHeight != canvas.Height || _surfaceWidth != canvas.Width) { _surfaceHeight = canvas.Height; _surfaceWidth = canvas.Width; // trigger rendering. this.TriggerRendering(); } // render only the cached scene. canvas.DrawColor(new global::Android.Graphics.Color(_backgroundColor)); View2D view = this.CreateView(); float zoomFactor = (float)this.Map.Projection.ToZoomFactor(this.MapZoom); _renderer.SceneRenderer.Render( canvas, view, zoomFactor, new Primitive2D[] { _onScreenBuffer }); }
/// <summary> /// The view on this map has changed. Maybe the layers need to load new data, they need to be notified. /// </summary> /// <param name="zoomFactor"></param> /// <param name="center"></param> /// <param name="view"></param> public void ViewChanged(float zoomFactor, GeoCoordinate center, View2D view) { foreach (var layer in _layers) { layer.ViewChanged(this, zoomFactor, center, view); } }
/// <summary> /// Zooms to the given list of markers. /// </summary> /// <param name="markers"></param> /// <param name="percentage"></param> public void ZoomToMarkers(List <MapMarker> markers, double percentage) { float height = this.SurfaceHeight; float width = this.SurfaceWidth; if (width > 0) { PointF2D[] points = new PointF2D[markers.Count]; for (int idx = 0; idx < markers.Count; idx++) { points [idx] = new PointF2D(this.Map.Projection.ToPixel(markers [idx].Location)); } View2D view = this.CreateView(); View2D fittedView = view.Fit(points, percentage); float zoom = (float)this.Map.Projection.ToZoomLevel(fittedView.CalculateZoom( width, height)); GeoCoordinate center = this.Map.Projection.ToGeoCoordinates( fittedView.Center [0], fittedView.Center [1]); this.SetMapView(center, this.MapTilt, zoom); } else { _latestZoomCall = new MapViewMarkerZoomEvent() { Markers = markers, Percentage = percentage }; } }
/// <summary> /// Raises the layout event. /// </summary> /// <param name="changed">If set to <c>true</c> changed.</param> /// <param name="left">Left.</param> ///( <param name="top">Top.</param> /// <param name="right">Right.</param> /// <param name="bottom">Bottom.</param> protected override void OnLayout(bool changed, int left, int top, int right, int bottom) { _target.Width = this.Width; _target.Height = this.Height; // create the view. View2D view = _renderer.Create(this.Width, this.Height, this.Map, (float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, false, true); this.SetOrtho(view); // notify the map that the view has changed. this.Map.ViewChanged((float)this.Map.Projection.ToZoomFactor(this.MapZoom), this.MapCenter, view); // build the layers list. var layers = new List <Layer>(); for (int layerIdx = 0; layerIdx < this.Map.LayerCount; layerIdx++) { // get the layer. layers.Add(this.Map[layerIdx]); } _renderer.Render(_target, layers, view, (float)this.Map.Projection.ToZoomFactor(this.MapZoom)); }
/// <summary> /// Raises the mousemove event. /// </summary> /// <param name="e"></param> protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); if (e.Button == MouseButtons.Left && _draggingCoordinates != null) { var currentCoordinates = new double[] { e.X, e.Y }; var delta = new double[] { _draggingCoordinates[0] - currentCoordinates[0], (_draggingCoordinates[1] - currentCoordinates[1]) }; var newCenter = new double[] { this.Width / 2.0f + delta[0], this.Height / 2.0f + delta[1] }; this.Center = _oldCenter; View2D view = _renderer.Create(this.Width, this.Height, this.Map, (float)this.Map.Projection.ToZoomFactor(this.ZoomLevel), this.Center, false, true); double[] sceneCenter = view.FromViewPort(this.Width, this.Height, newCenter[0], newCenter[1]); // project to new center. this.Center = this.Map.Projection.ToGeoCoordinates(sceneCenter[0], sceneCenter[1]); // notify the map. this.QueueNotifyMapViewChanged(); } }
/// <summary> /// Adds all primitives inside the given box for the given zoom. /// </summary> /// <param name="scene"></param> /// <param name="view"></param> /// <param name="zoomFactor"></param> public void Get(Scene2DSimple scene, View2D view, float zoomFactor) { // get all primitives. IEnumerable<Scene2DEntry> entries = _index.Get(view.OuterBox); foreach (var scene2DEntry in entries) { scene.AddPrimitive(scene2DEntry.Layer, scene2DEntry.Id, scene2DEntry.Scene2DPrimitive); } }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public override bool IsVisibleIn(View2D view, float zoom) { if (this.MinZoom > zoom || this.MaxZoom < zoom) { // outside of zoom bounds! return false; } return _bounds.Overlaps(view.OuterBox); }
/// <summary> /// Fills the given simple scene with objects inside the given view and for the given zoomFactor. /// </summary> /// <param name="scene"></param> /// <param name="view"></param> /// <param name="zoomFactor"></param> public void Get(Scene2DSimple scene, View2D view, float zoomFactor) { lock (_stream) { // make sure there is only synchonous access to the stream. // check what is in the non-simplified scene. IScene2DPrimitivesSource simpleSource = this.GetNonSimplifiedStream (); simpleSource.Get (scene, view, zoomFactor); // check what index this zoomfactor is for. int idx = this.SearchForScene (zoomFactor); if (idx >= 0) { // the index was found. if (!_loadedScenes.TryGetValue (idx, out simpleSource)) { // the scene was not found. long position = _index.SceneIndexes [idx]; _stream.Seek (position, SeekOrigin.Begin); LimitedStream stream = new LimitedStream (_stream); //Scene2DRTreeSerializer serializer = new Scene2DRTreeSerializer(true); //simpleSource = new Scene2DPrimitivesSource(serializer.Deserialize(stream)); OsmSharp.UI.Renderer.Scene.Storage.Styled.Scene2DStyledSerializer serializer = new Styled.Scene2DStyledSerializer (); simpleSource = serializer.Deserialize (stream, true); _loadedScenes.Add (idx, simpleSource); } simpleSource.Get (scene, view, zoomFactor); OsmSharp.Logging.Log.TraceEvent ("Scene2DLayeredSource", System.Diagnostics.TraceEventType.Verbose, string.Format ("Deserialized from scene at zoom {0} and idx {1} synchronized.", zoomFactor, idx)); } } }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> public override bool IsVisibleIn(View2D view) { if (view.OverlapsWithBox(MinX, MinY, MaxX, MaxY)) { return true; // maybe a better hittest? } return false; }
/// <summary> /// Returns true if the object is visible in the given view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public override bool IsVisibleIn(View2D view, float zoom) { if (this.MinZoom > zoom || this.MaxZoom < zoom) { // outside of zoom bounds! return false; } return this.IsVisibleIn(view); }
private void buttonShootPhotons_Click( object sender, EventArgs e ) { ////////////////////////////////////////////////////////////////////////// // 1] Shoot the photons and store the result into the structured buffer m_CS_PhotonShooter.Use(); m_SB_Random.SetInput( 0 ); m_SB_PhaseQuantile.SetInput( 1 ); m_SB_PhotonOut.SetOutput( 0 ); m_CB_PhotonShooterInput.m.MaxScattering = 100; m_CB_PhotonShooterInput.m.InitialPosition = new float2( floatTrackbarControlPositionX.Value, floatTrackbarControlPositionZ.Value ); // Center of the cube side m_CB_PhotonShooterInput.m.InitialIncidence = new float2( floatTrackbarControlOrientationPhi.Value * (float) Math.PI / 180.0f, floatTrackbarControlOrientationTheta.Value * (float) Math.PI / 180.0f ); // Vertical incidence m_CB_PhotonShooterInput.m.CubeSize = floatTrackbarControlCubeSize.Value; // Try a 100m thick cube // m_CB_PhotonShooterInput.m.SigmaScattering = 0.5f; m_CB_PhotonShooterInput.m.SigmaScattering = 0.04523893421169302263386206471922f; // re=6µm Gamma=2 N0=4e8 Sigma_t = N0 * PI * re² m_CB_PhotonShooterInput.m.FullSurface = (uint)(checkBoxFullSurface.Checked ? 1 : 0); // mean free path = 22.1048m int BatchesCount = PHOTONS_COUNT / PHOTON_BATCH_SIZE; for ( int BatchIndex=0; BatchIndex < BatchesCount; BatchIndex++ ) { m_CB_PhotonShooterInput.m.BatchIndex = (uint) BatchIndex; m_CB_PhotonShooterInput.UpdateData(); m_CS_PhotonShooter.Dispatch( 1, 1, 1 ); m_Device.Present( true ); progressBar1.Value = progressBar1.Maximum * (1+BatchIndex) / BatchesCount; Application.DoEvents(); } m_SB_PhotonOut.RemoveFromLastAssignedSlots(); ////////////////////////////////////////////////////////////////////////// // Splat photons m_Tex_Photons.RemoveFromLastAssignedSlots(); m_Device.Clear( m_Tex_Photons, new float4( 0, 0, 0, 0 ) ); m_SB_PhotonOut.SetInput( 0 ); // Splat data m_CB_SplatPhoton.m.SplatSize = 2.0f * (2.0f / m_Tex_Photons.Width); m_CB_SplatPhoton.UpdateData(); m_Device.SetRenderStates( RASTERIZER_STATE.CULL_NONE, DEPTHSTENCIL_STATE.DISABLED, BLEND_STATE.ALPHA_BLEND ); View2D[] Views = new View2D[] { m_Tex_Photons.GetView( 0, 0, 6*0, 6 ), m_Tex_Photons.GetView( 0, 0, 6*1, 6 ), m_Tex_Photons.GetView( 0, 0, 6*2, 6 ), }; m_Device.SetRenderTargets( m_Tex_Photons.Width, m_Tex_Photons.Height, Views, null ); m_PS_PhotonSplatter.Use(); m_Prim_Point.RenderInstanced( m_PS_PhotonSplatter, PHOTONS_COUNT ); // Splat additive intensity m_CB_SplatPhoton.m.SplatSize = 8.0f * (2.0f / m_Tex_Photons.Width); m_CB_SplatPhoton.m.SplatIntensity = 1000.0f / PHOTONS_COUNT; m_CB_SplatPhoton.UpdateData(); m_Device.SetRenderStates( RASTERIZER_STATE.CULL_NONE, DEPTHSTENCIL_STATE.DISABLED, BLEND_STATE.ADDITIVE ); Views = new View2D[] { m_Tex_Photons.GetView( 0, 0, 6*3, 6 ) }; m_Device.SetRenderTargets( m_Tex_Photons.Width, m_Tex_Photons.Height, Views, null ); m_PS_PhotonSplatter_Intensity.Use(); m_Prim_Point.RenderInstanced( m_PS_PhotonSplatter_Intensity, PHOTONS_COUNT ); m_Tex_Photons.RemoveFromLastAssignedSlots(); Render(); }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public override bool IsVisibleIn(View2D view, float zoom) { // TODO: refine this visible check. return _bounds.Overlaps(view.OuterBox); }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> public override bool IsVisibleIn(View2D view) { return _bounds.Overlaps(view.OuterBox); }
/// <summary> /// Returns true if the object is visible in the view. /// </summary> /// <returns><c>true</c> if this instance is visible in the specified view; otherwise, <c>false</c>.</returns> /// <param name="view">The view.</param> public abstract bool IsVisibleIn(View2D view);
/// <summary> /// Gets all objects in this scene for the specified view. /// </summary> /// <param name="view">View.</param> /// <param name="zoom"></param> public override IEnumerable<Scene2DPrimitive> Get(View2D view, float zoom) { var primitivesInView = new List<Scene2DPrimitive>(); lock (_primitives) { foreach (var layer in _primitives) { // loop over all layers in order. foreach (IScene2DPrimitive primitivePair in layer.Value) { // loop over all primitives in order. if (primitivePair.IsVisibleIn(view, zoom)) { primitivesInView.Add(new Scene2DPrimitive() { Layer = layer.Key, Primitive = primitivePair }); } } } } return primitivesInView; }
/// <summary> /// Returns true if the object is visible in the view and for the given zoom factor. /// </summary> /// <returns><c>true</c> if this instance is visible in the specified view; otherwise, <c>false</c>.</returns> /// <param name="view">The view.</param> /// <param name="zoom">The zoom factor.</param> public abstract bool IsVisibleIn(View2D view, float zoom);
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public bool IsVisibleIn(View2D view, float zoom) { if (this.MinZoom > zoom || this.MaxZoom < zoom) { // outside of zoom bounds! return false; } return view.Contains(this.X, this.Y); }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public override bool IsVisibleIn(View2D view, float zoom) { if (this.MinZoom > zoom || this.MaxZoom < zoom) { // outside of zoom bounds! return false; } return view.OverlapsWithBox(this.Left, this.Top, this.Right, this.Bottom); }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// <param name="zoom"></param> public bool IsVisibleIn(View2D view, float zoom) { if (this.MinZoom > zoom || this.MaxZoom < zoom) { // outside of zoom bounds! return false; } if (view.OverlapsWithBox (MinX, MinY, MaxX, MaxY)) { return true; // maybe a better hittest? } return false; }
/// <summary> /// Returns true if the object is visible in the given view. /// </summary> /// <param name="view"></param> /// <returns></returns> public override bool IsVisibleIn(View2D view) { return view.Contains(this.X, this.Y); }
/// <summary> /// Returns true if the object is visible on the view. /// </summary> /// <returns>true</returns> /// <c>false</c> /// <param name="view">View.</param> /// public override bool IsVisibleIn(View2D view) { return view.OverlapsWithBox(this.Left, this.Top, this.Right, this.Bottom); }
/// <summary> /// Gets all objects in this scene for the specified view. /// </summary> /// <param name="view">View.</param> /// <param name="zoom"></param> public override IEnumerable<Scene2DPrimitive> Get(View2D view, float zoom) { Scene2D scene = this.SearchForScene (zoom); List<IEnumerable<Scene2DPrimitive>> primitives = new List<IEnumerable<Scene2DPrimitive>>(); primitives.Add(_nonSimplifiedScene.Get(view, zoom)); if (scene != null) { primitives.Add(scene.Get (view, zoom)); } return new Scene2DPrimitiveEnumerable(primitives); }
/// <summary> /// Gets all objects in this scene for the specified view sorted according to layer number. /// </summary> /// <param name="view">View.</param> /// <param name="zoom"></param> public abstract IEnumerable<Scene2DPrimitive> Get(View2D view, float zoom);