public static SkeletonPoint DepthToSkeleton(Rectangle rect, byte[,,] depthData, int width,
int height, CoordinateConverter mapper)
{
var aveDepth = 0.0;
var count = 0;
for (int y = rect.Top; y < rect.Top + rect.Height && y < height; y++)
for (int x = rect.Left; x < rect.Left + rect.Width && x < width; x++) {
if (x > 0 && y > 0) {
aveDepth += depthData[y, x, 0];
count++;
}
}
var depth = PlayerDetector.ToWorldDepth(aveDepth / count);
var center = rect.Center();
var centerX = Math.Max(0, center.X);
centerX = Math.Min(centerX, width);
var centerY = Math.Max(0, center.Y);
centerY = Math.Min(centerY, height);
return mapper.MapDepthPointToSkeletonPoint((int)centerX, (int)centerY, depth);
}
public static void NormalizePoints(Point[] points, Rectangle rectangle)
{
if (rectangle.Height == 0 || rectangle.Width == 0)
return;
Matrix m = new Matrix();
m.Translate(rectangle.Center().X, rectangle.Center().Y);
if (rectangle.Width > rectangle.Height)
m.Scale(1, 1f * rectangle.Width / rectangle.Height);
else
m.Scale(1f * rectangle.Height / rectangle.Width, 1);
m.Translate(-rectangle.Center().X, -rectangle.Center().Y);
m.TransformPoints(points);
}
protected GraphicsPath CreateTailPath(Rectangle rect, Point tailPosition)
{
GraphicsPath gpTail = new GraphicsPath();
Point center = rect.Center();
int rectAverageSize = (rect.Width + rect.Height) / 2;
int tailWidth = (int)(TailWidthMultiplier * rectAverageSize);
tailWidth = Math.Min(Math.Min(tailWidth, rect.Width), rect.Height);
int tailOrigin = tailWidth / 2;
int tailLength = (int)MathHelpers.Distance(center, tailPosition);
gpTail.AddLine(0, -tailOrigin, 0, tailOrigin);
gpTail.AddLine(0, tailOrigin, tailLength, 0);
gpTail.CloseFigure();
using (Matrix matrix = new Matrix())
{
matrix.Translate(center.X, center.Y);
float tailDegree = MathHelpers.LookAtDegree(center, tailPosition);
matrix.Rotate(tailDegree);
gpTail.Transform(matrix);
}
return gpTail;
}
/// <summary>
/// Retrieves the rectangles in which images should be placed in side-by-side mode
/// </summary>
public static void GetSplitModeImageRectangles(Rectangle clientRectangle, Size maxImageSize, out Rectangle rectangle1, out Rectangle rectangle2)
{
var halfRectangle = new Rectangle(clientRectangle.X, clientRectangle.Y, clientRectangle.Width / 2, clientRectangle.Height);
var imageSize = maxImageSize.ConstrainedTo(halfRectangle.Size);
var center1 = halfRectangle.Center();
var center2 = new Point(center1.X + halfRectangle.Width, center1.Y);
rectangle1 = new Rectangle(imageSize.CenteredAround(center1), imageSize);
rectangle2 = new Rectangle(imageSize.CenteredAround(center2), imageSize);
if (rectangle1.X - clientRectangle.X > MIN_BORDER)
{
int shift = rectangle1.X - clientRectangle.X - MIN_BORDER;
rectangle1.X -= shift;
rectangle2.X += shift;
}
}
/// <summary>
/// Draws an arrow in the specified rectangle with the specified direction. Ratio is used on recursive calls
/// withing this function to adjust the sizing of bidirectional arrows
/// </summary>
public static void DrawArrow(this Graphics graphics, Rectangle area, ArrowType arrowType, double ratio = 1.0 / 3.0)
{
if (arrowType == ArrowType.Bidi)
{
var halfSize = new Size(area.Width / 2, area.Height);
graphics.DrawArrow(new Rectangle(area.Location, halfSize), ArrowType.Left, 2 * ratio);
graphics.DrawArrow(new Rectangle(new Point(area.Center().X, area.Location.Y), halfSize), ArrowType.Right, 2 * ratio);
return;
}
var oldMode = graphics.SmoothingMode;
graphics.SmoothingMode = SmoothingMode.AntiAlias;
float bodyHeight = area.Height / 3;
float headWidth = (area.Width * ratio).Rounded();
float bodyWidth = area.Width - headWidth;
PointF[] points =
{
new PointF(area.Left, area.Top + bodyHeight),
new PointF(area.Left + bodyWidth, area.Top + bodyHeight),
new PointF(area.Left + bodyWidth, area.Top),
new PointF(area.Right, area.Top + (area.Height / 2)),
new PointF(area.Left + bodyWidth, area.Bottom),
new PointF(area.Left + bodyWidth, area.Bottom - bodyHeight),
new PointF(area.Left, area.Bottom - bodyHeight),
};
if (arrowType == ArrowType.Left)
{
PointF center = area.Center();
for (int i = 0; i < points.Length; i++)
points[i].X += (2 * (center.X - points[i].X));
}
using (GraphicsPath path = new GraphicsPath())
{
path.AddPolygon(points);
graphics.FillPath(Brushes.Black, path);
graphics.DrawPath(crossPen, path);
}
graphics.SmoothingMode = oldMode;
}
protected override void Tick(Graphics graphics, Rectangle camera)
{
graphics.DrawImageUnscaled(_boardBitmap, -camera.X, -camera.Y);
var center = camera.Center();
var screencenter = new Vector2(camera.Width / 2.0f, camera.Height / 2.0f);
foreach (var pointable in EntitiesOfType<IPointable>())
{
var delta = pointable.Position - center;
var dist = Math.Min(camera.Width, camera.Height) / 2 - 10;
if (Math.Abs(delta.X) > dist || Math.Abs(delta.Y) > dist)
{
graphics.DrawPolygon(pointable.Pen, new[]
{
(screencenter + delta.Normalized * dist).Point,
(screencenter + Vector2.FromTheta(delta.Theta + 0.2f) * dist).Point,
(screencenter + Vector2.FromTheta(delta.Theta - 0.2f) * dist).Point
});
}
}
}