public void Point() { //Do various Point method calls to cover the point class with sufficient testing Point p0 = new Point(); Point p1 = new Point(0, 0); Point p2 = new Point(450, 120); Assert.IsTrue(p0.IsEmpty()); Assert.IsFalse(p1.IsEmpty()); Assert.AreNotEqual(p0, p1); Assert.AreEqual(450, p2.X); Assert.AreEqual(120, p2.Y); Assert.AreNotSame(p2.Clone(), p2); p0 = p2.Clone(); p0.X += 100; p0.Y = 150; p0[0] += p0[1]; Assert.AreEqual(new Point(700, 150), p0); Assert.AreEqual(p2, p2.GetBoundingBox().Min); Assert.AreEqual(p2, p2.GetBoundingBox().Max); Assert.IsTrue(p2.IsSimple()); Assert.IsFalse(p2.IsEmpty()); Assert.AreEqual(2, p2.NumOrdinates); Assert.AreEqual(new Point(400, 100), p2 + new Point(-50, -20)); Assert.AreEqual(new Point(500, 100), p2 - new Point(-50, 20)); Assert.AreEqual(new Point(900, 240), p2*2); Assert.AreEqual(0, p2.Dimension); Assert.AreEqual(450, p2[0]); Assert.AreEqual(120, p2[1]); Assert.IsNull(p2.Boundary()); Assert.AreEqual(p2.X.GetHashCode() ^ p2.Y.GetHashCode() ^ p2.IsEmpty().GetHashCode(), p2.GetHashCode()); Assert.Greater(p2.CompareTo(p1), 0); Assert.Less(p1.CompareTo(p2), 0); Assert.AreEqual(p2.CompareTo(new Point(450, 120)), 0); }
/// <summary> /// Constructs a new shape object. /// </summary> /// <param name="shapeMode">The desired shape.</param> public GMareCollision(Point[] points) { // Set nodes. _points = (Point[])points.Clone(); // Set node rectangles. SetNodes(); }
public IObjectiveFunction Fork() { return(new ForwardDifferenceGradientObjectiveFunction(this.InnerObjectiveFunction.Fork(), LowerBound, UpperBound, this.RelativeIncrement, this.MinimumIncrement) { Point = Point?.Clone(), GradientEvaluated = GradientEvaluated, ValueEvaluated = ValueEvaluated, _gradient = _gradient?.Clone() }); }
public void DoIt() { var point = new Point(); point.Desc.Name = "point one"; point.Desc.UId = "1-2-3"; point.X = 10; point.Y = 20; var point2 = (Point)point.Clone(); point2.Desc.Name = "point two"; point2.X = 200; Console.Out.WriteLine(point); Console.Out.WriteLine(point2); }
private void CalculateCollision(Vector velocity, LWShape target) { if (target == null) { return; } Distance min = new Distance { x = float.MaxValue, y = float.MaxValue }; Point collisionPoint = Point.CreateInvalidPoint(); LineSegment collisionLine = null; foreach (LineSegment originalLineSegment in _shape) { foreach (LineSegment targetLineSegment in target.GetSegments()) { Point originalPoint = originalLineSegment.from; if (target.IsWithIn(originalPoint) && !target.IsWithIn(originalPoint + velocity)) { continue; } LineSegment trajectory = LineSegment.Create( originalPoint, originalPoint + velocity ); Point intersection = LWCollide.Math.Intersection(trajectory, targetLineSegment); if (intersection.IsInvalidPoint()) { continue; } if (Distance.Create(originalPoint, intersection).GetPower() < min.GetPower()) { collisionPoint = intersection; min = Distance.Create(originalPoint, intersection); } collisionLine = targetLineSegment.Clone(); } } // does not collide if (collisionPoint.IsInvalidPoint() || collisionLine == null) { _cache.Register( _shape, target.GetSegments(), _position, target.GetPosition(), velocity, collisionPoint.Clone(), min.Clone(), Vector.Create(), Vector.Create()); return; } float primaryVectorLength = (float)System.Math.Sqrt((double)min.GetPower()); float secondaryVectorLength = (float)System.Math.Sqrt((double)velocity.GetPower()) - primaryVectorLength; Vector primaryVector = velocity * (float)(primaryVectorLength / System.Math.Sqrt((double)velocity.GetPower())); Vector secondaryVector = LWCollide.Math.GetLineVector(velocity, collisionLine) * secondaryVectorLength; _cache.Register( _shape, target.GetSegments(), _position, target.GetPosition(), velocity, collisionPoint.Clone(), min.Clone(), primaryVector, secondaryVector); }
public static Area GetArea(int rotation, Point lineEnd) { Point topLeft = lineEnd.Clone(); Point bottomRight = lineEnd.Clone(); if (rotation == (int) ArrowDirection.Up) { topLeft.Offset(-(ArrowHeight / 2), -ArrowWidth); bottomRight.Offset(ArrowHeight / 2, 0); } else if (rotation == (int) ArrowDirection.Down) { topLeft.Offset(-(ArrowHeight / 2), 0); bottomRight.Offset(ArrowHeight / 2, ArrowWidth); } else if (rotation == (int) ArrowDirection.Right) { topLeft.Offset(0, -(ArrowHeight / 2)); bottomRight.Offset(ArrowWidth, ArrowHeight / 2); } else if (rotation == (int) ArrowDirection.Left) { topLeft.Offset(-(ArrowWidth), -(ArrowHeight / 2)); bottomRight.Offset(0, ArrowHeight / 2); } return new Area(topLeft, bottomRight); }
public Area(Point topLeft, Point bottomRight) { TopLeft = topLeft.Clone(); BottomRight = bottomRight.Clone(); }
public Point GetPosition() { return(_position.Clone()); }
private static List <Point> RenderPoints(bool[,] maze, IMazeOptions options, int mazeWidth, int mazeLength) { var outer = options.Thickness; var inner = options.InnerThickness; var points = new List <Point>(); for (var z = 1; z < mazeLength - 1; z += 2) { for (var x = 1; x < mazeWidth - 1; x += 2) { var cellX = (x - 1) / 2; var cellZ = (z - 1) / 2; var topleft = new Point { X = options.X + cellX * (outer + inner), Y = options.Y, Z = options.Z + cellZ * (outer + inner), BlockName = options.Block }; if (maze[x, z - 1]) // top { for (var x2 = 0; x2 < outer + outer + inner; x2++) { for (var z2 = 0; z2 < outer; z2++) { var cell = topleft.Clone(); cell.X += x2; cell.Z += z2; points.Add(cell); } } } if (maze[x, z + 1]) // bottom { for (var x2 = 0; x2 < outer + outer + inner; x2++) { for (var z2 = outer + inner; z2 < outer + outer + inner; z2++) { var cell = topleft.Clone(); cell.X += x2; cell.Z += z2; points.Add(cell); } } } if (maze[x - 1, z]) // left { for (var z2 = 0; z2 < outer + outer + inner; z2++) { for (var x2 = 0; x2 < outer; x2++) { var cell = topleft.Clone(); cell.X += x2; cell.Z += z2; points.Add(cell); } } } if (maze[x + 1, z]) // right { for (var z2 = 0; z2 < outer + outer + inner; z2++) { for (var x2 = outer + inner; x2 < outer + outer + inner; x2++) { var cell = topleft.Clone(); cell.X += x2; cell.Z += z2; points.Add(cell); } } } } } // raise the maze if (options.Height == 1) { return(points.Distinct().ToList()); } var ypoints = new List <Point>(); for (var y = 0; y < options.Height; y++) { foreach (var p in points.Distinct()) { var yp = p.Clone(); yp.Y = options.Y + y; ypoints.Add(yp); } } return(ypoints); }
// Update is called once per frame void Update() { if (moving != null) // jeśli bool moving jest rózny on null { Vector2 dir = ((Vector2)Input.mousePosition - mouseStart); //inicjalizuj wektor kierunkowy Vector2 ndir = dir.normalized; //utwórz wektor jednostkowy z "dir" Vector2 adir = new Vector2(Mathf.Abs(dir.x), Mathf.Abs(dir.y)); //utwórz wektor o wartościach zawsze dodatnich NewIndex = Point.Clone(moving.index); // skopiuj obecną wartość index do nowej zmiennej Point add = Point.Zero; // utworz nowy punkt o wspolrzednych (0,0) //uproszcznie wzglednej pozycji myszki wokol punktu odniesienia do GORA DOL PRAWO LEWO switch (CheckPositionOnBoard(NewIndex)) { case 1: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : 0, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : 0)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 2: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : 0, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 0 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 3: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 0 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 0 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 4: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 0 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : 0)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 5: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : 0)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 6: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : 0, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 7: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 0 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 8: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 0 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } case 9: { if (dir.magnitude > 16) { if (adir.x > adir.y) // jezeli w wektorze [x,y] : |x| > |y| { add = (new Point((ndir.x > 0) ? 1 : -1, 0)); //to zmienna "add" jest punktem (1 dla ndir.x > 0 oraz -1 dla ndir.x < 0 , 0) } else if (adir.y > adir.x) // jezeli w wektorze [x,y] : |x| < |y| { add = (new Point(0, (ndir.y > 0) ? 1 : -1)); //to zmienna "add" jest punktem (0, 1 dla ndir.y > 0 oraz -1 dla ndir.y < 0) } } //jeżeli dlugosc wektora kierunkowego jest > 16 to: break; } } // ogranicz tworzenie wektora kierunkowego w zależnoeści od pozycji na planszy NewIndex.Add_indirect(add); // dodaj do zmiennej typu Point NewIndex zmienną add, jeden z wariantów : (1,0), (-1,0), (0,1), (0,-1) Vector2 pos = game.GetPositionFromPoint(moving.index); //utwórz wektor[x,y] "pos" o wartosci pozycji obecnego elementu. //GameBoard game -> GetPostiionFromPoint ( TilePiece moving -> index (Point)) if (!NewIndex.Equals(moving.index)) //jezeli funkcja NewIndex typu Point zwroci true to : { pos += Point.Multiply(add, 10).ToVector(); //dodaj do zmiennej "pos" typu Vector2 nowy wektor kierunkowy o dlugosci 10 } moving.MovePositionTo(pos); //uzyj funkcji MovePositionTo z parametrem pos typu Vector2 ze zmiennej moving typu TilePiece } }
public void Clone_a_valid_point_should_equal() { var point = new Point(100, 50); point.Clone().Equals(point).Should().BeTrue(); }
public static Point[] SphericalDensify(Point p0, Point p1, double length, Unit unit) { Point xyz0 = SphToCart3d(p0, unit); Point xyz1 = SphToCart3d(p1, unit); double dot01 = Dot(xyz0, xyz1); double angle01 = Math.Acos(dot01); double threshold = ToRadian(length, unit); int n = (int)(angle01 / threshold); if (n < 1) { return(new Point[0]); } // make sure the number of additional points is even // this way there will always be a segment in the middle // and something may be drawn there if (n % 2 != 0) { ++n; } Point axis; if (!Equals(angle01, Math.PI)) { axis = Cross(xyz0, xyz1); VecNormalize(axis); } else { double halfPi = HalfAngle(unit) / 2; if (Equals(p0[1], halfPi)) { axis = new Point(0, 1, 0); } else if (Equals(p0[1], -halfPi)) { axis = new Point(0, -1, 0); } else { double lon = ToRadian(p0[0], unit); axis = new Point(Math.Sin(lon), -Math.Cos(lon), 0); } } double step = angle01 / (n + 1); Point[] result = new Point[n]; double a = step; for (int i = 0; i < n; ++i, a += step) { // Axis-Angle rotation // see: https://en.wikipedia.org/wiki/Axis-angle_representation double cos_a = Math.Cos(a); double sin_a = Math.Sin(a); // cos_a * v Point s1 = xyz0.Clone(); Mul(s1, cos_a); // sin_a * (n x v) Point s2 = Cross(axis, xyz0); Mul(s2, sin_a); // (1 - cos_a)(n.v) * n Point s3 = axis.Clone(); Mul(s3, (1.0 - cos_a) * Dot(axis, xyz0)); // v_rot = cos_a * v + sin_a * (n x v) + (1 - cos_a)(n.v) * e Point v_rot = s1.Clone(); Add(v_rot, s2); Add(v_rot, s3); result[i] = Cart3dToSph(v_rot, unit); } return(result); }
private static void Free() { var arrivedPosition = new Point() { y = robotPosition.y, type = 1, x = robotPosition.x, parent = (Point)robotPosition.Clone(), backtracking = robotPosition.backtracking }; switch (direction) { case "U": arrivedPosition.y++; if (!arrivedPosition.backtracking) { q.Push(arrivedPosition.Down(true)); } break; case "D": arrivedPosition.y--; if (!arrivedPosition.backtracking) { q.Push(arrivedPosition.Up(true)); } break; case "R": arrivedPosition.x++; if (!arrivedPosition.backtracking) { q.Push(arrivedPosition.Left(true)); } break; case "L": arrivedPosition.x--; if (!arrivedPosition.backtracking) { q.Push(arrivedPosition.Right(true)); } break; } passedCoordinates.Add(arrivedPosition); if (passedCoordinates.Find(x => x.x == arrivedPosition.x && x.y == arrivedPosition.y + 1) is null) { var test = arrivedPosition.Up(false); q.Push(test); } if (passedCoordinates.Find(x => x.x == arrivedPosition.x && x.y == arrivedPosition.y - 1) is null) { q.Push(arrivedPosition.Down(false)); } if (passedCoordinates.Find(x => x.x == arrivedPosition.x - 1 && x.y == arrivedPosition.y) is null) { q.Push(arrivedPosition.Left(false)); } if (passedCoordinates.Find(x => x.x == arrivedPosition.x + 1 && x.y == arrivedPosition.y) is null) { q.Push(arrivedPosition.Right(false)); } robotPosition.x = arrivedPosition.x; robotPosition.y = arrivedPosition.y; robotPosition.backtracking = arrivedPosition.backtracking; robotPosition.parent = (Point)robotPosition.Clone(); }
public Node(float position, TNodePayload payload, Point point) { Position = Math.Round(position, 3).ToFloat(); Payload = payload; Point = point.Clone(); }
private Point[] refine_center(Point[] last_center, Image<Gray, Byte> img) { Point[] center = last_center.Clone() as Point[]; for (int iter = 0; iter < 3; iter++) { for (int i = 0; i < 2; i++) { Rectangle ROI = new Rectangle(Math.Max(center[i].X - 50,0),Math.Max( center[i].Y - 50,0),Math.Min(center[i].X+50,img.Width),Math.Min(center[i].Y+50,img.Height)); ROI.Width -= ROI.X; ROI.Height -= ROI.Y; try { Emgu.CV.CvInvoke.cvSetImageROI(img, ROI); if (img.GetMoments(false).GravityCenter.x > 0) { center[i].X = ROI.X + (int)img.GetMoments(false).GravityCenter.x; center[i].Y = ROI.Y + (int)img.GetMoments(false).GravityCenter.y; } } catch { } Emgu.CV.CvInvoke.cvResetImageROI(img); } } return center; }
private PolygonRegularizer(Point[] vertices) { this.vertices = (Point[])vertices.Clone(); }
public static void Main() { Point p1 = new Point(50, 50); Point p2 = p1; p2.X = 0; Console.WriteLine(p1); Console.WriteLine(p2); Point p3 = new Point(100, 100); Point p4 = (Point) p3.Clone(); p4.Y = 0; Console.WriteLine(p3); Console.WriteLine(p4); Point2 p5 = new Point2(100, 100, "Jane"); Point2 p6 = (Point2) p5.Clone(); Console.WriteLine(p5); Console.WriteLine(p6); p6.desc.PetName = "My new Point2"; p6.X = 9; Console.WriteLine(p5); Console.WriteLine(p6); }
/// <summary> /// Clones this instance. /// </summary> /// <returns></returns> public ICoordinate Clone() { return(new Coordinate(_point.Clone())); }
private void FindPointsInRange(IAxis x_axis, IAxis y_axis, out Point[] points) { points = new Point[0]; if ((x_axis == null || !x_axis.HasValidRange) || (y_axis == null || !y_axis.HasValidRange)) { // we need both axes to be valid to draw anything return; } ArrayList points_list = new ArrayList(); TreeIter iter; if (!model.GetIterFirst(out iter)) { return; } Point prev_point = null; do { IComparable x_val, y_val; if (!GetValue(iter, 0, out x_val) || !GetValue(iter, 1, out y_val)) { continue; } // don't clip a gapped point if (PointGapFunc != null && PointGapFunc(model, iter)) { if (x_axis.IsInRange(x_val)) { Point p = new Point(x_axis.ValueToGridCoords(x_val), y_axis.ValueToGridCoords(y_val), x_val, y_val); p.IsAGap = true; points_list.Add(p); } continue; } // create a line segment between the previous // point and the current point and see if the // segment intersects the viewing plane Point b = new Point(x_axis.ValueToGridCoords(x_val), y_axis.ValueToGridCoords(y_val), x_val, y_val); Point a = new Point(b.X, b.Y, b.XValue, b.YValue); if (prev_point != null) { a = prev_point; } // copy b before it becomes clipped prev_point = b.Clone() as Point; TreePath path = model.GetPath(iter); if (selected_path != null && selected_path.Compare(path) == 0) { b.IsSelected = true; } if (focused_path != null && focused_path.Compare(path) == 0) { b.IsFocused = true; } if (ClipSegment(x_axis, y_axis, ref a, ref b)) { if (a != b && a.IsClipped) { points_list.Add(a); } points_list.Add(b); } } while (model.IterNext(ref iter)); // Sort this list on the x axis points_list.Sort(new PointXAxisIComparer()); points = (Point[])points_list.ToArray(typeof(Point)); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static Point SetGeometry(this Point point, Point newPoint) { return(newPoint.Clone()); }
public Point CopyCenter() { return(_center.Clone()); }
/// <summary> /// Find the nearest point. /// </summary> public Point Interpolate(Point start, Point finish, int axissIndex, double?isolevel = null) { var startValue = start.Get(axissIndex) > finish.Get(axissIndex) ? finish.Get(axissIndex) : start.Get(axissIndex); var finishValue = start.Get(axissIndex) > finish.Get(axissIndex) ? start.Get(axissIndex) : finish.Get(axissIndex); var curA = startValue; var curB = finishValue; double funcA = 0; double funcB = 0; double calcA = 0; double calcB = 0; var point = start.Clone(); // Some constants var c = (3 - Math.Sqrt(5)) / 2; var fi = (Math.Sqrt(5) + 1) / 2; var calculated = Calculated.FirstIteration; for (; ;) { if ((curB - curA < accuracyEpsilon) && calculated != Calculated.FirstIteration) { var pointToReturn = point.Clone(); if (GetNearestOrMin(funcA, funcB, isolevel)) { pointToReturn.Set(axissIndex, curA); } else { pointToReturn.Set(axissIndex, curB); } return(pointToReturn); } calcA = curA + c * (curB - curA); point.Set(axissIndex, calcA); var toSet = Calc(point); calcB = curA + (1 - c) * (curB - curA); point.Set(axissIndex, calcB); var toSet2 = Calc(point); if (toSet.HasValue) { funcA = toSet.Value; } if (toSet2.HasValue) { funcB = toSet2.Value; } var forcedExit = false; if (!toSet.HasValue || !toSet2.HasValue) { // Cannot calculate the value. Get the nearest value and exit. forcedExit = true; } var result = GetNearestOrMin(funcA, funcB, isolevel); if (result) { curB = calcB; // This will exit from the function. if (forcedExit) { curA = curB; } calculated = Calculated.B; } else { curA = calcA; if (forcedExit) { curB = curA; } calculated = Calculated.A; } } }
public Point[] RecalibratePolygon(Point[] akershusPoly) { Point[] tempList = (Point[])akershusPoly.Clone(); //for (int i = 0; i < tempList.Length; i++) //{ // tempList[i].X = tempList[i].X + m_game.MapProvider.Map.Rectangle.X; // tempList[i].Y = tempList[i].Y + m_game.MapProvider.Map.Rectangle.Y; //} for (int i = 0; i < tempList.Length; i++) { tempList[i] = RecalibratePoint( tempList[i] ); } return tempList; }
/***************************************************/ private static double ShearAreaLine(Point ptA, Point ptB, double s, double tol = Tolerance.Distance) { //TODO Should do some checks if these are good Tolerances Point a = ptA.Clone(); Point b = ptB.Clone(); double axbx = a.X - b.X; if (Math.Abs(axbx) < tol) // The solution is zero { return(0); } double byay = b.Y - a.Y; double ax2 = Math.Pow(a.X, 2); double ay2 = Math.Pow(a.Y, 2); double horizTol = -Math.Min(b.Y, a.Y) * 0.003; // the bigger function becomes erratic under thease valuse (tested value) horizTol = horizTol < tol ? tol : horizTol; if (Math.Abs(byay) < horizTol) // The solution for a "constant" integral, i.e. horizontal line { return((axbx) * ( 10 * a.Y * Math.Pow(axbx, 2) * (3 * ax2 * a.Y - 2 * s) - 30 * a.X * a.Y * axbx * (ax2 * a.Y - 2 * s) + 15 * Math.Pow(ax2 * a.Y - 2 * s, 2) + 3 * ay2 * Math.Pow(axbx, 4) - 15 * a.X * ay2 * Math.Pow(axbx, 3) ) / (60 * a.Y)); } if (a.Y > -tol) //Everithing should happen below the X-axis { a.Y = -tol; ay2 = Math.Pow(a.Y, 2); byay = b.Y - a.Y; } if (b.Y > -tol) // and these should never be zero { b.Y = -tol; byay = b.Y - a.Y; } // if this change made (Math.Abs(byay) < Tolerance.MicroDistance) = true it is problem double ax3 = Math.Pow(a.X, 3); double bx2 = Math.Pow(b.X, 2); double bx3 = Math.Pow(b.X, 3); double ay3 = Math.Pow(a.Y, 3); double by2 = Math.Pow(b.Y, 2); double by3 = Math.Pow(b.Y, 3); double byay2 = Math.Pow(byay, 2); // Formula derivation outlined in https://github.com/BHoM/documentation/wiki/Shear-Area-Derivation double A = -( 20 * Math.Pow(axbx, 2) * (24 * s * byay2 + a.Y * ( -39 * by2 * ax2 + 6 * b.Y * a.X * a.Y * (14 * a.X - b.X) + ay2 * (-44 * ax2 + 4 * a.X * b.X + bx2) ) ) ) / (byay2); double B = -( 30 * axbx * (a.Y * ( 18 * by3 * ax3 + 3 * by2 * ax2 * a.Y * (5 * b.X - 23 * a.X) + 6 * b.Y * a.X * ay2 * (13 * ax2 - 3 * a.X * b.X - bx2) + ay3 * (-28 * ax3 + 6 * ax2 * b.X + 3 * a.X * bx2 + bx3) ) - 12 * s * byay2 * (3 * b.Y * a.X + a.Y * (b.X - 4 * a.X)) ) ) / (Math.Pow(byay, 3)); double C = ( 60 * a.Y * axbx * (a.Y * (2 * a.X + b.X) - 3 * b.Y * a.X) * (a.Y * ( 6 * by2 * ax2 - 3 * b.Y * a.X * a.Y * (3 * a.X + b.X) + ay2 * (4 * ax2 + a.X * b.X + bx2) ) - 12 * s * byay2 ) ) / (Math.Pow(byay, 4)); double D = ( 60 * Math.Log(b.Y / a.Y) * Math.Pow( a.Y * (3 * by2 * ax2 - 3 * b.Y * a.X * a.Y * (a.X + b.X) + ay2 * (ax2 + a.X * b.X + bx2)) - 6 * s * byay2 , 2) ) / (Math.Pow(byay, 5)); double E = 40 * byay * Math.Pow(axbx, 4) - 48 * Math.Pow(axbx, 3) * (3 * b.Y * a.X - 5 * a.X * a.Y + 2 * a.Y * b.X) + (15 * Math.Pow(axbx, 2) * ( 9 * by2 * ax2 - 6 * b.Y * a.X * a.Y * (8 * a.X - 5 * b.X) + ay2 * (40 * ax2 - 32 * a.X * b.X + bx2)) ) / (byay); double factor = (axbx / 2160); return((A + B + C + D + E) * factor); }
public static Geometry Intersection(Point point1, Point point2) { return(point2.IsIntersects(point1) ? point1.Clone() : null); }
public static bool EnumeratePointsBetween(Point from, Point to, double maxDelta, PointDelegate callback) { if (from.Equals(to)) return callback(from.Clone()); var c = (int)(from.GetDistanceTo(to) / maxDelta + 2); maxDelta = from.GetDistanceTo(to) / c; var dir = (to - from).Normalized(); for (var i = 0; i <= c; i++) { // from + dir * (maxDelta * i) if (!callback(new Point(from.X + dir.X * maxDelta * i, from.Y + dir.Y * maxDelta * i))) return false; } return true; }
public void DrawNavSymbol(Graphics g, SolidBrush sb, int x, int y, Point[] symbol, Orientation or, bool SkyDir, bool shrink) { Point[] pa = (Point[])symbol.Clone(); int len = pa.Length; for (int i = 0; i < len; i++) { switch (or) { case Orientation.mirrorX: pa[i].X = NavSymbol_size - pa[i].X; break; case Orientation.mirrorY: pa[i].Y = NavSymbol_size - pa[i].Y; break; case Orientation.right: pa[i].Y = symbol[i].X; pa[i].X = NavSymbol_size - symbol[i].Y; break; case Orientation.left: pa[i].Y = NavSymbol_size - symbol[i].X; pa[i].X = symbol[i].Y; break; } if (SkyDir) if (or == Orientation.right || or == Orientation.left) pa[i].Y -= NavSymbol_size / 5; else pa[i].X -= NavSymbol_size / 5; if (shrink) { pa[i].X /= 2; pa[i].Y /= 2; } pa[i].X += x; pa[i].Y += y; } Pen pen = new Pen(Color.Black, NavSymbol_size / (shrink ? 24 : 12)); g.DrawPolygon(pen, pa); g.FillPolygon(sb, pa); if (symbol == arrow_to) { DrawNavSymbol(g, sb, x, y, line_to, or, false, shrink); //draw other parts of symbol if (SkyDir) { string s; int dx, dy; float fontsize; int quot; switch (or) { case Orientation.normal: s = "N"; dx = 60; dy = 50; break; case Orientation.left: s = "W"; dx = 50; dy = 50; break; case Orientation.right: s = "E"; dx = 0; dy = 40; break; case Orientation.mirrorY: s = "S"; dx = 60; dy = -10; break; default: s = ""; dx = x; dy = y; break; } if (shrink) { fontsize = 8; quot = 200; } else { fontsize = 20; quot = 100; } Font font = new Font("Arial", fontsize * parent.df, FontStyle.Bold); dx = dx * NavSymbol_size / quot + x; dy = dy * NavSymbol_size / quot + y; g.DrawString(s, font, sb, dx, dy); } } }
internal void SetLocation(Point p) { location = p.Clone(); }
/// <summary> /// position = sign((Bx - Ax) * (Y - Ay) - (By - Ay) * (X - Ax)) /// </summary> /// <param name="jointPosition"></param> /// <param name="endPoint"></param> /// <returns></returns> public Quadrant InWhichQuadrant(Point jointPosition, Point endPoint) { var normalVectorPoint1 = jointPosition.Clone(); var normalVectorPoint2 = CalculateNormalVectorPoint(normalVectorPoint1); var infinityFlag = false; if (double.IsInfinity(normalVectorPoint2.Y)) { infinityFlag = true; } var jointQuadrant = InWhichQuadrant(jointPosition); var pointX = 0; var pointXn = 0; switch (jointQuadrant) { case Quadrant.I: pointX = 50; pointXn = -50; break; case Quadrant.II: pointX = 50; pointXn = -50; break; case Quadrant.III: pointX = -50; pointXn = 50; break; case Quadrant.IV: pointX = -50; pointXn = 50; break; } var vectorXPoint1 = jointPosition; var vectorXPoint2 = CalculatePointFromEquation(pointX, zeroPoint, jointPosition); normalVectorPoint2 = infinityFlag ? new Point() { X = normalVectorPoint2.X, Y = jointPosition.X } : CalculatePointFromEquation(pointXn, normalVectorPoint1, normalVectorPoint2); if (Equals(vectorXPoint2, default(Point)) || Equals(normalVectorPoint2, default(Point))) { return(Quadrant.None); } var positionByX = PositionSignByVector(vectorXPoint1, vectorXPoint2, endPoint); var positionByY = PositionSignByVector(normalVectorPoint1, normalVectorPoint2, endPoint); switch (positionByX) { case 0: case 1: return(positionByY <= 0 ? Quadrant.I : Quadrant.II); case -1: return(positionByY >= 0 ? Quadrant.III : Quadrant.IV); default: return(Quadrant.None); } }
public APuck(Point pos, Point speed, Point goalie) : base(pos, speed, 0) { if (goalie != null) Goalie = goalie.Clone(); }
public Area(Point topLeft, double actualWidth, double actualHeight) { TopLeft = topLeft.Clone(); BottomRight = new Point(TopLeft.X + actualWidth, TopLeft.Y + actualHeight); }