/// <summary>
/// Creates a new OSM data layer.
/// </summary>
/// <param name="projection"></param>
public LayerGpx(IProjection projection)
{
_projection = projection;
this.Scene = new Scene2DSimple();
this.Scene.BackColor = SimpleColor.FromKnownColor(KnownColor.Transparent).Value;
}
/// <summary>
/// Initialize this instance.
/// </summary>
public void Initialize()
{
this.BackgroundColor = UIColor.White;
var panGesture = new UIPanGestureRecognizer(Pan);
this.AddGestureRecognizer(panGesture);
var pinchGesture = new UIPinchGestureRecognizer(Pinch);
this.AddGestureRecognizer(pinchGesture);
// // create the renderer
// _renderer = new MapRenderer<CGContextWrapper> (
// new CGContextRenderer());
//
// create the cache renderer.
_cacheRenderer = new MapRenderer <CGContextWrapper> (
new CGContextRenderer());
_cachedScene = new Scene2DSimple();
_cachedScene.BackColor = SimpleColor.FromKnownColor(KnownColor.White).Value;
// create invalidation timer.
_render = true;
System.Threading.Timer timer = new System.Threading.Timer(InvalidateSimple,
null, 0, 50);
}
public void TestDomainColorNamed()
{
// parses the MapCSS.
var result = this.TestMapCSSParsing(
"OsmSharp.UI.Test.data.MapCSS.color-named.mapcss");
// Test the very minimum; no errors during parsing says a lot already!
var tree = result.Tree as Antlr.Runtime.Tree.CommonTree;
Assert.NotNull(tree);
Assert.AreEqual(2, tree.ChildCount);
// parse into domain.
var file = MapCSSDomainParser.Parse(tree);
Assert.IsNotNull(file);
Assert.AreEqual(1, file.Rules.Count);
Assert.AreEqual(1, file.Rules[0].Declarations.Count);
Assert.IsInstanceOf(typeof(DeclarationInt), file.Rules[0].Declarations[0]);
// get color declaration.
var declarationInt = file.Rules[0].Declarations[0] as DeclarationInt;
Assert.IsNotNull(declarationInt);
Assert.AreEqual(DeclarationIntEnum.Color, declarationInt.Qualifier);
// instantiate color.
var simpleColor = new SimpleColor();
simpleColor.Value = declarationInt.Eval((MapCSSObject)null);
Assert.AreEqual("#FFFFFF", simpleColor.HexRgb);
}
/// <summary>
/// Draws a polygon on the target. The coordinates given are scene coordinates.
/// </summary>
/// <param name="target"></param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <param name="color">Color.</param>
/// <param name="width">Width.</param>
/// <param name="fill">If set to <c>true</c> fill.</param>
protected override void DrawPolygon(Target2DWrapper <CGContextWrapper> target, double[] x, double[] y, int color, double width,
bool fill)
{
float widthInPixels = this.ToPixels(width);
SimpleColor simpleColor = SimpleColor.FromArgb(color);
target.Target.CGContext.SetLineWidth(widthInPixels);
target.Target.CGContext.SetFillColor(simpleColor.R / 256.0f, simpleColor.G / 256.0f, simpleColor.B / 256.0f,
simpleColor.A / 256.0f);
target.Target.CGContext.SetStrokeColor(simpleColor.R / 256.0f, simpleColor.G / 256.0f, simpleColor.B / 256.0f,
simpleColor.A / 256.0f);
//target.Target.SetLineDash (0, new float[0]);
target.Target.CGContext.BeginPath();
PointF[] points = new PointF[x.Length];
for (int idx = 0; idx < x.Length; idx++)
{
double[] transformed = this.Tranform(x[idx], y[idx]);
points[idx] = new PointF((float)transformed[0], (float)transformed[1]);
}
target.Target.CGContext.AddLines(points);
target.Target.CGContext.ClosePath();
//target.Target.DrawPath (CGPathDrawingMode.Stroke);
target.Target.CGContext.FillPath();
//target.Target.E
}
public DebugLine(Vector3 a, Vector3 b, int ticksLeft = 100, SimpleColor color = SimpleColor.White)
{
this.a = a;
this.b = b;
this.deathTick = Find.TickManager.TicksGame + ticksLeft;
this.color = color;
}
/// <summary>
/// Initialize this instance.
/// </summary>
void Initialize(MapView mapLayout)
{
_mapLayout = mapLayout;
this.SetWillNotDraw(false);
this.MapMinZoomLevel = 10;
this.MapMaxZoomLevel = 20;
_renderer = new MapRenderer <global::Android.Graphics.Canvas>(
new CanvasRenderer2D());
// initialize the gesture detection.
_gestureDetector = new GestureDetector(
this);
_scaleGestureDetector = new ScaleGestureDetector(
this.Context, this);
this.SetOnTouchListener(this);
_makerLayer = new LayerPrimitives(
new WebMercator());
// initialize all the caching stuff.
//_previousCache = null;
_cacheRenderer = new MapRenderer <global::Android.Graphics.Canvas>(
new CanvasRenderer2D());
_scene = new Scene2DSimple();
_scene.BackColor = SimpleColor.FromKnownColor(KnownColor.White).Value;
System.Threading.Timer timer = new Timer(InvalidateSimple,
null, 0, 50);
}
/// <summary>
/// Adds a new OsmSharpRoute.
/// </summary>
/// <param name="route">Stream.</param>
/// <param name="argb">Stream.</param>
/// <param name="width"></param>
public void AddRoute(Route route, int argb, double width)
{
if (route != null &&
route.Segments != null &&
route.Segments.Length > 0)
{ // there are entries.
// get x/y.
var x = new double[route.Segments.Length];
var y = new double[route.Segments.Length];
for (int idx = 0; idx < route.Segments.Length; idx++)
{
x[idx] = _projection.LongitudeToX(
route.Segments[idx].Longitude);
y[idx] = _projection.LatitudeToY(
route.Segments[idx].Latitude);
}
// set the default color if none is given.
var color = SimpleColor.FromArgb(argb);
var pointsId = _scene.AddPoints(x, y);
if (pointsId.HasValue)
{
_scene.AddStyleLine(pointsId.Value, 0, float.MinValue, float.MaxValue,
color.Value, (float)width, Renderer.Primitives.LineJoin.Round, null);
}
}
this.RaiseLayerChanged();
}
private static Material GetLineMat(SimpleColor color)
{
switch (color)
{
case SimpleColor.White:
return(LineMatWhite);
case SimpleColor.Red:
return(LineMatRed);
case SimpleColor.Green:
return(LineMatGreen);
case SimpleColor.Blue:
return(LineMatBlue);
case SimpleColor.Magenta:
return(LineMatMagenta);
case SimpleColor.Yellow:
return(LineMatYellow);
case SimpleColor.Cyan:
return(LineMatCyan);
default:
return(LineMatWhite);
}
}
/// <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>
/// Initialize implementation from IMapView.
/// </summary>
/// <param name="mapLayout"></param>
void IMapViewSurface.Initialize(MapView mapLayout)
{
// create the Open GL 2D target.
_target = new OpenGLTarget2D();
this.SetRenderer(_target);
_mapView = mapLayout;
this.SetWillNotDraw(false);
this.MapMinZoomLevel = 10;
this.MapMaxZoomLevel = 20;
// create the renderer.
_renderer = new MapRenderer <OpenGLTarget2D>(
new OpenGLRenderer2D());
// initialize the gesture detection.
this.SetOnTouchListener(this);
_scaleGestureDetector = new ScaleGestureDetector(
this.Context, this);
_rotateGestureDetector = new RotateGestureDetector(
this.Context, this);
_moveGestureDetector = new MoveGestureDetector(
this.Context, this);
_tagGestureDetector = new TapGestureDetector(
this.Context, this);
_makerLayer = new LayerPrimitives(
new WebMercator());
_scene = new Scene2D(new WebMercator(), 16);
_scene.BackColor = SimpleColor.FromKnownColor(KnownColor.White).Value;
}
/// <summary>
/// Draws a line on the target. The coordinates given are scene coordinates.
/// </summary>
/// <param name="target"></param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <param name="color">Color.</param>
/// <param name="width">Width.</param>
/// <param name="lineJoin"></param>
/// <param name="dashes"></param>
protected override void DrawLine(Target2DWrapper <CGContextWrapper> target, double[] x, double[] y, int color, double width,
LineJoin lineJoin, int[] dashes)
{
float widthInPixels = this.ToPixels(width) * _scaleFactor;
SimpleColor simpleColor = SimpleColor.FromArgb(color);
target.Target.CGContext.SetLineJoin(CGLineJoin.Round);
target.Target.CGContext.SetLineWidth(widthInPixels);
target.Target.CGContext.SetStrokeColor(simpleColor.R / 256.0f, simpleColor.G / 256.0f, simpleColor.B / 256.0f,
simpleColor.A / 256.0f);
target.Target.CGContext.SetLineDash(0, new float[0]);
if (dashes != null && dashes.Length > 1)
{
float[] intervals = new float[dashes.Length];
for (int idx = 0; idx < dashes.Length; idx++)
{
intervals[idx] = dashes[idx];
}
target.Target.CGContext.SetLineDash(0.0f, intervals);
}
// transform the points all at once.
double[][] transformed = this.TransformAll(x, y);
// construct path.
target.Target.CGContext.BeginPath();
PointF[] points = new PointF[x.Length];
for (int idx = 0; idx < x.Length; idx++)
{
points[idx] = new PointF((float)transformed[idx][0], (float)transformed[idx][1]);
}
target.Target.CGContext.AddLines(points);
target.Target.CGContext.DrawPath(CGPathDrawingMode.Stroke);
}
public void TestMapCSSWayRendering1()
{
// create the data source.
MemoryDataSource source = new MemoryDataSource(
Node.Create(1, 1, 1),
Node.Create(2, -1, -1),
Way.Create(1, new SimpleTagsCollection(Tag.Create("highway", "residential")), 1, 2));
// create CSS.
string css = "canvas { " +
"fill-color: white; " +
"} " +
"way { " +
" width: 2; " +
" color: black; " +
"} ";
// do the rendering.
Bitmap rendering = this.Render(source, css);
// check result.
Assert.AreEqual(SimpleColor.FromKnownColor(OsmSharp.UI.KnownColor.White).Value,
rendering.GetPixel(0, 99).ToArgb());
Assert.AreEqual(SimpleColor.FromKnownColor(OsmSharp.UI.KnownColor.White).Value,
rendering.GetPixel(99, 0).ToArgb());
for (int x = 0; x < 100; x++)
{
Assert.AreEqual(SimpleColor.FromKnownColor(OsmSharp.UI.KnownColor.Black).Value,
rendering.GetPixel(x, x).ToArgb());
}
}
public void TestDomainColorNamed()
{
// parses the MapCSS.
AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsing(
"OsmSharp.UI.Unittests.Data.MapCSS.color-named.mapcss");
// Test the very minimum; no errors during parsing says a lot already!
var tree = result.Tree as Antlr.Runtime.Tree.CommonTree;
Assert.NotNull(tree);
Assert.AreEqual(2, tree.ChildCount);
// parse into domain.
MapCSSFile file = MapCSSDomainParser.Parse(tree);
Assert.IsNotNull(file);
Assert.AreEqual(1, file.Rules.Count);
Assert.AreEqual(1, file.Rules[0].Declarations.Count);
Assert.IsInstanceOf(typeof(DeclarationInt), file.Rules[0].Declarations[0]);
// get color declaration.
var declarationInt = file.Rules[0].Declarations[0] as DeclarationInt;
Assert.IsNotNull(declarationInt);
Assert.AreEqual(DeclarationIntEnum.Color, declarationInt.Qualifier);
// instantiate color.
var simpleColor = new SimpleColor();
simpleColor.Value = declarationInt.Eval((MapCSSObject)null);
Assert.AreEqual("#FFFFFF", simpleColor.HexRgb);
}
void mapControl1_MapMouseClick(MapControlEventArgs e)
{
if (_router != null)
{
var routerPoint = _router.Resolve(Vehicle.Car, e.Position);
if (routerPoint != null)
{
_points.Add(routerPoint);
_layerPrimitives.AddPoint(routerPoint.Location, 15, SimpleColor.FromKnownColor(KnownColor.Black).Value);
_layerPrimitives.AddPoint(routerPoint.Location, 7, SimpleColor.FromKnownColor(KnownColor.White).Value);
}
if (_points.Count > 1)
{
var tspRouter = new RouterTSPWrapper <RouterTSPAEXGenetic>(
new RouterTSPAEXGenetic(), _router);
var route = tspRouter.CalculateTSP(Vehicle.Car, _points.ToArray());
if (route != null)
{
_layerRoute.Clear();
_layerRoute.AddRoute(route);
}
}
}
}
/// <summary>
/// Подсчитывает среднеквадратичное отклонение по каждому компоненту RGB.
/// </summary>
/// <param name="image">Матрица первого изображения</param>
/// <param name="imageStart">Левая верхняя сопоставляемая точка в матрице image</param>
/// <param name="template">Матрица сопоставляемого шаблона</param>
/// <param name="reservedColor">Точки этого цвета в шаблоне не учитываются</param>
public static SimpleColor CalculateDifference(SimpleColor[][] image, Point imageStart,
SimpleColor[][] template, SimpleColor reservedColor)
{
int red = 0, green = 0, blue = 0;
int uncounted = 0;
int width = template.GetLength(0);
int height = template[0].GetLength(0);
for (int dx = 0; dx < width; ++dx)
for (int dy = 0; dy < height; ++dy)
{
var templateColor = template[dx][dy];
if (reservedColor == templateColor)
{
++uncounted;
continue;
}
var imageColor = image[imageStart.X + dx][imageStart.Y + dy];
var dR = imageColor.R - templateColor.R;
var dG = imageColor.G - templateColor.G;
var dB = imageColor.B - templateColor.B;
red += dR * dR;
green += dG * dG;
blue += dB * dB;
}
var totalPoints = width * height - uncounted;
return GetResultSimpleColor(red, green, blue, totalPoints);
}
/// <summary>
/// Recodes the given byte.
/// </summary>
internal override byte Recode(byte codedByte)
{
// Get key byte
byte keyByte;
switch (_colorTracker) {
case ColorCode.Blue:
// Set source information and next color
keyByte = _currentColor.Blue;
_colorTracker = ColorCode.Red;
break;
case ColorCode.Green:
// Set source information and next color
keyByte = _currentColor.Green;
_colorTracker = ColorCode.Blue;
break;
case ColorCode.Red:
// Color code red always sets the new color and updates the position information
_currentColor = _imageData.GetNextColor();
// Set source information and next color
keyByte = _currentColor.Red;
_colorTracker = ColorCode.Green;
break;
default:
throw new Exception("Bonk");
}
// Return the recoded byte
return (byte)(keyByte - codedByte);
}
public static Color ToUnityColor(this SimpleColor color)
{
switch (color)
{
case SimpleColor.White:
return(Color.white);
case SimpleColor.Red:
return(Color.red);
case SimpleColor.Green:
return(Color.green);
case SimpleColor.Blue:
return(Color.blue);
case SimpleColor.Magenta:
return(Color.magenta);
case SimpleColor.Yellow:
return(Color.yellow);
case SimpleColor.Cyan:
return(Color.cyan);
default:
throw new ArgumentException();
}
}
/// <summary>
/// Initialize implementation from IMapView.
/// </summary>
/// <param name="mapLayout"></param>
void IMapViewSurface.Initialize(MapView mapLayout)
{
_mapView = mapLayout;
this.SetWillNotDraw(false);
this.MapMinZoomLevel = 10;
this.MapMaxZoomLevel = 20;
_renderer = new MapRenderer <global::Android.Graphics.Canvas>(
new CanvasRenderer2D());
// initialize the gesture detection.
this.SetOnTouchListener(this);
_scaleGestureDetector = new ScaleGestureDetector(
this.Context, this);
_rotateGestureDetector = new RotateGestureDetector(
this.Context, this);
_moveGestureDetector = new MoveGestureDetector(
this.Context, this);
_tagGestureDetector = new TapGestureDetector(
this.Context, this);
_makerLayer = new LayerPrimitives(
new WebMercator());
// initialize all the caching stuff.
_backgroundColor = SimpleColor.FromKnownColor(KnownColor.White).Value;
_cacheRenderer = new MapRenderer <global::Android.Graphics.Canvas>(
new CanvasRenderer2D());
}
/// <summary>
/// Adds a new OsmSharpRoute.
/// </summary>
/// <param name="route">Stream.</param>
/// <param name="argb">Stream.</param>
public void AddRoute(OsmSharpRoute route, int argb)
{
if (route.Entries != null && route.Entries.Length > 0)
{ // there are entries.
// get x/y.
var x = new double[route.Entries.Length];
var y = new double[route.Entries.Length];
for (int idx = 0; idx < route.Entries.Length; idx++)
{
x[idx] = _projection.LongitudeToX(
route.Entries[idx].Longitude);
y[idx] = _projection.LatitudeToY(
route.Entries[idx].Latitude);
}
// set the default color if none is given.
SimpleColor blue = new SimpleColor()
{
Value = argb
};
SimpleColor color = SimpleColor.FromArgb(argb);
this.Scene.AddLine(float.MinValue, float.MaxValue, x, y,
color.Value, 4);
}
}
/// <summary>
/// Draws a polygon on the target. The coordinates given are scene coordinates.
/// </summary>
/// <param name="target"></param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <param name="color">Color.</param>
/// <param name="width">Width.</param>
/// <param name="fill">If set to <c>true</c> fill.</param>
protected override void DrawPolygon(Target2DWrapper <CGContextWrapper> target, double[] x, double[] y, int color, double width,
bool fill)
{
float widthInPixels = this.ToPixels(width) * _scaleFactor;
SimpleColor simpleColor = SimpleColor.FromArgb(color);
target.Target.CGContext.SetLineWidth(widthInPixels);
target.Target.CGContext.SetFillColor(simpleColor.R / 256.0f, simpleColor.G / 256.0f, simpleColor.B / 256.0f,
simpleColor.A / 256.0f);
target.Target.CGContext.SetStrokeColor(simpleColor.R / 256.0f, simpleColor.G / 256.0f, simpleColor.B / 256.0f,
simpleColor.A / 256.0f);
// transform the points all at once.
double[][] transformed = this.TransformAll(x, y);
// build the path.
target.Target.CGContext.BeginPath();
PointF[] points = new PointF[x.Length];
for (int idx = 0; idx < x.Length; idx++)
{
points[idx] = new PointF((float)transformed[idx][0], (float)transformed[idx][1]);
}
target.Target.CGContext.AddLines(points);
target.Target.CGContext.ClosePath();
target.Target.CGContext.FillPath();
}
/// <summary>
/// Raises the draw frame event.
/// </summary>
/// <param name="gl">Gl.</param>
public void OnDrawFrame(IGL10 gl)
{
// Replace the current matrix with the identity matrix
gl.GlMatrixMode(GL10.GlProjection);
gl.GlLoadIdentity(); // OpenGL docs
gl.GlOrthof(_left, _right, _bottom, _top, -1, 1);
for (int idx = 0; idx < _triangles.Count; idx++)
{
gl.GlVertexPointer(3, GL10.GlFloat, 0, _triangles[idx].Vertices);
gl.GlEnableClientState(GL10.GlVertexArray);
gl.GlColorPointer(4, GL10.GlUnsignedByte, 0, _triangles[idx].Colors);
gl.GlEnableClientState(GL10.GlColorArray);
gl.GlDrawArrays(GL10.GlTriangleStrip, 0, _triangles[idx].Count);
}
for (int idx = 0; idx < _lines.Count; idx++)
{
gl.GlVertexPointer(3, GL10.GlFloat, 0, _lines[idx].Vertices);
gl.GlEnableClientState(GL10.GlVertexArray);
SimpleColor color = new SimpleColor()
{
Value = _lines[idx].Color
};
gl.GlColor4f(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f);
gl.GlLineWidth(_lines [idx].Width);
gl.GlDrawArrays(GL10.GlLineStrip, 0, _lines[idx].Count);
}
}
/// <summary>
/// Adds a new OsmSharpRoute.
/// </summary>
/// <param name="route">Stream.</param>
public void AddRoute(Route route)
{
// set the default color if none is given.
var blue = SimpleColor.FromKnownColor(KnownColor.Blue);
var transparantBlue = SimpleColor.FromArgb(128, blue.R, blue.G, blue.B);
this.AddRoute(route, transparantBlue.Value);
}
public void WriteGridColor(SimpleColor color)
{
if (ClientsCount == 0)
{
return;
}
EnqueueWrite(new ColorSocketObject(SocketConstants.SocketAction.GridColor, color.A, color.R, color.G, color.B));
}
/// <summary>
/// Draws the backcolor.
/// </summary>
/// <param name="target"></param>
/// <param name="backColor"></param>
protected override void DrawBackColor(Target2DWrapper <CGContextWrapper> target, int backColor)
{
SimpleColor backColorSimple = SimpleColor.FromArgb(backColor);
target.Target.CGContext.SetFillColor(backColorSimple.R / 256.0f, backColorSimple.G / 256.0f, backColorSimple.B / 256.0f,
backColorSimple.A / 256.0f);
target.Target.CGContext.FillRect(new RectangleF(0, 0,
target.Width * _scaleFactor, target.Height * _scaleFactor));
}
/// <param name="reservedColor">Points in template which match reservedColor are considered transparent</param>
/// <exception cref="System.ArgumentException"></exception>
public ImageSearcher(SimpleColor[][] template, SimpleColor reservedColor)
{
CheckSize(template);
CheckTransparentDistribution(template, reservedColor);
this.template = template;
this.reservedColor = reservedColor;
InitializeSmallPictureTemplate();
}
private void connection_OnGridColorReceived(SimpleColor gridColor)
{
if (gridPen != null)
{
gridPen.Dispose();
}
gridPen = new Pen(Color.FromArgb(gridColor.A, gridColor.R, gridColor.G, gridColor.B));
RefreshMapPictureBox();
}
public Gene(FastImage src, int minx, int miny, int maxx, int maxy, int minsz, int maxsz)
{
x = _rnd.Next(minx, maxx);
y = _rnd.Next(miny, maxy);
sz = _rnd.Next(minsz, maxsz);
//color = new SimpleColor(_rnd.Next(0, 256), _rnd.Next(0, 256), _rnd.Next(0, 256));
SimpleColor sc = src.GetPixel(_rnd.Next(0, src.width), _rnd.Next(0, src.height));
color = new SimpleColor(sc.GetR(), sc.GetG(), sc.GetB());
}
public void SetGridColor(SimpleColor gridColor)
{
if (gridPen != null)
{
gridPen.Dispose();
}
gridPen = new Pen(Color.FromArgb(gridColor.A, gridColor.R, gridColor.G, gridColor.B));
RefreshAll();
}
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol, Thing thing = null)
{
base.DrawGhost(def, center, rot, ghostCol);
SimpleColor circleColor = SimpleColor.Red;
if (ghostCol == Designator_Place.CanPlaceColor)
{
circleColor = SimpleColor.Green;
}
GenDraw.DrawCircleOutline(center.ToVector3Shifted() + new Vector3(0, AltitudeLayer.MetaOverlays.AltitudeFor(), 3).RotatedBy(rot.AsAngle), 1.5f, circleColor);
}
/// <summary>
/// Returns the canvas color.
/// </summary>
/// <returns></returns>
public override SimpleColor GetCanvasColor()
{
if (_mapCSSFile != null &&
_mapCSSFile.CanvasFillColor.HasValue)
{ // instantiate the simple color.
return(new SimpleColor()
{
Value = _mapCSSFile.CanvasFillColor.Value
});
}
return(SimpleColor.FromKnownColor(KnownColor.Black));
}
public static SimpleColor Blend(SimpleColor a, SimpleColor b)
{
int rval, gval, bval;
double aval;
rval = RGBClamp((int)(a.GetA() * (a.GetR() - b.GetR()) + b.GetR()));
gval = RGBClamp((int)(a.GetA() * (a.GetG() - b.GetG()) + b.GetG()));
bval = RGBClamp((int)(a.GetA() * (a.GetB() - b.GetB()) + b.GetB()));
aval = a.GetA() + b.GetA() * (1 - a.GetA());
return(new SimpleColor(rval, gval, bval, aval));
}
/// <summary>
/// Draws the backcolor.
/// </summary>
/// <param name="target"></param>
/// <param name="backColor"></param>
protected override void DrawBackColor(Target2DWrapper <CGContextWrapper> target, int backColor)
{
var backColorSimple = SimpleColor.FromArgb(backColor);
target.Target.CGContext.SetFillColor(backColorSimple.R / 256.0f, backColorSimple.G / 256.0f, backColorSimple.B / 256.0f,
backColorSimple.A / 256.0f);
_rectangle.X = 0;
_rectangle.Y = 0;
_rectangle.Width = target.Width * _scaleFactor;
_rectangle.Height = target.Height * _scaleFactor;
target.Target.CGContext.FillRect(_rectangle);
}
private static Material GetLineMat(SimpleColor color)
{
return(color switch
{
SimpleColor.White => LineMatWhite,
SimpleColor.Red => LineMatRed,
SimpleColor.Green => LineMatGreen,
SimpleColor.Blue => LineMatBlue,
SimpleColor.Magenta => LineMatMagenta,
SimpleColor.Yellow => LineMatYellow,
SimpleColor.Cyan => LineMatCyan,
_ => LineMatWhite,
});
public static Color ToUnityColor(this SimpleColor color)
{
return(color switch
{
SimpleColor.White => Color.white,
SimpleColor.Red => Color.red,
SimpleColor.Green => Color.green,
SimpleColor.Blue => Color.blue,
SimpleColor.Magenta => Color.magenta,
SimpleColor.Yellow => Color.yellow,
SimpleColor.Cyan => Color.cyan,
_ => throw new ArgumentException(),
});
public ImageViewerForm(Bitmap image, SimpleColor differences)
{
InitializeComponent();
this.MinimumSize = this.Size;
this.MaximizeBox = false;
this.MaximumSize = this.Size;
this.pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
this.pictureBox.Image = new Bitmap(image);
this.pictureBox.BorderStyle = BorderStyle.FixedSingle;
this.redLabel.Text = differences.R.ToString();
this.greenLabel.Text = differences.G.ToString();
this.blueLabel.Text = differences.B.ToString();
}
public static bool Equals(SimpleColor[][] left, SimpleColor[][] right)
{
if (object.ReferenceEquals(left, right))
return true;
int width = Width(left);
int heigth = Height(left);
if (width != Width(right) || heigth != Height(right))
return false;
for (int x = 0; x < width; ++x)
for (int y = 0; y < heigth; ++y)
if (left[x][y] != right[x][y])
return false;
return true;
}
/// <summary>
/// Searches for subpictures that match template
/// </summary>
public IEnumerable<Point> GetPositions(SimpleColor[][] source)
{
var smallPicturePositions = GetSmallPicturePositions(source);
foreach (var pos in smallPicturePositions)
{
if (ImageComparer.Equals(
source,
pos,
template,
reservedColor,
maxDifference))
{
yield return pos;
}
}
}
private static bool IsAllPointsHasOneColor(SimpleColor[][] image, Point start, Point delta, SimpleColor color)
{
while (start.X >= 0 && start.X < ImageComparer.Width(image) &&
start.Y >= 0 && start.Y < ImageComparer.Height(image))
{
if (image[start.X][start.Y] != color)
return false;
start.X += delta.X;
start.Y += delta.Y;
}
return true;
}
private static void SmartInsert(SimpleColor[] minValues, Point[] positions, SimpleColor value, Point pos)
{
int indexOfMax = 0;
for (int i = 1; i < minValues.Length; ++i)
if (Compare(minValues[i], minValues[indexOfMax]) > 0)
indexOfMax = i;
if (Compare(value, minValues[indexOfMax]) < 0)
{
minValues[indexOfMax] = value;
positions[indexOfMax] = pos;
}
}
public ImageData(Bitmap keyFile)
{
int index = 0;
int width = keyFile.Width;
int height = keyFile.Height;
_length = width * height;
_colors = new SimpleColor[_length];
_currentIndex = -1;
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++) {
Color pixel = keyFile.GetPixel(x, y);
_colors[index++] = new SimpleColor(pixel.R, pixel.G, pixel.B);
}
}
private void Learn(SimpleColor[][] image, int elementsLeft, List<Rectangle> invalidRegions)
{
int width = ImageComparer.Width(image);
int height = ImageComparer.Height(image);
int maxX = width - this.Width + 1;
int maxY = height - this.Height + 1;
var differences = ImageConverter.CreateMatrix<SimpleColor>(maxX, maxY);
Parallel.For(0, maxX, x =>
{
for (int y = 0; y < maxY; ++y)
differences[x][y] = ImageComparer.CalculateDifference(
image,
new Point(x, y),
this.template,
this.reservedColor);
});
var bestPositions = new List<Point>();
while (elementsLeft > 0)
{
var position = FindMin(differences, bestPositions);
bestPositions.Add(position);
--elementsLeft;
}
var minDiffs = bestPositions.Select(pos => differences[pos.X][pos.Y]).ToArray();
UpdateAdmissibleDifference(minDiffs);
UpdateAdmissibleDifferenceForSmallTemplate(image, bestPositions.ToArray());
}
/// <exception cref="System.ArgumentException">Invalid template</exception>
/// <exception cref="System.ArgumentNullException"></exception>
public BitmapSearcher(Bitmap template, SimpleColor transparentColor)
{
if (object.ReferenceEquals(template, null))
throw new ArgumentNullException("template");
searcher = new ImageSearcher(Converter.ToMatrix(template), transparentColor);
}
public static int Width(SimpleColor[][] image)
{
return image.Length;
}
public static int Height(SimpleColor[][] image)
{
return image[0].Length;
}
/// <summary>
/// Сопоставляет с шаблоном часть изображения
/// </summary>
/// <param name="image">Изображение, часть которого будет сопоставляться с шаблоном</param>
/// <param name="imageStart">Левая верхняя сопоставляемая точка изображения</param>
/// <param name="template">Сопоставляемый шаблон</param>
/// <param name="reservedColor">Не учитываемый цвет в шаблоне</param>
/// <param name="admissibleDifference">Содержит максимальные допустимые отклонения</param>
/// <returns>Результат сравнения</returns>
public static bool Equals(SimpleColor[][] image, Point imageStart,
SimpleColor[][] template, SimpleColor reservedColor, SimpleColor admissibleDifference)
{
SimpleColor diff = CalculateDifference(image, imageStart, template, reservedColor);
return (diff.R <= admissibleDifference.R && diff.G <= admissibleDifference.G && diff.B <= admissibleDifference.B);
}
private void UpdateAdmissibleDifferenceForSmallTemplate(SimpleColor[][] sourceMatrix, Point[] positions)
{
foreach (var position in positions)
{
SimpleColor simpleColor = ImageComparer.CalculateDifference(
sourceMatrix,
new Point(position.X + smallPictureRegion.Left, position.Y + smallPictureRegion.Top),
smallPictureTemplate,
reservedColor);
smallPictureMaxDifference.R = Math.Max(smallPictureMaxDifference.R, simpleColor.R);
smallPictureMaxDifference.G = Math.Max(smallPictureMaxDifference.G, simpleColor.G);
smallPictureMaxDifference.B = Math.Max(smallPictureMaxDifference.B, simpleColor.B);
}
}
private void UpdateAdmissibleDifference(SimpleColor[] differences)
{
foreach (var difference in differences)
{
maxDifference.R = Math.Max(maxDifference.R, difference.R);
maxDifference.G = Math.Max(maxDifference.G, difference.G);
maxDifference.B = Math.Max(maxDifference.B, difference.B);
}
}
private Point FindMin(SimpleColor[][] differences, List<Point> taken)
{
int width = ImageComparer.Width(differences);
int height = ImageComparer.Height(differences);
SimpleColor min = (SimpleColor)Color.White;
Point pos = new Point();
object locker = new object();
Parallel.For(0, width, x =>
{
Point localPos = new Point();
SimpleColor localMin;
localPos.X = x;
lock (locker)
localMin = min;
for (int y = 0; y < height; ++y)
{
bool valid = true;
foreach (var p in taken)
if (IsConflicted(p, x, y))
{
valid = false;
break;
}
if (valid && Compare(differences[x][y], localMin) < 0)
{
localMin = differences[x][y];
localPos.Y = y;
}
}
lock (locker)
if (Compare(localMin, min) < 0)
{
min = localMin;
pos = localPos;
}
});
if (min == (SimpleColor)Color.White)
throw new InvalidOperationException("Cant find all subpictures. State may be corrupted now.");
return pos;
}
/// <summary>
/// Searches for potential positions of template
/// </summary>
private IEnumerable<Point> GetSmallPicturePositions(SimpleColor[][] source)
{
int maxX = source.GetLength(0) - template.GetLength(0);
int maxY = source[0].GetLength(0) - template[0].GetLength(0);
var verticals = new List<Point>[maxX];
Parallel.For(0, maxX, x =>
{
verticals[x] = new List<Point>();
for (int y = 0; y < maxY; ++y)
{
if (ImageComparer.Equals(
source,
new Point(x + smallPictureRegion.Left, y + smallPictureRegion.Top),
smallPictureTemplate,
reservedColor,
smallPictureMaxDifference))
{
verticals[x].Add(new Point(x, y));
}
}
});
for (int x = 0; x < maxX; ++x)
foreach (var p in verticals[x])
yield return p;
}
private static Tiling CreateTiling(double offsetX, double offsetY, double width, SimpleColor color)
{
Tiling tiling = new Tiling(new Rect(0, 0, width, 2));
tiling.Position.Translate(offsetX, offsetY);
var tilingEditor = new FixedContentEditor(tiling);
tilingEditor.GraphicProperties.IsStroked = false;
tilingEditor.GraphicProperties.FillColor = color;
tilingEditor.DrawRectangle(new Rect(0, 0, width, 1));
LinearGradient gradient = new LinearGradient(new Point(0, 0), new Point(width, 0));
gradient.GradientStops.Add(new GradientStop(color, 0));
gradient.GradientStops.Add(new GradientStop(RgbColors.White, .5));
gradient.GradientStops.Add(new GradientStop(color, 1));
tilingEditor.GraphicProperties.FillColor = gradient;
tilingEditor.DrawRectangle(new Rect(0, 1, width, 1));
return tiling;
}
private static void UniteDifferences(ref SimpleColor left, SimpleColor right)
{
left.R = Math.Max(left.R, right.R);
left.G = Math.Max(left.G, right.G);
left.B = Math.Max(left.B, right.B);
}
/// <summary>
/// Translates a lineair ring.
/// </summary>
/// <param name="scene">The scene to add primitives to.</param>
/// <param name="projection">The projection used to convert the objects.</param>
/// <param name="lineairRing"></param>
private void TranslateLineairRing(Scene2D scene, IProjection projection, LineairRing lineairRing)
{
// build the rules.
List<MapCSSRuleProperties> rules =
this.BuildRules(new MapCSSObject(lineairRing));
// validate what's there.
if (rules.Count == 0)
{
return;
}
// get x/y.
double[] x = null, y = null;
if (lineairRing.Coordinates != null &&
lineairRing.Coordinates.Count > 0)
{ // pre-calculate x/y.
x = new double[lineairRing.Coordinates.Count];
y = new double[lineairRing.Coordinates.Count];
for (int idx = 0; idx < lineairRing.Coordinates.Count; idx++)
{
x[idx] = projection.LongitudeToX(
lineairRing.Coordinates[idx].Longitude);
y[idx] = projection.LatitudeToY(
lineairRing.Coordinates[idx].Latitude);
}
// simplify.
if (x.Length > 2)
{
double[][] simplified = SimplifyCurve.Simplify(new double[][] { x, y }, 0.0001);
x = simplified[0];
y = simplified[1];
}
}
// add the z-index.
foreach (var rule in rules)
{
float minZoom = (float)projection.ToZoomFactor(rule.MinZoom);
float maxZoom = (float)projection.ToZoomFactor(rule.MaxZoom);
int zIndex;
if (!rule.TryGetProperty<int>("zIndex", out zIndex))
{
zIndex = 0;
}
// interpret the results.
if (x != null)
{ // there is a valid interpretation of this way.
int color;
int fillColor;
if (rule.TryGetProperty("fillColor", out fillColor))
{ // render as an area.
float fillOpacity;
if(rule.TryGetProperty("fillOpacity", out fillOpacity))
{
SimpleColor simpleFillColor = new SimpleColor() { Value = fillColor };
fillColor = SimpleColor.FromArgb((int)(255 * fillOpacity),
simpleFillColor.R, simpleFillColor.G, simpleFillColor.B).Value;
}
uint? pointsId = scene.AddPoints(x, y);
if (pointsId.HasValue)
{
scene.AddStylePolygon(pointsId.Value, this.CalculateSceneLayer(OffsetArea, zIndex), minZoom, maxZoom, fillColor, 1, true);
if (rule.TryGetProperty("color", out color))
{
scene.AddStylePolygon(pointsId.Value, this.CalculateSceneLayer(OffsetCasing, zIndex), minZoom, maxZoom, color, 1, false);
}
}
}
}
}
}
private static void CheckTransparentDistribution(SimpleColor[][] template, SimpleColor transparent)
{
int width = ImageComparer.Width(template);
int height = ImageComparer.Height(template);
bool badTransparentDistribution =
IsAllPointsHasOneColor(template, new Point(0, 0), new Point(1, 0), transparent) ||
IsAllPointsHasOneColor(template, new Point(0, 0), new Point(0, 1), transparent) ||
IsAllPointsHasOneColor(template, new Point(width - 1, height - 1), new Point(-1, 0), transparent) ||
IsAllPointsHasOneColor(template, new Point(width - 1, height - 1), new Point(0, -1), transparent);
if (badTransparentDistribution)
throw BadTransparentDistributionException;
}
/// <summary>
/// Updates maximal admissible differences
/// </summary>
/// <param name="elements">Count of elements on the image that should match template</param>
public void Learn(SimpleColor[][] image, int elements)
{
Learn(image, elements, new List<Rectangle>());
}
private static void CheckSize(SimpleColor[][] template)
{
if (template.GetLength(0) < smallTemplateWidth || template[0].GetLength(0) < smallTemplateHeight)
throw new ArgumentException(
string.Format("To small size of template. Required at least: width = {0}, height = {1}",
smallTemplateWidth, smallTemplateHeight));
}
// A simple comparator
private static int Compare(SimpleColor leftDifference, SimpleColor rightDifference)
{
return (leftDifference.R + leftDifference.G + leftDifference.B)
.CompareTo(rightDifference.R + rightDifference.G + rightDifference.B);
}
