public void TestRectangleF2DFitAndKeepAspectRatio() { double delta = 0.00001; RectangleF2D rectangle = new RectangleF2D(0, 0, 1, 1); PointF2D[] points = new PointF2D[] { new PointF2D(2, 2), new PointF2D(1, 1) }; RectangleF2D fitted = rectangle.FitAndKeepAspectRatio(points, 0); Assert.AreEqual(1, fitted.Width, delta); Assert.AreEqual(1, fitted.Height, delta); Assert.AreEqual(1, fitted.BottomLeft[0], delta); Assert.AreEqual(1, fitted.BottomLeft[1], delta); Assert.AreEqual(2, fitted.TopRight[0], delta); Assert.AreEqual(2, fitted.TopRight[1], delta); // this should create the exact same rectangle as in the other tests. rectangle = RectangleF2D.FromBoundsAndCenter(System.Math.Sqrt(2) * 2, System.Math.Sqrt(2) * 2, 0, 0, 45); fitted = rectangle.FitAndKeepAspectRatio(points, 0); Assert.AreEqual(System.Math.Sqrt(2), fitted.Width, delta); Assert.AreEqual(System.Math.Sqrt(2), fitted.Height, delta); Assert.AreEqual(0.5, fitted.BottomLeft[0], delta); Assert.AreEqual(1.5, fitted.BottomLeft[1], delta); Assert.AreEqual(2.5, fitted.TopRight[0], delta); Assert.AreEqual(1.5, fitted.TopRight[1], delta); }
/// <summary> /// Draws an image on the target. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="nativeImage"></param> protected override void DrawImage(Target2DWrapper <global::Android.Graphics.Canvas> target, double left, double top, double right, double bottom, INativeImage nativeImage) { var rectangle = new RectangleF2D(left, top, right - left, bottom - top); this.DrawImage(target, rectangle, nativeImage); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> protected override object DrawImage(Target2DWrapper <CGContextWrapper> target, RectangleF2D bounds, byte[] imageData, object tag) { target.Target.CGContext.SetAllowsFontSubpixelQuantization(true); target.Target.CGContext.SetAllowsFontSmoothing(true); target.Target.CGContext.SetAllowsAntialiasing(true); target.Target.CGContext.SetAllowsSubpixelPositioning(true); target.Target.CGContext.SetShouldAntialias(true); PointF2D bottomLeft = new PointF2D(this.Tranform(bounds.BottomLeft [0], bounds.BottomLeft [1])); PointF2D bottomRight = new PointF2D(this.Tranform(bounds.BottomRight [0], bounds.BottomRight [1])); PointF2D topLeft = new PointF2D(this.Tranform(bounds.TopLeft [0], bounds.TopLeft [1])); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); RectangleF2D transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); target.Target.CGContext.SaveState(); target.Target.CGContext.TranslateCTM((float)transformed.BottomLeft [0], (float)transformed.BottomLeft [1]); target.Target.CGContext.RotateCTM(-(float)((Radian)transformed.Angle).Value); if (tag is CGImage) { CGImage image = tag as CGImage; target.Target.CGContext.DrawImage(new RectangleF(0, 0, (float)transformed.Width, (float)transformed.Height), image); } target.Target.CGContext.RestoreState(); return(tag); }
/// <summary> /// Creates a transformation matrix that transforms coordinates the viewport of given size to inside the given rectangle. The bottom-left of the rectangle is assumed to be the origin. /// </summary> /// <param name="rectangle"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="invertX"></param> /// <param name="invertY"></param> /// <returns></returns> public static Matrix2D ToRectangle(RectangleF2D rectangle, double width, double height, bool invertX, bool invertY) { // scale to match the width/height that was given. var scale = Matrix2D.Scale(rectangle.Width / width, rectangle.Height / height); // rotate to align with rectangle. var rotate = Matrix2D.Rotate(((Radian)rectangle.Angle).Value); // translate to the bottom-left of the rectangle. var translate = Matrix2D.Translate(rectangle.BottomLeft[0], rectangle.BottomLeft[1]); Matrix2D invert; if (!invertX && !invertY) { // everything normal. invert = Matrix2D.Scale(1, 1); } else if (!invertX && invertY) { // only y inverted. invert = Matrix2D.Scale(1, -1); } else if (invertX && !invertY) { // only x inverted. invert = Matrix2D.Scale(-1, 1); } else { // both inverted. invert = Matrix2D.Scale(-1, -1); } return(scale * rotate * translate * invert); }
/// <summary> /// Creates a tranformation matrix that transforms coordinates from inside the given rectangle to a viewport of given size. The bottom-left of the rectangle is assumed to be the origin. /// </summary> /// <param name="rectangle"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="invertX"></param> /// <param name="invertY"></param> /// <returns></returns> public static Matrix2D FromRectangle(RectangleF2D rectangle, double width, double height, bool invertX, bool invertY) { Matrix2D invert; if (!invertX && !invertY) { // everything normal. invert = Matrix2D.Scale(1, 1); } else if (!invertX && invertY) { // only y inverted. invert = Matrix2D.Scale(1, -1); } else if (invertX && !invertY) { // only x inverted. invert = Matrix2D.Scale(-1, 1); } else { // both inverted. invert = Matrix2D.Scale(-1, -1); } // translate the bottom-left of the rectangle to the origin. var translate = Matrix2D.Translate(-rectangle.BottomLeft[0], -rectangle.BottomLeft[1]); // rotate the rectangle to align with x-y axis. var rotate = Matrix2D.Rotate(-((Radian)rectangle.Angle).Value); // scale to match the width/height that was given. var scale = Matrix2D.Scale(width / rectangle.Width, height / rectangle.Height); return(invert * translate * rotate * scale); }
/// <summary> /// Initializes a new instance of the <see cref="OsmSharp.UI.Renderer.View2D"/> class. /// </summary> private View2D(RectangleF2D rectangle, bool invertX, bool invertY) { _invertX = invertX; _invertY = invertY; _rectangle = rectangle; }
TextShape CreateCustomTextualMarker(ComplexShape markerShape) { RectangleF2D box = new RectangleF2D(-15, -15, 30, 30); EllipseShape eShape = new EllipseShape(box); TextShape txt = new TextShape(); eShape.BeginUpdate(); eShape.Name = "bg"; eShape.Appearance.ContentBrush = new SolidBrushObject(Color.White); eShape.Appearance.BorderBrush = new SolidBrushObject(Color.Black); eShape.Appearance.BorderWidth = 2; eShape.EndUpdate(); txt.BeginUpdate(); txt.Name = "marketText"; txt.Text = "Test"; txt.Box = box; txt.AppearanceText.TextBrush = new SolidBrushObject(Color.Black); txt.AppearanceText.Font = new Font("Tahoma", 8f); txt.ShadingFlags = ShadingFlags.NoShading; txt.EndUpdate(); markerShape.AddRange(new BaseShape[] { eShape, txt }); return(txt); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> protected override object DrawImage(Target2DWrapper <Canvas> target, RectangleF2D bounds, byte[] imageData, object tag) { global::Android.Graphics.Bitmap image = (tag as global::Android.Graphics.Bitmap); if (image == null) { image = global::Android.Graphics.BitmapFactory.DecodeByteArray( imageData, 0, imageData.Length); } PointF2D bottomLeft = new PointF2D(this.Tranform(bounds.BottomLeft [0], bounds.BottomLeft [1])); PointF2D bottomRight = new PointF2D(this.Tranform(bounds.BottomRight [0], bounds.BottomRight [1])); PointF2D topLeft = new PointF2D(this.Tranform(bounds.TopLeft [0], bounds.TopLeft [1])); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); RectangleF2D transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); target.Target.Save(); target.Target.Translate((float)transformed.BottomLeft [0], (float)transformed.BottomLeft [1]); target.Target.Rotate(-(float)((Degree)transformed.Angle).Value); target.Target.DrawBitmap(image, new global::Android.Graphics.Rect(0, 0, image.Width, image.Height), new global::Android.Graphics.RectF(0, 0, (float)transformed.Width, (float)transformed.Height), null); target.Target.Restore(); return(tag); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="nativeImage">Image data.</param> protected override void DrawImage(Target2DWrapper <Canvas> target, RectangleF2D bounds, INativeImage nativeImage) { var nativeAndroidImage = (nativeImage as NativeImage); global::Android.Graphics.Bitmap image = nativeAndroidImage.Image; this.Transform(bounds.BottomLeft [0], bounds.BottomLeft [1], _transformed1); PointF2D bottomLeft = new PointF2D(_transformed1[0], _transformed1[1]); this.Transform(bounds.BottomRight [0], bounds.BottomRight [1], _transformed1); PointF2D bottomRight = new PointF2D(_transformed1[0], _transformed1[1]); this.Transform(bounds.TopLeft [0], bounds.TopLeft [1], _transformed1); PointF2D topLeft = new PointF2D(_transformed1[0], _transformed1[1]); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); var transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); _paint.AntiAlias = true; _paint.FilterBitmap = true; target.Target.Save(); target.Target.Translate((float)transformed.BottomLeft [0], (float)transformed.BottomLeft [1]); target.Target.Rotate(-(float)((Degree)transformed.Angle).Value); if (image != null) { target.Target.DrawBitmap(image, new global::Android.Graphics.Rect(0, 0, image.Width, image.Height), new global::Android.Graphics.RectF(0, 0, (float)transformed.Width, (float)transformed.Height), _paint); } target.Target.Restore(); }
/// <summary> /// Initializes a new instance of the <see cref="OsmSharp.UI.Renderer.Scene.Scene2DPrimitives.TiltedImage2D"/> class. /// </summary> /// <param name="bounds">Bounds.</param> /// <param name="imageData">Image data.</param> public ImageTilted2D(RectangleF2D bounds, byte[] imageData, float minZoom, float maxZoom) { _bounds = bounds; this.ImageData = imageData; this.MinZoom = minZoom; this.MaxZoom = maxZoom; }
/// <summary> /// Initializes a new instance of the <see cref="OsmSharp.UI.Renderer.Scene.Scene2DPrimitives.TiltedImage2D"/> class. /// </summary> /// <param name="bounds">Bounds.</param> /// <param name="nativeImage">Image data.</param> public ImageTilted2D(RectangleF2D bounds, INativeImage nativeImage, float minZoom, float maxZoom) { _bounds = bounds; this.NativeImage = nativeImage; this.MinZoom = minZoom; this.MaxZoom = maxZoom; }
/// <summary> /// Initializes a new instance of the <see cref="OsmSharp.UI.Renderer.View2D"/> class. /// </summary> private View2D(RectangleF2D rectangle, bool invertX, bool invertY) { _invertX = invertX; _invertY = invertY; _rectangle = rectangle; var box = _rectangle.BoundingBox; _minX = box.Min[0]; _minY = box.Min[1]; _maxX = box.Max[0]; _maxY = box.Max[1]; }
public void TestRectangleF2DOuterBox() { double delta = 0.00001; // this should create the exact same rectangle as in the other tests. RectangleF2D rectangle = RectangleF2D.FromBoundsAndCenter(System.Math.Sqrt(2) * 2, System.Math.Sqrt(2) * 2, 3, 1, 45); // get the box and tests it's bounds. BoxF2D box = rectangle.BoundingBox; Assert.AreEqual(1, box.Min[0], delta); Assert.AreEqual(-1, box.Min[1], delta); Assert.AreEqual(5, box.Max[0], delta); Assert.AreEqual(3, box.Max[1], delta); }
public void TestRectangleF2DOutsideTransforms() { RectangleF2D rectangle = new RectangleF2D(0, 0, 1, 1); double[] converted = rectangle.TransformFrom(100, 100, false, false, new double[] { -100, -100 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(-1, converted [0]); Assert.AreEqual(-1, converted [1]); double[] convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(-100, convertedBack [0]); Assert.AreEqual(-100, convertedBack [1]); }
/// <summary> /// Creates a new instance of the <see cref="OsmSharp.UI.Renderer.View2D"/> class. /// </summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="centerX">The center x.</param> /// <param name="centerY">The center y.</param> /// <param name="xInverted">When true x increases from left to right, when false otherwise.</param> /// <param name="yInverted">When true y increases from bottom to top, when false otherwise.</param> /// <param name="angleY"></param> public static View2D CreateFromCenterAndSize(double width, double height, double centerX, double centerY, bool xInverted, bool yInverted, Degree angleY) { if (width <= 0) { throw new ArgumentOutOfRangeException("width", "width has to be larger and not equal to zero."); } if (height <= 0) { throw new ArgumentOutOfRangeException("height", "height has to be larger and not equal to zero."); } return(new View2D(RectangleF2D.FromBoundsAndCenter(width, height, centerX, centerY, angleY), xInverted, yInverted)); }
public void TestRectangleF2DRotationAroundPoint() { double delta = 0.00001; RectangleF2D rectangle = new RectangleF2D(2, 2, 1, 1); RectangleF2D rotatedRectangle = rectangle.RotateAround(90, new PointF2D(2, 2)); Assert.AreEqual(2, rotatedRectangle.BottomLeft [0], delta); Assert.AreEqual(2, rotatedRectangle.BottomLeft [1], delta); Assert.AreEqual(2, rotatedRectangle.BottomRight [0], delta); Assert.AreEqual(1, rotatedRectangle.BottomRight [1], delta); Assert.AreEqual(3, rotatedRectangle.TopLeft [0], delta); Assert.AreEqual(2, rotatedRectangle.TopLeft [1], delta); Assert.AreEqual(3, rotatedRectangle.TopRight [0], delta); Assert.AreEqual(1, rotatedRectangle.TopRight [1], delta); }
/// <summary> /// Adds the image. /// </summary> /// <returns>The image.</returns> /// <param name="layer">Layer.</param> /// <param name="minZoom">Minimum zoom.</param> /// <param name="maxZoom">Max zoom.</param> /// <param name="rectangle">Rectangle.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> public override uint AddImage(int layer, float minZoom, float maxZoom, RectangleF2D rectangle, byte[] imageData, object tag) { if (imageData == null) { throw new ArgumentNullException("imageData"); } lock (_primitives) { uint id = _nextId; _nextId++; var imageTilted2D = new ImageTilted2D(rectangle, imageData, minZoom, maxZoom); imageTilted2D.Tag = tag; this.AddPrimitive(layer, id, imageTilted2D); return(id); } }
public void TestRectangleF2DCreateFromBoundsAndCenter() { double delta = 0.00001; // this should create the exact same rectangle as in the other tests. RectangleF2D rectangle = RectangleF2D.FromBoundsAndCenter(System.Math.Sqrt(2) * 2, System.Math.Sqrt(2) * 2, 3, 1, 45); RectangleF2D rectangleReference = new RectangleF2D(1, 1, System.Math.Sqrt(2) * 2, System.Math.Sqrt(2) * 2, 45); Assert.AreEqual(rectangleReference.Height, rectangle.Height); Assert.AreEqual(rectangleReference.Width, rectangle.Width); Assert.AreEqual(rectangleReference.BottomLeft[0], rectangle.BottomLeft[0], delta); Assert.AreEqual(rectangleReference.BottomLeft[1], rectangle.BottomLeft[1], delta); Assert.AreEqual(rectangleReference.TopLeft[0], rectangle.TopLeft[0], delta); Assert.AreEqual(rectangleReference.TopLeft[1], rectangle.TopLeft[1], delta); Assert.AreEqual(rectangleReference.TopRight[0], rectangle.TopRight[0], delta); Assert.AreEqual(rectangleReference.TopRight[1], rectangle.TopRight[1], delta); Assert.AreEqual(rectangleReference.BottomRight[0], rectangle.BottomRight[0], delta); Assert.AreEqual(rectangleReference.BottomRight[1], rectangle.BottomRight[1], delta); }
/// <summary> /// Draws an image on the target. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="nativeImage"></param> /// <returns>The image.</returns> protected override void DrawImage(Target2DWrapper <CGContextWrapper> target, double left, double top, double right, double bottom, INativeImage nativeImage) { // get the native image. var iosNativeImage = (nativeImage as NativeImage); // get CGImage. CGImage image = iosNativeImage.Image; var bounds = new RectangleF2D(left, bottom, (left - right), (top - bottom)); target.Target.CGContext.SetAllowsFontSubpixelQuantization(true); target.Target.CGContext.SetAllowsFontSmoothing(true); target.Target.CGContext.SetAllowsAntialiasing(true); target.Target.CGContext.SetAllowsSubpixelPositioning(true); target.Target.CGContext.SetShouldAntialias(true); PointF2D bottomLeft = new PointF2D(this.Transform(bounds.BottomLeft[0], bounds.BottomLeft[1])); PointF2D bottomRight = new PointF2D(this.Transform(bounds.BottomRight[0], bounds.BottomRight[1])); PointF2D topLeft = new PointF2D(this.Transform(bounds.TopLeft[0], bounds.TopLeft[1])); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); RectangleF2D transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); target.Target.CGContext.SaveState(); target.Target.CGContext.TranslateCTM((float)transformed.BottomLeft[0], (float)transformed.BottomLeft[1]); target.Target.CGContext.RotateCTM(-(float)((Radian)transformed.Angle).Value); target.Target.CGContext.ScaleCTM(-1, 1); // build rectangle. _rectangle.X = 0; _rectangle.Y = 0; _rectangle.Width = (float)transformed.Width; _rectangle.Height = (float)transformed.Height; target.Target.CGContext.DrawImage(_rectangle, image); target.Target.CGContext.RestoreState(); }
public void TestRectangleF2DOverlaps() { double delta = 0.00001; RectangleF2D rectangle = new RectangleF2D(1, 1, System.Math.Sqrt(2) * 2, System.Math.Sqrt(2) * 2, 45); double[] converted = rectangle.TransformFrom(100, 100, false, false, new double[] { 25, 75 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(3, converted[0], delta); Assert.AreEqual(2, converted[1], delta); double[] convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(25, convertedBack[0], delta); Assert.AreEqual(75, convertedBack[1], delta); Assert.IsFalse(rectangle.Overlaps(new BoxF2D(5, 3, 6, 4))); Assert.IsTrue(rectangle.Overlaps(new BoxF2D(3.5, 1.5, 4.5, 2.5))); Assert.IsTrue(rectangle.Overlaps(new BoxF2D(2, 0.5, 3, 1.5))); Assert.IsTrue(rectangle.Overlaps(new BoxF2D(0, -2, 4, 6))); Assert.IsTrue(rectangle.Overlaps(new BoxF2D(4, -2, 6, 4))); Assert.IsTrue(rectangle.Overlaps(new BoxF2D(1.5, -2, 2.5, 4))); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> protected abstract void DrawImage(Target2DWrapper <TTarget> target, RectangleF2D bounds, INativeImage tag);
/// <summary> /// Fites this view around the given points but keeps aspect ratio and /// </summary> /// <param name="points"></param> /// <returns></returns> public View2D Fit(PointF2D[] points, double percentage) { RectangleF2D rotated = this.Rectangle.FitAndKeepAspectRatio(points, percentage); return(new View2D(rotated, _invertX, _invertY)); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="nativeImage">Image data.</param> protected override void DrawImage(Target2DWrapper <Graphics> target, RectangleF2D bounds, INativeImage nativeImage) { }
/// <summary> /// Creates a tranformation matrix that transforms coordinates from inside the given rectangle to a viewport of given size. The bottom-left of the rectangle is assumed to be the origin. /// </summary> /// <param name="rectangle"></param> /// <param name="width"></param> /// <param name="height"></param> /// <returns></returns> public static Matrix2D FromRectangle(RectangleF2D rectangle, double width, double height) { return(Matrix2D.FromRectangle(rectangle, width, height, false, false)); }
public void TestRectangleF2DNoDirection() { RectangleF2D rectangle = new RectangleF2D(0, 0, 1, 1); Assert.AreEqual(0, rectangle.BottomLeft[0]); Assert.AreEqual(0, rectangle.BottomLeft[1]); Assert.AreEqual(1, rectangle.BottomRight[0]); Assert.AreEqual(0, rectangle.BottomRight[1]); Assert.AreEqual(0, rectangle.TopLeft[0]); Assert.AreEqual(1, rectangle.TopLeft[1]); Assert.AreEqual(1, rectangle.TopRight[0]); Assert.AreEqual(1, rectangle.TopRight[1]); Assert.AreEqual(0, rectangle.Angle.Value); BoxF2D box = rectangle.BoundingBox; Assert.AreEqual(0, box.Min[0]); Assert.AreEqual(0, box.Min[1]); Assert.AreEqual(1, box.Max[0]); Assert.AreEqual(1, box.Max[1]); Assert.IsTrue(rectangle.Contains(0.25, 0.75)); Assert.IsFalse(rectangle.Contains(1.2, 0.25)); Assert.IsFalse(rectangle.Contains(0.25, 1.2)); Assert.IsTrue(rectangle.Contains(new PointF2D(0.25, 0.75))); Assert.IsFalse(rectangle.Contains(new PointF2D(1.2, 0.25))); Assert.IsFalse(rectangle.Contains(new PointF2D(0.25, 1.2))); Assert.AreEqual(1, rectangle.Distance(new PointF2D(2, 0))); Assert.AreEqual(0, rectangle.Distance(new PointF2D(1, 0))); Assert.AreEqual(1, rectangle.Distance(new PointF2D(0, 2))); Assert.AreEqual(0, rectangle.Distance(new PointF2D(0, 1))); Assert.AreEqual(1, rectangle.Distance(new PointF2D(-1, 0.5))); Assert.AreEqual(0, rectangle.Distance(new PointF2D(0, 0.5))); Assert.AreEqual(1, rectangle.Height); Assert.AreEqual(1, rectangle.Width); double[] converted = rectangle.TransformFrom(100, 100, false, false, new double[] { 25, 75 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(0.25, converted [0]); Assert.AreEqual(0.75, converted [1]); double[] convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(25, convertedBack [0]); Assert.AreEqual(75, convertedBack [1]); converted = rectangle.TransformFrom(100, 100, false, true, new double[] { 25, 75 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(0.25, converted [0]); Assert.AreEqual(0.25, converted [1]); convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(25, convertedBack [0]); Assert.AreEqual(25, convertedBack [1]); converted = rectangle.TransformFrom(100, 100, true, false, new double[] { 25, 75 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(0.75, converted [0]); Assert.AreEqual(0.75, converted [1]); convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(75, convertedBack [0]); Assert.AreEqual(75, convertedBack [1]); converted = rectangle.TransformFrom(100, 100, true, true, new double[] { 25, 75 }); Assert.AreEqual(2, converted.Length); Assert.AreEqual(0.75, converted [0]); Assert.AreEqual(0.25, converted [1]); convertedBack = rectangle.TransformTo(100, 100, false, false, converted); Assert.AreEqual(2, convertedBack.Length); Assert.AreEqual(75, convertedBack [0]); Assert.AreEqual(25, convertedBack [1]); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> protected override object DrawImage(Target2DWrapper <Graphics> target, RectangleF2D bounds, byte[] imageData, object tag) { return(tag); }
/// <summary> /// Adds the image. /// </summary> /// <returns>The image.</returns> /// <param name="layer">Layer.</param> /// <param name="minZoom">Minimum zoom.</param> /// <param name="maxZoom">Max zoom.</param> /// <param name="rectangle">Rectangle.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> public abstract uint AddImage(int layer, float minZoom, float maxZoom, RectangleF2D rectangle, byte[] imageData, object tag);
/// <summary> /// Rotates this view around it's center with a given angle and returns the modified version. /// </summary> /// <returns>The around center.</returns> /// <param name="angle">Angle.</param> public View2D RotateAroundCenter(Radian angle) { RectangleF2D rotated = this.Rectangle.RotateAroundCenter(angle); return(new View2D(rotated, _invertX, _invertY)); }
/// <summary> /// Adds the image. /// </summary> /// <returns>The image.</returns> /// <param name="layer">Layer.</param> /// <param name="minZoom">Minimum zoom.</param> /// <param name="maxZoom">Max zoom.</param> /// <param name="rectangle">Rectangle.</param> /// <param name="imageData">Image data.</param> /// <param name="tag">Tag.</param> public override uint AddImage(int layer, float minZoom, float maxZoom, RectangleF2D rectangle, byte[] imageData, object tag) { return(_nonSimplifiedScene.AddImage(layer, minZoom, maxZoom, rectangle, imageData, tag)); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="nativeImage">Image data.</param> protected override void DrawImage(Target2DWrapper <RenderContext> target, RectangleF2D bounds, INativeImage nativeImage) { DrawImage(target, bounds.TopLeft[0], bounds.TopLeft[1], bounds.BottomRight[0], bounds.BottomRight[1], nativeImage); }