private void BuildRing(HalfEdge eStartRing) { CoordinateList line = new CoordinateList(); HalfEdge e = eStartRing; Coordinate orig = e.Orig; line.Add(orig.Clone(), false); // scan along the path until a node is found (if one exists) while (e.Sym.Degree() == 2) { HalfEdge eNext = e.Next; // check if edges form a ring - if so, we're done if (eNext == eStartRing) { break; } // add point to line, and move to next edge orig = eNext.Orig; line.Add(orig.Clone(), false); e = eNext; } // add final node Coordinate dest = e.Dest; line.Add(dest.Clone(), false); // store the scanned line AddLine(line); }
public override MapObject Copy(IDGenerator generator) { var e = new Entity(generator.GetNextObjectID()) { GameData = GameData, EntityData = EntityData.Clone(), Origin = Origin.Clone() }; CopyBase(e, generator); return(e); }
public void TestClone() { Coordinate c = new Coordinate(100.0, 200.0, 50.0); Coordinate clone = (Coordinate)c.Clone(); Assert.IsTrue(c.Equals3D(clone)); }
private IPolygon CreateSelectionPolygon(Coordinate worldPosition) { if (MultiSelectionMode == MultiSelectionMode.Rectangle) { if (0 == Math.Abs(mouseDownLocation.X - worldPosition.X)) { return(null); } if (0 == Math.Abs(mouseDownLocation.Y - worldPosition.Y)) { return(null); } return(CreatePolygon(Math.Min(mouseDownLocation.X, worldPosition.X), Math.Max(mouseDownLocation.Y, worldPosition.Y), Math.Max(mouseDownLocation.X, worldPosition.X), Math.Min(mouseDownLocation.Y, worldPosition.Y))); } var vertices = selectPoints.Select(point => Map.ImageToWorld(point)).ToList(); if (vertices.Count == 1) { // too few points to create a polygon return(null); } vertices.Add((Coordinate)worldPosition.Clone()); vertices.Add((Coordinate)vertices[0].Clone()); ILinearRing newLinearRing = GeometryFactory.CreateLinearRing(vertices.ToArray()); return(GeometryFactory.CreatePolygon(newLinearRing, null)); }
/// <summary> /// /// </summary> /// <param name="errorType"></param> /// <param name="pt"></param> public TopologyValidationError(TopologyValidationErrors errorType, Coordinate pt) { this.errorType = errorType; if (pt != null) { this.pt = (Coordinate)pt.Clone(); } }
public void EqualOperator_Works() { Coordinate coor1 = new Coordinate(0, 1); Coordinate coor1Clone = (Coordinate)coor1.Clone(); (coor1 == coor1Clone).Should().BeTrue(); (coor1 == new Coordinate(coor1.X + 1, coor1.Y)).Should().BeFalse(); }
public void CloneTest() { var target = new Coordinate(5, 15); object expected = new Coordinate(5, 15); object actual = target.Clone(); Assert.AreEqual(expected, actual); }
public void CloneTest() { var target = new Coordinate(5, 15); object expected = new Coordinate(5, 15); object actual = target.Clone(); Assert.AreEqual(expected, actual); }
public ValidationError(ValidationErrorType errorType, Coordinate pt) { if (pt == null) { throw new ArgumentNullException("pt"); } this.errorType = errorType; this.pt = pt.Clone(); }
public virtual object Clone() { Line l = new Line(); l.Coordinate = Coordinate.Clone() as AxisCoordinate; l.LineWidth = LineWidth; l.MarkColor = MarkColor; l.Text = Text; return(l); }
public void test_Clone() { //create a coordinate Coordinate coord = new Coordinate(testX, testY, testZ); //create a new coordinate by cloning the first Coordinate coord2 = coord.Clone() as Coordinate; //check that the values are the same Assertion.AssertEquals("Clone: ", true, coord.Equals(coord2)); }
public Coordinate fixedCoordinate(Coordinate coor) { if (t.InMap(coor) == true) { return(coor.Clone()); } int x, y; x = Mathf.Clamp(coor.x, 0, t.UnitCounts.x - 1); y = Mathf.Clamp(coor.y, 0, t.UnitCounts.y - 1); return(new Coordinate(x, y)); }
private void SetClickOnExistingSelection(bool set, Coordinate worldPosition) { clickOnExistingSelection = set; if (clickOnExistingSelection) { orgMouseDownLocation = (Coordinate)worldPosition.Clone(); } else { orgMouseDownLocation = null; } }
/// <summary> /// Move the last coordinate added /// </summary> /// <param name="worldCoord">The new position</param> internal override void MoveCoordinate(Coordinate worldCoord) { if (LastCoordinate != null) { var coordinates = this.Coordinates; LastMouseCoordinate = worldCoord.Clone(); ActiveCollection.MovedCoordinate(coordinates, LastMouseCoordinate); CreateFeatureGeometry(); } }
/// <summary> /// Builds a line starting from the given edge. /// The start edge origin is a node (valence = 1 or >= 3), /// unless it is part of a pure ring. /// </summary> /// <remarks> /// A pure ring has no other incident lines. /// In this case the start edge may occur anywhere on the ring. /// </remarks> /// <remarks> /// The line is built up to the next node encountered, /// or until the start edge is re-encountered /// (which happens if the edges form a ring). /// </remarks> /// <param name="eStart"></param> private void BuildLine(HalfEdge eStart) { CoordinateList line = new CoordinateList(); DissolveHalfEdge e = (DissolveHalfEdge)eStart; _ringStartEdge = null; MarkHalfEdge.MarkBoth(e); Coordinate orig = e.Orig; line.Add(orig.Clone(), false); // scan along the path until a node is found (if one exists) while (e.Sym.Degree() == 2) { UpdateRingStartEdge(e); DissolveHalfEdge eNext = (DissolveHalfEdge)e.Next; // check if edges form a ring - if so, we're done if (eNext == eStart) { BuildRing(_ringStartEdge); return; } // add point to line, and move to next edge orig = eNext.Orig; line.Add(orig.Clone(), false); e = eNext; MarkHalfEdge.MarkBoth(e); } // add final node Coordinate dest = e.Dest; line.Add(dest.Clone(), false); // queue up the final node edges StackEdges(e.Sym); // store the scanned line AddLine(line); }
public void ClonedCoordinateMustHaveSameXAndYThanOriginal() { // Given int coordX = 10; int coordY = 20; Coordinate original = new Coordinate(coordX, coordY); // When Coordinate copied = original.Clone(); // Then Assert.IsTrue(original.X == coordX, "Cloned X must be same as Original X"); Assert.IsTrue(original.Y == coordY, "Cloned Y must be same as Original Y"); }
public static Coordinate FindElement2(int[,] matrix, Coordinate origin, Coordinate dest, int x) { if (!origin.Inbounds(matrix) || !dest.Inbounds(matrix)) { return(null); } if (matrix[origin.row, origin.column] == x) { return(origin); } else if (!origin.IsBefore(dest)) { return(null); } /* Set start to start of diagonal and end to the end of the diagonal. Since * the grid may not be square, the end of the diagonal may not equal dest. */ Coordinate start = (Coordinate)origin.Clone(); int diagDist = Math.Min(dest.row - origin.row, dest.column - origin.column); Coordinate end = new Coordinate(start.row + diagDist, start.column + diagDist); Coordinate p = new Coordinate(0, 0); /* Do binary search on the diagonal, looking for the first element greater than x */ while (start.IsBefore(end)) { p.SetToAverage(start, end); if (x > matrix[p.row, p.column]) { start.row = p.row + 1; start.column = p.column + 1; } else { end.row = p.row - 1; end.column = p.column - 1; } } /* Split the grid into quadrants. Search the bottom left and the top right. */ return(PartitionAndSearch(matrix, origin, dest, start, x)); }
public static List <Coordinate> GetCoordinates(Coordinate topLeft, int length, Alignment alignment) { var coordinates = new List <Coordinate>(); var horizontal = alignment == Alignment.Horizontal; for (int i = 0; i < length; i++) { var newCoordinate = (Coordinate)topLeft.Clone(); if (horizontal) { newCoordinate.XCoordinate += i; } else { newCoordinate.YCoordinate += i; } coordinates.Add(newCoordinate); } return(coordinates); }
private IsoscelesRightTriangle CreateTriangleFromCoordinates(Coordinate coor1, Coordinate coor2, Coordinate coor3, string label) { //right sight up triangle: Coordinate newCoor1 = (Coordinate)coor1.Clone(); Coordinate newCoor2 = (Coordinate)coor2.Clone(); Coordinate newCoor3 = (Coordinate)coor3.Clone(); List <Coordinate> triangleCoorindates = new List <Coordinate> { newCoor1, newCoor2, newCoor3 }; var newTriangle = new IsoscelesRightTriangle(_properties.NonHypotenuseSideLengthInPixels, triangleCoorindates, label); return(newTriangle); }
public Page MovePageUnit(Page page, Coordinate from, Coordinate to) { var pageUnits = page.Contents[from.X, from.Y]; foreach (var pageUnit in pageUnits) { pageUnit.Coordinate = (Coordinate)to.Clone(); if (page.Contents[to.X, to.Y] == null) { page.Contents[to.X, to.Y] = new List <PageUnit>(); } page.Contents[to.X, to.Y].Add(pageUnit); } page.Contents[from.X, from.Y] = null; return(page); }
public void ClonedClass_ShouldBe_DecoupledFromOriginalClass() { // Arrange int originalX = 10; int originalY = 20; int clonedX = 2000; int clonedY = 3000; var coordinate = new Coordinate(originalX, originalY); // Act var coordinateClone = coordinate.Clone() as Coordinate; coordinateClone.X = clonedX; coordinateClone.Y = clonedY; // Assert Assert.IsNotNull(coordinateClone); // Original object should not be touched Assert.AreEqual(originalX, coordinate.X); Assert.AreEqual(originalY, coordinate.Y); Assert.AreEqual(clonedX, coordinateClone.X); Assert.AreEqual(clonedY, coordinateClone.Y); }
/// <summary> /// Add a world coordinate to the measurer /// </summary> internal override void AddCoordinate(Coordinate worldCoord) { if (ActiveCollection.CanAddCoordinate()) { var coordinates = this.Coordinates; if (LastCoordinate == null) { ActiveCollection.CoordinateSystem = this.CoordinateSystem; ActiveCollection.Transform = this.PixelToWorldTransform; coordinates.Clear(); } var coordinateToAdd = worldCoord.Clone(); coordinates.Add(coordinateToAdd); ActiveCollection.AddedCoordinate(coordinates, coordinateToAdd); LastCoordinate = coordinateToAdd; CreateFeatureGeometry(); } }
private static Coordinate findMyPivot(double[,] matrix, double target, Coordinate s, Coordinate e) { if ((!s.inBound(matrix)) || (!e.inBound(matrix))) { return(null); } else if (matrix[s.col, s.row] == target) { return(s); } else if (!s.isBefore(e)) { return(null); } Coordinate ss = s.Clone(); int DisCol = e.col - s.col; int DisRow = e.row - s.row; int Dis = System.Math.Min(DisCol, DisRow); Coordinate ee = new Coordinate(s.col + Dis, s.row + Dis); Coordinate p = new Coordinate(); while (ss.isBefore(ee)) { p.setToMid(ss, ee); if (target > matrix[p.col, p.row]) { ss.col = p.col + 1; ss.row = p.row + 1; } else { ee.col = p.col - 1; ee.row = p.col - 1; } } return(ss); }
private static ILineString AppendCurvePoint(ILineString lineString, Coordinate worldPos) { List <Coordinate> vertices = new List <Coordinate>(); for (int i = 0; i < lineString.Coordinates.Length; i++) { if (1 == i) { // remove duplicate start points, see MouseDown if ((lineString.Coordinates[0].X != lineString.Coordinates[1].X) && (lineString.Coordinates[0].Y != lineString.Coordinates[1].Y)) { vertices.Add(lineString.Coordinates[i]); } } else { vertices.Add(lineString.Coordinates[i]); } } vertices.Add((Coordinate)worldPos.Clone()); return(GeometryFactory.CreateLineString(vertices.ToArray())); }
public Coordinate Transform(Coordinate coordinate) { var xy = new[] { coordinate.X, coordinate.Y }; double[] z = null; if (!coordinate.Z.Equals(Coordinate.NullOrdinate)) { z = new[] { coordinate.Z } } ; Reproject.ReprojectPoints(xy, z, Source, Target, 0, 1); var ret = (Coordinate)coordinate.Clone(); ret.X = xy[0]; ret.Y = xy[1]; if (z != null) { ret.Z = z[0]; } return(ret); }
private static Coordinate findMyPivot(double[,] matrix, double target, Coordinate s, Coordinate e) { if ((!s.inBound(matrix)) || (!e.inBound(matrix))) { return null; } else if (matrix[s.col, s.row] == target) { return s; } else if (!s.isBefore(e)) { return null; } Coordinate ss = s.Clone(); int DisCol = e.col - s.col; int DisRow = e.row - s.row; int Dis = System.Math.Min(DisCol, DisRow); Coordinate ee = new Coordinate(s.col + Dis, s.row + Dis); Coordinate p = new Coordinate(); while (ss.isBefore(ee)) { p.setToMid(ss, ee); if (target > matrix[p.col, p.row]) { ss.col = p.col + 1; ss.row = p.row + 1; } else { ee.col = p.col - 1; ee.row = p.col - 1; } } return ss; }
public void Clone_should_create_a_new_instance_of_Coordinate() { coordinate.Clone() .Should().Not.Be.SameInstanceAs(coordinate); }
/* * La génétation du chemin comprend l'algorithme A* * et la construction de la chaine de déplacement pour se rendre du départ à l'arrivé en remontant l'analyse de A* */ private void PathGeneration() { cible = new Coordinate(x_cible, y_cible); depart = new Coordinate(x_depart, y_depart); //graph (contient les obstacles) int infini = (largeur * hauteur) ^ 2; Dictionary <int, Coordinate> Q_listeDeSommet = new Dictionary <int, Coordinate>(); Dictionary <Coordinate, int> dT = new Dictionary <Coordinate, int>(); //Coordinate S1, int ordre_de_vérification Dictionary <Coordinate, int> dH = new Dictionary <Coordinate, int>(); //Coordinate S1, int fonction_de_cout (et valeur infini2 pour les obstacles) cheminInverse = new Dictionary <Coordinate, int>(); //populer la liste Q de tout les sommets du graph for (int i = 0; i < largeur * hauteur; i++) { Q_listeDeSommet[i] = new Coordinate(); } int k_indexe = 0; for (int l = 0; l < largeur; l++) { for (int h = 0; h < hauteur; h++) { Coordinate coordinate = new Coordinate(l, h); Q_listeDeSommet[k_indexe] = coordinate; if (graph[coordinate]) //obstacle { dH[coordinate] = infini * 2; } dT[coordinate] = infini; if (!dH.ContainsKey(coordinate)) // si il n'y a pas déjà un obstacle { //la fonction de coût est la distance pythagorienne entre le sommet actuel et le sommet d'arrivé int delta_x = (x_cible - l) * (x_cible - l); int delta_y = (y_cible - h) * (y_cible - h); int fonction_h = (int)(Mathf.Sqrt(delta_x + delta_y)); dH[coordinate] = fonction_h; } k_indexe++; } } dT[depart] = 0; //l'ordre de la case de départ est 0 bool fin = false; int tour = 0; while (Q_listeDeSommet.Count > 0 && !fin) { tour++; int valeurMin = infini * 4; int indexeMinQ = 0; //WARNING Coordinate s1 = new Coordinate(); // (0,0) foreach (KeyValuePair <int, Coordinate> sommet in Q_listeDeSommet) { try { if ((dT[sommet.Value] + dH[sommet.Value]) < valeurMin) { valeurMin = dT[sommet.Value] + dH[sommet.Value]; indexeMinQ = sommet.Key; s1.Clone(sommet.Value); } } catch (KeyNotFoundException) { //la position de i à été supprimé } } //la cible est-elle atteinte? if (cible.Equals(s1)) { fin = true; } //on retire s1 de Q bool indexeRemoved = false; indexeRemoved = Q_listeDeSommet.Remove(indexeMinQ); //on ajoute s1 au graph cheminInverse //contruit le graph qui servira à remonter l'ordre T en fesait ainsi le chemin inverse. cheminInverse[s1] = dT[s1]; //check et assigner l'ordre T les quatres directions haut, droit, bas, gauche Coordinate haut = new Coordinate(s1.X, s1.Y + 1); Coordinate droit = new Coordinate(s1.X + 1, s1.Y); Coordinate bas = new Coordinate(s1.X, s1.Y - 1); Coordinate gauche = new Coordinate(s1.X - 1, s1.Y); //haut try { if (dT[haut] > dT[s1] + 1 && dH[haut] < infini * 2) { dT[haut] = dT[s1] + 1; } } catch (KeyNotFoundException) { //s1 est en haut du graph } //droite try { if (dT[droit] > dT[s1] + 1 && dH[droit] < infini * 2) { dT[droit] = dT[s1] + 1; } } catch (KeyNotFoundException) { //s1 est à droite du graph } //bas try { if (dT[bas] > dT[s1] + 1 && dH[bas] < infini * 2) { dT[bas] = dT[s1] + 1; } } catch (KeyNotFoundException) { //s1 est en bas du graph } //gauche try { if (dT[gauche] > dT[s1] + 1 && dH[gauche] < infini * 2) { dT[gauche] = dT[s1] + 1; } } catch (KeyNotFoundException) { //s1 est à gauche du graph } } //faire le chemin inverse Coordinate positionChemin = new Coordinate(); positionChemin.Clone(cible); //on commence par la fin, par la cible int indexPath = 0; //on remonte le chemin et on arrête à la position de depart while (!positionChemin.Equals(depart)) { Vector2Int direction = new Vector2Int(); int ordreMin = infini; //check et assigner l'ordre T les quatres directions haut, droit, bas, gauche Coordinate haut = new Coordinate(positionChemin.X, positionChemin.Y + 1); Coordinate droit = new Coordinate(positionChemin.X + 1, positionChemin.Y); Coordinate bas = new Coordinate(positionChemin.X, positionChemin.Y - 1); Coordinate gauche = new Coordinate(positionChemin.X - 1, positionChemin.Y); //haut try { if (ordreMin > cheminInverse[haut]) { ordreMin = cheminInverse[haut]; direction = Vector2Int.down; //chemin inverse } } catch (KeyNotFoundException) { //la position en haut n'a pas d'ordre } //droite try { if (ordreMin > cheminInverse[droit]) { ordreMin = cheminInverse[droit]; direction = Vector2Int.left; //chemin inverse //direction = Vector2Int.right; } } catch (KeyNotFoundException) { //la position à droite n'a pas d'ordre } //bas try { if (ordreMin > cheminInverse[bas]) { ordreMin = cheminInverse[bas]; direction = Vector2Int.up; //chemin inverse //direction = Vector2Int.down; } } catch (KeyNotFoundException) { //la position en bas n'a pas d'ordre } //gauche try { if (ordreMin > cheminInverse[gauche]) { ordreMin = cheminInverse[gauche]; direction = Vector2Int.right; //chemin inverse //direction = Vector2Int.left; } } catch (KeyNotFoundException) { //la position à gauche n'a pas d'ordre } if (direction == Vector2Int.down) { //la position actu a monté positionChemin.Y++; } else if (direction == Vector2Int.left) { //la position actu est allé vers la droite positionChemin.X++; } else if (direction == Vector2Int.up) { //la position actu a dessendu positionChemin.Y--; } else if (direction == Vector2Int.right) { //la position actu est allé vers la gauche positionChemin.X--; } path[indexPath] = direction; // indexPath++; } }
/// <summary> /// Initializes a new instance of the TopologyValidationError class. /// </summary> public TopologyValidationError(int errorType, Coordinate pt) { this._errorType = errorType; this._pt = (Coordinate)pt.Clone(); }