public static void FillPolygon(int[] x, int[] y, int n) { if (n < 3) { return; } var pta = new RawVector2[n - 1]; var pta0 = new RawVector2(x[0], y[0]); for (var i = 1; i < n; i++) { pta[i - 1] = new RawVector2(x[i], y[i]); } using (var geo1 = new PathGeometry(Factory)) using (var sink1 = geo1.Open()) { sink1.BeginFigure(pta0, FigureBegin); sink1.AddLines(pta); sink1.EndFigure(FigureEnd); sink1.Close(); D2D.FillGeometry(geo1, _currentColor); } }
public WICBitmapCanvas (WIC.Bitmap bmp, D2D1.RenderTargetProperties properties, Direct2DFactories factories = null) : base (new D2D1.WicRenderTarget ((factories ?? Direct2DFactories.Shared).D2DFactory, bmp, properties), factories) { this.Bmp = bmp; this.scale = properties.DpiX / 96.0; var bmpSize = bmp.Size; this.size = new Size (bmpSize.Width / scale, bmpSize.Height / scale); }
public static void DrawMultiLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiLineString lines, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map, float offset) { for (var i = 0; i < lines.NumGeometries; i++) { var line = (ILineString)lines[i]; DrawLineString(renderTarget, factory, line, pen, penWidth, penStrokeStyle, map, offset); } }
public static void DrawRoundRect(int x, int y, int wid, int hei, int arcWid, int arcHei) { D2D.DrawRoundedRectangle(new RoundedRectangle() { Rect = new RectangleF(x, y, wid, hei), RadiusX = arcWid, RadiusY = arcHei, }, _currentColor); }
public static void DrawImage(Image image, int x, int y, int wid, int hei) { if (image == null) { return; } D2D.DrawBitmap(image, new RectangleF(x, y, wid, hei), 1.0f, BitmapInterpolationMode.NearestNeighbor); }
public static D2D.Geometry ToSharpDX(this Geometry geometry, D2D.Factory factory, RectangleF rect) { var d2dGeometry = new D2D.PathGeometry(factory); var sink = d2dGeometry.Open(); sink.AddGeometry(geometry, rect); sink.Close(); return d2dGeometry; }
public sd.Brush GetBrush(sd.RenderTarget target) { if (brush == null || !ReferenceEquals(brush.Tag, target)) { if (brush != null) brush.Dispose(); brush = new sd.SolidColorBrush(target, Color.ToDx()) { Tag = target }; } return brush; }
public static void DrawImage(Image image, int x, int y) { if (image == null) { return; } D2D.DrawBitmap(image, new RectangleF(x, y, image.GetWidth(null), image.GetHeight(null)), 1.0f, BitmapInterpolationMode.NearestNeighbor); }
protected override sd.Brush Create(sd.RenderTarget target) { return new sd.LinearGradientBrush( target, new sd.LinearGradientBrushProperties { StartPoint = StartPoint.ToDx(), EndPoint = EndPoint.ToDx() }, new sd.GradientStopCollection(GraphicsHandler.CurrentRenderTarget, new[] { new sd.GradientStop { Color = StartColor.ToDx(), Position = 0f }, new sd.GradientStop { Color = EndColor.ToDx(), Position = 1f } }, WrapMode == GradientWrapMode.Reflect ? sd.ExtendMode.Mirror : sd.ExtendMode.Wrap) ); }
public static void DrawPolygon(int[] x, int[] y, int n) { if (n < 2) { return; } var l = n - 1; for (var i = 0; i < l; i++) { D2D.DrawLine(new RawVector2(x[i] - 0.5f, y[i] - 0.5f), new RawVector2(x[i + 1] - 0.5f, y[i + 1] - 0.5f), _currentColor); } D2D.DrawLine(new RawVector2(x[l] - 0.5f, y[l] - 0.5f), new RawVector2(x[0] - 0.5f, y[0] - 0.5f), _currentColor); }
/// <summary> /// Creates and pushes a D2D layer if necessary. Returns the layer or null if not required. /// </summary> /// <param name="element">The element.</param> /// <param name="renderTarget">The render target.</param> /// <param name="rootElement"></param> /// <returns></returns> public static D2D.Layer CreateAndPushLayerIfNecessary(this Jupiter.FrameworkElement element, D2D.RenderTarget renderTarget, Jupiter.FrameworkElement rootElement) { if (element.Opacity >= 1) //element.Clip == null && //element.RenderTransform == null) { return null; } var layer = new D2D.Layer(renderTarget); var layerParameters = new D2D.LayerParameters(); layerParameters.Opacity = (float)element.Opacity; layerParameters.ContentBounds = element.GetBoundingRect(rootElement).ToSharpDX(); renderTarget.PushLayer(ref layerParameters, layer); return layer; }
protected override sd.Brush Create(sd.RenderTarget target) { return new sd.RadialGradientBrush( target, new sd.RadialGradientBrushProperties { Center = Center.ToDx(), GradientOriginOffset = (GradientOrigin - Center).ToDx(), RadiusX = Radius.Width, RadiusY = Radius.Height }, new sd.GradientStopCollection(GraphicsHandler.CurrentRenderTarget, new[] { new sd.GradientStop { Color = StartColor.ToDx(), Position = 0f }, new sd.GradientStop { Color = EndColor.ToDx(), Position = 1f } }, WrapMode.ToDx()) ); }
/// <summary> /// Renders a LineString to the map. /// </summary> /// <param name="renderTarget">The render target</param> /// <param name="factory">The factory to create shapes</param> /// <param name="line">LineString to render</param> /// <param name="pen">Pen style used for rendering</param> /// <param name="map">Map reference</param> /// <param name="offset">Offset by which line will be moved to right</param> public static void DrawLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, ILineString line, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map, float offset) { var points = TransformToImage(line, map); if (points.Length > 1) { using (var geom = new D2D1.PathGeometry(factory)) { using (var gs = geom.Open()) { gs.BeginFigure(points[0], D2D1.FigureBegin.Filled); gs.AddLines(points); gs.EndFigure(D2D1.FigureEnd.Open); gs.Close(); } renderTarget.DrawGeometry(geom, pen, penWidth, penStrokeStyle); } } }
public static void DrawLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, ILineString line, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map) { DrawLineString(renderTarget, factory, line, pen, penWidth, penStrokeStyle, map, 0); }
public static sd.Brush ToDx(this Brush brush, sd.RenderTarget target) { var obj = (BrushData)brush.ControlObject; return obj.Get(target); }
public static async Task<D2D.Brush> ToSharpDX( this Jupiter.Media.Brush brush, D2D.RenderTarget renderTarget, RectangleF rect) { if (brush == null) return null; var solidColorBrush = brush as Jupiter.Media.SolidColorBrush; if (solidColorBrush != null) { var color = solidColorBrush.Color.ToSharpDX(); return new D2D.SolidColorBrush( renderTarget, color, new D2D.BrushProperties { Opacity = (float)solidColorBrush.Opacity }); } var linearGradientBrush = brush as Jupiter.Media.LinearGradientBrush; if (linearGradientBrush != null) { var properties = new D2D.LinearGradientBrushProperties(); //properties.StartPoint = // new Vector2( // (float)(linearGradientBrush.StartPoint.X * renderTarget.Size.Width), // (float)(linearGradientBrush.StartPoint.Y * renderTarget.Size.Height)); //properties.EndPoint = // new Vector2( // (float)(linearGradientBrush.EndPoint.X * renderTarget.Size.Width), // (float)(linearGradientBrush.EndPoint.Y * renderTarget.Size.Height)); properties.StartPoint = new Vector2( rect.Left + (float)(linearGradientBrush.StartPoint.X * rect.Width), rect.Top + (float)(linearGradientBrush.StartPoint.Y * rect.Height)); properties.EndPoint = new Vector2( rect.Left + (float)(linearGradientBrush.EndPoint.X * rect.Width), rect.Top + (float)(linearGradientBrush.EndPoint.Y * rect.Height)); var brushProperties = new D2D.BrushProperties(); brushProperties.Opacity = (float)linearGradientBrush.Opacity; if (linearGradientBrush.Transform != null) { brushProperties.Transform = linearGradientBrush.Transform.ToSharpDX(); } var gradientStopCollection = linearGradientBrush.GradientStops.ToSharpDX(renderTarget); return new D2D.LinearGradientBrush( renderTarget, properties, brushProperties, gradientStopCollection); } var imageBrush = brush as Jupiter.Media.ImageBrush; if (imageBrush != null) { var bitmap = await imageBrush.ImageSource.ToSharpDX(renderTarget); var w = bitmap.PixelSize.Width; var h = bitmap.PixelSize.Height; Matrix3x2 transform = Matrix3x2.Identity; switch (imageBrush.Stretch) { case Stretch.None: transform.M31 += rect.Left + rect.Width * 0.5f - w / 2; transform.M32 += rect.Top + rect.Height * 0.5f - h / 2; break; case Stretch.Fill: transform = Matrix3x2.Scaling( rect.Width / w, rect.Height / h); transform.M31 += rect.Left; transform.M32 += rect.Top; break; case Stretch.Uniform: var bitmapAspectRatio = (float)w / h; var elementAspectRatio = rect.Width / rect.Height; if (bitmapAspectRatio > elementAspectRatio) { var scale = rect.Width / w; transform = Matrix3x2.Scaling(scale); transform.M31 += rect.Left; transform.M32 += rect.Top + rect.Height * 0.5f - scale * h / 2; } else // (elementAspectRatio >= bitmapAspectRatio) { var scale = rect.Height / h; transform = Matrix3x2.Scaling(scale); transform.M31 += rect.Left + rect.Width * 0.5f - scale * w / 2; transform.M32 += rect.Top; } break; case Stretch.UniformToFill: var bitmapAspectRatio2 = (float)w / h; var elementAspectRatio2 = rect.Width / rect.Height; if (bitmapAspectRatio2 > elementAspectRatio2) { var scale = rect.Height / h; transform = Matrix3x2.Scaling(scale); transform.M31 += rect.Left + rect.Width * 0.5f - scale * w / 2; transform.M32 += rect.Top; } else // (elementAspectRatio >= bitmapAspectRatio) { var scale = rect.Width / w; transform = Matrix3x2.Scaling(scale); transform.M31 += rect.Left; transform.M32 += rect.Top + rect.Height * 0.5f - scale * h / 2; } break; } return new D2D.BitmapBrush1( (D2D.DeviceContext)renderTarget, bitmap, new D2D.BitmapBrushProperties1 { ExtendModeX = D2D.ExtendMode.Clamp, ExtendModeY = D2D.ExtendMode.Clamp, InterpolationMode = D2D.InterpolationMode.HighQualityCubic }) { Opacity = (float)imageBrush.Opacity, Transform = transform }; // var writeableBitmap = imageBrush.ImageSource as WriteableBitmap; // var bitmapImage = imageBrush.ImageSource as BitmapImage; // if (bitmapImage != null) // { // writeableBitmap = // await WriteableBitmapFromBitmapImageExtension.FromBitmapImage(bitmapImage); // } // CompositionEngine c; // return new D2D.BitmapBrush( // renderTarget, // writeableBitmap.ToSharpDX(), //} } #if DEBUG throw new NotSupportedException("Only SolidColorBrush supported for now"); #else return new D2D.SolidColorBrush(renderTarget, Color.Transparent); #endif }
public static void DrawMultiPoint(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiPoint points, D2D1.Brush brush, float size, Vector2 offset, Map map) { for (var i = 0; i < points.NumGeometries; i++) { var point = (IPoint)points[i]; DrawPoint(renderTarget, factory, point, brush, size, offset, map); } }
private static D2D1.Bitmap CreateDefaultsymbol(D2D1.RenderTarget renderTarget) { return Converter.ToSharpDXBitmap(renderTarget, DefaultSymbol, 1f); }
public static void DrawPoint(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IPoint point, D2D1.Brush b, float size, Vector2 offset, Map map) { if (point == null) return; var pp = TransformToImage(point.Coordinate, map); if (double.IsNaN(point.X)) return; pp += offset; var e = new D2D1.Ellipse(pp, size, size); renderTarget.FillEllipse(e, b); renderTarget.DrawEllipse(e, b); }
internal async Task RenderChildren(D2D.RenderTarget renderTarget, FrameworkElement rootElement, FrameworkElement fe) { var children = fe.GetChildrenByZIndex(); foreach (var dependencyObject in children) { var child = dependencyObject as FrameworkElement; Debug.Assert(child != null); if (child != null && child.Opacity > 0 && child.Visibility == Visibility.Visible) { await this.Render(renderTarget, rootElement, child); } } }
public async Task Render(D2D.RenderTarget renderTarget, FrameworkElement rootElement, FrameworkElement fe) { var textBlock = fe as TextBlock; if (textBlock != null) { await TextBlockRenderer.Render(this, renderTarget, rootElement, textBlock); return; } var rectangle = fe as Jupiter.Shapes.Rectangle; if (rectangle != null) { await RectangleRenderer.Render(this, renderTarget, rootElement, rectangle); return; } var border = fe as Border; if (border != null) { await BorderRenderer.Render(this, renderTarget, rootElement, border); return; } var image = fe as Image; if (image != null) { await ImageRenderer.Render(this, renderTarget, rootElement, image); return; } var ellipse = fe as Ellipse; if (ellipse != null) { #pragma warning disable 4014 EllipseRenderer.Render(this, renderTarget, rootElement, ellipse); #pragma warning restore 4014 return; } var line = fe as Line; if (line != null) { await LineRenderer.Render(this, renderTarget, rootElement, line); return; } var path = fe as Jupiter.Shapes.Path; if (path != null) { await PathRenderer.Render(this, renderTarget, rootElement, path); return; } await FrameworkElementRenderer.Render(this, renderTarget, rootElement, fe); }
public async Task Compose(D2D.RenderTarget renderTarget, FrameworkElement fe) { renderTarget.BeginDraw(); renderTarget.Clear(new SharpDX.Color(0, 0, 0, 0)); await this.Render(renderTarget, fe, fe); renderTarget.EndDraw(); }
public static sd.Bitmap ToDx(this Image image, sd.RenderTarget target, Size? fittingSize = null) { if (fittingSize != null) { var icon = image as Icon; if (icon != null) { return icon.GetFrame(1f, fittingSize).Bitmap.ToDx(target); } } var handler = (ID2DBitmapHandler)image.Handler; return target != null ? handler.GetBitmap(target) : null; }
public static void DrawMultiPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiPolygon pols, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map) { for (var i = 0; i < pols.NumGeometries; i++) { var p = (IPolygon)pols[i]; DrawPolygon(renderTarget, factory, p, brush, pen, penWidth, penStrokeStyle, clip, map); } }
public static void DrawPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IPolygon pol, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map) { if (pol.ExteriorRing == null) return; Vector2[] points; var startPoint = TransformToImage(pol.ExteriorRing, map, out points); if (points.Length > 1) { using (var geom = new D2D1.PathGeometry(factory)) { using (var gs = geom.Open()) { gs.SetFillMode(D2D1.FillMode.Alternate); gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled); gs.AddLines(points); gs.EndFigure(D2D1.FigureEnd.Closed); for (var i = 0; i < pol.NumInteriorRings; i++) { startPoint = TransformToImage(pol.GetInteriorRingN(i), map, out points); if (points.Length > 1) { gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled); gs.AddLines(points); gs.EndFigure(D2D1.FigureEnd.Closed); } } gs.Close(); } if (brush != null) renderTarget.FillGeometry(geom, brush); if (pen != null) renderTarget.DrawGeometry(geom, pen, penWidth, penStrokeStyle); } } }
public static void DrawRect(int x1, int y1, int width, int height) { D2D.DrawRectangle(new RectangleF(x1, y1, width, height), _currentColor); }
public static void DrawPoint(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IPoint point, D2D1.Bitmap symbol, Vector2 offset, float rotation, Map map) { if (point == null) return; var pp = TransformToImage(point.Coordinate, map); if (double.IsNaN(pp.X)) return; pp += offset; bool symbolCreated = false; if (symbol == null) //We have no point style - Use a default symbol { symbol = CreateDefaultsymbol(renderTarget); symbolCreated = true; } lock (symbol) { if (rotation != 0 && !Single.IsNaN(rotation)) { var startingTransform = new Matrix3x2(renderTarget.Transform.ToArray()); var transform = renderTarget.Transform; var rotationCenter = pp; Matrix3x2.Rotation(rotation, rotationCenter); transform *= Matrix3x2.Rotation(rotation, rotationCenter); renderTarget.Transform = transform; //if (symbolscale == 1f) //{ // g.DrawImage(symbol, (pp.X - symbol.Width/2f + offset.X), // (pp.Y - symbol.Height/2f + offset.Y)); //} //else //{ // var width = symbol.Width*symbolscale; // var height = symbol.Height*symbolscale; // g.DrawImage(symbol, (int) pp.X - width/2 + offset.X*symbolscale, // (int) pp.Y - height/2 + offset.Y*symbolscale, width, height); //} var dx = 0.5d*symbol.PixelSize.Width; var dy = 0.5d*symbol.PixelSize.Height; renderTarget.DrawBitmap(symbol, new SharpDX.RectangleF(Convert.ToSingle(pp.X - dx), Convert.ToSingle(pp.Y + dy), symbol.PixelSize.Width, symbol.PixelSize.Height), 1f, SharpDX.Direct2D1.BitmapInterpolationMode.Linear); renderTarget.Transform = startingTransform; } else { //if (symbolscale == 1f) //{ // g.DrawImageUnscaled(symbol, (int) (pp.X - symbol.Width/2f + offset.X), // (int) (pp.Y - symbol.Height/2f + offset.Y)); //} //else //{ // var width = symbol.Width*symbolscale; // var height = symbol.Height*symbolscale; // g.DrawImage(symbol, (int) pp.X - width/2 + offset.X*symbolscale, // (int) pp.Y - height/2 + offset.Y*symbolscale, width, height); //} var dx = 0.5d * symbol.PixelSize.Width; var dy = 0.5d * symbol.PixelSize.Height; renderTarget.DrawBitmap(symbol, new SharpDX.RectangleF(Convert.ToSingle(pp.X - dx), Convert.ToSingle(pp.Y + dy), symbol.PixelSize.Width, symbol.PixelSize.Height), 1f, D2D1.BitmapInterpolationMode.Linear); } } if (symbolCreated) symbol.Dispose(); }
public RenderTargetCanvas(D2D1.RenderTarget renderTarget, Direct2DFactories factories = null) { if (renderTarget == null) throw new ArgumentNullException ("renderTarget"); this.factories = factories ?? Direct2DFactories.Shared; Initialize (renderTarget); }
public static void DrawMultiPoint(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiPoint points, D2D1.Bitmap symbol, Vector2 offset, float rotation, Map map) { for (var i = 0; i < points.NumGeometries; i++) { var point = (IPoint)points[i]; DrawPoint(renderTarget, factory, point, symbol, offset, rotation, map); } }
public static sd.Bitmap ToDx(this Image image, sd.RenderTarget target) { var handler = (ID2DBitmapHandler)image.Handler; return handler.GetBitmap(target); }
public static void DrawString(string text, int x, int y) { D2D.DrawText(text, _textFormat, new RectangleF(x, y - _fontCached.Metrics.Height(text), 400, 400), _currentColor); }
public static async Task<D2D.Bitmap1> ToSharpDX(this ImageSource imageSource, D2D.RenderTarget renderTarget) { var wb = imageSource as Jupiter.Media.Imaging.WriteableBitmap; if (wb == null) { var bi = imageSource as Jupiter.Media.Imaging.BitmapImage; if (bi == null) { return null; } wb = await WriteableBitmapFromBitmapImageExtension.FromBitmapImage(bi); if (wb == null) { return null; } } int width = wb.PixelWidth; int height = wb.PixelHeight; //var cpuReadBitmap = CompositionEngine.CreateCpuReadBitmap(width, height); var cpuReadBitmap = CompositionEngine.CreateRenderTargetBitmap(width, height); //var mappedRect = cpuReadBitmap.Map(D2D.MapOptions.Write | D2D.MapOptions.Read | D2D.MapOptions.Discard); using (var readStream = wb.PixelBuffer.AsStream()) { var pitch = width * 4; //using (var writeStream = // new DataStream( // userBuffer: mappedRect.DataPointer, // sizeInBytes: mappedRect.Pitch * height, // canRead: false, // canWrite: true)) { var buffer = new byte[pitch * height]; readStream.Read(buffer, 0, buffer.Length); cpuReadBitmap.CopyFromMemory(buffer, pitch); //for (int i = 0; i < height; i++) //{ // readStream.Read(buffer, 0, mappedRect.Pitch); // writeStream.Write(buffer, 0, buffer.Length); //} } } //cpuReadBitmap.CopyFromMemory(); return cpuReadBitmap; }
private void RenderInternal(D2D1.Factory factory, D2D1.RenderTarget rt, Map map, Envelope envelope) { //if style is not enabled, we don't need to render anything if (!Style.Enabled) return; var geoms = GetGeometriesInView(envelope); if (geoms.Count == 0) return; var stylesToRender = GetStylesToRender(Style); foreach (var style in stylesToRender) { if (style is VectorStyle) { using (var tmp = SharpDXVectorStyle.FromVectorStyle(rt, factory, (VectorStyle)style)) { //Linestring outlines is drawn by drawing the layer once with a thicker line //before drawing the "inline" on top. if (tmp.EnableOutline) { foreach (var geom in geoms) { if (geom != null) { //Draw background of all line-outlines first if (geom is ILineString) SharpDXVectorRenderer.DrawLineString(rt, factory, geom as ILineString, tmp.Outline, tmp.OutlineWidth, tmp.OutlineStrokeStyle, map, tmp.LineOffset); else if (geom is IMultiLineString) SharpDXVectorRenderer.DrawMultiLineString(rt, factory, geom as IMultiLineString, tmp.Outline, tmp.OutlineWidth, tmp.OutlineStrokeStyle, map, tmp.LineOffset); } } } foreach (IGeometry geom in geoms) { if (geom != null) RenderGeometry(factory, rt, map, geom, tmp); } } } else { lock(_syncRoot) _logger.Debug(fmh => fmh("Not a VectorStyle!")); } } }
private void RenderGeometry(D2D1.Factory factory, D2D1.RenderTarget g, Map map, IGeometry feature, SharpDXVectorStyle style) { if (feature == null) return; var geometryType = feature.OgcGeometryType; switch (geometryType) { case OgcGeometryType.Polygon: if (style.EnableOutline) SharpDXVectorRenderer.DrawPolygon(g, factory, (IPolygon)feature, style.Fill, style.Outline, style.OutlineWidth, style.OutlineStrokeStyle, ClippingEnabled, map); else SharpDXVectorRenderer.DrawPolygon(g, factory, (IPolygon)feature, style.Fill, null, 0f, null, ClippingEnabled, map); break; case OgcGeometryType.MultiPolygon: if (style.EnableOutline) SharpDXVectorRenderer.DrawMultiPolygon(g, factory, (IMultiPolygon)feature, style.Fill, style.Outline, style.OutlineWidth, style.OutlineStrokeStyle, ClippingEnabled, map); else SharpDXVectorRenderer.DrawMultiPolygon(g, factory, (IMultiPolygon)feature, style.Fill, null, 0f, null, ClippingEnabled, map); break; case OgcGeometryType.LineString: SharpDXVectorRenderer.DrawLineString(g, factory, (ILineString)feature, style.Line, style.LineWidth, style.LineStrokeStyle, map, style.LineOffset); return; case OgcGeometryType.MultiLineString: SharpDXVectorRenderer.DrawMultiLineString(g, factory, (IMultiLineString)feature, style.Line, style.LineWidth, style.LineStrokeStyle, map, style.LineOffset); break; case OgcGeometryType.Point: if (style.Symbol != null || style.PointColor == null) { SharpDXVectorRenderer.DrawPoint(g, factory, (IPoint)feature, style.Symbol, style.SymbolOffset, style.SymbolRotation, map); return; } SharpDXVectorRenderer.DrawPoint(g, factory, (IPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map); break; case OgcGeometryType.MultiPoint: if (style.Symbol != null || style.PointColor == null) { SharpDXVectorRenderer.DrawMultiPoint(g, factory, (IMultiPoint)feature, style.Symbol, style.SymbolOffset, style.SymbolRotation, map); } else { SharpDXVectorRenderer.DrawMultiPoint(g, factory, (IMultiPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map); } break; case OgcGeometryType.GeometryCollection: var coll = (IGeometryCollection)feature; for (var i = 0; i < coll.NumGeometries; i++) { IGeometry geom = coll[i]; RenderGeometry(factory, g, map, geom, style); } break; default: lock (_syncRoot) _logger.Debug( fmh => fmh("Unhandled geometry: {0}", feature.OgcGeometryType)); break; } }
public RenderTargetCanvas(DXGI.Surface surface, D2D1.RenderTargetProperties properties, Direct2DFactories factories = null) { if (surface == null) throw new ArgumentNullException ("surface"); this.factories = factories ?? Direct2DFactories.Shared; Initialize (new D2D1.RenderTarget (this.factories.D2DFactory, surface, properties)); }
private void RenderInternal(D2D1.Factory factory, D2D1.RenderTarget rt, Map map, Envelope envelope, Rendering.Thematics.ITheme theme) { var ds = new FeatureDataSet(); lock (_syncRoot) { DataSource.Open(); DataSource.ExecuteIntersectionQuery(envelope, ds); DataSource.Close(); } var scale = map.MapScale; var zoom = map.Zoom; foreach (FeatureDataTable features in ds.Tables) { // Transform geometries if necessary if (CoordinateTransformation != null) { for (var i = 0; i < features.Count; i++) { features[i].Geometry = ToTarget(features[i].Geometry); } } //Linestring outlines is drawn by drawing the layer once with a thicker line //before drawing the "inline" on top. if (Style.EnableOutline) { for (int i = 0; i < features.Count; i++) { var feature = features[i]; var outlineStyle = theme.GetStyle(feature) as VectorStyle; if (outlineStyle == null) continue; if (!(outlineStyle.Enabled && outlineStyle.EnableOutline)) continue; double compare = outlineStyle.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale; if (!(outlineStyle.MinVisible <= compare && compare <= outlineStyle.MaxVisible)) continue; using (var sdxStyle = SharpDXVectorStyle.FromVectorStyle(rt, factory, outlineStyle)) { if (sdxStyle != null) { //Draw background of all line-outlines first if (feature.Geometry is ILineString) { SharpDXVectorRenderer.DrawLineString(rt, factory, (ILineString)feature.Geometry, sdxStyle.Outline, sdxStyle.OutlineWidth, sdxStyle.OutlineStrokeStyle, map, sdxStyle.LineOffset); } else if (feature.Geometry is IMultiLineString) { SharpDXVectorRenderer.DrawMultiLineString(rt, factory, (IMultiLineString)feature.Geometry, sdxStyle.Outline, sdxStyle.OutlineWidth, sdxStyle.OutlineStrokeStyle, map, sdxStyle.LineOffset); } } } } } var sdxVectorStyles = new Dictionary<VectorStyle, SharpDXVectorStyle>(); for (var i = 0; i < features.Count; i++) { var feature = features[i]; var style = theme.GetStyle(feature); if (style == null) continue; if (!style.Enabled) continue; var compare = style.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale; if (!(style.MinVisible <= compare && compare <= style.MaxVisible)) continue; IEnumerable<IStyle> stylesToRender = GetStylesToRender(style); if (stylesToRender == null) return; foreach (var styleToRender in stylesToRender) { if (!styleToRender.Enabled) continue; if (!(styleToRender is VectorStyle)) continue; if (!(style.MinVisible <= compare && compare <= style.MaxVisible)) continue; var vstyle = (VectorStyle) styleToRender; SharpDXVectorStyle sdxStyle; if (!sdxVectorStyles.TryGetValue(vstyle, out sdxStyle)) { sdxStyle = SharpDXVectorStyle.FromVectorStyle(rt, factory, vstyle); sdxVectorStyles.Add(vstyle, sdxStyle); } RenderGeometry(factory, rt, map, feature.Geometry, sdxStyle); } } foreach (var value in sdxVectorStyles.Values) value.Dispose(); } }
protected void Initialize(D2D1.RenderTarget renderTarget) { this.renderTarget = renderTarget; renderTarget.BeginDraw (); }
public static void DrawLine(int x1, int y1, int x2, int y2) { D2D.DrawLine(new RawVector2(x1, y1), new RawVector2(x2, y2), _currentColor); //throw new NotImplementedException(); }