private static void PositionGeometry(CALayer renderedGeometry, IViewport viewport, IStyle style, IFeature feature)
{
if (feature.Geometry is Point)
{
GeometryRenderer.PositionPoint(renderedGeometry, feature.Geometry as Point, style, viewport);
}
if (feature.Geometry is MultiPoint)
{
return;
}
if (feature.Geometry is LineString)
{
return;
}
if (feature.Geometry is MultiLineString)
{
return;
}
if (feature.Geometry is Polygon)
{
return;
}
if (feature.Geometry is MultiPolygon)
{
GeometryRenderer.PositionMultiPolygon(renderedGeometry as CALayer, feature.Geometry as MultiPolygon, style, viewport);
}
if (feature.Geometry is IRaster)
{
GeometryRenderer.PositionRaster(renderedGeometry, feature.Geometry.GetBoundingBox(), viewport);
}
}
/// <summary>
/// uses the BarcodeWriterGeneric implementation and the <see cref="WriteableBitmapRenderer"/> class for decoding
/// </summary>
/// <param name="writer"></param>
/// <param name="content"></param>
/// <returns></returns>
public static Geometry WriteAsGeometry(this IBarcodeWriterGeneric writer, string content)
{
var bitmatrix = writer.Encode(content);
var renderer = new GeometryRenderer();
return(renderer.Render(bitmatrix, writer.Format, content, writer.Options));
}
private void Draw(SKSurface surface, double scale)
{
var canvas = surface.Canvas;
surface.Canvas.Clear(CanvasBackgroundColor.ToSkiaColor());
_gridRenderer.Render(canvas, scale);
if (ToolCollection == null)
{
return;
}
_backgroundImageRenderer.Render(canvas, scale);
foreach (var geom in ToolCollection.Geometries)
{
GeometryRenderer.Render(canvas, geom, scale);
}
//TODO Try to do this on demand, rather than every draw...
// Snapshotting without encoding is rather fast though and does not impact performance that much
SnapShot = surface.Snapshot();
//TODO Look into this
// Not really needed, but keeps the memory slightly lower and does not impact performance that much
var mem = GC.GetTotalMemory(true);
System.Diagnostics.Debug.WriteLine($"Mem {mem}");
}
public static List <IFeature> RenderStackedLabelLayer(IViewport viewport, BasicLayer layer)
{
lock (_syncRoot)
{
var renderedFeatures = new List <IFeature> ();
var canvas = new CALayer();
canvas.Opacity = (float)layer.Opacity;
//todo: take into account the priority
var features = layer.GetFeaturesInView(viewport.Extent, viewport.Resolution);
var margin = viewport.Resolution * 15;
var clusters = new List <Cluster> ();
//todo: repeat until there are no more merges
ClusterFeatures(clusters, features, margin, null, viewport, viewport.Resolution);
//CenterClusters (clusters);
//CATransaction.Begin();
//CATransaction.SetValueForKey (MonoTouch.Foundation.NSNumber.FromBoolean(true), CATransaction.DisableActionsKey);
foreach (var cluster in clusters)
{
var feature = cluster.Features.OrderBy(f => f.Geometry.GetBoundingBox().GetCentroid().Y).FirstOrDefault();
//SetFeatureOutline (feature, layer.LayerName, cluster.Features.Count);
//var bb = RenderBox(cluster.Box, viewport);
//Zorg dat dit ALTIJD decimal zelfde ISet als ViewChanged is
//var feature = cluster.Features.FirstOrDefault ();
var styles = feature.Styles ?? Enumerable.Empty <IStyle>();
foreach (var style in styles)
{
if (feature.Styles != null && style.Enabled)
{
var styleKey = layer.LayerName; //feature.GetHashCode ().ToString ();
var renderedGeometry = (feature[styleKey] != null) ? (CALayer)feature[styleKey] : null;
if (renderedGeometry == null)
{
renderedGeometry = GeometryRenderer.RenderPoint(feature.Geometry as Mapsui.Geometries.Point, style, viewport);
feature [styleKey] = renderedGeometry;
feature ["first"] = true;
}
else
{
feature ["first"] = false;
}
}
}
renderedFeatures.Add(feature);
//renderedFeatures.Add (bb);
}
return(renderedFeatures);
}
}
private void RenderGeoJson()
{
var path = NSBundle.MainBundle.PathForResource("GeoJSON_Sample", "geojson");
var url = new NSUrl(path, isDir: false);
var parser = new GeoJSONParser(url);
parser.Parse();
var renderer = new GeometryRenderer(mapView, parser.Features);
renderer.Render();
}
private void RenderKML()
{
var path = NSBundle.MainBundle.PathForResource("KML_Sample", "kml");
var url = new NSUrl(path, isDir: false);
var parser = new KMLParser(url);
parser.Parse();
var renderer = new GeometryRenderer(mapView, parser.Placemarks, parser.Styles);
renderer.Render();
}
internal SpriteRenderSystem(bool cameraIndependent = false)
{
if (!cameraIndependent)
{
order = int.MaxValue - 256;
}
else
{
order = int.MaxValue - 255;
}
cameraIndependency = cameraIndependent;
spriteBatch = new SpriteBatch(Engine.SharedEngine.GraphicsDevice);
renderer = new GeometryRenderer(spriteBatch);
}
public static GeometryRenderer FromBaseObject(BaseObject baseObj)
{
if (baseObj == null || baseObj.NativeObject == IntPtr.Zero)
{
return(null);
}
GeometryRenderer obj = baseObj as GeometryRenderer;
if (object.Equals(obj, null))
{
obj = new GeometryRenderer(CreatedWhenConstruct.CWC_NotToCreate);
obj.BindNativeObject(baseObj.NativeObject, "CGeometryRenderer");
obj.IncreaseCast();
}
return(obj);
}
private static CALayer RenderGeometry(IViewport viewport, IStyle style, IFeature feature)
{
if (feature.Geometry is Mapsui.Geometries.Point)
{
return(null); //!!!GeometryRenderer.RenderPoint (feature.Geometry as Mapsui.Geometries.Point, style, viewport);
}
else if (feature.Geometry is Polygon)
{
return(GeometryRenderer.RenderPolygonOnLayer(feature.Geometry as Polygon, style, viewport));
}
else if (feature.Geometry is MultiPolygon)
{
return(GeometryRenderer.RenderMultiPolygonOnLayer(feature.Geometry as MultiPolygon, style, viewport));
}
else if (feature.Geometry is IRaster)
{
return(GeometryRenderer.RenderRasterOnLayer(feature.Geometry as IRaster, style, viewport));
}
return(null);
}
private static CALayer RenderBox(BoundingBox box, IViewport viewport)
{
//const int margin = 32;
//const int halfMargin = margin / 2;
var p1 = viewport.WorldToScreen(box.Min);
var p2 = viewport.WorldToScreen(box.Max);
var rectangle = new RectangleF();
rectangle.Width = (float)(p2.X - p1.X); // + margin);
rectangle.Height = (float)(p1.Y - p2.Y); // + margin);
var v = GeometryRenderer.ConvertBoundingBox(box, viewport);
var canvas = new CALayer();
canvas.Frame = v;
canvas.BorderColor = new MonoTouch.CoreGraphics.CGColor(255, 255, 255, 1);
canvas.BorderWidth = 2;
return(canvas);
}
public RenderContext(GeometryRenderer renderer, MeshList meshList)
{
this.renderer = renderer;
this.meshList = meshList;
}
/// <summary>
/// Initializes a new instance of the <see cref="BarcodeWriterGeometry"/> class.
/// </summary>
public BarcodeWriterGeometry()
{
Renderer = new GeometryRenderer();
}
public void UpdatePath()
{
new QrEncoder(ErrorCorrectLevel).TryEncode(Text, out m_QrCode);
m_width = m_QrCode.Matrix == null ? 21 : m_QrCode.Matrix.Width;
PathGeometry = GeometryRenderer.DarkModuleGeometry(m_QrCode.Matrix);
}
public SketchPage()
{
Title = "Sketching";
SaveCommand = new Command(async() => { await SaveImage(); });
_sketchView = new SketchView
{
VerticalOptions = LayoutOptions.FillAndExpand,
HorizontalOptions = LayoutOptions.FillAndExpand,
};
_sketchView.CanDrawOutsideImageBounds = false;
_sketchView.EnableGrid = false;
// How to remove all tools
//_sketchView.RemoveAllToolbarItems();
// How to add all tools
//_sketchView.AddAllToolbarItems();
// How to remove selected tools
//_sketchView.RemoveToolbarItemByIndex(2); // Highlight
//_sketchView.RemoveToolbarItemByName(ToolNames.HighlightTool); // Highlight
// Setup custom toolbar with title, colors and color descriptions
_sketchView.AddToolbarItem(ImageSource.FromResource("SketchUpp.Resources.ruler.png", typeof(RulerTool.RulerTool).GetTypeInfo().Assembly), new RulerTool.RulerTool(Navigation), null);
var customToolbarName = "Fuktmarkering";
var customToolbarColors = new List <KeyValuePair <string, Color> >
{
new KeyValuePair <string, Color>("Dry", Color.FromHex("#FBD447")),
new KeyValuePair <string, Color>("Moist", Color.FromHex("#FFB678")),
new KeyValuePair <string, Color>("Wet", Color.FromHex("#FF5149")),
new KeyValuePair <string, Color>("Leaking place", Color.FromHex("#54A7D4")),
new KeyValuePair <string, Color>("Rot", Color.FromHex("#4BD47B"))
};
// How to add custom tools
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Line.png", typeof(LineTool).GetTypeInfo().Assembly), new LineTool(ToolNames.LineTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Curve.png", typeof(CurveTool).GetTypeInfo().Assembly), new CurveTool(ToolNames.CurveTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Highlight.png", typeof(HighlightTool).GetTypeInfo().Assembly), new HighlightTool(ToolNames.HighlightTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Circle.png", typeof(CircleTool).GetTypeInfo().Assembly), new CircleTool(ToolNames.CircleTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Oval.png", typeof(OvalTool).GetTypeInfo().Assembly), new OvalTool(ToolNames.OvalTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Rectangle.png", typeof(RectangleTool).GetTypeInfo().Assembly), new RectangleTool(ToolNames.RectangleTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Arrow.png", typeof(ArrowTool).GetTypeInfo().Assembly), new ArrowTool(ToolNames.ArrowTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Point.png", typeof(MarkTool).GetTypeInfo().Assembly), new MarkTool(ToolNames.PointTool, customToolbarName, customToolbarColors), null);
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Text.png", typeof(TextTool).GetTypeInfo().Assembly), new TextTool(Navigation, ToolNames.TextTool, customToolbarName, customToolbarColors), null);
// Text with rounded corners if fill is active
//_sketchView.AddToolbarItem(ImageSource.FromResource("Sketching.Resources.Text.png", typeof(TextTool).GetTypeInfo().Assembly), new TextTool(Navigation, "RoundedFill", customToolbarName, customToolbarColors, true), null);
// Create a custom MoistMeasure tool
var moistColors = new List <KeyValuePair <string, Color> >
{
new KeyValuePair <string, Color>("MP1", Color.FromHex("#FBD447")),
new KeyValuePair <string, Color>("MP2", Color.FromHex("#FFB678")),
new KeyValuePair <string, Color>("MP3", Color.FromHex("#FFB678")),
new KeyValuePair <string, Color>("MP4", Color.FromHex("#FF5149"))
};
var moistTool = new MoistTool("Moisture", "Mätpunkter", moistColors)
{
ShowDefaultToolbar = false
};
var assembly = typeof(SketchPage).GetTypeInfo().Assembly;
_sketchView.AddToolbarItem(ImageSource.FromResource("SketchUpp.Resources.Moist.png", assembly), moistTool, null);
GeometryRenderer.AddRenderer(new MoistRenderer());
// Add default tools
_sketchView.AddDefaultToolbarItems();
// How to add the undo buttons
//_sketchView.AddUndoTools();
ToolbarItems.Add(new ToolbarItem {
Text = "Save", Command = SaveCommand
});
ToolbarItems.Add(new ToolbarItem {
Text = "Photo", Command = new Command(async() => { await TakePhoto(); })
});
ToolbarItems.Add(new ToolbarItem {
Text = "Album", Command = new Command(async() => { await SelectImage(); })
});
Content = _sketchView;
}
public void Dispose()
{
renderer.Dispose();
renderer = null;
}
public BaseObject Create()
{
GeometryRenderer emptyInstance = new GeometryRenderer(CreatedWhenConstruct.CWC_NotToCreate);
return(emptyInstance);
}
public void ReadAllRecords(GeometryRenderer ctx)
{
// We shouldn't have any dependent resources if _curOffset is 0
// (curOffset == 0) -> (renderData.dependentResources.Count == 0)
Debug.Assert((curOffset > 0) || (dependentResources.Count == 0));
// The buffer being null implies that curOffset must be 0.
// (buffer == null) -> (curOffset == 0)
Debug.Assert((buffer != null) || (curOffset == 0));
// The _curOffset must be less than the length, if there is a buffer.
Debug.Assert((buffer == null) || (curOffset <= buffer.Length));
if (curOffset > 0)
{
unsafe
{
fixed(byte *pByte = this.buffer)
{
// This pointer points to the current read point in the
// instruction stream.
byte *pCur = pByte;
// This points to the first byte past the end of the
// instruction stream (i.e. when to stop)
byte *pEndOfInstructions = pByte + curOffset;
// Iterate across the entire list of instructions, stopping at the
// end or when it has signalled a stop.
while ((pCur < pEndOfInstructions) && !ctx.ShouldStopWalking)
{
RecordHeader *pCurRecord = (RecordHeader *)pCur;
switch (pCurRecord->Type)
{
case RecordType.DrawLine:
{
DrawLineCommand *data = (DrawLineCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawLine(
(Pen)DependentLookup(data->PenIndex),
data->StartPoint,
data->EndPoint
);
}
break;
case RecordType.DrawRectangle:
{
DrawRectangleCommand *data = (DrawRectangleCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawRectangle(
(Brush)DependentLookup(data->BrushIndex),
(Pen)DependentLookup(data->PenIndex),
data->Rectangle
);
}
break;
case RecordType.DrawRoundedRectangle:
{
DrawRoundedRectangleCommand *data = (DrawRoundedRectangleCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawRoundedRectangle(
(Brush)DependentLookup(data->BrushIndex),
(Pen)DependentLookup(data->PenIndex),
data->Rectangle,
data->radiusX,
data->radiusY
);
}
break;
case RecordType.DrawEllipse:
{
DrawEllipseCommand *data = (DrawEllipseCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawEllipse(
(Brush)DependentLookup(data->BrushIndex),
(Pen)DependentLookup(data->PenIndex),
data->Center,
data->RadiusX,
data->RadiusY
);
}
break;
case RecordType.DrawGlyphRun:
{
DrawGlyphRunCommand *data = (DrawGlyphRunCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawGlyphRun(
(Brush)DependentLookup(data->BrushIndex),
(GlyphRun)DependentLookup(data->GlyphRunIndex)
);
}
break;
case RecordType.DrawText:
{
DrawTextCommand *data = (DrawTextCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawText(
(Brush)DependentLookup(data->BrushIndex),
(FormattedText)DependentLookup(data->FormattedTextIndex)
);
}
break;
case RecordType.DrawGeometry:
{
DrawGeometryCommand *data = (DrawGeometryCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawGeometry(
(Brush)DependentLookup(data->BrushIndex),
(Pen)DependentLookup(data->PenIndex),
(Geometry)DependentLookup(data->GeometryIndex)
);
}
break;
case RecordType.DrawImage:
{
DrawImageCommand *data = (DrawImageCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawImage(
(ITexture)DependentLookup(data->ImageSourceIndex),
data->rectangle,
data->UVMin,
data->UVMax
);
}
break;
case RecordType.DrawSlicedImage:
{
DrawSlicedImageCommand *data = (DrawSlicedImageCommand *)(pCur + sizeof(RecordHeader));
ctx.DrawImage(
(ITexture)DependentLookup(data->ImageSourceIndex),
data->Rectangle,
(data->sliceLeft, data->sliceTop, data->sliceRight, data->sliceBottom)
);
}
break;
case RecordType.PushClip:
{
PushClipCommand *data = (PushClipCommand *)(pCur + sizeof(RecordHeader));
ctx.PushClip(
(Geometry)DependentLookup(data->ClipGeometryIndex)
);
}
break;
case RecordType.Pop:
{
ctx.Pop();
}
break;
default:
throw new ArgumentOutOfRangeException();
break;
}
pCur += pCurRecord->Size;
}
}
}
}
}
