public RenderPoint(Point ACenter, SoundPoint ALink)
{
Link = ALink;
Center = ACenter;
Region = new EllipseGeometry(ACenter, Radius, Radius);
Region.Freeze();
Bounds = new Rect(ACenter.X - Radius, ACenter.Y - Radius, Radius * 2, Radius * 2);
}
protected Geometry GeometryFromAnnotation(Annotation annotation)
{
if (annotation == null || annotation.Points == null || annotation.Points.Count == 0)
{
return(null);
}
if (annotation.Points.Count == 1)
{
Point p = new Point(annotation.Points[0].X + this.Left, annotation.Points[0].Y + this.Top);
EllipseGeometry ellipse = new EllipseGeometry(p, 3.0, 3.0);
if (ellipse.CanFreeze)
{
ellipse.Freeze();
}
return(ellipse);
}
else if (annotation.Points.Count == 2)
{
Point p1 = new Point(annotation.Points[0].X + this.Left, annotation.Points[0].Y + this.Top);
Point p2 = new Point(annotation.Points[1].X + this.Left, annotation.Points[1].Y + this.Top);
LineGeometry line = new LineGeometry(p1, p2);
if (line.CanFreeze)
{
line.Freeze();
}
return(line);
}
else
{
StreamGeometry streamGeometry = new StreamGeometry();
using (StreamGeometryContext sgc = streamGeometry.Open())
{
Point start = new Point(annotation.Points[0].X + this.Left, annotation.Points[0].Y + this.Top);
sgc.BeginFigure(start, true, true);
for (int i = 1; i < annotation.Points.Count; i++)
{
Point next = new Point(annotation.Points[i].X + this.Left, annotation.Points[i].Y + this.Top);
sgc.LineTo(next, true, true);
}
}
if (streamGeometry.CanFreeze)
{
streamGeometry.Freeze();
}
return(streamGeometry);
}
}
public EllipseGeometry GetInfluenceCircle(int gridSize, double radius)
{
if (_influenceCircle == null || _gridSizeScreenRect != gridSize || _influenceCircleRadius != radius)
{
_influenceCircle = new EllipseGeometry(GetScreenRectCenterPoint(gridSize), radius, radius);
if (_influenceCircle.CanFreeze)
{
_influenceCircle.Freeze();
}
_influenceCircleRadius = radius;
}
return(_influenceCircle);
}
public Geometry GetHandle()
{
var freeableGeometry = _handles.FirstOrDefault(f => f.IsFree);
if (freeableGeometry == null)
{
var geometry = new EllipseGeometry(new System.Windows.Point(0, 0), 10, 10);
geometry.Freeze();
freeableGeometry = new Freeable(geometry);
}
freeableGeometry.IsFree = false;
_handles.Add(freeableGeometry);
return(freeableGeometry.Geometry);
}
public override void Draw(DrawingContext context, Matrix matrix)
{
if (!this.ShouldDraw || !PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext))
{
return;
}
Pen pen = new Pen((Brush)Brushes.Transparent, 15.0);
pen.Freeze();
Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix;
EllipseGeometry ellipseGeometry = new EllipseGeometry((Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.CenterProperty), (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusXProperty), (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusYProperty));
ellipseGeometry.Transform = (Transform) new MatrixTransform(matrix1);
ellipseGeometry.Freeze();
context.DrawGeometry((Brush)null, pen, (System.Windows.Media.Geometry)ellipseGeometry);
context.DrawGeometry((Brush)null, this.ThinPen, (System.Windows.Media.Geometry)ellipseGeometry);
}
public Path GetCircumCircle(Polygon polygon)
{
if (!circles.ContainsKey(polygon))
{
Triad triad = triangles[polygon];
EllipseGeometry geometry = new EllipseGeometry();
geometry.Center = new Point(triad.CircumcircleX, triad.CircumcircleY);
geometry.RadiusX = geometry.RadiusY = Math.Sqrt(triad.CircumcircleR2);
geometry.Freeze();
Path path = new Path();
Panel.SetZIndex(path, CircleZIndex);
path.StrokeThickness = CircleStrokeTickness;
path.Stroke = new SolidColorBrush(circleStrokeColor);
path.Data = geometry;
circles[polygon] = path;
}
return(circles[polygon]);
}
protected override Geometry GetLayoutClip(Size layoutSlotSize)
{
Point ellipsePoint = new Point(layoutSlotSize.Width / 2, layoutSlotSize.Height / 2);
Geometry borderClip = new EllipseGeometry(ellipsePoint,
layoutSlotSize.Width / 2.1, layoutSlotSize.Height / 2.1);
borderClip.Freeze();
Geometry baseClip = base.GetLayoutClip(layoutSlotSize);
if (baseClip == null)
{
return(borderClip);
}
CombinedGeometry mergedClip = new CombinedGeometry(
GeometryCombineMode.Intersect, baseClip, borderClip);
mergedClip.Freeze();
return(mergedClip);
}
private DrawingGroup CreateElement(Color color, int radius, Vector position)
{
var transparent = color;
transparent.A = 1;
EllipseGeometry geom = new EllipseGeometry(new Point(radius, radius), radius, radius);
geom.Freeze();
var d = new DrawingGroup();
d.Children.Add(new GeometryDrawing(new RadialGradientBrush(color, transparent), new Pen(new SolidColorBrush(color), 1), geom));
TransformGroup tg = new TransformGroup();
tg.Children.Add(new TranslateTransform(position.X, position.Y));
d.Transform = tg;
MainVisualArea.Add(d);
return(d);
}
public Path CreateVertexPoint(Vertex vertex)
{
if (this.verticesPaths == null)
{
this.verticesPaths = new Dictionary <Vertex, Path>();
}
if (!this.verticesPaths.ContainsKey(vertex))
{
EllipseGeometry geometry = new EllipseGeometry();
geometry.Center = new Point(vertex.X, vertex.Y);
geometry.RadiusX = geometry.RadiusY = VertexRadius;
geometry.Freeze();
Path path = new Path();
path.StrokeThickness = VertexTickness;
path.Stroke = new SolidColorBrush(VertexColor);
path.Data = geometry;
this.verticesPaths[vertex] = path;
}
return(this.verticesPaths[vertex]);
}
protected override void OnRender(DrawingContext dc)
{
// Draw background
dc.DrawRectangle(Brushes.White, null, new Rect(RenderSize));
Transform t = new MatrixTransform(TheModel.GetTikzToScreenTransform().ToWpfMatrix());
t.Freeze();
Pen pen = new Pen(Brushes.WhiteSmoke, 1);
pen.Freeze();
TheModel.DrawRaster(
(p1, p2) => dc.DrawLine(pen, t.Transform(p1), t.Transform(p2)),
(r1, r2) =>
{
EllipseGeometry eg = new EllipseGeometry(new Point(0, 0), r1, r2);
eg.Transform = t;
eg.Freeze();
dc.DrawGeometry(null, pen, eg);
});
}
public virtual Drawing GetLightSource(LightColor color)
{
const double GunRange = 0.05;
const double CoreRange = 0.16;
const double CoreRange2 = CoreRange * 0.75;
var drawingVisual = new DrawingVisual();
using (var dc = drawingVisual.RenderOpen()) {
var geometry = new StreamGeometry();
using (var sgc = geometry.Open()) {
sgc.BeginFigure(new Point(0.5, 0.5 + GunRange), true, false);
sgc.LineTo(new Point(0.8, 0.5 + GunRange), true, false);
sgc.LineTo(new Point(0.8, 0.5 - GunRange), false, false);
sgc.LineTo(new Point(0.5, 0.5 - GunRange), true, false);
sgc.ArcTo(new Point(0.5, 0.5 + GunRange), new Size(0.2, 0.2), 0, true, SweepDirection.Counterclockwise, true, false);
}
geometry.Transform = DefaultScaleTransform;
geometry.Freeze();
dc.DrawGeometry(Brushes.Black, BlackPen, geometry);
var ellipse = new EllipseGeometry(new Rect(0.5 - CoreRange - 0.195, 0.5 - CoreRange, CoreRange * 2, CoreRange * 2))
{
Transform = DefaultScaleTransform
};
ellipse.Freeze();
dc.DrawGeometry(GetBrush(color), null, ellipse);
ellipse = new EllipseGeometry(new Rect(0.5 - CoreRange2 - 0.195, 0.5 - CoreRange2, CoreRange2 * 2, CoreRange2 * 2))
{
Transform = DefaultScaleTransform
};
ellipse.Freeze();
dc.DrawGeometry(GetDarkBrush(color), null, ellipse);
}
return(Freeze(drawingVisual.Drawing));
}
private void AddBranchAdornment(ITextViewLine line, SnapshotSpan span, LineCoverage coverage)
{
var diameter = _textView.LineHeight / _branchCoverageSpotHeightDivider;
var spacing = _branchCoverageSpotGap + diameter;
var top = (line.Height - diameter) / 2d;
var brush = _brushesAndPens[coverage.BranchCoverageState].Brush;
var pen = _brushesAndPens[coverage.BranchCoverageState].Pen;
var groupIndex = 0;
var index = 0;
var left = _sequenceCoverageLineWidth * 1.5d;
foreach (var branchPoint in coverage.BranchesVisited)
{
foreach (var branch in branchPoint)
{
var rect = new Rect(left, line.Top + top, diameter, diameter);
var geometry = new EllipseGeometry(rect);
geometry.Freeze();
var brushOverride = brush;
var penOverride = pen;
if (branch && coverage.BranchVisitors[groupIndex][index].Any(p => SelectedTests.Contains(p)))
{
brushOverride = _selectedBrushAndPen.Brush;
penOverride = _selectedBrushAndPen.Pen;
}
var drawing = new GeometryDrawing(branch ? brushOverride : null, penOverride, geometry);
drawing.Freeze();
var drawingImage = new DrawingImage(drawing);
drawingImage.Freeze();
var image = new Image()
{
Source = drawingImage
};
var testMethod = coverage.BranchVisitors[groupIndex][index].FirstOrDefault();
if (testMethod != null)
{
image.MouseLeftButtonDown += (o, e) => e.Handled = true;
image.MouseLeftButtonUp += (o, e) => _selectTestCommand.Execute(testMethod);
image.Cursor = Cursors.Hand;
image.Tag = coverage.BranchVisitors[groupIndex][index].ToArray();
image.MouseRightButtonDown += (o, e) => e.Handled = true;
image.MouseRightButtonUp += OnTestCoverageRightButtonUp;
SharedDictionaryManager.InitializeDictionaries(image.Resources.MergedDictionaries);
}
Canvas.SetLeft(image, geometry.Bounds.Left);
Canvas.SetTop(image, geometry.Bounds.Top);
_adornmentLayer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, null);
left += spacing;
index++;
}
groupIndex++;
index = 0;
left += spacing;
}
}
public PointSet[] GetSetsToDraw(Point leftTopView, Point rightBottomView, Window window)//, Matrix m)
{
lock (world.tickLocker)
{
calcOtherWatch.Restart();
calcWatch.Restart();
PointSet[] setsToDraw =
world.pointsManager.getPointsSets(
leftTopView.X, rightBottomView.X, leftTopView.Y, rightBottomView.Y,
maxPartiesRendered);
calcGetSetsTimes.Add(calcOtherWatch.ElapsedMilliseconds);
calcOtherWatch.Restart();
int clustersDrawed = 0;
int totalElements = 0;
foreach (Cluster c in world.pointsManager.clusters)
{
if (c != null && c.idX >= world.pointsManager.li && c.idX <= world.pointsManager.ri && c.idY >= world.pointsManager.ti && c.idY <= world.pointsManager.bi)
{
clustersDrawed++;
totalElements += c.container.Values.Count;
}
}
calcIterateClustersTimes.Add(calcOtherWatch.ElapsedMilliseconds);
calcOtherWatch.Restart();
int coloredGeometrySetLength = 0;
double foodGetTime = 0;
int foodGetCount = 0;
double createGeometryTime = 0;
int geometriesCreated = 0;
int geometriesRestored = 0;
//Parallel.For(0, coloredGeometry.Length - 1, (i) =>
for (int i = 0; i < setsToDraw.Length; i++)
{
PointSet set = setsToDraw[i];
ColoredGeometry cg = new ColoredGeometry();
Object val = set.linkedObjects[CacheLastHashGeometryType];
uint oldHash = 0;
if (val != null)
{
oldHash = (uint)val;
}
uint nowHash = set.hash;
if (oldHash == nowHash)
{
Object val2 = set.linkedObjects[CacheColoredGeometryType];
if (val2 != null)
{
geometriesRestored++;
continue;
}
}
geometriesCreated++;
set.linkedObjects[CacheLastHashGeometryType] = nowHash;
switch (set.type)
{
case World.ZoaType:
break;
case World.FoodType:
double size = (set.joinDist * 2);
double alpha =
(world.pointsManager.lowestPointSize * world.pointsManager.lowestPointSize * set.points.Count * 4) / //total food area
(Math.PI * size * size / 4);
if (alpha > 1)
{
alpha = 1;
}
coloredGeometrySetLength++;
double fire = 0;
double grass = 0;
double ocean = 0;
double toxicity = 0;
foreach (StaticPoint p in set.points)
{
Food f = (Food)p.linkedObjects[World.WorldObjectType]; //world.food[p.id];
fire += f.fire;
grass += f.grass;
ocean += f.ocean;
toxicity += f.toxicity;
}
toxicity /= set.points.Count;
/*Geometry g = new RectangleGeometry(
* new Rect(
* new Point(set.x - size / 2, set.y - size / 2),
* new Point(set.x + size / 2, set.y + size / 2))
* );*/
Geometry g = new EllipseGeometry(
new Rect(set.x - size / 2, set.y - size / 2, size, size)
);
g.Freeze();
double sum = fire + grass + ocean;
Color c = Color.FromArgb(
(byte)(alpha * 255), //coeff * 255),
(byte)(fire / sum * 255),
(byte)(grass / sum * 255),
(byte)(ocean / sum * 255));
cg = new ColoredGeometry(g, c, null);
break;
}
set.linkedObjects[CacheColoredGeometryType] = cg;
}//);
createGeometryTime /= coloredGeometrySetLength;
foodGetTime /= foodGetCount;
foodGetTimes.Add(foodGetTime);
createGeometryTimes.Add(createGeometryTime);
calcGeometryTimes.Add(calcOtherWatch.ElapsedMilliseconds);
calcTimes.Add(calcWatch.ElapsedMilliseconds);
if (calcTimes.Count > checkTimes)
{
calcTimes.RemoveAt(0);
}
if (calcGetSetsTimes.Count > checkTimes)
{
calcGetSetsTimes.RemoveAt(0);
}
if (calcIterateClustersTimes.Count > checkTimes)
{
calcIterateClustersTimes.RemoveAt(0);
}
if (calcGeometryTimes.Count > checkTimes)
{
calcGeometryTimes.RemoveAt(0);
}
int calcTime = 0;
foreach (double d in calcTimes)
{
calcTime += (int)d;
}
calcTime /= calcTimes.Count;
int calcGetSetsTime = 0;
foreach (double d in calcGetSetsTimes)
{
calcGetSetsTime += (int)d;
}
calcGetSetsTime /= calcGetSetsTimes.Count;
int calcIterateClustersTime = 0;
foreach (double d in calcIterateClustersTimes)
{
calcIterateClustersTime += (int)d;
}
calcIterateClustersTime /= calcIterateClustersTimes.Count;
int calcGeometryTime = 0;
foreach (double d in calcGeometryTimes)
{
calcGeometryTime += (int)d;
}
calcGeometryTime /= calcGeometryTimes.Count;
int renderTime = 0;
lock (renderTimes)
foreach (double d in renderTimes)
{
renderTime += (int)d;
}
if (renderTimes.Count > 0)
{
renderTime /= renderTimes.Count;
}
try
{
window.Dispatcher.Invoke(() =>
{
if (window.Title != null)
{
window.Title = String.Format(
"Clusters: {14}x{15}x{16} isGeneratingLayer: {17}|{18}%" +
" ClustersDrawed: {0}/{1}, Elements(Rendered/MaxRendered/InViewedClusters/Total): {2}/{3}/{4}/{5} " +
//"ElapsedTime: CalcSets/CalcClusters/CalcGeometry/CalcAll {6}/{7}/{8}/{9}ms" +
" Render {10}/Total {11}ms Geometries(Restored/Created): {12}/{13} FixedLayer: {19}",
//" CacheSize(CG/Drawings): {14}/{15}",
clustersDrawed, world.pointsManager.clusters.Length,
setsToDraw.Length, maxPartiesRendered, totalElements, world.pointsManager.pointsCount,
calcGetSetsTime, calcIterateClustersTime, calcGeometryTime,
calcTime, renderTime, calcTime + renderTime,
geometriesRestored, geometriesCreated,
world.pointsManager.clusters.GetLength(0), world.pointsManager.clusters.GetLength(1), world.pointsManager.clusters.GetLength(2),
world.pointsManager.isGeneratingLayer, (int)(world.pointsManager.layerGeneratingProgress * 100),
world.pointsManager.fixedLayerId);//,
}
//geometriesCache.Count, drawingsCache.Count);
});
}
catch (Exception e) { }
return(setsToDraw);
}
}
