private static bool AreInputFieldsValid([NotNull] ICircle circle,
[NotNull] Tuple <double, double> xt1And2,
[NotNull] Tuple <double, double> yt1And2)
{
return(circle.IsUnknown || double.IsNaN(xt1And2.Item1) || double.IsNaN(xt1And2.Item2) ||
double.IsNaN(yt1And2.Item1) || double.IsNaN(yt1And2.Item2));
}
/// <summary>
/// Writes a shape to a string, in a format that can be read by
/// <see cref="SpatialContext"/>.
/// Overloaded to provide a <paramref name="numberFormat"/>.
/// </summary>
/// <param name="shape">Not null</param>
/// <param name="numberFormat">A standard or custom numeric .NET format string (float).</param>
/// <returns>Not null</returns>
public static string WriteShape(IShape shape, string numberFormat)
{
if (shape is IPoint)
{
IPoint point = (IPoint)shape;
return(point.X.ToString(numberFormat, CultureInfo.InvariantCulture) + " " + point.Y.ToString(numberFormat, CultureInfo.InvariantCulture));
}
else if (shape is IRectangle)
{
IRectangle rect = (IRectangle)shape;
return(rect.MinX.ToString(numberFormat, CultureInfo.InvariantCulture) + " " +
rect.MinY.ToString(numberFormat, CultureInfo.InvariantCulture) + " " +
rect.MaxX.ToString(numberFormat, CultureInfo.InvariantCulture) + " " +
rect.MaxY.ToString(numberFormat, CultureInfo.InvariantCulture));
}
else if (shape is ICircle)
{
ICircle c = (ICircle)shape;
return("Circle(" +
c.Center.X.ToString(numberFormat, CultureInfo.InvariantCulture) + " " +
c.Center.Y.ToString(numberFormat, CultureInfo.InvariantCulture) + " " +
"d=" + c.Radius.ToString(numberFormat, CultureInfo.InvariantCulture) +
")");
}
return(shape.ToString());
}
private ICircle CalculatedCircleOne([NotNull] ICircle one,
[NotNull] ICircle two)
{
return(one.Radius > two.Radius
? two
: one);
}
public Curve( ICircle circle, bool assignID = true) : this()
{
if(circle is ICurve)
Initialize((circle as ICurve).StartAngle, (circle as ICurve).EndAngle, circle.Data, (circle as ICurve).Type, assignID);
else
Initialize( 0, 0, circle.Data, CurveType.Full, assignID);
}
protected virtual void TestCircle(double x, double y, double dist)
{
ICircle c = ctx.MakeCircle(x, y, dist);
String msg = c.ToString();
ICircle c2 = ctx.MakeCircle(ctx.MakePoint(x, y), dist);
Assert.Equal(c, c2);
Assert.Equal(c.GetHashCode(), c2.GetHashCode());
Assert.Equal(/*msg,*/ dist > 0, c.HasArea);
double area = c.GetArea(ctx);
Assert.True(/*msg,*/ c.HasArea == (area > 0.0));
IRectangle bbox = c.BoundingBox;
Assert.Equal(/*msg,*/ dist > 0, bbox.GetArea(ctx) > 0);
Assert.True(area <= bbox.GetArea(ctx));
if (!ctx.IsGeo)
{
//if not geo then units of dist == units of x,y
AssertEqualsRatio(msg, bbox.Height, dist * 2);
AssertEqualsRatio(msg, bbox.Width, dist * 2);
}
AssertRelation(msg, SpatialRelation.CONTAINS, c, c.Center);
AssertRelation(msg, SpatialRelation.CONTAINS, bbox, c);
}
internal void ValidateStartAndEndPoint([NotNull] ICircle circle,
[NotNull] Point startPoint,
[NotNull] Point endPoint)
{
if (!ValidatePoint(circle,
startPoint))
{
string message = "StartPoint {0} is not on circle [{1}] with radius {2}!".Inject(startPoint,
circle.CentrePoint,
circle.Radius);
Logger.Error(message);
throw new ArgumentException(message);
}
if (ValidatePoint(circle,
endPoint))
{
return;
}
string text = "EndPoint {0} is not on circle [{1}] with radius {2}!".Inject(endPoint,
circle.CentrePoint,
circle.Radius);
Logger.Error(text);
throw new ArgumentException(text);
}
public double Distance(ICircle other)
{
var line = new Line(CentrePoint,
other.CentrePoint);
return(line.Length);
}
public string FormatCircle(ICircle circle)
{
SolutionNode currentSolutionNode = null;
StringBuilder sb = new StringBuilder(1024);
foreach (Node node in circle.Nodes)
{
ArtifactNode artifact = node as ArtifactNode;
if (artifact == null)
{
continue;
}
if (artifact.SolutionNode != currentSolutionNode)
{
if (currentSolutionNode != null)
{
sb.Append(",");
}
currentSolutionNode = artifact.SolutionNode;
sb.Append(nodeFormattingService.FormatSolution(currentSolutionNode));
sb.Append(":");
}
else
{
sb.Append(" -> ");
}
sb.Append(nodeFormattingService.FormatArtifact(artifact));
}
return(sb.ToString());
}
private void Builder(object sender, RoutedEventArgs e)
{
Builder builder = new ComplexObjectBuilder();
builder.CreateComplexObject();
builder.SetCircle();
builder.SetSquare();
ICircle circle = builder.ComplexObject.Circle;
ISquare square = builder.ComplexObject.Square;
Rectangle rect = new Rectangle()
{
Fill = new SolidColorBrush(square.GetSqureColor()), Height = square.GetSideSize(), Width = square.GetSideSize()
};
Ellipse el = new Ellipse()
{
Fill = new SolidColorBrush(circle.GetCirleColor()), Height = circle.GetRadius() * 2, Width = circle.GetRadius() * 2
};
Grid grid = new Grid();
grid.Children.Add(rect);
grid.Children.Add(el);
Canvas.SetLeft(grid, 10);
Canvas.SetTop(grid, y);
canvas.Children.Add(grid);
y += rect.Height + 5;
}
// ReSharper disable once MethodTooLong
private Tuple <double, double> CircleOneCalculateXt1And2([NotNull] ICircle circle)
{
// r1^2 * (xp-c) +- r1 * (yb-d) * sqrt((xp-c)^2+(yb-d)^2-r1^2) + a
double r = circle.Radius;
double c = circle.X;
double d = circle.Y;
double xp = m_IntersectionPoint.X;
double yp = m_IntersectionPoint.Y;
double rSquare = Math.Pow(r,
2);
double xpMinusC = xp - c;
double ypMinusD = yp - d;
double xpMinusCSquare = Math.Pow(xpMinusC,
2);
double ypMinusDSquare = Math.Pow(ypMinusD,
2);
double rSquareMultiplyXpMinusA = rSquare * xpMinusC;
double rMultipleYbMinusB = r * ypMinusD;
double squareRootXt = Math.Sqrt(xpMinusCSquare + ypMinusDSquare - rSquare);
double commonBottom = xpMinusCSquare + ypMinusDSquare;
double topOne = rSquareMultiplyXpMinusA + rMultipleYbMinusB * squareRootXt;
double topTwo = rSquareMultiplyXpMinusA - rMultipleYbMinusB * squareRootXt;
double resultOne = topOne / commonBottom + c;
double resultTwo = topTwo / commonBottom + c;
return(new Tuple <double, double>(resultOne,
resultTwo));
}
// ReSharper disable once MethodTooLong
private Tuple <double, double> CircleOneCalculateYt1And2([NotNull] ICircle circle)
{
// r0^2 * (yp-b) +- r0 * (xb-a) * sqrt((xp-a)^2+(yb-b)^2-r0^2) + b
double r = circle.Radius;
double a = circle.X;
double b = circle.Y;
double xp = m_IntersectionPoint.X;
double yp = m_IntersectionPoint.Y;
double rSquare = Math.Pow(r,
2);
double xpMinusA = xp - a;
double ypMinusB = yp - b;
double xpMinusASquare = Math.Pow(xpMinusA,
2);
double ypMinusBSquare = Math.Pow(ypMinusB,
2);
double rSquareMultiplyYpMinusB = rSquare * ypMinusB;
double rMultipleXpMinusA = r * xpMinusA;
double squareRootXt = Math.Sqrt(xpMinusASquare + ypMinusBSquare - rSquare);
double commonBottom = xpMinusASquare + ypMinusBSquare;
double topOne = rSquareMultiplyYpMinusB + rMultipleXpMinusA * squareRootXt;
double topTwo = rSquareMultiplyYpMinusB - rMultipleXpMinusA * squareRootXt;
double resultOne = topOne / commonBottom + b;
double resultTwo = topTwo / commonBottom + b;
return(new Tuple <double, double>(resultOne,
resultTwo));
}
public static void ThrowIfInvalidShape(ICircle shape)
{
if (shape.Center == shape.Another)
{
throw new InvalidShapeException();
}
}
public static IList <Point> GetIntersects(ICircle circle, ISegment line)
{
IList <Point> list = new List <Point>();
IPoint startPoint = line.GetKeyPoint(KeyPointType.Start);
IPoint endPoint = line.GetKeyPoint(KeyPointType.End);
IList <Point> RayIntersections = circle.Intersection(
new Ray2D(new Point(startPoint.X, startPoint.Y), new Point(endPoint.X, endPoint.Y))
);
foreach (Point p in RayIntersections)
{
if (p.X < Math.Max(startPoint.X, endPoint.X) &&
p.X > Math.Min(startPoint.X, endPoint.X) &&
p.Y < Math.Max(startPoint.Y, endPoint.Y) &&
p.Y > Math.Min(startPoint.Y, endPoint.Y))
{
list.Add(p);
}
}
return(list);
}
public bool IntersectsWithCircle(ICircle aCircle)
{
float testX = aCircle.GetCenterX();
float testY = aCircle.GetCenterY();
if (aCircle.GetCenterX() < this.GetX())
{
testX = this.GetX();
}
else if (aCircle.GetCenterX() > this.GetX() + this.GetWidth())
{
testX = this.GetX() + this.GetWidth();
}
if (aCircle.GetCenterY() < this.GetY())
{
testY = this.GetY();
}
else if (aCircle.GetCenterY() > this.GetY() + this.GetHeight())
{
testY = this.GetY() + this.GetHeight();
}
float distanceX = aCircle.GetCenterX() - testX;
float distanceY = aCircle.GetCenterY() - testY;
float distance = (int)Math.Sqrt((distanceX * distanceX) + (distanceY * distanceY));
return(distance <= aCircle.GetRadius());
}
public double GetCircleSquare(ICircle circle)
{
var circleService = _shapeServiceFactory.CreateCircleService();
return
(circleService.GetSquare(circle));
}
/// <summary>
/// All <see cref="ICircle"/> implementations should use this definition of <see cref="object.Equals(object)"/>.
/// </summary>
public static bool Equals(ICircle thiz, object o)
{
if (thiz == null)
{
throw new ArgumentNullException("thiz");
}
if (thiz == o)
{
return(true);
}
var circle = o as ICircle;
if (circle == null)
{
return(false);
}
if (!thiz.Center.Equals(circle.Center))
{
return(false);
}
if (!circle.Radius.Equals(thiz.Radius))
{
return(false);
}
return(true);
}
public static PointPair IntersectCircleAndCircle(IFigure circle1, IFigure circle2)
{
ICircle c1 = (ICircle)circle1;
ICircle c2 = (ICircle)circle2;
return(Math.GetIntersectionOfCircles(c1.Center, c1.Radius, c2.Center, c2.Radius));
}
public bool Intersects(ICircle finishPointStarboard)
{
double distance = Distance(finishPointStarboard);
double delta = distance - Radius;
return((delta < 0) || (Math.Abs(delta) <= SelkieConstants.EpsilonDistance));
}
public DesignPatterns(ISingletonProcessor singletonProcessor, IAdapterDemo adapterDemo, ICircle circle, IRocket rocket)
{
_singletonProcessor = singletonProcessor;
_adapterdemo = adapterDemo;
_circle = circle;
_rocket = rocket;
}
//Saves updated properties depending on shape type and closes form.
private void SaveChangesButton_Click(object sender, EventArgs e)
{
if (this.Shape.GetType().Name == "Circle")
{
ICircle circle = (ICircle)this.Shape;
circle.ChangeSize(new PointF((float)this.CenterXNumber.Value, (float)this.CenterYNumber.Value),
(float)this.RadiusNumber.Value);
}
else if (this.Shape.GetType().Name == "Rectangle")
{
IRectangle rectangle = (IRectangle)this.Shape;
rectangle.ChangeSize(new PointF((float)this.PointXNumber.Value, (float)this.PointYNumber.Value),
(float)this.WidthNumber.Value, (float)this.HeightNumber.Value);
}
else if (this.Shape.GetType().Name == "Triangle")
{
ITriangle triangle = (ITriangle)this.Shape;
triangle.ChangeSize(
new PointF((float)this.PointAXCoordinateNumber.Value, (float)this.PointAYCoordinateNumber.Value),
new PointF((float)this.PointBXCoordinateNumber.Value, (float)this.PointBYCoordinateNumber.Value),
new PointF((float)this.PointCXCoordinateNumber.Value, (float)this.PointCYCoordinateNumber.Value));
}
this.Shape.ChangeColor(this.newColor);
this.Close();
}
public override double Area(ICircle circle)
{
//formula is a simplified case of area(rect).
double lat = DistanceUtils.ToRadians(90 - circle.Radius);
return(2 * Math.PI * radiusDEG * radiusDEG * (1 - Math.Sin(lat)));
}
private ICircle CalculatedCircleZero([NotNull] ICircle one,
[NotNull] ICircle two)
{
return(one.Radius > two.Radius
? one
: two);
}
public static bool CanEat(ICircle player, ICircle ball)
{
float X_Distance = player.X - ball.X;
float Y_Distance = player.Y - ball.Y;
float Distance = (float)Math.Sqrt(X_Distance * X_Distance + Y_Distance * Y_Distance);
return player.Radius > (Distance + ball.Radius);
}
public bool IntersectsWithCircle(ICircle aCircle)
{
float distanceX = this.GetCenterX() - aCircle.GetCenterX();
float distanceY = this.GetCenterY() - aCircle.GetCenterY();
float distance = (int)Math.Sqrt(distanceX * distanceX + distanceY * distanceY);
return(distance <= this.GetRadius() + aCircle.GetRadius());
}
public virtual void TestCircleShapeSupport()
{
ICircle circle = ctx.MakeCircle(ctx.MakePoint(0, 0), 10);
SpatialArgs args = new SpatialArgs(SpatialOperation.Intersects, circle);
Query query = this.strategy.MakeQuery(args);
assertNotNull(query);
}
public static bool CanEat(ICircle player, ICircle ball)
{
float X_Distance = player.X - ball.X;
float Y_Distance = player.Y - ball.Y;
float Distance = (float)Math.Sqrt(X_Distance * X_Distance + Y_Distance * Y_Distance);
return(player.Radius > (Distance + ball.Radius));
}
public static void TestCircleReset(SpatialContext ctx)
{
ICircle c = ctx.MakeCircle(3, 4, 5);
ICircle c2 = ctx.MakeCircle(5, 6, 7);
c2.Reset(3, 4, 5); // to c1
Assert.Equal(c, c2);
Assert.Equal(c.BoundingBox, c2.BoundingBox);
}
private void OnCircleIsFull(ICircle Circle)
{
List <ICircle> circlesToDestroy = GetNeighbourCircles(Circle);
foreach (ICircle circleToDestroy in circlesToDestroy)
{
circleToDestroy.DestroySlices();
}
}
public static ICircle GetCircleProperties()
{
ICircle circle = Factory.GetInstanceICircle();
Point center = new Point();
/* get input from user start point */
Console.Write("Enter center coordinate x1,y1: ");
string coOrdinate = Console.ReadLine();
string[] coOrdinateValues = coOrdinate.Split(',');
if (coOrdinateValues.Count() == 0)
{
circle = null;
return(circle);
}
else if (coOrdinateValues.Count() == 2)
{
/* parsing check and setting null if parsing fails */
int parseStorageX = 0, parseStorageY = 0;
if (InputValidator.IsInt(coOrdinateValues[0], ref parseStorageX) & InputValidator.IsInt(coOrdinateValues[1], ref parseStorageY))
{
center.X = parseStorageX;
center.Y = parseStorageY;
circle.center = center;
}
else
{
circle = null;
return(circle);
}
/* get input from user radius */
Console.Write("Enter radius: ");
coOrdinate = Console.ReadLine();
/* parsing check and setting null if parsing fails */
int parseStorage = 0;
if (InputValidator.IsInt(coOrdinate, ref parseStorage))
{
circle.radius = parseStorage;
}
else
{
circle = null;
return(circle);
}
return(circle);
}//else if
else
{
circle = null;
return(circle);
}
}//GetCircleProperties
protected virtual IPoint RandomPointIn(ICircle c)
{
double d = c.Radius * random.NextDouble();
double angleDEG = 360 * random.NextDouble();
IPoint p = ctx.DistCalc.PointOnBearing(c.Center, d, angleDEG, ctx, null);
Assert.Equal(SpatialRelation.CONTAINS, c.Relate(p));
return(p);
}
public void UnknownTest()
{
ICircle actual = Circle.Unknown;
Assert.True(actual.IsUnknown,
"IsUnknown");
Assert.True(actual.CentrePoint.IsUnknown,
"CentrePoint.IsUnknown");
}
public static IList<Point> GetIntersects(ICircle circle, IRay line)
{
IList<Point> list = new List<Point>();
double a = Math.Pow(line.Vector.X, 2) + Math.Pow(line.Vector.Y, 2);
double b = 2 * (line.Vector.X * (line.Point.X - circle.Center.X)
+ line.Vector.Y * (line.Point.Y - circle.Center.Y));
double c = Math.Pow(circle.Center.X, 2) + Math.Pow(circle.Center.Y, 2);
c += Math.Pow(line.Point.X, 2) + Math.Pow(line.Point.Y, 2);
c -= 2 * (circle.Center.X * line.Point.X + circle.Center.Y * line.Point.Y);
c -= Math.Pow(circle.Radius, 2);
double bb4ac = b * b - 4 * a * c;
if (bb4ac < 0)
return list;
else if (bb4ac == 0)
{
double mu = -b / (2 * a);
Point intersectionPoint = new Point(line.Point.X + mu * line.Vector.X,
line.Point.Y + mu * line.Vector.Y);
list.Add(intersectionPoint);
}
else
{
double mu = -b + Math.Sqrt(bb4ac) / (2 * a);
Point intersectionPoint1 = new Point(line.Point.X + mu * line.Vector.X,
line.Point.Y + mu * line.Vector.Y);
mu = -b - Math.Sqrt(bb4ac) / (2 * a);
Point intersectionPoint2 = new Point(line.Point.X + mu * line.Vector.X,
line.Point.Y + mu * line.Vector.Y);
list.Add(intersectionPoint1);
list.Add(intersectionPoint2);
}
return list;
}
private static void AssertTurnCircleArcSegment(ITurnCircleArcSegment actual,
ICircle expectedCircle,
Point expectedStartPoint,
Point expectedEndPoint,
Constants.CircleOrigin origin)
{
Assert.AreEqual(origin,
actual.CircleOrigin,
"CircleOrigin");
Assert.AreEqual(expectedCircle.CentrePoint,
actual.CentrePoint,
"CentrePoint");
Assert.AreEqual(expectedCircle.Radius,
actual.Radius,
"Radius");
Assert.AreEqual(expectedStartPoint,
actual.StartPoint,
"StartPoint");
Assert.AreEqual(expectedEndPoint,
actual.EndPoint,
"EndPoint");
}
public CircleCollisionDetector(DynamicGameObject dgo, IShape shape)
{
this.dgo = dgo;
circle = shape as ICircle;
}
public static IList<Point> GetIntersects(ICircle circle, IPoint point)
{
IList<Point> list = new List<Point>();
if ((Math.Pow((point.X - circle.Center.X), 2) + Math.Pow((point.Y - circle.Center.Y), 2)).IsEqual(circle.Radius))
{
list.Add(new Point(point.X, point.Y));
}
return list;
}
public static IList<Point> GetIntersects(ICircle circle, ISegment line)
{
IList<Point> list = new List<Point>();
IPoint startPoint = line.GetKeyPoint(KeyPointType.Start);
IPoint endPoint = line.GetKeyPoint(KeyPointType.End);
IList<Point> RayIntersections = circle.Intersection(
new Ray2D(new Point(startPoint.X, startPoint.Y), new Point(endPoint.X, endPoint.Y))
);
foreach (Point p in RayIntersections)
{
if (p.X < Math.Max(startPoint.X, endPoint.X)
&& p.X > Math.Min(startPoint.X, endPoint.X)
&& p.Y < Math.Max(startPoint.Y, endPoint.Y)
&& p.Y > Math.Min(startPoint.Y, endPoint.Y))
{
list.Add(p);
}
}
return list;
}
protected override void OnDependenciesChanged()
{
mirrorPoint = Mirror as IPoint;
mirrorLine = Mirror as ILine;
mirrorCircle = Mirror as ICircle;
}
public CirclePresenter(ICircle circle)
{
circleDetails = circle;
}
