diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java index 32a4c9c..a788e88 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java @@ -36,10 +36,6 @@ public final class AStar { return node; } - static Node dajAStarNode(GridCoord gridCoord) { - return dajAStarNode(gridCoord.x, gridCoord.y); - } - ArrayList dajNiezamknietychSasiadow() { ArrayList wynik = new ArrayList<>(); Node sasiad; @@ -85,7 +81,7 @@ public final class AStar { zKierunku = EGeoDirection.UNDEFINED; } - Node(GridCoord id) { + Node(Coord.Grid id) { this(id.x, id.y); } @@ -133,16 +129,16 @@ public final class AStar { * @param rodzajDzialania rodzaj działania, w ramach którego określana jest droga * @return uporządkowana kolekcja współrzędnych kolejnych kwadratów drogi zawierająca kwadrat startowy i docelowy lub kolekcja pusta, gdy nie istnieje droga */ - public static ArrayList wyznaczDroge(GridCoord[] punktyProfilujace, EGeoDirection staryKierunek, - ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) { + public static ArrayList wyznaczDroge(Coord.Grid[] punktyProfilujace, EGeoDirection staryKierunek, + ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) { if (null == punktyProfilujace || 0 == punktyProfilujace.length) { return null; } Node.reset(); - ArrayList wynik = new ArrayList<>(); - GridCoord start; - GridCoord stop = punktyProfilujace[0]; - ArrayList odcinek; + ArrayList wynik = new ArrayList<>(); + Coord.Grid start; + Coord.Grid stop = punktyProfilujace[0]; + ArrayList odcinek; for (int i = 1; i < punktyProfilujace.length; i++) { start = stop; stop = punktyProfilujace[i]; @@ -178,8 +174,8 @@ public final class AStar { * @param zawieraStartowy parametr wskazujący, czy wyznaczona droga ma zawierać kwadrat startowy * @return uporządkowana kolekcja współrzędnych kolejnych kwadratów drogi zawierająca kwadrat startowy (jeśli zawieraStartowy==true) i docelowy lub kolekcja pusta, gdy nie istnieje droga */ - public static ArrayList wyznaczDroge(GridCoord start, GridCoord stop, EGeoDirection staryKierunek, - boolean zawieraStartowy, ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) { + public static ArrayList wyznaczDroge(Coord.Grid start, Coord.Grid stop, EGeoDirection staryKierunek, + boolean zawieraStartowy, ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) { PriorityQueue listaOtwarta = new PriorityQueue<>(100, (o1, o2) -> Double.compare(o1.kosztZHeurystyka, o2.kosztZHeurystyka)); boolean naPrzelaj = false; @@ -204,13 +200,13 @@ public final class AStar { aktualny = Node.dajAStarNode(start.x, start.y); aktualny.zKierunku = staryKierunek; listaOtwarta.add(aktualny); - ArrayList wynik = new ArrayList(); + ArrayList wynik = new ArrayList(); int licznik_zabezpieczajacy = 200000; while (listaOtwarta.size() > 0 && licznik_zabezpieczajacy-- > 0) { aktualny = listaOtwarta.remove(); if (aktualny.koncowy) { while (null != aktualny) { - wynik.add(new GridCoord(aktualny.x, aktualny.y)); + wynik.add(new Coord.Grid(aktualny.x, aktualny.y)); aktualny = aktualny.poprzednik; } if (!zawieraStartowy) { @@ -231,8 +227,8 @@ public final class AStar { if (naPrzelaj) { stopienPrzejezdnosci = Math.max(Teren.minStopienPrzejezdNaPrzelaj, stopienPrzejezdnosci); } - double nowyKosztOdStartu = (float) aktualny.kosztOdStartu + GridCoord.odleglosc(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci; - double nowyKosztZHeurystyka = nowyKosztOdStartu + GridCoord.odleglosc(sasiad.x, sasiad.y, stop.x, stop.y); + double nowyKosztOdStartu = aktualny.kosztOdStartu + Coord.Grid.distance(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci; + double nowyKosztZHeurystyka = nowyKosztOdStartu + Coord.Grid.distance(sasiad.x, sasiad.y, stop.x, stop.y); if (sasiad.kosztZHeurystyka > nowyKosztZHeurystyka) { //UPDATE kosztow i zmiany w kolejce sasiad.kosztOdStartu = nowyKosztOdStartu; @@ -259,12 +255,12 @@ public final class AStar { * @param zawieraStartowy parametr wskazujący, czy wyznaczona droga ma zawierać kwadrat startowy * @return uporządkowana kolekcja współrzędnych kolejnych kwadratów drogi zawierająca kwadrat startowy (jeśli zawieraStartowy==true) i docelowy lub kolekcja pusta, gdy nie istnieje droga */ - public static ArrayList wyznaczDrogeNew(GridCoord start, GridCoord stop, EGeoDirection staryKierunek, - boolean zawieraStartowy, ERodzajPodwozia podwozie, - ERodzajDzialania rodzajDzialania, - double szerokoscPokonywRowow, - double glebokoscBrodzenia, - double predkoscPlywania) { + public static ArrayList wyznaczDrogeNew(Coord.Grid start, Coord.Grid stop, EGeoDirection staryKierunek, + boolean zawieraStartowy, ERodzajPodwozia podwozie, + ERodzajDzialania rodzajDzialania, + double szerokoscPokonywRowow, + double glebokoscBrodzenia, + double predkoscPlywania) { PriorityQueue listaOtwarta = new PriorityQueue<>(100, new Comparator() { public int compare(Node o1, Node o2) { return Double.compare(o1.kosztZHeurystyka, o2.kosztZHeurystyka); @@ -293,13 +289,13 @@ public final class AStar { aktualny = Node.dajAStarNode(start.x, start.y); aktualny.zKierunku = staryKierunek; listaOtwarta.add(aktualny); - ArrayList wynik = new ArrayList(); + ArrayList wynik = new ArrayList(); int licznik_zabezpieczajacy = 200000; while (listaOtwarta.size() > 0 && licznik_zabezpieczajacy-- > 0) { aktualny = listaOtwarta.remove(); if (aktualny.koncowy) { while (null != aktualny) { - wynik.add(new GridCoord(aktualny.x, aktualny.y)); + wynik.add(new Coord.Grid(aktualny.x, aktualny.y)); aktualny = aktualny.poprzednik; } if (!zawieraStartowy) { @@ -320,8 +316,8 @@ public final class AStar { if (naPrzelaj) { stopienPrzejezdnosci = Math.max(Teren.minStopienPrzejezdNaPrzelaj, stopienPrzejezdnosci); } - double nowyKosztOdStartu = (float) aktualny.kosztOdStartu + GridCoord.odleglosc(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci; - double nowyKosztZHeurystyka = nowyKosztOdStartu + GridCoord.odleglosc(sasiad.x, sasiad.y, stop.x, stop.y); + double nowyKosztOdStartu = aktualny.kosztOdStartu + Coord.Grid.distance(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci; + double nowyKosztZHeurystyka = nowyKosztOdStartu + Coord.Grid.distance(sasiad.x, sasiad.y, stop.x, stop.y); if (sasiad.kosztZHeurystyka > nowyKosztZHeurystyka) { //UPDATE kosztow i zmiany w kolejce sasiad.kosztOdStartu = nowyKosztOdStartu; diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/Arkusz.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/Arkusz.java deleted file mode 100644 index eaf6536..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/Arkusz.java +++ /dev/null @@ -1,35 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje; - -import java.util.ArrayList; - -public class Arkusz { - - ArrayList wezly = new ArrayList<>(); - // arkusz mapy zawiera luki rozlacznie (jeden luk moze nalezec tylko do jednego arkusza) - ArrayList luki = new ArrayList<>(); - - // liczba arkuszy mapy - static int lx = 0; - static int ly = 0; - - /** - * Funkcja porownuje wspolrzedne leksykograficznie. - * @param x1 - * @param y1 - * @param x2 - * @param y2 - * @return - */ - static boolean mniejszeWspolrzedne(int x1, int y1, int x2, int y2) { - if (x1 < x2) { - return true; - } - if (x1 > x2) { - return false; - } - if (y1 < y2) { - return true; - } - return false; - } -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java index 902a8ff..b75f563 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java @@ -1,6 +1,5 @@ package pl.wat.ms4ds.terenfunkcje; - /** * Klasa algorytmiczna do wyznaczania kwadratów odcinka (dyskretyzacja odcinka kwadratami/pikselami). */ @@ -25,7 +24,7 @@ public class Bresenham { * @param y2 współrzędna y końca * @return tablicę kolejnych kwadratów tworzących odcinek o zadanych końcach */ - public static GridCoord[] generateSegment(int x1, int y1, int x2, int y2) { + public static Coord.Grid[] generateSegment(int x1, int y1, int x2, int y2) { int x = x1; int y = y1; int dx = x2 - x1; @@ -44,9 +43,9 @@ public class Bresenham { if (dx >= dy) { // poruszamy się po x p = ddy - dx; - GridCoord[] res = new GridCoord[dx + 1]; + Coord.Grid[] res = new Coord.Grid[dx + 1]; for (int i = 0; i <= dx; i++) { - res[i] = new GridCoord(x, y); + res[i] = new Coord.Grid(x, y); if (p > 0) { y += sy; p -= ddx; @@ -58,9 +57,9 @@ public class Bresenham { } else { // poruszamy sie po y p = ddx - dy; - GridCoord[] res = new GridCoord[dy + 1]; + Coord.Grid[] res = new Coord.Grid[dy + 1]; for (int i = 0; i <= dy; i++) { - res[i] = new GridCoord(x, y); + res[i] = new Coord.Grid(x, y); if (p > 0) { x += sx; p -= ddy; @@ -72,8 +71,7 @@ public class Bresenham { } } - - static void print(GridCoord[] segment) { + static void print(Coord.Grid[] segment) { StringBuilder sb = new StringBuilder(300); sb.append('['); int last = segment.length - 1; diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/Coord.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/Coord.java new file mode 100644 index 0000000..88ef67e --- /dev/null +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/Coord.java @@ -0,0 +1,353 @@ +package pl.wat.ms4ds.terenfunkcje; + +public class Coord { + + public static class Geo { + public double lat; + public double lon; + + public Geo() { + } + + public Geo(double lat, double lon) { + this.lat = lat; + this.lon = lon; + } + + public Geo(GeoCoord other) { + lat = other.lat; + lon = other.lon; + } + } + + /** + * Współrzędne punktu odwzorowania kartograficznego PUWG 1992. + *

+ * Wartości współrzędnych [metry]. + * + */ + public static class Puwg { + /** + * Współrzędna X (oś odcietych) odwzorowania kartograficznego [metry]. + */ + public double easting; + /** + * Współrzędna Y (oś rzędnych) odwzorowania kartograficznego [metry]. + */ + public double northing; + + public Puwg() { + this.easting = 0; + this.northing = 0; + } + + public Puwg(double easting, double northing) { + this.easting = easting; + this.northing = northing; + } + } + + public static class Grid { + + /** + * Współrzędna pozioma (oś OX) w siatce kwadratów. Indeks kolumny. + */ + public int x; + /** + * Współrzędna pionowa (oś OY) w siatce kwadratów. Indeks wiersza. + */ + public int y; + + /** + * Konstruktor klasy na bazie współrzędnych geograficznych. + * + * @param lon długość geograficzna + * @param lat szerokość geograficzna + */ + public Grid(double lon, double lat) { + double xms_f = (lon + 180) * MapConsts.DEG_MS; + long xms = (long) xms_f; + x = zamienWspXmsNaIdKwadratuX(xms); + + double yms_f = (lat + 90) * MapConsts.DEG_MS; + long yms = (long) yms_f; + y = zamienWspYmsNaIdKwadratuY(yms); + } + + + public String toString() { + StringBuilder sb = new StringBuilder("(x= "); + sb.append(x); + sb.append(", y= "); + sb.append(y); + sb.append(')'); +// String s = "(x= " + Integer.toString(x) + ", y= " + Integer.toString(y) + ")"; + return sb.toString(); + } + + private static final double ODWROT_SS_DX_MS = 1.0 / MapConsts.SS_DX_MS; + private static final double ODWROT_SS_DY_MS = 1.0 / MapConsts.SS_DY_MS; + + public static double distance(Grid a, Grid b) { + int dx = a.x - b.x; + int dy = a.y - b.y; + return Math.sqrt(dx * dx + dy * dy) * MapConsts.DL_MK; + } + + public static double distance(int x1, int y1, int x2, int y2) { + int dx = x2 - x1; + int dy = y2 - y1; + return Math.sqrt(dx * dx + dy * dy) * MapConsts.DL_MK; + } + + private static final float DL_MK2 = MapConsts.DL_MK * 0.0009765625f; + + /** + * Funkcja zwraca aproksymowaną odległość między środkami małych kwadratów [m]. + * + * @param x1 Wsp X id malego kwadratu pocz. + * @param y1 Wsp Y id malego kwadratu pocz. + * @param x2 Wsp X id malego kwadratu konc. + * @param y2 Wsp Y id malego kwadratu konc. + * @return Odległość miedzy srodkami malych kwadratow [m]. + */ + public static float distanceApprox(int x1, int y1, int x2, int y2) { + int dx = x2 - x1; + int dy = y2 - y1; + int min, max, approx; + if (dx < 0) dx = -dx; + if (dy < 0) dy = -dy; + if (dx < dy) { + min = dx; + max = dy; + } else { + min = dy; + max = dx; + } + approx = (max * 1007) + (min * 441); + if (max < (min << 4)) { + approx -= (max * 40); + } + float odl = approx * DL_MK2; + return odl; + } + + public Grid() { + x = -1; + y = -1; + } + + public Grid(int x, int y) { + this.x = x; + this.y = y; + } + + public Grid(Grid orig) { + this.x = orig.x; + this.y = orig.y; + } + + public int getX() { + return x; + } + + public void setX(int x) { + this.x = x; + } + + public int getY() { + return y; + } + + public void setY(int y) { + this.y = y; + } + + public void set(Grid orig) { + x = orig.x; + y = orig.y; + } + + public void set(int x, int y) { + this.x = x; + this.y = y; + } + + @Override + public final boolean equals(Object o) { + if (!(o instanceof Grid grid)) return false; + + return x == grid.x && y == grid.y; + } + + @Override + public final int hashCode() { + int result = x; + result = 31 * result + y; + return result; + } + + } + + /** + * Zamienia współrzęną GridCoord.x na długość geograficzną środka małego kwadratu + * + * @param idX współrzęna x GridCoord + * @return długość geograficzna + */ + public static float zamienIdKwadratuXNaDlugoscGeo(int idX) { + long xms = zamienIdKwadratuXNaWspXms(idX); + double lon = (double) xms / (double) MapConsts.DEG_MS - 180; + return (float) lon; + } + + /** + * Zamienia współrzęną GridCoord.y na szerokość geograficzną środka małego kwadratu + * + * @param idY współrzęna y GridCoord + * @return szerokość geograficzna + */ + public static float zamienIdKwadratuYNaSzerokoscGeo(int idY) { + long yms = zamienIdKwadratuYNaWspYms(idY); + double lat = (double) yms / (double) MapConsts.DEG_MS - 90; + return (float) lat; + } + + /** + * Funkcja zamienia wsp. X GridCoord na wsp. geo xms w milisekundach. + * Zwracana wspolrzedna lezy w srodku kwadratu. + */ + public static long zamienIdKwadratuXNaWspXms(int idKwX) { + // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) + // przesuniecie wspolrzednych do srodka kwadratu + long xms = MapConsts.X_REF_MS + (long) ((idKwX + 0.5) * MapConsts.SS_DX_MS); + xms %= MapConsts.ANGLE_360_MS; + return xms; + } + + /** + * Funkcja zamienia wsp. Y GridCoord na wsp. geo yms w milisekundach. + * Zwracana wspolrzedna lezy w srodku kwadratu. + */ + public static long zamienIdKwadratuYNaWspYms(int idKwY) { + // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) + // przesuniecie wspolrzednych do srodka kwadratu + long yms = MapConsts.Y_REF_MS + (long) ((idKwY + 0.5) * MapConsts.SS_DY_MS); + return yms; + } + + /** + * Zamienia długość geograficzną na współrzędna x GridCoord. + * + * @param lon długość geograficzna + * @return współrzędna x klasy GridCoord + */ + public static int zamienDlugoscGeoNaIdKwadratuX(double lon) { + double xms_f = (lon + 180) * MapConsts.DEG_MS; + return zamienWspXmsNaIdKwadratuX((long) xms_f); + } + + /** + * Zamienia szerokość geograficzną na współrzędna y GridCoord. + * + * @param lat szerokość geograficzna + * @return współrzędna y klasy GridCoord + */ + public static int zamienSzerokoscGeoNaIdKwadratuY(double lat) { + double yms_f = (lat + 90) * MapConsts.DEG_MS; + return zamienWspYmsNaIdKwadratuY((long) yms_f); + } + + /** + * Funkcja zamienia dlugosc geog. xms w milisekundach na IdKwadrat.x. + * + * @param xms długość geograficzna (lon) w milisekundach + * @return współrzędna GridCoord.x + */ + public static int zamienWspXmsNaIdKwadratuX(long xms) { + // wspolrzedne geograficzne w milisekundach zawieraja sie w zakresie: + // 0 <= x < 360 dlugosc geograficzna + // 0 <= y <= 180 szerokosc geograficzna + if ((xms < 0) || (xms >= 360 * MapConsts.DEG_MS)) { + // poza zakresem + return -1; + } + long x = xms; + if (x < MapConsts.X_REF_MS) { +// // poza zakresem + long dx = x + MapConsts.ANGLE_360_MS - MapConsts.X_REF_MS; + if (dx > MapConsts.DX_REF_MS) { + return -1; + } + x += MapConsts.ANGLE_360_MS; + } +// if (x > MapConsts.X_REF_MS + MapConsts.DX_REF_MS) { +// // poza zakresem +// return -1; +// } + // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) + double xx = (x - MapConsts.X_REF_MS) * ODWROT_SS_DX_MS; +// x = (x - MapConsts.X_REF_MS) / MapConsts.SS_DX_MS; + return (int) xx; + } + + /** + * Funkcja zamienia szerokosc geog. yms w milisekundach na IdKwadrat.y. + * + * @param yms szerokosc geograficzna (lat) w milisekundach + * @return współrzędna GridCoord.y + */ + public static int zamienWspYmsNaIdKwadratuY(long yms) { + // wspolrzedne geograficzne w milisekundach zawieraja sie w zakresie: + // 0 <= x < 360 dlugosc geograficzna + // 0 <= y <= 180 szerokosc geograficzna + if (yms < MapConsts.Y_REF_MS) { + // poza zakresem + return -1; + } + // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) + double yy = (yms - MapConsts.Y_REF_MS) * ODWROT_SS_DY_MS; +// long y = (yms - MapConsts.Y_REF_MS) / MapConsts.SS_DY_MS; + return (int) yy; + } + + /** + * Wyznacza wspolrzedne lewego dolnego wierzcholka oraz prawego gornego wierzcholka + * prostokata opisanego na obszarze: rejon. + * + * @param rejon + * @param min + * @param max + */ + public static void minMaxIdKwadratu(Grid[] rejon, Grid min, Grid max) { + if (rejon == null) { + return; + } + if (min == null) { + min = new Grid(rejon[0].x, rejon[0].y); + } + if (max == null) { + max = new Grid(rejon[0].x, rejon[0].y); + } + for (int i = 1; i < rejon.length; i++) { + if (min.x > rejon[i].x) { + min.x = rejon[i].x; + } + if (min.y > rejon[i].y) { + min.y = rejon[i].y; + } + if (max.x < rejon[i].x) { + max.x = rejon[i].x; + } + if (max.y < rejon[i].y) { + max.y = rejon[i].y; + } + } + } + + + private static final double ODWROT_SS_DX_MS = 1.0 / MapConsts.SS_DX_MS; + private static final double ODWROT_SS_DY_MS = 1.0 / MapConsts.SS_DY_MS; + + +} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java index 3b51144..f00c6c2 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java @@ -1,13 +1,14 @@ package pl.wat.ms4ds.terenfunkcje; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import pl.wat.ms4ds.common.EGeoDirection; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; public class GeomUtils { + private static final Logger logger = LoggerFactory.getLogger(GeomUtils.class); /** *

Wyznacznik macierzy (kwadratowej stopnia 3) @@ -23,7 +24,7 @@ public class GeomUtils { * @return det3 == 0, gdy punkt jest wpolliniowy, det3 wieksze od 0, gdy punkt lezy po lewej stronie wektora, * det3 mniejsze od 0, gdy punkt lezy po prawej stronie wektora, */ - public static long det3(GridCoord p, GridCoord q, GridCoord r) { + public static long det3(Coord.Grid p, Coord.Grid q, Coord.Grid r) { return p.x * (q.y - r.y) + q.x * (r.y - p.y) + r.x * (p.y - q.y); } @@ -56,7 +57,7 @@ public class GeomUtils { * @param r Punkt testowany * @return true, jesli punkt r lezy na odcinku */ - public static boolean include(GridCoord p, GridCoord q, GridCoord r) { + public static boolean include(Coord.Grid p, Coord.Grid q, Coord.Grid r) { return det3(p, q, r) == 0 && Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) && @@ -91,7 +92,7 @@ public class GeomUtils { * @param r Punkt testowany * @return true, jeśli punkt r należy do odcinka p-q */ - public static boolean includeHorizontaly(GridCoord p, GridCoord q, GridCoord r) { + public static boolean includeHorizontaly(Coord.Grid p, Coord.Grid q, Coord.Grid r) { return p.y == r.y && Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x); @@ -146,7 +147,7 @@ public class GeomUtils { * @param s punkt końcowy drugiego odcinka * @return true, jeśli odcinki przecinają się wewnętrznie */ - public static boolean cross(GridCoord p, GridCoord q, GridCoord r, GridCoord s) { + public static boolean cross(Coord.Grid p, Coord.Grid q, Coord.Grid r, Coord.Grid s) { long det3_pqr = det3(p, q, r); long det3_pqs = det3(p, q, s); long det3_rsp = det3(r, s, p); @@ -209,7 +210,7 @@ public class GeomUtils { * @param s punkt końcowy drugiego odcinka * @return true, jeśli odcinki mają część wspólną */ - public static boolean intersection(GridCoord p, GridCoord q, GridCoord r, GridCoord s) { + public static boolean intersection(Coord.Grid p, Coord.Grid q, Coord.Grid r, Coord.Grid s) { long det3_pqr = det3(p, q, r); long det3_pqs = det3(p, q, s); long det3_rsp = det3(r, s, p); @@ -233,7 +234,7 @@ public class GeomUtils { * @param p Testowany punkt. * @return true, jeśli testowany punkt leży wewnątrz wielokąta */ - public static boolean insidePolygon(GridCoord[] polygon, GridCoord p) { + public static boolean insidePolygon(Coord.Grid[] polygon, Coord.Grid p) { // sprawdzenie czy punkt p należy do jednego z boków wielokąta for (int i = 0; i < polygon.length; i++) { int i_plus_1 = (i + 1) % polygon.length; @@ -244,7 +245,7 @@ public class GeomUtils { // punkty p i p1 wyznaczają półprostą równoległą do osi OX // współrzędna X punktu p1 musi być większa od największej // współrzędnej X wśród wszystkich wierzchołków wielokąta - GridCoord p1 = new GridCoord(p.x + 1, p.y); + Coord.Grid p1 = new Coord.Grid(p.x + 1, p.y); for (int i = 0; i < polygon.length; i++) { p1.x = Math.max(polygon[i].x, p1.x); } @@ -300,7 +301,7 @@ public class GeomUtils { * @param py Wsp. y testowanego punktu. * @return true, jeśli testowany punkt leży wewnątrz wielokąta */ - public static boolean insidePolygon(GridCoord[] polygon, int px, int py) { + public static boolean insidePolygon(Coord.Grid[] polygon, int px, int py) { // sprawdzenie czy punkt p nie należy do jednego z boków wielokąta for (int i = 0; i < polygon.length; i++) { int i_plus_1 = (i + 1) % polygon.length; @@ -311,7 +312,7 @@ public class GeomUtils { // punkty p i p1 wyznaczają półprostą równoległą do osi OX // współrzędna X punktu p1 musi być większa od największej // współrzędnej X wśród wszystkich wierzchołków wielokąta - GridCoord p1 = new GridCoord(px + 1, py); + Coord.Grid p1 = new Coord.Grid(px + 1, py); for (int i = 0; i < polygon.length; i++) { p1.x = Math.max(polygon[i].x, p1.x); } @@ -382,7 +383,7 @@ public class GeomUtils { * @param stop kwadrat końcowy wektora * @return kierunek geograficzny klasy EGeoDirection */ - public static EGeoDirection kierunek(GridCoord start, GridCoord stop) { + public static EGeoDirection kierunek(Coord.Grid start, Coord.Grid stop) { if (start.x == stop.x && start.y == stop.y) { return EGeoDirection.UNDEFINED; } @@ -444,7 +445,7 @@ public class GeomUtils { * @return kierunek geograficzny klasy EGeoDirection dla wektora zadanego przez kwadrat początkowy * i końcowy lub UNDEFINED dla kwadratów niesąsiednich */ - public static EGeoDirection kierunekDlaSasiada(GridCoord start, GridCoord stop) { + public static EGeoDirection kierunekDlaSasiada(Coord.Grid start, Coord.Grid stop) { int d = Math.abs(start.x - stop.x) + Math.abs(start.y - stop.y); if (d == 1 || d == 2) { if (start.x == stop.x) { @@ -541,103 +542,34 @@ public class GeomUtils { /** * Funkcja wyznacza sumaryczną długość drogi podanej jako ciąg sąsiednich kwadratów * - * @param kwadraty droga jako ciąg sąsiednich kwadratów + * @param road droga jako ciąg sąsiednich kwadratów * @return sumaryczna długość drogi [m] */ - public static float dlugoscDrogiPoKwadratch(GridCoord[] kwadraty) { + public static float dlugoscDrogiPoKwadratch(Coord.Grid[] road) { float dl = 0; - for (int i = 1; i < kwadraty.length; i++) { - dl += GridCoord.odleglosc(kwadraty[i - 1], kwadraty[i]); + for (int i = 1; i < road.length; i++) { + dl += Coord.Grid.distance(road[i - 1], road[i]); } return dl; } - /** - * Funkcja wyznacza sumaryczną długość drogi podanej jako ciąg sąsiednich kwadratów - * - * @param kwadraty droga jako ciąg sąsiednich kwadratów - * @return sumaryczna długość drogi [m] - */ - public static float dlugoscDrogiPoKwadratch(ArrayList kwadraty) { - float dl = 0; - for (int i = 1; i < kwadraty.size(); i++) { - dl += GridCoord.odleglosc(kwadraty.get(i - 1), kwadraty.get(i)); - } - return dl; - } - - // funkcja zwraca kwadrat znajdujacy sie na kierunku - // od kwadratu "kp" do kwadratu "kk" - // w odleglosci "LKwadrat" liczby kwadratow - // LKWadrat nie moze byc wieksze niz odleglosc miedzy kp i kk - public static GridCoord kwadratNaKierunkuWOdleglosci(GridCoord kp, - GridCoord kk, int LKwadrat) { - GridCoord id = null; - GridCoord[] tab = null; - - tab = kwadratyOdcinka(kp.x, kp.y, kk.x, kk.y); - if ((tab != null) && (tab.length > 0)) { - id = new GridCoord(); - if ((LKwadrat < tab.length) && LKwadrat >= 0) { - id.x = tab[LKwadrat].x; - id.y = tab[LKwadrat].y; - } else { - id.x = tab[tab.length - 1].x; - id.y = tab[tab.length - 1].y; - } - } - return id; - } - - /** - * Transformuje wspolrzedne koncow odcinka do odcinka zaczepionego w punkcie (0,0). - * - * @param pocz - * @param kon - * @param kon_nowy - */ - public static void transformOdcinekDo0X0Y(GridCoord pocz, GridCoord kon, - GridCoord kon_nowy) { - if ((pocz == null) || (kon == null)) { - return; - } - if (kon_nowy == null) { - kon_nowy = new GridCoord(); - } - kon_nowy.x = kon.x - pocz.x; - kon_nowy.y = kon.y - pocz.y; - } - - // transformuje wspolrzedne kwadratow na odcinku: kwadraty - // przesuniecie o wektor o wspolrzednych wsp0X0Y - public static void transformKwadratyZ0X0Y(GridCoord wsp0X0Y, - GridCoord[] kwadraty) { - if ((kwadraty == null) || (wsp0X0Y == null)) { - return; - } - for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i].x += wsp0X0Y.x; - kwadraty[i].y += wsp0X0Y.y; - } - } - /** * Funkcja wyznacza tablicę kwadratów leżących na łamanej. * * @param punktyLamanej tablica wspolrzednych tworzących łamaną * @return kwadratyWyj kolekcja kwadratów leżących na łamanej */ - public static ArrayList kwadratyLamanej(GridCoord[] punktyLamanej) { - ArrayList kwadratyWyj = new ArrayList(); + public static ArrayList kwadratyLamanej(Coord.Grid[] punktyLamanej) { + ArrayList kwadratyWyj = new ArrayList(); if (punktyLamanej.length == 2) { - GridCoord[] kwadraty = kwadratyOdcinka(punktyLamanej[0], punktyLamanej[1]); + Coord.Grid[] kwadraty = kwadratyOdcinka(punktyLamanej[0], punktyLamanej[1]); for (int i = 0; i < kwadraty.length; i++) { kwadratyWyj.add(kwadraty[i]); } return kwadratyWyj; } for (int i = 0; i < punktyLamanej.length - 1; i++) { - GridCoord[] kwadraty = kwadratyOdcinka(punktyLamanej[i], punktyLamanej[i + 1]); + Coord.Grid[] kwadraty = kwadratyOdcinka(punktyLamanej[i], punktyLamanej[i + 1]); int lko; if (i < punktyLamanej.length - 2) { // odcinek lamanej nie jest ostatni, zatem bez ostatniego kwadratu odcinka, @@ -659,8 +591,8 @@ public class GeomUtils { * @param punktyLamanej tablica wspolrzednych odcinków tworzących łamaną * @return tablica (ciąg) sąsiednich kwadratów leżących na łamanej */ - public static GridCoord[] kwadratyLamanej2(GridCoord[] punktyLamanej) { - GridCoord[] kwadratyWyj; + public static Coord.Grid[] kwadratyLamanej2(Coord.Grid[] punktyLamanej) { + Coord.Grid[] kwadratyWyj; if (punktyLamanej.length == 2) { kwadratyWyj = kwadratyOdcinka(punktyLamanej[0], punktyLamanej[1]); return kwadratyWyj; @@ -669,10 +601,10 @@ public class GeomUtils { for (int i = 0; i < punktyLamanej.length - 1; i++) { maxLen += Math.abs(punktyLamanej[i].x - punktyLamanej[i + 1].x) + Math.abs(punktyLamanej[i].y - punktyLamanej[i + 1].y) + 1; } - GridCoord[] helpTab = new GridCoord[maxLen]; + Coord.Grid[] helpTab = new Coord.Grid[maxLen]; int lastLen = 0; for (int i = 0; i < punktyLamanej.length - 1; i++) { - GridCoord[] kwadraty = kwadratyOdcinka(punktyLamanej[i], punktyLamanej[i + 1]); + Coord.Grid[] kwadraty = kwadratyOdcinka(punktyLamanej[i], punktyLamanej[i + 1]); // liczba kwadratów bieżącego odcinka do zapamietania int lko; if (i < punktyLamanej.length - 2) { @@ -689,7 +621,7 @@ public class GeomUtils { // lastLen++; // } } - kwadratyWyj = new GridCoord[lastLen]; + kwadratyWyj = new Coord.Grid[lastLen]; System.arraycopy(helpTab, 0, kwadratyWyj, 0, lastLen); // for (int i = 0; i < lastLen; i++) { // kwadratyWyj[i] = helpTab[i]; @@ -704,7 +636,7 @@ public class GeomUtils { * @param kon wspolrzedna konca odcinka * @return tablica sąsiednich kwadratow lezacych na odcinku */ - public static GridCoord[] kwadratyOdcinka(GridCoord pocz, GridCoord kon) { + public static Coord.Grid[] kwadratyOdcinka(Coord.Grid pocz, Coord.Grid kon) { return kwadratyOdcinka(pocz.x, pocz.y, kon.x, kon.y); } @@ -717,12 +649,12 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica sąsiednich kwadratow lezacych na odcinku */ - public static GridCoord[] kwadratyOdcinka(int xp, int yp, int xk, int yk) { - GridCoord[] kwadraty; + public static Coord.Grid[] kwadratyOdcinka(int xp, int yp, int xk, int yk) { + Coord.Grid[] kwadraty; if ((xp == xk) && (yp == yk)) { // odcinek skladajacy sie z jednego kwadratu - kwadraty = new GridCoord[1]; - kwadraty[0] = new GridCoord(xp, yp); + kwadraty = new Coord.Grid[1]; + kwadraty[0] = new Coord.Grid(xp, yp); return kwadraty; } if (xp == xk) { @@ -757,17 +689,17 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica kwadratow lezacych na odcinku */ - private static GridCoord[] kwadratyOdcinkaPionowego(int xp, int yp, int xk, int yk) { - GridCoord[] kwadraty = new GridCoord[Math.abs(yp - yk) + 1]; + private static Coord.Grid[] kwadratyOdcinkaPionowego(int xp, int yp, int xk, int yk) { + Coord.Grid[] kwadraty = new Coord.Grid[Math.abs(yp - yk) + 1]; if (yp < yk) { // zorientowanie wektora do gory for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp, yp + i); + kwadraty[i] = new Coord.Grid(xp, yp + i); } } else { // zorientowanie wektora do dolu for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp, yp - i); + kwadraty[i] = new Coord.Grid(xp, yp - i); } } return kwadraty; @@ -783,17 +715,17 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica kwadratow lezacych na odcinku */ - private static GridCoord[] kwadratyOdcinkaPoziomego(int xp, int yp, int xk, int yk) { - GridCoord[] kwadraty = new GridCoord[Math.abs(xp - xk) + 1]; + private static Coord.Grid[] kwadratyOdcinkaPoziomego(int xp, int yp, int xk, int yk) { + Coord.Grid[] kwadraty = new Coord.Grid[Math.abs(xp - xk) + 1]; if (xp < xk) { // zorientowanie wektora w prawo for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp + i, yp); + kwadraty[i] = new Coord.Grid(xp + i, yp); } } else { // zorientowanie wektora w lewo for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp - i, yp); + kwadraty[i] = new Coord.Grid(xp - i, yp); } } return kwadraty; @@ -809,12 +741,12 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica kwadratow lezacych na odcinku */ - private static GridCoord[] kwadratyOdcinkaDowolnego(int xp, int yp, int xk, int yk) { + private static Coord.Grid[] kwadratyOdcinkaDowolnego(int xp, int yp, int xk, int yk) { int x = xp; int y = yp; int dx = xk - xp; int dy = yk - yp; - GridCoord[] tab; + Coord.Grid[] tab; int abs_dx = Math.abs(dx); int abs_dy = Math.abs(dy); if (abs_dx > abs_dy) { @@ -822,9 +754,9 @@ public class GeomUtils { // wyznaczenie wspolczynnikow prostej zawierającej odcinek na podstawie środków kwadratów double a = (double) dy / (double) dx; double b = yp + 0.5 - a * (xp + 0.5); - tab = new GridCoord[abs_dx + 1]; + tab = new Coord.Grid[abs_dx + 1]; int i = 0; - tab[i] = new GridCoord(x, y); + tab[i] = new Coord.Grid(x, y); if (dx > 0) { // idziemy w prawo w kierunku rosnacych wartosci x if (dy > 0) { @@ -840,7 +772,7 @@ public class GeomUtils { y++; } i++; - tab[i] = new GridCoord(x, y); + tab[i] = new Coord.Grid(x, y); } } else { // prosta zawierająca odcinek jest funkcją malejącą @@ -855,7 +787,7 @@ public class GeomUtils { y--; } i++; - tab[i] = new GridCoord(x, y); + tab[i] = new Coord.Grid(x, y); } } } else { @@ -873,7 +805,7 @@ public class GeomUtils { y++; } i++; - tab[i] = new GridCoord(x, y); + tab[i] = new Coord.Grid(x, y); } } else { // prosta zaierająca odcinek jest funkcją rosnącą @@ -888,7 +820,7 @@ public class GeomUtils { y--; } i++; - tab[i] = new GridCoord(x, y); + tab[i] = new Coord.Grid(x, y); } } } @@ -916,7 +848,7 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica kwadratow lezacych na odcinku */ - private static GridCoord[] kwadratyOdcinkaDowolnego2(int xp, int yp, int xk, int yk) { + private static Coord.Grid[] kwadratyOdcinkaDowolnego2(int xp, int yp, int xk, int yk) { int dx = xk - xp; int dy = yk - yp; if (Math.abs(dx) > Math.abs(dy)) { @@ -934,9 +866,9 @@ public class GeomUtils { if (dx > 0) { // idziemy w prawo w kierunku rosnacych wartosci x - GridCoord[] temp = new GridCoord[Math.abs(dx) + Math.abs(dy) + 1]; + Coord.Grid[] temp = new Coord.Grid[Math.abs(dx) + Math.abs(dy) + 1]; int dl = 0; - temp[dl] = new GridCoord(); + temp[dl] = new Coord.Grid(); temp[dl].x = xp; temp[dl].y = yp; dl++; @@ -953,22 +885,22 @@ public class GeomUtils { yg = (int) ygf; y1 = yd / MapConsts.DL_MK + 1; y2 = yg / MapConsts.DL_MK + 1; - temp[dl] = new GridCoord(); + temp[dl] = new Coord.Grid(); temp[dl].x = x; temp[dl].y = y1; dl++; if (y1 != y2) { - temp[dl] = new GridCoord(); + temp[dl] = new Coord.Grid(); temp[dl].x = x; temp[dl].y = y2; dl++; } } - temp[dl] = new GridCoord(); + temp[dl] = new Coord.Grid(); temp[dl].x = xk; temp[dl].y = yk; dl++; - GridCoord[] kwadraty = new GridCoord[dl]; + Coord.Grid[] kwadraty = new Coord.Grid[dl]; System.arraycopy(temp, 0, kwadraty, 0, dl); // for (int i = 0; i < kwadraty.length; i++) { // // przepisanie referencji na wspolrzedne kwadratow @@ -978,8 +910,8 @@ public class GeomUtils { } else { // idziemy w lewo w kierunku malejacych wartosci x // zamiana koncow odcinka - GridCoord[] temp = kwadratyOdcinkaDowolnego2(xk, yk, xp, yp); - GridCoord[] kwadraty = new GridCoord[temp.length]; + Coord.Grid[] temp = kwadratyOdcinkaDowolnego2(xk, yk, xp, yp); + Coord.Grid[] kwadraty = new Coord.Grid[temp.length]; for (int i = 0; i < kwadraty.length; i++) { kwadraty[i] = temp[kwadraty.length - 1 - i]; } @@ -988,7 +920,7 @@ public class GeomUtils { } else { // przypadek, gdy poruszamy sie po osi OY // zamiana wspolrzednych koncow odcinka - GridCoord[] kwadraty = kwadratyOdcinkaDowolnego2(yp, xp, yk, xk); + Coord.Grid[] kwadraty = kwadratyOdcinkaDowolnego2(yp, xp, yk, xk); // przepisanie wspolrzednych do nowej tablicy // z zamiana wspolrzednych for (int i = 0; i < kwadraty.length; i++) { @@ -1010,29 +942,29 @@ public class GeomUtils { * @param yk wspolrzedna y konca * @return tablica kwadratow lezacych na odcinku */ - private static GridCoord[] kwadratyOdcinkaNaPrzekatnej(int xp, int yp, int xk, int yk) { + private static Coord.Grid[] kwadratyOdcinkaNaPrzekatnej(int xp, int yp, int xk, int yk) { int dx = xk - xp; int dy = yk - yp; - GridCoord[] kwadraty = new GridCoord[Math.abs(dx) + 1]; + Coord.Grid[] kwadraty = new Coord.Grid[Math.abs(dx) + 1]; if ((dx > 0) && (dy > 0)) { // wektor typu "/" do gory for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp + i, yp + i); + kwadraty[i] = new Coord.Grid(xp + i, yp + i); } } else if ((dx > 0) && (dy < 0)) { // wektor typu "\" do dolu for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp + i, yp - i); + kwadraty[i] = new Coord.Grid(xp + i, yp - i); } } else if ((dx < 0) && (dy < 0)) { // wektor typu "/" do dolu for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp - i, yp - i); + kwadraty[i] = new Coord.Grid(xp - i, yp - i); } } else { // wektor typu "\" do gory for (int i = 0; i < kwadraty.length; i++) { - kwadraty[i] = new GridCoord(xp - i, yp + i); + kwadraty[i] = new Coord.Grid(xp - i, yp + i); } } return kwadraty; @@ -1044,11 +976,11 @@ public class GeomUtils { * @param rejon * @return ograniczenie dolne wspolrzednych rejonu */ - public static GridCoord wspXYOgranDolne(GridCoord[] rejon) { + public static Coord.Grid wspXYOgranDolne(Coord.Grid[] rejon) { if (rejon == null) { return null; } - GridCoord kw_min = new GridCoord(); + Coord.Grid kw_min = new Coord.Grid(); kw_min.x = rejon[0].x; kw_min.y = rejon[0].y; for (int i = 1; i < rejon.length; i++) { @@ -1068,11 +1000,11 @@ public class GeomUtils { * @param rejon * @return ograniczenie górne wspolrzednych rejonu */ - public static GridCoord wspXYOgranGorne(GridCoord[] rejon) { + public static Coord.Grid wspXYOgranGorne(Coord.Grid[] rejon) { if (rejon == null) { return null; } - GridCoord kw_max = new GridCoord(); + Coord.Grid kw_max = new Coord.Grid(); kw_max.x = rejon[0].x; kw_max.y = rejon[0].y; for (int i = 1; i < rejon.length; i++) { @@ -1113,17 +1045,17 @@ public class GeomUtils { * @param rejon tablica wierzchołków obszaru * @return poprawioną tablicę wierzchołków obszaru */ - public static GridCoord[] poprawRejon(GridCoord[] rejon) { + public static Coord.Grid[] poprawRejon(Coord.Grid[] rejon) { if ((rejon == null) || (rejon.length <= 0)) { return null; } int j = 0; - GridCoord[] rejon_temp = new GridCoord[rejon.length]; + Coord.Grid[] rejon_temp = new Coord.Grid[rejon.length]; rejon_temp[j] = rejon[j]; for (int i = j + 1; i < rejon.length; i++) { - if (!GridCoord.czyIdentyczne(rejon[i], rejon_temp[j])) { + if (!rejon[i].equals(rejon_temp[j])) { if (i == rejon.length - 1) { - if (GridCoord.czyIdentyczne(rejon[i], rejon_temp[0])) { + if (rejon[i].equals(rejon_temp[0])) { break; } } @@ -1131,10 +1063,10 @@ public class GeomUtils { rejon_temp[j] = rejon[i]; } } - if ((j > 0) && (GridCoord.czyIdentyczne(rejon_temp[0], rejon_temp[j]))) { + if ((j > 0) && (rejon_temp[0].equals(rejon_temp[j]))) { j--; } - GridCoord[] rejon_popr = new GridCoord[j + 1]; + Coord.Grid[] rejon_popr = new Coord.Grid[j + 1]; System.arraycopy(rejon_temp, 0, rejon_popr, 0, rejon_popr.length); // for (int k = 0; k < rejonPopr.length; k++) { // rejonPopr[k] = rejon_temp[k]; @@ -1148,23 +1080,23 @@ public class GeomUtils { * @param rej kolejne wierzchołki obszaru zadawane prawoskretnie * @return tablica kwadratów należących do zadanego obszaru */ - public static GridCoord[] kwadratyObszaru(GridCoord[] rej) { + public static Coord.Grid[] kwadratyObszaru(Coord.Grid[] rej) { if (rej == null) { return null; } - GridCoord[] kwadraty = null; - GridCoord[] rejon = poprawRejon(rej); + Coord.Grid[] kwadraty = null; + Coord.Grid[] rejon = poprawRejon(rej); if (rejon.length == 1) { //TODO Tu raczej jest blad - kwadraty = new GridCoord[1]; + kwadraty = new Coord.Grid[1]; return kwadraty; } if (rejon.length == 2) { return kwadratyOdcinka(rejon[0].x, rejon[0].y, rejon[1].x, rejon[1].y); } - GridCoord kw_min = wspXYOgranDolne(rejon); - GridCoord kw_max = wspXYOgranGorne(rejon); + Coord.Grid kw_min = wspXYOgranDolne(rejon); + Coord.Grid kw_max = wspXYOgranGorne(rejon); int dl = (kw_max.x - kw_min.x + 1) * (kw_max.y - kw_min.y + 1); - GridCoord[] kwadraty_temp = new GridCoord[dl]; + Coord.Grid[] kwadraty_temp = new Coord.Grid[dl]; // sprawdzenie kazdego kwadratu z duzego obszaru // (prostokat opisany na rejonie) dl = 0; @@ -1173,15 +1105,15 @@ public class GeomUtils { if (insidePolygon(rejon, x, y)) { // if (nalezyDoObszaru(rejon, i, j)) { // kwadrat o indeksach (i,j) nalezy do obszaru - kwadraty_temp[dl] = new GridCoord(x, y); + kwadraty_temp[dl] = new Coord.Grid(x, y); dl++; } } } - kwadraty = new GridCoord[dl]; + kwadraty = new Coord.Grid[dl]; System.arraycopy(kwadraty_temp, 0, kwadraty, 0, dl); // for (int i = 0; i < kwadraty.length; i++) { -// kwadraty[i] = new GridCoord(); +// kwadraty[i] = new Coord.GridCoord(); // kwadraty[i].x = kwadraty_temp[i].x; // kwadraty[i].y = kwadraty_temp[i].y; // } @@ -1194,11 +1126,11 @@ public class GeomUtils { * @param odc odcinek wejściowy * @return współrzędne środka zadanego odcinka */ - public static GridCoord srodekOdcinka(GridCoord[] odc) { - GridCoord srodek = null; + public static Coord.Grid srodekOdcinka(Coord.Grid[] odc) { + Coord.Grid srodek = null; int xsr = 0, ysr = 0; if ((odc != null) && (odc.length > 0)) { - srodek = new GridCoord(); + srodek = new Coord.Grid(); for (int j = 0; j < odc.length; j++) { xsr = xsr + odc[j].x; ysr = ysr + odc[j].y; @@ -1216,15 +1148,15 @@ public class GeomUtils { * @param kon koniec wejsciowego odcinka * @return współrzędne środka zadanego odcinka */ - public static GridCoord srodekOdcinka(GridCoord pocz, GridCoord kon) { - GridCoord srodek = null; + public static Coord.Grid srodekOdcinka(Coord.Grid pocz, Coord.Grid kon) { + Coord.Grid srodek = null; int xsr = 0, ysr = 0; if ((pocz == null) || (kon == null)) { return srodek; } xsr = (pocz.x + kon.x) / 2; ysr = (pocz.y + kon.y) / 2; - srodek = new GridCoord(xsr, ysr); + srodek = new Coord.Grid(xsr, ysr); return srodek; } @@ -1236,9 +1168,9 @@ public class GeomUtils { * @param waga waga współrzędnych początku odcinka * @return ważone współrzędne środka zadanego odcinka */ - public static GridCoord srodekOdcinkaWazony(GridCoord pocz, - GridCoord kon, float waga) { - GridCoord srodek = null; + public static Coord.Grid srodekOdcinkaWazony(Coord.Grid pocz, + Coord.Grid kon, float waga) { + Coord.Grid srodek = null; if ((waga < 0.0f) || (waga > 1.0f)) { return srodek; } @@ -1250,7 +1182,7 @@ public class GeomUtils { float f_ysr = pocz.y * waga + kon.y * (1.0f - waga); xsr = (int) f_xsr; ysr = (int) f_ysr; - srodek = new GridCoord(xsr, ysr); + srodek = new Coord.Grid(xsr, ysr); return srodek; } @@ -1261,19 +1193,19 @@ public class GeomUtils { * @param pocz punkt od którego liczona pozostała długość drogi * @return pozostała długość odcinka od punktu pocz [m] */ - public static float wyznaczPozostalaDlugoscDrogi(ArrayList droga, int pocz) { + public static float wyznaczPozostalaDlugoscDrogi(ArrayList droga, int pocz) { if ((droga == null) || (droga.size() == 0) || (pocz < 0) || (pocz >= droga.size())) { return 0.0f; } - float dl = 0.0f; - GridCoord idkw1 = droga.get(pocz); - GridCoord idkw2; + double dl = 0.0f; + Coord.Grid idkw1 = droga.get(pocz); + Coord.Grid idkw2; for (int j = pocz + 1; j < droga.size() - 1; j++) { idkw2 = droga.get(j); - dl += GridCoord.odleglosc(idkw1.x, idkw1.y, idkw2.x, idkw2.y); + dl += Coord.Grid.distance(idkw1.x, idkw1.y, idkw2.x, idkw2.y); idkw1 = idkw2; } - return dl; + return (float) dl; } /** @@ -1283,7 +1215,7 @@ public class GeomUtils { * @param p2 współrzędna malego kwadratu konc. * @return Odległość między środkami małych kwadratów [m]. */ - public static float odleglosc(GridCoord p1, GridCoord p2) { + public static float odleglosc(Coord.Grid p1, Coord.Grid p2) { // odleglosc miedzy srodkami malych kwadratow if (null == p1 || null == p2) { return -1.0f; @@ -1333,38 +1265,37 @@ public class GeomUtils { // ===================================================================== public static void main(String[] args) { - float odl = GridCoord.odleglosc(1, 1, 2, 2); - float odl2 = GridCoord.odlegloscApprox(1, 1, 2, 2); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); - odl = GridCoord.odleglosc(1, 1, 21, 21); - odl2 = GridCoord.odlegloscApprox(1, 1, 21, 21); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); - odl = GridCoord.odleglosc(1, 1, 1, 21); - odl2 = GridCoord.odlegloscApprox(1, 1, 1, 21); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); - odl = GridCoord.odleglosc(1, 1, 10, 21); - odl2 = GridCoord.odlegloscApprox(1, 1, 10, 21); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); - odl = GridCoord.odleglosc(1, 1, 100, 210); - odl2 = GridCoord.odlegloscApprox(1, 1, 100, 210); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); - odl = GridCoord.odleglosc(1, 1, 5, 210); - odl2 = GridCoord.odlegloscApprox(1, 1, 5, 210); - System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2)); - System.out.println(", delta = " + (odl - odl2) / odl); + double odl = Coord.Grid.distance(1, 1, 2, 2); + double odl2 = Coord.Grid.distanceApprox(1, 1, 2, 2); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); + odl = Coord.Grid.distance(1, 1, 21, 21); + odl2 = Coord.Grid.distanceApprox(1, 1, 21, 21); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); - GridCoord p = new GridCoord(4, 6); - GridCoord q = new GridCoord(8, 2); - GridCoord r = new GridCoord(6, 4); - GridCoord s = new GridCoord(8, 6); + odl = Coord.Grid.distance(1, 1, 1, 21); + odl2 = Coord.Grid.distanceApprox(1, 1, 1, 21); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); - GridCoord startCoord = new GridCoord(10, 10); - GridCoord stopCoord = new GridCoord(); + odl = Coord.Grid.distance(1, 1, 10, 21); + odl2 = Coord.Grid.distanceApprox(1, 1, 10, 21); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); + + odl = Coord.Grid.distance(1, 1, 100, 210); + odl2 = Coord.Grid.distanceApprox(1, 1, 100, 210); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); + + odl = Coord.Grid.distance(1, 1, 5, 210); + odl2 = Coord.Grid.distanceApprox(1, 1, 5, 210); + logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl); + + + Coord.Grid p = new Coord.Grid(4, 6); + Coord.Grid q = new Coord.Grid(8, 2); + Coord.Grid r = new Coord.Grid(6, 4); + Coord.Grid s = new Coord.Grid(8, 6); + + Coord.Grid startCoord = new Coord.Grid(10, 10); + Coord.Grid stopCoord = new Coord.Grid(); for (int y = 20; y >= 0; y--) { for (int x = 0; x <= 20; x++) { stopCoord.set(x, y); @@ -1403,84 +1334,84 @@ public class GeomUtils { } System.out.println(); - EGeoDirection kier = kierunek(new GridCoord(10, 10), new GridCoord(10, 15)); + EGeoDirection kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(10, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(10, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(10, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 10)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 10)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 10)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 10)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(9, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(9, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(11, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(11, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(9, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(9, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(11, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(11, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 9)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 9)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 11)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 11)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 9)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 9)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 11)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 11)); System.out.println(kier); // Kierunki pośrednie: PLN-WSC, PLD-WSC, PLN-ZAC, PLD-ZAC - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 5)); System.out.println(kier); // PLN-WSC - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 16)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 16)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 14)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 14)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(16, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(16, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(14, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(14, 15)); System.out.println(kier); // PLD-WSC - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 6)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 6)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(15, 4)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(15, 4)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(16, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(16, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(14, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(14, 5)); System.out.println(kier); //PLN-ZAC - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 16)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 16)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 14)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 14)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(6, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(6, 15)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(4, 15)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(4, 15)); System.out.println(kier); // PLD-ZAC - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 6)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 6)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(5, 4)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(5, 4)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(6, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(6, 5)); System.out.println(kier); - kier = kierunek(new GridCoord(10, 10), new GridCoord(4, 5)); + kier = kierunek(new Coord.Grid(10, 10), new Coord.Grid(4, 5)); System.out.println(kier); boolean przeciecie = intersection(p, q, r, s); @@ -1504,8 +1435,8 @@ public class GeomUtils { przeciecie = intersection(p, q, r, s); - GridCoord[] lamana = {new GridCoord(8, 8), new GridCoord(3, 4), new GridCoord(6, 11)}; - GridCoord[] tab = kwadratyLamanej2(lamana); + Coord.Grid[] lamana = {new Coord.Grid(8, 8), new Coord.Grid(3, 4), new Coord.Grid(6, 11)}; + Coord.Grid[] tab = kwadratyLamanej2(lamana); long det = det3(1, 0, 4, 0, 2, 2); @@ -1518,28 +1449,28 @@ public class GeomUtils { det = det3(1, 1, 4, 4, 3, 4); -// GridCoord[] polygon = new GridCoord[21]; -// polygon[0] = new GridCoord(12, 18); -// polygon[1] = new GridCoord(16, 18); -// polygon[2] = new GridCoord(18, 13); -// polygon[3] = new GridCoord(21, 13); -// polygon[4] = new GridCoord(22, 9); -// polygon[5] = new GridCoord(20, 7); -// polygon[6] = new GridCoord(17, 7); -// polygon[7] = new GridCoord(15, 9); -// polygon[8] = new GridCoord(13, 7); -// polygon[9] = new GridCoord(15, 5); -// polygon[10] = new GridCoord(17, 5); -// polygon[11] = new GridCoord(14, 2); -// polygon[12] = new GridCoord(8, 8); -// polygon[13] = new GridCoord(9, 3); -// polygon[14] = new GridCoord(6, 4); -// polygon[15] = new GridCoord(3, 4); -// polygon[16] = new GridCoord(2, 10); -// polygon[17] = new GridCoord(6, 11); -// polygon[18] = new GridCoord(6, 13); -// polygon[19] = new GridCoord(7, 15); -// polygon[20] = new GridCoord(10, 13); +// Coord.GridCoord[] polygon = new Coord.GridCoord[21]; +// polygon[0] = new Coord.GridCoord(12, 18); +// polygon[1] = new Coord.GridCoord(16, 18); +// polygon[2] = new Coord.GridCoord(18, 13); +// polygon[3] = new Coord.GridCoord(21, 13); +// polygon[4] = new Coord.GridCoord(22, 9); +// polygon[5] = new Coord.GridCoord(20, 7); +// polygon[6] = new Coord.GridCoord(17, 7); +// polygon[7] = new Coord.GridCoord(15, 9); +// polygon[8] = new Coord.GridCoord(13, 7); +// polygon[9] = new Coord.GridCoord(15, 5); +// polygon[10] = new Coord.GridCoord(17, 5); +// polygon[11] = new Coord.GridCoord(14, 2); +// polygon[12] = new Coord.GridCoord(8, 8); +// polygon[13] = new Coord.GridCoord(9, 3); +// polygon[14] = new Coord.GridCoord(6, 4); +// polygon[15] = new Coord.GridCoord(3, 4); +// polygon[16] = new Coord.GridCoord(2, 10); +// polygon[17] = new Coord.GridCoord(6, 11); +// polygon[18] = new Coord.GridCoord(6, 13); +// polygon[19] = new Coord.GridCoord(7, 15); +// polygon[20] = new Coord.GridCoord(10, 13); // // // // przesunięcie wielokata o wektor @@ -1547,7 +1478,7 @@ public class GeomUtils { // polygon[k].x += 1000; // polygon[k].y += 1000; // } -// GridCoord p = new GridCoord(); +// Coord.GridCoord p = new Coord.GridCoord(); // for (int j = 20; j >= 0; j--) { // for (int i = 0; i < 25; i++) { // p.x = i + 1000; @@ -1583,13 +1514,13 @@ public class GeomUtils { // odl = odleglosc(10, 1, 2, 20); // odl = odleglosc(1, 1, 2, 2); // -// GridCoord[] rejon = new GridCoord[4]; -// rejon[0] = new GridCoord(20, 18); -// rejon[1] = new GridCoord(27, 9); -// rejon[2] = new GridCoord(9, 1); -// rejon[3] = new GridCoord(2, 15); +// Coord.GridCoord[] rejon = new Coord.GridCoord[4]; +// rejon[0] = new Coord.GridCoord(20, 18); +// rejon[1] = new Coord.GridCoord(27, 9); +// rejon[2] = new Coord.GridCoord(9, 1); +// rejon[3] = new Coord.GridCoord(2, 15); // -// ArrayList kwadraty = kwadratyLamanej(rejon); +// ArrayList< Coord.GridCoord> kwadraty = kwadratyLamanej(rejon); // System.out.println(kwadraty); @@ -1604,20 +1535,20 @@ public class GeomUtils { /* * int xp = 50000; int yp = 8000; int xk = 20; int yk = 1; */ -// GridCoord[] rejon = new GridCoord[4]; -// rejon[0] = new GridCoord(); +// Coord.GridCoord[] rejon = new Coord.GridCoord[4]; +// rejon[0] = new Coord.GridCoord(); // rejon[0].x = 20; // rejon[0].y = 18; -// rejon[1] = new GridCoord(); +// rejon[1] = new Coord.GridCoord(); // rejon[1].x = 27; // rejon[1].y = 9; -// rejon[2] = new GridCoord(); +// rejon[2] = new Coord.GridCoord(); // rejon[2].x = 9; // rejon[2].y = 1; -// rejon[3] = new GridCoord(); +// rejon[3] = new Coord.GridCoord(); // rejon[3].x = 2; // rejon[3].y = 15; -// GridCoord[] kwadraty = kwadratyObszaru(rejon); +// Coord.GridCoord[] kwadraty = kwadratyObszaru(rejon); /* * WspXY[] kwadraty = kwadratyOdcinka(xp, yp, xk, yk); diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/GridCoord.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/GridCoord.java deleted file mode 100644 index f4b6f6f..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/GridCoord.java +++ /dev/null @@ -1,689 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje; - -//import pl.wat.wcy.exception.IdKwadratuException; - - -import pl.wat.ms4ds.common.EGeoDirection; - -public class GridCoord { - - public int x; - public int y; - - /** - * Konstruktor klasy na bazie współrzędnych geograficznych. - * - * @param lon długość geograficzna - * @param lat szerokość geograficzna - */ - public GridCoord(double lon, double lat) { - double xms_f = (lon + 180) * MapConsts.DEG_MS; - long xms = (long) xms_f; - x = zamienWspXmsNaIdKwadratuX(xms); - - double yms_f = (lat + 90) * MapConsts.DEG_MS; - long yms = (long) yms_f; - y = zamienWspYmsNaIdKwadratuY(yms); - } - - /** - * Funkcja zamienia dlugosc geog. xms w milisekundach na IdKwadrat.x. - * - * @param xms długość geograficzna (lon) w milisekundach - * @return współrzędna GridCoord.x - */ - public static int zamienWspXmsNaIdKwadratuX(long xms) { - // wspolrzedne geograficzne w milisekundach zawieraja sie w zakresie: - // 0 <= x < 360 dlugosc geograficzna - // 0 <= y <= 180 szerokosc geograficzna - if ((xms < 0) || (xms >= 360 * MapConsts.DEG_MS)) { - // poza zakresem - return -1; - } - long x = xms; - if (x < MapConsts.X_REF_MS) { -// // poza zakresem - long dx = x + MapConsts.ANGLE_360_MS - MapConsts.X_REF_MS; - if (dx > MapConsts.DX_REF_MS) { - return -1; - } - x += MapConsts.ANGLE_360_MS; - } -// if (x > MapConsts.X_REF_MS + MapConsts.DX_REF_MS) { -// // poza zakresem -// return -1; -// } - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - double xx = (x - MapConsts.X_REF_MS) * ODWROT_SS_DX_MS; -// x = (x - MapConsts.X_REF_MS) / MapConsts.SS_DX_MS; - return (int) xx; - } - - /** - * Funkcja zamienia szerokosc geog. yms w milisekundach na IdKwadrat.y. - * - * @param yms szerokosc geograficzna (lat) w milisekundach - * @return współrzędna GridCoord.y - */ - public static int zamienWspYmsNaIdKwadratuY(long yms) { - // wspolrzedne geograficzne w milisekundach zawieraja sie w zakresie: - // 0 <= x < 360 dlugosc geograficzna - // 0 <= y <= 180 szerokosc geograficzna -// if ((yms < MapConsts.Y_REF_MS) || (yms > MapConsts.Y_REF_MS + MapConsts.DY_REF_MS)) { -// // poza zakresem -// return -1; -// } - if (yms < MapConsts.Y_REF_MS) { - // poza zakresem - return -1; - } - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - double yy = (yms - MapConsts.Y_REF_MS) * ODWROT_SS_DY_MS; -// long y = (yms - MapConsts.Y_REF_MS) / MapConsts.SS_DY_MS; - return (int) yy; - } - - /** - * Zamienia długość geograficzną na współrzędna x GridCoord. - * - * @param lon długość geograficzna - * @return współrzędna x klasy GridCoord - */ - public static int zamienDlugoscGeoNaIdKwadratuX(double lon) { - double xms_f = (lon + 180) * MapConsts.DEG_MS; - return zamienWspXmsNaIdKwadratuX((long) xms_f); - } - - /** - * Zamienia szerokość geograficzną na współrzędna y GridCoord. - * - * @param lat szerokość geograficzna - * @return współrzędna y klasy GridCoord - */ - public static int zamienSzerokoscGeoNaIdKwadratuY(double lat) { - double yms_f = (lat + 90) * MapConsts.DEG_MS; - return zamienWspYmsNaIdKwadratuY((long) yms_f); - } - - public GridCoord kwadratSasiedni(EGeoDirection kier) { - GridCoord idKwSasiedni = new GridCoord(); - switch (kier) { - case NORTH: - idKwSasiedni.x = x; - idKwSasiedni.y = y + 1; - break; - case NORTHEAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y + 1; - break; - case EAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y; - break; - case SOUTHEAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y - 1; - break; - case SOUTH: - idKwSasiedni.x = x; - idKwSasiedni.y = y - 1; - break; - case SOUTHWEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y - 1; - break; - case WEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y; - break; - case NORTHWEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y + 1; - break; - default: - } - return idKwSasiedni; - } - - public void kwadratSasiedni(GridCoord idKwSasiedni, EGeoDirection kier) { - switch (kier) { - case NORTH: - idKwSasiedni.x = x; - idKwSasiedni.y = y + 1; - break; - case NORTHEAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y + 1; - break; - case EAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y; - break; - case SOUTHEAST: - idKwSasiedni.x = x + 1; - idKwSasiedni.y = y - 1; - break; - case SOUTH: - idKwSasiedni.x = x; - idKwSasiedni.y = y - 1; - break; - case SOUTHWEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y - 1; - break; - case WEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y; - break; - case NORTHWEST: - idKwSasiedni.x = x - 1; - idKwSasiedni.y = y + 1; - break; - default: - } - } - - public GridCoord[] dajSasiadow() { - GridCoord[] sasiedzi = new GridCoord[8]; - sasiedzi[0] = new GridCoord(x, y + 1); - sasiedzi[1] = new GridCoord(x + 1, y + 1); - sasiedzi[2] = new GridCoord(x + 1, y); - sasiedzi[3] = new GridCoord(x + 1, y - 1); - sasiedzi[4] = new GridCoord(x, y - 1); - sasiedzi[5] = new GridCoord(x - 1, y - 1); - sasiedzi[6] = new GridCoord(x - 1, y); - sasiedzi[7] = new GridCoord(x - 1, y + 1); - return sasiedzi; - } - - public static GridCoord[] dajSasiadow(int x, int y) { - GridCoord[] sasiedzi = new GridCoord[8]; - sasiedzi[0] = new GridCoord(x, y + 1); - sasiedzi[1] = new GridCoord(x + 1, y + 1); - sasiedzi[2] = new GridCoord(x + 1, y); - sasiedzi[3] = new GridCoord(x + 1, y - 1); - sasiedzi[4] = new GridCoord(x, y - 1); - sasiedzi[5] = new GridCoord(x - 1, y - 1); - sasiedzi[6] = new GridCoord(x - 1, y); - sasiedzi[7] = new GridCoord(x - 1, y + 1); - return sasiedzi; - } - - public static GridCoord[] dajSasiadow(GridCoord centralny) { - GridCoord[] sasiedzi = new GridCoord[8]; - sasiedzi[0] = new GridCoord(centralny.x, centralny.y + 1); - sasiedzi[1] = new GridCoord(centralny.x + 1, centralny.y + 1); - sasiedzi[2] = new GridCoord(centralny.x + 1, centralny.y); - sasiedzi[3] = new GridCoord(centralny.x + 1, centralny.y - 1); - sasiedzi[4] = new GridCoord(centralny.x, centralny.y - 1); - sasiedzi[5] = new GridCoord(centralny.x - 1, centralny.y - 1); - sasiedzi[6] = new GridCoord(centralny.x - 1, centralny.y); - sasiedzi[7] = new GridCoord(centralny.x - 1, centralny.y + 1); - return sasiedzi; - } - - public GridCoord[] dajOtoczenie() { - GridCoord[] sasiedzi = new GridCoord[9]; - sasiedzi[0] = new GridCoord(x, y); - sasiedzi[1] = new GridCoord(x, y + 1); - sasiedzi[2] = new GridCoord(x + 1, y + 1); - sasiedzi[3] = new GridCoord(x + 1, y); - sasiedzi[4] = new GridCoord(x + 1, y - 1); - sasiedzi[5] = new GridCoord(x, y - 1); - sasiedzi[6] = new GridCoord(x - 1, y - 1); - sasiedzi[7] = new GridCoord(x - 1, y); - sasiedzi[8] = new GridCoord(x - 1, y + 1); - return sasiedzi; - } - - public static GridCoord[] dajOtoczenie(int x, int y) { - GridCoord[] sasiedzi = new GridCoord[9]; - sasiedzi[0] = new GridCoord(x, y); - sasiedzi[1] = new GridCoord(x, y + 1); - sasiedzi[2] = new GridCoord(x + 1, y + 1); - sasiedzi[3] = new GridCoord(x + 1, y); - sasiedzi[4] = new GridCoord(x + 1, y - 1); - sasiedzi[5] = new GridCoord(x, y - 1); - sasiedzi[6] = new GridCoord(x - 1, y - 1); - sasiedzi[7] = new GridCoord(x - 1, y); - sasiedzi[8] = new GridCoord(x - 1, y + 1); - return sasiedzi; - } - - public static GridCoord[] dajOtoczenie(GridCoord centralny) { - GridCoord[] sasiedzi = new GridCoord[8]; - sasiedzi[0] = new GridCoord(centralny.x, centralny.y); - sasiedzi[1] = new GridCoord(centralny.x, centralny.y + 1); - sasiedzi[2] = new GridCoord(centralny.x + 1, centralny.y + 1); - sasiedzi[3] = new GridCoord(centralny.x + 1, centralny.y); - sasiedzi[4] = new GridCoord(centralny.x + 1, centralny.y - 1); - sasiedzi[5] = new GridCoord(centralny.x, centralny.y - 1); - sasiedzi[6] = new GridCoord(centralny.x - 1, centralny.y - 1); - sasiedzi[7] = new GridCoord(centralny.x - 1, centralny.y); - sasiedzi[8] = new GridCoord(centralny.x - 1, centralny.y + 1); - return sasiedzi; - } - - public boolean rowne(int x, int y) { - return this.x == x && this.y == y; - } - - public String toString() { - StringBuilder sb = new StringBuilder("(x= "); - sb.append(x); - sb.append(", y= "); - sb.append(y); - sb.append(')'); -// String s = "(x= " + Integer.toString(x) + ", y= " + Integer.toString(y) + ")"; - return sb.toString(); - } - - /** - * Zamienia współrzęną GridCoord.x na długość geograficzną środka małego kwadratu - * - * @param idX współrzęna x GridCoord - * @return długość geograficzna - */ - public static float zamienIdKwadratuXNaDlugoscGeo(int idX) { - long xms = zamienIdKwadratuXNaWspXms(idX); - double lon = (double) xms / (double) MapConsts.DEG_MS - 180; - return (float) lon; - } - - /** - * Zamienia współrzęną GridCoord.y na szerokość geograficzną środka małego kwadratu - * - * @param idY współrzęna y GridCoord - * @return szerokość geograficzna - */ - public static float zamienIdKwadratuYNaSzerokoscGeo(int idY) { - long yms = zamienIdKwadratuYNaWspYms(idY); - double lat = (double) yms / (double) MapConsts.DEG_MS - 90; - return (float) lat; - } - - /** - * Zamienia współrzęną GridCoord.x na długość geograficzną lewego dolnego rogu małego kwadratu - * - * @param idX współrzęna x GridCoord - * @return długość geograficzna - */ - public static float zamienIdKwadratuXNaDlugoscGeoLD(int idX) { - long xms = zamienIdKwadratuXNaWspXmsLD(idX); - double lon = (double) xms / (double) MapConsts.DEG_MS - 180; - return (float) lon; - } - - /** - * Zamienia współrzęną GridCoord.y na szerokość geograficzną środka małego kwadratu - * - * @param idY współrzęna y GridCoord - * @return szerokość geograficzna - */ - public static float zamienIdKwadratuYNaSzerokoscGeoLD(int idY) { - long yms = zamienIdKwadratuYNaWspYmsLD(idY); - double lat = (double) yms / (double) MapConsts.DEG_MS - 90; - return (float) lat; - } - - public static int zamienWspUtmNaIdkwadratuX(String wspolrzedneUtm) { - // ////////////////////////////////// - // wspolrzedne - znaki w formacie 522644N0154232E - // wyznaczenie numeru kwadraty Au2 dla wspolrzednej X - // np.: '153200' to 304 - - int xms = Teren.zamienWspSMSNaWspXms(wspolrzedneUtm); - int idKwX = GridCoord.zamienWspXmsNaIdKwadratuX(xms); - return idKwX; - } - - public static int zamienWspUtmNaIdkwadratuY(String wspolrzedneUtm) { - // ////////////////////////////////// - // wspolrzedne - znaki w formacie 522644N0154232E - // wyznaczenie numeru kwadraty Au2 dla wspolrzednej Y - // np.: '153200' to 304 - int yms = Teren.zamienWspSMSNaWspYms(wspolrzedneUtm); - int idKwY = GridCoord.zamienWspYmsNaIdKwadratuY(yms); - return idKwY; - } - - public GridCoord(String wspolrzedne) { - this.x = zamienWspUtmNaIdkwadratuX(wspolrzedne); - this.y = zamienWspUtmNaIdkwadratuY(wspolrzedne); - } - - public static GridCoord zamienWspUtmNaIdKwadratu(String wspolrzedne) { - // Utworzenie obiektu GridCoord ze wspolrzednych UTM - GridCoord kwadrat = new GridCoord(wspolrzedne); - return kwadrat; - } - - public static String zamienIdKwadratuNaWspUtm(GridCoord kwadrat) { - long xms = zamienIdKwadratuXNaWspXms(kwadrat.x); - long yms = zamienIdKwadratuYNaWspYms(kwadrat.y); - return Teren.zamienWspXmsYmsNaWspSMS(xms, yms); - } - - /** - * Funkcja zamienia wsp. X GridCoord na wsp. geo xms w milisekundach. - * Zwracana wspolrzedna lezy w srodku kwadratu. - */ - public static long zamienIdKwadratuXNaWspXms(int idKwX) { - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - // przesuniecie wspolrzednych do srodka kwadratu - long xms = MapConsts.X_REF_MS + (long) ((idKwX + 0.5) * MapConsts.SS_DX_MS); - xms %= MapConsts.ANGLE_360_MS; - return xms; - } - - /** - * Funkcja zamienia wsp. Y GridCoord na wsp. geo yms w milisekundach. - * Zwracana wspolrzedna lezy w srodku kwadratu. - */ - public static long zamienIdKwadratuYNaWspYms(int idKwY) { - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - // przesuniecie wspolrzednych do srodka kwadratu - long yms = MapConsts.Y_REF_MS + (long) ((idKwY + 0.5) * MapConsts.SS_DY_MS); - return yms; - } - - /** - * Funkcja zamienia wsp. X GridCoord na wsp. geo xms w milisekundach lewego dolnego rogu malego kwadratu. - * Zwracana wspolrzedna lezy w srodku kwadratu. - */ - public static long zamienIdKwadratuXNaWspXmsLD(int idKwX) { - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - // przesuniecie wspolrzednych do srodka kwadratu - long xms = MapConsts.X_REF_MS + (long) (idKwX * MapConsts.SS_DX_MS); - xms %= MapConsts.ANGLE_360_MS; - return xms; - } - - /** - * Funkcja zamienia wsp. Y GridCoord na wsp. geo yms w milisekundach lewego dolnego rogu malego kwadratu. - * Zwracana wspolrzedna lezy w srodku kwadratu. - */ - public static long zamienIdKwadratuYNaWspYmsLD(int idKwY) { - // indeksowanie kwadratow pola walki zaczyna sie od (0, 0) - // przesuniecie wspolrzednych do srodka kwadratu - long yms = MapConsts.Y_REF_MS + (long) (idKwY * MapConsts.SS_DY_MS); - return yms; - } - - private static final double ODWROT_SS_DX_MS = 1.0 / MapConsts.SS_DX_MS; - private static final double ODWROT_SS_DY_MS = 1.0 / MapConsts.SS_DY_MS; - - /** - * Funkcja sprawdza, czy kwadraty sa takie same. - * - * @param id1 - * @param id2 - * @return - */ - public static boolean czyIdentyczne(GridCoord id1, GridCoord id2) { - if (null == id1 || null == id2) { - return false; - } - if (id1.x != id2.x || id1.y != id2.y) { - return false; - } else - return true; - } - - /** - * Funkcja zwraca odleglosc miedzy srodkami malych kwadratow [m]. - * - * @param p1 współrzędna malego kwadratu pocz. - * @param p2 współrzędna malego kwadratu konc. - * @return Odległość między środkami małych kwadratów [m]. - */ - public static float odleglosc(GridCoord p1, GridCoord p2) { - // odleglosc miedzy srodkami malych kwadratow - if (null == p1 || null == p2) { - return -1.0f; - } - int xx = p1.x - p2.x; - xx *= xx; - int yy = p1.y - p2.y; - yy *= yy; - float odl = (float) Math.sqrt(xx + yy); - odl *= MapConsts.DL_MK; - return odl; - } - - /** - * Funkcja zwraca odległość między środkami małych kwadratów [m]. - * - * @param x1 Wsp X id malego kwadratu pocz. - * @param y1 Wsp Y id malego kwadratu pocz. - * @param x2 Wsp X id malego kwadratu konc. - * @param y2 Wsp Y id malego kwadratu konc. - * @return Odległość miedzy srodkami malych kwadratow [m]. - */ - public static float odleglosc(int x1, int y1, int x2, int y2) { - // odleglosc miedzy srodkami malych kwadratow - int xx = x1 - x2; - xx *= xx; - int yy = y1 - y2; - yy *= yy; - float odl = (float) Math.sqrt(xx + yy); - odl *= MapConsts.DL_MK; - return odl; - } - - /** - * Funkcja zwraca odległość między środkami małych kwadratów [m]. - * - * @param dx odległość w kwadratach na osi OX. - * @param dy odległość w kwadratach na osi OY. - * @return Odległość miedzy srodkami malych kwadratow [m]. - */ - public static float odleglosc(int dx, int dy) { - float odl = (float) Math.sqrt(dx * dx + dy * dy); - odl *= MapConsts.DL_MK; - return odl; - } - - private static final float DL_MK2 = MapConsts.DL_MK * 0.0009765625f; - /** - * Funkcja zwraca aproksymowaną odległość między środkami małych kwadratów [m]. - * - * @param x1 Wsp X id malego kwadratu pocz. - * @param y1 Wsp Y id malego kwadratu pocz. - * @param x2 Wsp X id malego kwadratu konc. - * @param y2 Wsp Y id malego kwadratu konc. - * @return Odległość miedzy srodkami malych kwadratow [m]. - */ - public static float odlegloscApprox(int x1, int y1, int x2, int y2) { - int dx = x2 - x1; - int dy = y2 - y1; - int min, max, approx; - if (dx < 0) dx = -dx; - if (dy < 0) dy = -dy; - if (dx < dy) { - min = dx; - max = dy; - } else { - min = dy; - max = dx; - } - approx = (max * 1007) + (min * 441); - if (max < (min << 4)) { - approx -= (max * 40); - } - float odl = approx * DL_MK2; - return odl; - } - - public static int iloczynSkalarny(GridCoord p1, GridCoord p2) { - int wynik; - wynik = p1.x * p2.x + p1.y * p2.y; - return wynik; - } - - // funkcja sprawdza, czy dwa obszary skierowane maja czesc wspolna - public static boolean majaCzescWspolna(GridCoord[] rejon1, GridCoord[] rejon2) { - if ((rejon1 == null) || (rejon2 == null)) { - return false; - } - for (int i = 0; i < rejon2.length; i++) { - if (GeomUtils.insidePolygon(rejon1, rejon2[i].x, rejon2[i].y)) { - return true; - } - } - for (int i = 0; i < rejon1.length; i++) { - if (GeomUtils.insidePolygon(rejon2, rejon1[i].x, rejon1[i].y)) { - return true; - } - } - return false; - } - - // wyznacza stosunek czesci wspolnej obszarow do obszaru bazowego - public static float stosunekCzesciWspolnej(GridCoord[] rejon_bazowy, GridCoord[] rejon2) { - if ((rejon_bazowy == null) || (rejon2 == null)) { - return 0.0f; - } - boolean majaCzescWspolna = majaCzescWspolna(rejon_bazowy, rejon2); - if (!majaCzescWspolna) { - return 0.0f; - } - GridCoord[] kwadraty1 = GeomUtils.kwadratyObszaru(rejon_bazowy); - GridCoord[] kwadraty2 = GeomUtils.kwadratyObszaru(rejon2); - int maxWspolnych = 0; - if (kwadraty1.length <= kwadraty2.length) { - maxWspolnych = kwadraty1.length; - } else { - maxWspolnych = kwadraty2.length; - } - if ((kwadraty1 == null) || (kwadraty2 == null)) { - return 0.0f; - } - int wspolnych = 0; - for (int i = 0; i < kwadraty1.length; i++) { - for (int j = 0; j < kwadraty2.length; j++) { - if (czyIdentyczne(kwadraty1[i], kwadraty2[j])) { - wspolnych++; - } - } - } - return ((float) wspolnych) / ((float) (maxWspolnych)); - } - - // wyznacza wspolrzedne lewego dolnego wierzcholka oraz - // prawego gornego wierzcholka prostokata opisanego na obszarze: rejon - public static void minMaxIdKwadratu(GridCoord[] rejon, GridCoord min, GridCoord max) { - if (rejon == null) { - return; - } - if (min == null) { - min = new GridCoord(rejon[0].x, rejon[0].y); - } - if (max == null) { - max = new GridCoord(rejon[0].x, rejon[0].y); - } - for (int i = 1; i < rejon.length; i++) { - if (min.x > rejon[i].x) { - min.x = rejon[i].x; - } - if (min.y > rejon[i].y) { - min.y = rejon[i].y; - } - if (max.x < rejon[i].x) { - max.x = rejon[i].x; - } - if (max.y < rejon[i].y) { - max.y = rejon[i].y; - } - } - } - - public void update(double lon, double lat) { - double xms_f = (lon + 180) * MapConsts.DEG_MS; - long xms = (long) xms_f; - x = zamienWspXmsNaIdKwadratuX(xms); - - double yms_f = (lat + 90) * MapConsts.DEG_MS; - long yms = (long) yms_f; - y = zamienWspYmsNaIdKwadratuY(yms); - } - - public GridCoord() { - x = -1; - y = -1; - } - - public GridCoord(int x, int y) { -/* try { - if (x < 0 || y < 0) - throw new IdKwadratuException(); - } - catch (IdKwadratuException e) { - System.out.print(e.opis); - } -*/ - this.x = x; - this.y = y; - } - - public GridCoord(GridCoord oryginal) { - this.x = oryginal.x; - this.y = oryginal.y; - } - - public int getX() { - return x; - } - - public void setX(int x) { - this.x = x; - } - - public int getY() { - return y; - } - - public void setY(int y) { - this.y = y; - } - - public void set(GridCoord oryginal) { - x = oryginal.x; - y = oryginal.y; - } - - public void set(int x, int y) { - this.x = x; - this.y = y; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = prime + x; - result = prime * result + y; - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (!(obj instanceof GridCoord)) { - return false; - } - GridCoord other = (GridCoord) obj; - if (x != other.x) { - return false; - } - if (y != other.y) { - return false; - } - return true; - } - -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/LukDrogowy.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/LukDrogowy.java deleted file mode 100644 index bf3d98d..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/LukDrogowy.java +++ /dev/null @@ -1,113 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje; - -import java.util.StringTokenizer; - -public class LukDrogowy { - - private WezelDrogowy[] wezly = new WezelDrogowy[2]; - int id = -1; - int dlugosc = 0; - int szerokosc = 0; - int rodzajNawierzchni = 0; - boolean jestMostem = false; - - LukDrogowy() {} - - LukDrogowy(String opis) { - if (null == opis || opis.length() == 0){ - SiecDrogowa.logger.debug("Pusty ciag opis w konstruktorze Luku Drogowego."); - return; - } - StringTokenizer st = new StringTokenizer(opis, " \t"); - String[] tokenTable = new String[st.countTokens()]; - for (int i = 0; st.hasMoreTokens(); i++) { - tokenTable[i] = st.nextToken(); - } - if (tokenTable.length == 6) { - try { - int id = Integer.parseInt(tokenTable[0]); - WezelDrogowy wezel = SiecDrogowa.instancja.wezly.get(id); - if (null == wezel) - SiecDrogowa.logger.warn("Brak wierzcholka (1) poczatkowego luku. [" + opis + "]."); - this.getWezly()[0] = wezel; - wezel.luki.add(this); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [Wezel 1]."); - } - try { - int id = Integer.parseInt(tokenTable[1]); - WezelDrogowy wezel = SiecDrogowa.instancja.wezly.get(id); - if (null == wezel) - SiecDrogowa.logger.warn("Brak wierzcholka (2) koncowego luku. [" + opis + "]."); - this.getWezly()[1] = wezel; - wezel.luki.add(this); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [Wezel 2]."); - } - if (this.wezly[0].id == this.wezly[1].id) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [wezly sa identyczne]."); - } - if (GridCoord.czyIdentyczne(this.wezly[0].idKw, this.wezly[1].idKw)) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [wezly sa identyczne]."); - } - try { - this.dlugosc = Integer.parseInt(tokenTable[2]); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [Dlugosc]."); - } - try { - this.szerokosc = Integer.parseInt(tokenTable[3]); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [Szerokosc]."); - } - try { - this.rodzajNawierzchni = Integer.parseInt(tokenTable[4]); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [RodzajNawierzchni]."); - } - try { - int b = Integer.parseInt(tokenTable[5]); - this.jestMostem = (b != 0); - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z lukami [CzyJestMost]."); - } - } - } - - public int getDlugosc() { - return dlugosc; - } - - public void setDlugosc(int dlugosc) { - this.dlugosc = dlugosc; - } - - public int getSzerokosc() { - return szerokosc; - } - - public void setSzerokosc(int szerokosc) { - this.szerokosc = szerokosc; - } - - public int getRodzajNawierzchni() { - return rodzajNawierzchni; - } - - public void setRodzajNawierzchni(int rodzajNawierzchni) { - this.rodzajNawierzchni = rodzajNawierzchni; - } - - public boolean isJestMostem() { - return jestMostem; - } - - public void setJestMostem(boolean jestMostem) { - this.jestMostem = jestMostem; - } - - public WezelDrogowy[] getWezly() { - return wezly; - } - -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java index 5132936..805276c 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java @@ -9,10 +9,10 @@ public class RightBigSquare extends BigSquare implements Serializable { private static final Logger logger = LoggerFactory.getLogger(RightBigSquare.class); - private Square kwadraty[][]; + private Square squares[][]; Square getKwadrat(int ssX, int ssY) { - return kwadraty[ssX][ssY]; + return squares[ssX][ssY]; } /** @@ -46,34 +46,34 @@ public class RightBigSquare extends BigSquare implements Serializable { ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(sb.toString())); for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) { for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) { - float f = kwadraty[x][y].stopienZalesienia * 100.0f; + float f = squares[x][y].stopienZalesienia * 100.0f; int hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; out.writeByte(hex); - f = kwadraty[x][y].stopienZawodnienia * 100.0f; + f = squares[x][y].stopienZawodnienia * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; out.writeByte(hex); - f = kwadraty[x][y].stopienZabudowy * 100.0f; + f = squares[x][y].stopienZabudowy * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; out.writeByte(hex); - f = kwadraty[x][y].stopienZabagnienia * 100.0f; + f = squares[x][y].stopienZabagnienia * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; out.writeByte(hex); - out.writeInt(kwadraty[x][y].wysokoscSrednia); - out.writeInt(kwadraty[x][y].roznicaWzniesien); + out.writeInt(squares[x][y].wysokoscSrednia); + out.writeInt(squares[x][y].roznicaWzniesien); hex = 0; int bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestDroga.length; i++) { + for (int i = 0; i < squares[x][y].jestDroga.length; i++) { // jest odcinek drogi na tym kierunku - if (kwadraty[x][y].jestDroga[i]) { + if (squares[x][y].jestDroga[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -82,9 +82,9 @@ public class RightBigSquare extends BigSquare implements Serializable { hex = 0; bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestPrzeszkodaWodna.length; i++) { + for (int i = 0; i < squares[x][y].jestPrzeszkodaWodna.length; i++) { // jest odcinek przeszkody wodnej na tym kierunku - if (kwadraty[x][y].jestPrzeszkodaWodna[i]) { + if (squares[x][y].jestPrzeszkodaWodna[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -93,9 +93,9 @@ public class RightBigSquare extends BigSquare implements Serializable { hex = 0; bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestRow.length; i++) { + for (int i = 0; i < squares[x][y].jestRow.length; i++) { // jest odcinek rowu na tym kierunku - if (kwadraty[x][y].jestRow[i]) { + if (squares[x][y].jestRow[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -180,126 +180,126 @@ public class RightBigSquare extends BigSquare implements Serializable { } ss_all[x][y] = ss; // jest odcinek drogi na tym kierunku - if (kwadraty[x][y].jestDroga[NORTH]) { + if (squares[x][y].jestDroga[NORTH]) { ss[2][2].majorRoads |= NORTH_CODE; ss[2][3].majorRoads |= NORTH_CODE | SOUTH_CODE; ss[2][4].majorRoads |= NORTH_CODE | SOUTH_CODE; } - if (kwadraty[x][y].jestDroga[NORTH_EAST]) { + if (squares[x][y].jestDroga[NORTH_EAST]) { ss[2][2].majorRoads |= NORTH_EAST_CODE; ss[3][3].majorRoads |= NORTH_EAST_CODE | SOUTH_WEST_CODE; ss[4][4].majorRoads |= NORTH_EAST_CODE | SOUTH_WEST_CODE; } - if (kwadraty[x][y].jestDroga[EAST]) { + if (squares[x][y].jestDroga[EAST]) { ss[2][2].majorRoads |= EAST_CODE; ss[3][2].majorRoads |= EAST_CODE | WEST_CODE; ss[4][2].majorRoads |= EAST_CODE | WEST_CODE; } - if (kwadraty[x][y].jestDroga[SOUTH_EAST]) { + if (squares[x][y].jestDroga[SOUTH_EAST]) { ss[2][2].majorRoads |= SOUTH_EAST_CODE; ss[3][1].majorRoads |= SOUTH_EAST_CODE | NORTH_WEST_CODE; ss[4][0].majorRoads |= SOUTH_EAST_CODE | NORTH_WEST_CODE; } - if (kwadraty[x][y].jestDroga[SOUTH]) { + if (squares[x][y].jestDroga[SOUTH]) { ss[2][2].majorRoads |= SOUTH_CODE; ss[2][1].majorRoads |= SOUTH_CODE | NORTH_CODE; ss[2][0].majorRoads |= SOUTH_CODE | NORTH_CODE; } - if (kwadraty[x][y].jestDroga[SOUTH_WEST]) { + if (squares[x][y].jestDroga[SOUTH_WEST]) { ss[2][2].majorRoads |= SOUTH_WEST_CODE; ss[1][1].majorRoads |= SOUTH_WEST_CODE | NORTH_EAST_CODE; ss[0][0].majorRoads |= SOUTH_WEST_CODE | NORTH_EAST_CODE; } - if (kwadraty[x][y].jestDroga[WEST]) { + if (squares[x][y].jestDroga[WEST]) { ss[2][2].majorRoads |= WEST_CODE; ss[1][2].majorRoads |= WEST_CODE | EAST_CODE; ss[0][2].majorRoads |= WEST_CODE | EAST_CODE; } - if (kwadraty[x][y].jestDroga[NORTH_WEST]) { + if (squares[x][y].jestDroga[NORTH_WEST]) { ss[2][2].majorRoads |= NORTH_WEST_CODE; ss[1][3].majorRoads |= NORTH_WEST_CODE | SOUTH_EAST_CODE; ss[0][4].majorRoads |= NORTH_WEST_CODE | SOUTH_EAST_CODE; } // jest odcinek rzeki na tym kierunku - if (kwadraty[x][y].jestPrzeszkodaWodna[NORTH]) { + if (squares[x][y].jestPrzeszkodaWodna[NORTH]) { ss[2][2].rivers |= NORTH_CODE; ss[2][3].rivers |= NORTH_CODE | SOUTH_CODE; ss[2][4].rivers |= NORTH_CODE | SOUTH_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[NORTH_EAST]) { + if (squares[x][y].jestPrzeszkodaWodna[NORTH_EAST]) { ss[2][2].rivers |= NORTH_EAST_CODE; ss[3][3].rivers |= NORTH_EAST_CODE | SOUTH_WEST_CODE; ss[4][4].rivers |= NORTH_EAST_CODE | SOUTH_WEST_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[EAST]) { + if (squares[x][y].jestPrzeszkodaWodna[EAST]) { ss[2][2].rivers |= EAST_CODE; ss[3][2].rivers |= EAST_CODE | WEST_CODE; ss[4][2].rivers |= EAST_CODE | WEST_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[SOUTH_EAST]) { + if (squares[x][y].jestPrzeszkodaWodna[SOUTH_EAST]) { ss[2][2].rivers |= SOUTH_EAST_CODE; ss[3][1].rivers |= SOUTH_EAST_CODE | NORTH_WEST_CODE; ss[4][0].rivers |= SOUTH_EAST_CODE | NORTH_WEST_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[SOUTH]) { + if (squares[x][y].jestPrzeszkodaWodna[SOUTH]) { ss[2][2].rivers |= SOUTH_CODE; ss[2][1].rivers |= SOUTH_CODE | NORTH_CODE; ss[2][0].rivers |= SOUTH_CODE | NORTH_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[SOUTH_WEST]) { + if (squares[x][y].jestPrzeszkodaWodna[SOUTH_WEST]) { ss[2][2].rivers |= SOUTH_WEST_CODE; ss[1][1].rivers |= SOUTH_WEST_CODE | NORTH_EAST_CODE; ss[0][0].rivers |= SOUTH_WEST_CODE | NORTH_EAST_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[WEST]) { + if (squares[x][y].jestPrzeszkodaWodna[WEST]) { ss[2][2].rivers |= WEST_CODE; ss[1][2].rivers |= WEST_CODE | EAST_CODE; ss[0][2].rivers |= WEST_CODE | EAST_CODE; } - if (kwadraty[x][y].jestPrzeszkodaWodna[NORTH_WEST]) { + if (squares[x][y].jestPrzeszkodaWodna[NORTH_WEST]) { ss[2][2].rivers |= NORTH_WEST_CODE; ss[1][3].rivers |= NORTH_WEST_CODE | SOUTH_EAST_CODE; ss[0][4].rivers |= NORTH_WEST_CODE | SOUTH_EAST_CODE; } // jest odcinek rowu na tym kierunku - if (kwadraty[x][y].jestRow[NORTH]) { + if (squares[x][y].jestRow[NORTH]) { ss[2][2].drains |= NORTH_CODE; ss[2][3].drains |= NORTH_CODE | SOUTH_CODE; ss[2][4].drains |= NORTH_CODE | SOUTH_CODE; } - if (kwadraty[x][y].jestRow[NORTH_EAST]) { + if (squares[x][y].jestRow[NORTH_EAST]) { ss[2][2].drains |= NORTH_EAST_CODE; ss[3][3].drains |= NORTH_EAST_CODE | SOUTH_WEST_CODE; ss[4][4].drains |= NORTH_EAST_CODE | SOUTH_WEST_CODE; } - if (kwadraty[x][y].jestRow[EAST]) { + if (squares[x][y].jestRow[EAST]) { ss[2][2].drains |= EAST_CODE; ss[3][2].drains |= EAST_CODE | WEST_CODE; ss[4][2].drains |= EAST_CODE | WEST_CODE; } - if (kwadraty[x][y].jestRow[SOUTH_EAST]) { + if (squares[x][y].jestRow[SOUTH_EAST]) { ss[2][2].drains |= SOUTH_EAST_CODE; ss[3][1].drains |= SOUTH_EAST_CODE | NORTH_WEST_CODE; ss[4][0].drains |= SOUTH_EAST_CODE | NORTH_WEST_CODE; } - if (kwadraty[x][y].jestRow[SOUTH]) { + if (squares[x][y].jestRow[SOUTH]) { ss[2][2].drains |= SOUTH_CODE; ss[2][1].drains |= SOUTH_CODE | NORTH_CODE; ss[2][0].drains |= SOUTH_CODE | NORTH_CODE; } - if (kwadraty[x][y].jestRow[SOUTH_WEST]) { + if (squares[x][y].jestRow[SOUTH_WEST]) { ss[2][2].drains |= SOUTH_WEST_CODE; ss[1][1].drains |= SOUTH_WEST_CODE | NORTH_EAST_CODE; ss[0][0].drains |= SOUTH_WEST_CODE | NORTH_EAST_CODE; } - if (kwadraty[x][y].jestRow[WEST]) { + if (squares[x][y].jestRow[WEST]) { ss[2][2].drains |= WEST_CODE; ss[1][2].drains |= WEST_CODE | EAST_CODE; ss[0][2].drains |= WEST_CODE | EAST_CODE; } - if (kwadraty[x][y].jestRow[NORTH_WEST]) { + if (squares[x][y].jestRow[NORTH_WEST]) { ss[2][2].drains |= NORTH_WEST_CODE; ss[1][3].drains |= NORTH_WEST_CODE | SOUTH_EAST_CODE; ss[0][4].drains |= NORTH_WEST_CODE | SOUTH_EAST_CODE; @@ -308,17 +308,17 @@ public class RightBigSquare extends BigSquare implements Serializable { for (int i = 0; i < m; i++) { for (int j = 0; j < m; j++) { int hex = 0; - if (kwadraty[x][y].stopienZalesienia > 0) { + if (squares[x][y].stopienZalesienia > 0) { hex = TerrainType.FOREST.ID; - } else if (kwadraty[x][y].stopienZawodnienia > 0) { + } else if (squares[x][y].stopienZawodnienia > 0) { hex = TerrainType.WATER.ID; - } else if (kwadraty[x][y].stopienZabudowy > 0) { + } else if (squares[x][y].stopienZabudowy > 0) { hex = TerrainType.BUILDINGS.ID; - } else if (kwadraty[x][y].stopienZabagnienia > 0) { + } else if (squares[x][y].stopienZabagnienia > 0) { hex = TerrainType.SWAMP.ID; } ss[i][j].terrainType = (byte) hex; - ss[i][j].elevation = (short) kwadraty[x][y].wysokoscSrednia; + ss[i][j].elevation = (short) squares[x][y].wysokoscSrednia; } } } @@ -376,7 +376,7 @@ public class RightBigSquare extends BigSquare implements Serializable { ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(sb.toString())); for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) { for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) { - ss.elevation = (short) kwadraty[x][y].wysokoscSrednia; + ss.elevation = (short) squares[x][y].wysokoscSrednia; for (int i = 0; i < m; i++) { for (int j = 0; j < m; j++) { ss.save(out); @@ -397,13 +397,13 @@ public class RightBigSquare extends BigSquare implements Serializable { sb.append(".bin"); Square.RawData ss = new Square.RawData(); ObjectInputStream in = new ObjectInputStream(new FileInputStream(sb.toString())); - kwadraty = new Square[MapConsts.SS_PER_BS_X][MapConsts.SS_PER_BS_Y]; + squares = new Square[MapConsts.SS_PER_BS_X][MapConsts.SS_PER_BS_Y]; int x0 = idX * MapConsts.SS_PER_BS_X; int y0 = idY * MapConsts.SS_PER_BS_Y; for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) { for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) { Square kw = new Square(x0 + x, y0 + y); - kwadraty[x][y] = kw; + squares[x][y] = kw; ss.load(in); switch (ss.terrainType) { case 0: @@ -461,7 +461,7 @@ public class RightBigSquare extends BigSquare implements Serializable { in.close(); logger.debug("Doczytano plik mapy: " + sb.toString()); } catch (IOException e) { - kwadraty = null; + squares = null; throw e; } } @@ -514,7 +514,7 @@ public class RightBigSquare extends BigSquare implements Serializable { float f; int hex = 0; if (zalesienie) { - f = kwadraty[x][y].stopienZalesienia * 100.0f; + f = squares[x][y].stopienZalesienia * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; @@ -522,7 +522,7 @@ public class RightBigSquare extends BigSquare implements Serializable { out.writeByte(hex); hex = 0; if (zawodnienie) { - f = kwadraty[x][y].stopienZawodnienia * 100.0f; + f = squares[x][y].stopienZawodnienia * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; @@ -530,7 +530,7 @@ public class RightBigSquare extends BigSquare implements Serializable { out.writeByte(hex); hex = 0; if (zabudowa) { - f = kwadraty[x][y].stopienZabudowy * 100.0f; + f = squares[x][y].stopienZabudowy * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; @@ -538,19 +538,19 @@ public class RightBigSquare extends BigSquare implements Serializable { out.writeByte(hex); hex = 0; if (zabagnienie) { - f = kwadraty[x][y].stopienZabagnienia * 100.0f; + f = squares[x][y].stopienZabagnienia * 100.0f; hex = (int) f; hex = (hex > 100) ? 100 : hex; hex = (hex < 0) ? 0 : hex; } out.writeByte(hex); if (wysokosc) { - out.writeInt(kwadraty[x][y].wysokoscSrednia); + out.writeInt(squares[x][y].wysokoscSrednia); } else { out.writeInt(0); } if (roznicaWzniesien) { - out.writeInt(kwadraty[x][y].roznicaWzniesien); + out.writeInt(squares[x][y].roznicaWzniesien); } else { out.writeInt(0); } @@ -558,9 +558,9 @@ public class RightBigSquare extends BigSquare implements Serializable { hex = 0; if (drogi) { bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestDroga.length; i++) { + for (int i = 0; i < squares[x][y].jestDroga.length; i++) { // jest odcinek drogi na tym kierunku - if (kwadraty[x][y].jestDroga[i]) { + if (squares[x][y].jestDroga[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -570,9 +570,9 @@ public class RightBigSquare extends BigSquare implements Serializable { hex = 0; if (rzeki) { bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestPrzeszkodaWodna.length; i++) { + for (int i = 0; i < squares[x][y].jestPrzeszkodaWodna.length; i++) { // jest odcinek przeszkody wodnej na tym kierunku - if (kwadraty[x][y].jestPrzeszkodaWodna[i]) { + if (squares[x][y].jestPrzeszkodaWodna[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -582,9 +582,9 @@ public class RightBigSquare extends BigSquare implements Serializable { hex = 0; if (rowy) { bit_1 = 1; - for (int i = 0; i < kwadraty[x][y].jestRow.length; i++) { + for (int i = 0; i < squares[x][y].jestRow.length; i++) { // jest odcinek rowu na tym kierunku - if (kwadraty[x][y].jestRow[i]) { + if (squares[x][y].jestRow[i]) { hex |= bit_1; } bit_1 <<= 1; @@ -610,13 +610,13 @@ public class RightBigSquare extends BigSquare implements Serializable { sb.append(MapConsts.KWADRATY_DIR); sb.append(fileName); ObjectInputStream in = new ObjectInputStream(new FileInputStream(sb.toString())); - kwadraty = new Square[MapConsts.SS_PER_BS_X][MapConsts.SS_PER_BS_Y]; + squares = new Square[MapConsts.SS_PER_BS_X][MapConsts.SS_PER_BS_Y]; int x0 = idX * MapConsts.SS_PER_BS_X; int y0 = idY * MapConsts.SS_PER_BS_Y; for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) { for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) { Square kw = new Square(x0 + x, y0 + y); - kwadraty[x][y] = kw; + squares[x][y] = kw; int hex = in.readByte(); kw.stopienZalesienia = (float) hex * (1.0f / 100.f); hex = in.readByte(); @@ -659,7 +659,7 @@ public class RightBigSquare extends BigSquare implements Serializable { in.close(); logger.debug("Doczytano plik mapy: " + sb.toString()); } catch (IOException e) { - kwadraty = null; + squares = null; throw e; } } @@ -668,25 +668,25 @@ public class RightBigSquare extends BigSquare implements Serializable { boolean wysokosc, boolean roznicaWzniesien, boolean drogi, boolean rzeki, boolean rowy) { for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) { for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) { - kwadraty[x][y].stopienZalesienia = (zalesienie) ? 0 : kwadraty[x][y].stopienZalesienia; - kwadraty[x][y].stopienZawodnienia = (zawodnienie) ? 0 : kwadraty[x][y].stopienZawodnienia; - kwadraty[x][y].stopienZabudowy = (zabudowa) ? 0 : kwadraty[x][y].stopienZabudowy; - kwadraty[x][y].stopienZabagnienia = (zabagnienie) ? 0 : kwadraty[x][y].stopienZabagnienia; - kwadraty[x][y].wysokoscSrednia = (wysokosc) ? 0 : kwadraty[x][y].wysokoscSrednia; - kwadraty[x][y].roznicaWzniesien = (roznicaWzniesien) ? 0 : kwadraty[x][y].roznicaWzniesien; + squares[x][y].stopienZalesienia = (zalesienie) ? 0 : squares[x][y].stopienZalesienia; + squares[x][y].stopienZawodnienia = (zawodnienie) ? 0 : squares[x][y].stopienZawodnienia; + squares[x][y].stopienZabudowy = (zabudowa) ? 0 : squares[x][y].stopienZabudowy; + squares[x][y].stopienZabagnienia = (zabagnienie) ? 0 : squares[x][y].stopienZabagnienia; + squares[x][y].wysokoscSrednia = (wysokosc) ? 0 : squares[x][y].wysokoscSrednia; + squares[x][y].roznicaWzniesien = (roznicaWzniesien) ? 0 : squares[x][y].roznicaWzniesien; if (drogi) { - for (int i = 0; i < kwadraty[x][y].jestDroga.length; i++) { - kwadraty[x][y].jestDroga[i] = false; + for (int i = 0; i < squares[x][y].jestDroga.length; i++) { + squares[x][y].jestDroga[i] = false; } } if (rzeki) { - for (int i = 0; i < kwadraty[x][y].jestPrzeszkodaWodna.length; i++) { - kwadraty[x][y].jestPrzeszkodaWodna[i] = false; + for (int i = 0; i < squares[x][y].jestPrzeszkodaWodna.length; i++) { + squares[x][y].jestPrzeszkodaWodna[i] = false; } } if (rowy) { - for (int i = 0; i < kwadraty[x][y].jestRow.length; i++) { - kwadraty[x][y].jestRow[i] = false; + for (int i = 0; i < squares[x][y].jestRow.length; i++) { + squares[x][y].jestRow[i] = false; } } } diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/SiecDrogowa.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/SiecDrogowa.java deleted file mode 100644 index 75b9c7e..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/SiecDrogowa.java +++ /dev/null @@ -1,365 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje; - -import java.io.BufferedReader; -import java.io.BufferedWriter; -import java.io.FileReader; -import java.io.FileWriter; -import java.io.IOException; -import java.util.ArrayList; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import pl.wat.ms4ds.common.EGeoDirection; - -public class SiecDrogowa { - - static final Logger logger = LoggerFactory.getLogger(SiecDrogowa.class); - - ArrayList luki; - ArrayList wezly; - static SiecDrogowa instancja; - static String path; - - Arkusz[][] arkusze; - - public int liczbaZmian = 0; - static final int LICZBA_ZMIAN = 50; - - SiecDrogowa(String dataPath) { - instancja = this; -// File wd = new File("."); -// PATH = wd.getPath(); - path = dataPath; - this.odczytajWezly(path + "/nodes.txt"); - logger.debug("wczytano " + this.wezly.size() + " wezlow."); - this.odczytajLuki(path + "/arcs.txt"); - logger.debug("wczytano " + this.luki.size() + " lukow."); - stworzArkusze(); - - -// logger.debug("Liczba lukow w arkuszach:"); -// int ll = 0; -// for (int i = 0; i < Arkusz.lx; i++) { -// for (int j = 0; j < Arkusz.ly; j++) { -// logger.debug(String.format("(%1$2d, %2$2d) - %3$6d", i, j, this.arkusze[i][j].luki.size())); -// ll += this.arkusze[i][j].luki.size(); -// } -// } -// logger.debug("Sum. liczba lukow w arkuszach:" + ll); - } - - void odczytajWezly(String fname) { - try { - FileReader fis = new FileReader(fname); - BufferedReader br = new BufferedReader(fis); - if (br.ready()) { - String line = br.readLine().trim(); - int licz = Integer.parseInt(line); - this.wezly = new ArrayList(licz);// + 1000); - while (null != (line = br.readLine())) { - WezelDrogowy nowyWezel = new WezelDrogowy(line); - nowyWezel.id = this.wezly.size(); //Indeksowanie od 0 - this.wezly.add(nowyWezel); - } - } - br.close(); - } catch (IOException e) { - logger.warn("Brak pliku z wezlami: " + fname); - } - } - - void odczytajLuki(String fname) { - try { - FileReader fis = new FileReader(fname); - BufferedReader br = new BufferedReader(fis); - if (br.ready()) { - String line = br.readLine().trim(); - int licz = Integer.parseInt(line); - this.luki = new ArrayList(licz);// + 1000); - while (null != (line = br.readLine())) { - LukDrogowy nowyLuk = new LukDrogowy(line); - nowyLuk.id = this.luki.size(); //Indeksowanie od 0 - this.luki.add(nowyLuk); - } - } - br.close(); - } catch (IOException e) { - logger.warn("Brak pliku z lukami: " + fname); - } - } - - void stworzArkusze() { - // wyznaczenie wymiarow pola walki w malych kwadratach - Arkusz.lx = MapConsts.getDX_REF() * MapConsts.BS_PER_DEG_X * MapConsts.SS_PER_BS_X; - Arkusz.ly = MapConsts.getDY_REF() * MapConsts.BS_PER_DEG_Y * MapConsts.SS_PER_BS_Y; - // wyznacznie liczby arkuszy mapy w obu wymiarach - Arkusz.lx = Arkusz.lx / MapConsts.SS_PER_SHEET + 1; - Arkusz.ly = Arkusz.ly / MapConsts.SS_PER_SHEET + 1; - this.arkusze = new Arkusz[Arkusz.lx][Arkusz.ly]; - for (int i = 0; i < Arkusz.lx; i++) { - for (int j = 0; j < Arkusz.ly; j++) { - this.arkusze[i][j] = new Arkusz(); - } - } - // wspolrzedne arkusza mapy - int xa, ya; - for (int i = 0; i < this.wezly.size(); i++) { - WezelDrogowy wezel = this.wezly.get(i); - xa = wezel.idKw.x / MapConsts.SS_PER_SHEET; - ya = wezel.idKw.y / MapConsts.SS_PER_SHEET; - this.arkusze[xa][ya].wezly.add(wezel); - } - int xa2, ya2; - for (int i = 0; i < this.luki.size(); i++) { - LukDrogowy luk = this.luki.get(i); - xa = luk.getWezly()[0].idKw.x / MapConsts.SS_PER_SHEET; - ya = luk.getWezly()[0].idKw.y / MapConsts.SS_PER_SHEET; - xa2 = luk.getWezly()[1].idKw.x / MapConsts.SS_PER_SHEET; - ya2 = luk.getWezly()[1].idKw.y / MapConsts.SS_PER_SHEET; - boolean b = Arkusz.mniejszeWspolrzedne(xa, ya, xa2, ya2); - if (b) { - this.arkusze[xa][ya].luki.add(luk); - } else { - this.arkusze[xa2][ya2].luki.add(luk); - } - } - } - - public static void utworzSiecDrogowa() { -// if (null == instancja){ -// instancja = new SiecDrogowa(MapConsts.DROGI_DIR); -// } - } - - public static LukDrogowy dodajLuk(WezelDrogowy wezel1, WezelDrogowy wezel2) { - utworzSiecDrogowa(); - LukDrogowy nowyLuk = new LukDrogowy(); - nowyLuk.getWezly()[0] = wezel1; - wezel1.luki.add(nowyLuk); - nowyLuk.getWezly()[1] = wezel2; - wezel2.luki.add(nowyLuk); - instancja.luki.add(nowyLuk); - nowyLuk.id = instancja.luki.size() - 1; - return nowyLuk; - } - - public static WezelDrogowy dodajWezel(String wspUTM) { - utworzSiecDrogowa(); - // TODO dodac weryfikacje poprawnosci wspolrzednych UTM - WezelDrogowy nowyWezel = new WezelDrogowy(); - nowyWezel.setXms(Teren.zamienWspSMSNaWspXms(wspUTM.substring(0, 6))); - nowyWezel.setYms(Teren.zamienWspSMSNaWspXms(wspUTM.substring(8, 14))); - int x = GridCoord.zamienWspXmsNaIdKwadratuX(nowyWezel.getXms()); - int y = GridCoord.zamienWspYmsNaIdKwadratuY(nowyWezel.getYms()); - nowyWezel.idKw = new GridCoord(x, y); - nowyWezel.luki = new ArrayList(); - instancja.wezly.add(nowyWezel); - nowyWezel.id = instancja.wezly.size() - 1; - return nowyWezel; - } - - public static void usunLuk(LukDrogowy usuwanyLuk) { - utworzSiecDrogowa(); - if (usuwanyLuk.id < 0 || usuwanyLuk.id >= instancja.luki.size()) { - return; - } - int ostatniId = instancja.luki.size() - 1; - LukDrogowy lukOstatni = instancja.luki.get(ostatniId); - lukOstatni.id = usuwanyLuk.id; - instancja.luki.set(lukOstatni.id, lukOstatni); - instancja.luki.remove(ostatniId); - // aktualizacja wezlow luku - usuwanyLuk.getWezly()[0].luki.remove(usuwanyLuk); - usuwanyLuk.getWezly()[1].luki.remove(usuwanyLuk); - if (usuwanyLuk.getWezly()[0].luki.size() == 0) { - usunWezel(usuwanyLuk.getWezly()[0]); - } - if (usuwanyLuk.getWezly()[1].luki.size() == 0) { - usunWezel(usuwanyLuk.getWezly()[1]); - } - } - - public static void usunWezel(WezelDrogowy usuwanyWezel) { - utworzSiecDrogowa(); - if (usuwanyWezel.id < 0 || usuwanyWezel.id >= instancja.wezly.size()) { - return; - } - int ostatniId = instancja.wezly.size() - 1; - WezelDrogowy wezelOstatni = instancja.wezly.get(ostatniId); - wezelOstatni.id = usuwanyWezel.id; - instancja.wezly.set(wezelOstatni.id, wezelOstatni); - instancja.wezly.remove(ostatniId); - } - - public static void wpiszDrogiWKwadraty() { - utworzSiecDrogowa(); - GridCoord[] kwadratyOdcinka; - for (int i = 0; i < instancja.luki.size(); i++) { - LukDrogowy luk = instancja.luki.get(i); - GridCoord kw1 = luk.getWezly()[0].idKw; - GridCoord kw2 = luk.getWezly()[1].idKw; - kwadratyOdcinka = GeomUtils.kwadratyOdcinka(kw1, kw2); - wpiszOdcinekDrogiWKwadraty(kwadratyOdcinka); - } - Teren.zapisBuforaMapyDoPliku(); - } - - static void wpiszOdcinekDrogiWKwadraty(GridCoord[] kwadratyOdcinka) { - if (null == kwadratyOdcinka) { - return; - } - for (int i = 0; i < kwadratyOdcinka.length - 1; i++) { - GridCoord idkw1 = kwadratyOdcinka[i]; - GridCoord idkw2 = kwadratyOdcinka[i + 1]; - EGeoDirection kier = GeomUtils.kierunekDlaSasiada(idkw1, idkw2); - Square kw = Teren.getKwadrat(idkw1.x, idkw1.y); - if (null != kw) { - kw.jestDroga[kier.id] = true; - } - kw = Teren.getKwadrat(idkw2.x, idkw2.y); - if (null != kw) { - // wyznaczam kierunek przeciwny - kier = kier.oppositeDirect(); - kw.jestDroga[kier.id] = true; - } - } - } - - public void aktualizujPliki(boolean wymuszony) throws IOException { - if (wymuszony) { - if (this.liczbaZmian == 0) - // nie bylo modyfikacji od ostatniej zapisu - return; - this.liczbaZmian = -1; - } - this.liczbaZmian++; - this.liczbaZmian %= LICZBA_ZMIAN; - if (0 == this.liczbaZmian) { - try { - // zapisanie wezlow - BufferedWriter bw = new BufferedWriter(new FileWriter(path + "\\nodes.txt")); - String linia = Integer.toString(this.wezly.size()); - bw.write(linia, 0, linia.length()); - bw.newLine(); - String s; - for (int i = 0; i < this.wezly.size(); i++) { - WezelDrogowy wezel = this.wezly.get(i); - s = String.format("%07d", wezel.id); - linia = s; - linia += " "; - s = String.format("%010d", wezel.getXms()); - linia += s; - linia += " "; - s = String.format("%010d", wezel.getYms()); - linia += s; - linia += " "; - int most = 0; - if (wezel.jestMostem) { - most = 1; - } - s = String.format("%01d", most); - linia += s; - bw.write(linia, 0, linia.length()); - bw.newLine(); - } - bw.close(); - logger.info("Zapisano plik wezlow sieci drogowej: " + path + "\\nodes.txt"); - } catch (IOException e) { - logger.warn("Blad zapisu pliku wezlow sieci drogowej: " + path + "\\nodes.txt"); - } - try { - // zapisanie lukow - BufferedWriter bw = new BufferedWriter(new FileWriter(path + "\\arcs.txt")); - String linia = Integer.toString(this.luki.size()); - bw.write(linia, 0, linia.length()); - bw.newLine(); - String s; - for (int i = 0; i < this.luki.size(); i++) { - LukDrogowy luk = this.luki.get(i); - s = String.format("%07d", luk.getWezly()[0].id); - linia = s; - linia += " "; - s = String.format("%07d", luk.getWezly()[1].id); - linia += s; - linia += " "; - s = String.format("%05d", luk.dlugosc); - linia += s; - linia += " "; - s = String.format("%02d", luk.szerokosc); - linia += s; - linia += " "; - int most = 0; - if (luk.jestMostem) { - most = 1; - } - s = String.format("%01d", most); - linia += s; - bw.write(linia, 0, linia.length()); - bw.newLine(); - } - bw.close(); - logger.info("Zapisano plik lukow sieci drogowej: " + path + "\\arcs.txt"); - } catch (IOException e) { - logger.warn("Blad zapisu pliku lukow sieci drogowej: " + path + "\\arcs.txt"); - } - } - } - - // funkcja zwraca kolekcje lukow wewnatrz prostokata - // zawartego miedzy lewym dolnym i prawym gornym punktem - public static ArrayList dajLukiWObszarze(String wspUtmLD, String wspUtmPG) { - utworzSiecDrogowa(); - int xms = Teren.zamienWspSMSNaWspXms(wspUtmLD); - int yms = Teren.zamienWspSMSNaWspYms(wspUtmLD); - int xa_ld = GridCoord.zamienWspXmsNaIdKwadratuX(xms); - xa_ld /= MapConsts.SS_PER_SHEET; - int ya_ld = GridCoord.zamienWspYmsNaIdKwadratuY(yms); - ya_ld /= MapConsts.SS_PER_SHEET; - - xms = Teren.zamienWspSMSNaWspXms(wspUtmPG); - yms = Teren.zamienWspSMSNaWspYms(wspUtmPG); - int xa_pg = GridCoord.zamienWspXmsNaIdKwadratuX(xms); - xa_pg /= MapConsts.SS_PER_SHEET; - int ya_pg = GridCoord.zamienWspYmsNaIdKwadratuY(yms); - ya_pg /= MapConsts.SS_PER_SHEET; - - //if (xa_ld > xa_pg || ya_ld > ya_pg) { - // return null; - //} - if (xa_ld > xa_pg) { - int tmp = xa_ld; - xa_ld = xa_pg; - xa_pg = tmp; - } - if (ya_ld > ya_pg) { - int tmp = ya_ld; - ya_ld = ya_pg; - ya_pg = tmp; - } - ArrayList luki = new ArrayList(); - // wspolrzedne arkusza mapy - for (int xa = xa_ld; xa <= xa_pg; xa++) { - for (int ya = ya_ld; ya <= ya_pg; ya++) { - if (instancja.arkusze[xa][ya].luki != null) { - luki.addAll(instancja.arkusze[xa][ya].luki); - } - } - } - return luki; - } - - public static void main(String[] args) { -// GridCoord idKw = GridCoord.zamienWspUtmNaIdKwadratu("520101N0160202E"); -// String utm = GridCoord.zamienIdKwadratuNaWspUtm(idKw); -// int xms = GridCoord.zamienIdKwadratuXNaWspXms(idKw.x); -// int yms = GridCoord.zamienIdKwadratuYNaWspYms(idKw.y); -// utm = Teren.zamienWspXmsYmsNaWspUtm(xms, yms); -// float lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idKw.x); -// float lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idKw.y); -// idKw.x = GridCoord.zamienDlugoscGeoNaIdKwadratuX(lon); -// idKw.y = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(lat); - utworzSiecDrogowa(); - SiecDrogowa.wpiszDrogiWKwadraty(); - } - -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java index 39322ac..5c5a704 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java @@ -44,9 +44,9 @@ public class Square { public float stopienZalesienia; public float stopienZawodnienia; public float stopienZabagnienia; - public boolean jestDroga[]; - public boolean jestRow[]; - public boolean jestPrzeszkodaWodna[]; + public boolean[] jestDroga; + public boolean[] jestRow; + public boolean[] jestPrzeszkodaWodna; public int roznicaWzniesien; public int wysokoscSrednia; //////////////////////////////////////// diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java index f378ce6..e3d2ee0 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java @@ -184,8 +184,8 @@ public class Teren { * @return Nazwa zwracanego pliku z danymi (null - gdy niepoprawne współrzędne). */ public static String getFileName(double lat, double lon) { - int idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(lon); - int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(lat); + int idX = Coord.zamienDlugoscGeoNaIdKwadratuX(lon); + int idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(lat); int bigX = idX / MapConsts.SS_PER_BS_X; int bigY = idY / MapConsts.SS_PER_BS_Y; return getFileName(bigX, bigY); @@ -258,14 +258,14 @@ public class Teren { private static ReentrantLock synchr; public static Square getKwadratPUWG(double northing, double easting) { - GeoCoord geoCoord = new GeoCoord(); + Coord.Geo geoCoord = new Coord.Geo(); CoordUtils.convertPUWG1992ToWGS84(northing, easting, geoCoord); return getKwadrat(geoCoord.lat, geoCoord.lon); } public static Square getKwadrat(double lat, double lon) { - int idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(lon); - int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(lat); + int idX = Coord.zamienDlugoscGeoNaIdKwadratuX(lon); + int idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(lat); return getKwadrat(idX, idY); } @@ -294,7 +294,7 @@ public class Teren { return bigSquares[bsX][bsY].getKwadrat(ssX, ssY); } - private static GridCoord[] history = new GridCoord[MapConsts.MAX_BIG_SQUARES_IN_MEMORY]; + private static Coord.Grid[] history = new Coord.Grid[MapConsts.MAX_BIG_SQUARES_IN_MEMORY]; private static int bigSquaresInMemory = 0; private static void makeRoom(int bigX, int bigY) { @@ -380,7 +380,7 @@ public class Teren { static { for (int i = 0; i < history.length; i++) { - history[i] = new GridCoord(); + history[i] = new Coord.Grid(); } przejezdnoscZawsze = MapConsts.ustawienia.getProperty("przejezdnosc_zawsze").equals("on"); minStopienPrzejezd = Double.parseDouble(MapConsts.ustawienia.getProperty("minimalny_stopien_przejezdnosci")); diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java index 76cd537..7e408b5 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java @@ -48,9 +48,9 @@ public class TerrainUtils { } else { wysBezwzgObserwatora = kwOd.wysokoscSrednia + ho; } - GridCoord[] kwadratyNaOdcinku = Bresenham.generateSegment(x1, y1, x2, y2); - float dlugoscOdcinka = GridCoord.odleglosc(x1, y1, x2, y2); - float tangAlfa0 = roznicaWysokosci / dlugoscOdcinka; + Coord.Grid[] kwadratyNaOdcinku = Bresenham.generateSegment(x1, y1, x2, y2); + double dlugoscOdcinka = Coord.Grid.distance(x1, y1, x2, y2); + double tangAlfa0 = roznicaWysokosci / dlugoscOdcinka; float dh_max = 0; for (int i = 1; i < kwadratyNaOdcinku.length - 1; i++) { @@ -71,7 +71,7 @@ public class TerrainUtils { continue; } - float odleg = GridCoord.odleglosc(kwadratyNaOdcinku[i].x, kwadratyNaOdcinku[i].y, x1, y1); + double odleg = Coord.Grid.distance(kwadratyNaOdcinku[i].x, kwadratyNaOdcinku[i].y, x1, y1); // float tangAlfa = roznWysAkt / odleg; // if (tangAlfa0 < tangAlfa) { if (tangAlfa0 * odleg < dh) { @@ -95,7 +95,7 @@ public class TerrainUtils { } public static float sredStopienWidoczOptycznej(float wysokoscObserwatora, float wysokoscCelu, - GridCoord kwadratOd, int dl1, GridCoord kwadratDo, int dl2) { + Coord.Grid kwadratOd, int dl1, Coord.Grid kwadratDo, int dl2) { float stop = 0.0f; for (int x1 = kwadratOd.x; x1 < kwadratOd.x + dl1; x1++) for (int y1 = kwadratOd.y; y1 < kwadratOd.y + dl1; y1++) diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/WezelDrogowy.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/WezelDrogowy.java deleted file mode 100644 index d9e165e..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/WezelDrogowy.java +++ /dev/null @@ -1,96 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje; - -import java.util.ArrayList; -import java.util.StringTokenizer; - -public class WezelDrogowy { - int id = -1; - private int xms = 0; - private int yms = 0; - boolean jestMostem = false; - GridCoord idKw; - ArrayList luki = new ArrayList(); - - WezelDrogowy() { - } - - WezelDrogowy(String opis) { - if (null == opis || opis.length() == 0){ - SiecDrogowa.logger.debug("Pusty ciag opis w konstruktorze Wezla Drogowego."); - return; - } - StringTokenizer st = new StringTokenizer(opis, " \t"); - String[] tokenTable = new String[st.countTokens()]; - for (int i = 0; st.hasMoreTokens(); i++) { - tokenTable[i] = st.nextToken(); - } - if (tokenTable.length == 3) { - try { - this.xms = Integer.parseInt(tokenTable[0]); - //TODO KONSULTACJA WYWALAMY/ ODKOMENTOWUJEMY -// //Zabezpieczenie przed zaokraglaniem na krawedziach mapy -// if (this.xms < MapConsts.X_REF_MS) -// this.xms = MapConsts.X_REF_MS; -// if (this.xms > MapConsts.X_REF_MS + MapConsts.DX_REF_MS) -// this.xms = MapConsts.X_REF_MS + MapConsts.DX_REF_MS; - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z wezlami [Wezel: " + this.id + " X]."); - } - try { - this.yms = Integer.parseInt(tokenTable[1]); -// //Zabezpieczenie przed zaokraglaniem na krawedziach mapy -// if (this.yms < MapConsts.Y_REF_MS) -// this.yms = MapConsts.Y_REF_MS; -// if (this.yms > MapConsts.Y_REF_MS + MapConsts.DY_REF_MS) -// this.yms = MapConsts.Y_REF_MS + MapConsts.DY_REF_MS; - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z wezlami [Wezel: " + this.id + " Y]."); - } - try { - this.jestMostem = Integer.parseInt(tokenTable[2]) != 0 ? true : false; - } catch (NumberFormatException e) { - SiecDrogowa.logger.warn("Bledne dane w pliku z wezlami [Wezel: " + this.id + " czyJestMost]."); - } - int x = GridCoord.zamienWspXmsNaIdKwadratuX(getXms()); - int y = GridCoord.zamienWspYmsNaIdKwadratuY(getYms()); - this.idKw = new GridCoord(x, y); - } - else - { - SiecDrogowa.logger.warn("Bledne ilosc tokenow w linii [" + opis + "]."); - } - } - - public boolean isJestMostem() { - return jestMostem; - } - - public void setJestMostem(boolean jestMostem) { - this.jestMostem = jestMostem; - } - - public GridCoord getIdKw() { - return idKw; - } - - public void setIdKw(GridCoord idKw) { - this.idKw = new GridCoord(idKw); - } - - public void setXms(int xms) { - this.xms = xms; - } - - public int getXms() { - return xms; - } - - public void setYms(int yms) { - this.yms = yms; - } - - public int getYms() { - return yms; - } - -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java index e3dbe82..41d8347 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java @@ -2,6 +2,7 @@ package pl.wat.ms4ds.terenfunkcje.konwersja; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import pl.wat.ms4ds.terenfunkcje.Coord; import pl.wat.ms4ds.terenfunkcje.GeoCoord; public class CoordTest { @@ -14,7 +15,7 @@ public class CoordTest { logger.debug(" "); PUWGCoord puwgCoord = new PUWGCoord(); - GeoCoord geoCoord = new GeoCoord(); + Coord.Geo geoCoord = new Coord.Geo(); geoCoord.lon = 19; geoCoord.lat = 50; CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat, geoCoord.lon, puwgCoord); diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java index ed5f52f..b1e1b28 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java @@ -1,8 +1,6 @@ package pl.wat.ms4ds.terenfunkcje.konwersja; -import pl.wat.ms4ds.terenfunkcje.GeoCoord; -import pl.wat.ms4ds.terenfunkcje.GridCoord; -import pl.wat.ms4ds.terenfunkcje.Square; +import pl.wat.ms4ds.terenfunkcje.Coord; import pl.wat.ms4ds.terenfunkcje.Teren; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -27,7 +25,7 @@ public class CoordUtils { public static void main(String[] args) throws Exception { - HashMap daneWysokHashMap = new HashMap(); + HashMap daneWysokHashMap = new HashMap(); if (args.length > 0) { dataDir = args[0]; } @@ -64,7 +62,7 @@ public class CoordUtils { } - private static void readData(String fileName, HashMap daneWysokHashMap) throws IOException { + private static void readData(String fileName, HashMap daneWysokHashMap) throws IOException { try { StringBuilder sb = new StringBuilder(100); sb.append(dataDir); @@ -73,7 +71,7 @@ public class CoordUtils { FileReader fis = new FileReader(sb.toString()); // PUWG 1992 PUWGCoord puwgCoord = new PUWGCoord(); - GeoCoord latLon = new GeoCoord(); + Coord.Geo latLon = new Coord.Geo(); double wysokosc = 0.0; StringTokenizer st = null; String line = null; @@ -106,7 +104,7 @@ public class CoordUtils { logger.warn("Bledne dane w pliku: " + fileName); } convertPUWG1992ToWGS84(puwgCoord.northing, puwgCoord.easting, latLon); - GridCoord idKw = new GridCoord(latLon.lon, latLon.lat); + Coord.Grid idKw = new Coord.Grid(latLon.lon, latLon.lat); NMTData daneWysok = daneWysokHashMap.get(idKw); if (daneWysok == null) { daneWysok = new NMTData(idKw, wysokosc, 1); @@ -197,7 +195,7 @@ public class CoordUtils { * @param easting współrzędne na osi OX odwzorowania kartograficznego PUWG-1992 do konwersji [metry] * @param geoCoord współrzędne geograficzne odwzorowania WGS-84 po konwersji [stopnie] */ - public static void convertPUWG1992ToWGS84(double northing, double easting, GeoCoord geoCoord) { + public static void convertPUWG1992ToWGS84(double northing, double easting, Coord.Geo geoCoord) { double tmd = (northing + 5300000.0) / OK; double sr = sphsr(0.0); double ftphi = tmd / sr; diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java index c52dc47..cff874e 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java @@ -10,7 +10,7 @@ import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.MultiPointZShape; import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PointShape; import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PolygonShape; import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PolylineShape; -import pl.wat.ms4ds.terenfunkcje.GridCoord; +import pl.wat.ms4ds.terenfunkcje.Coord; import pl.wat.ms4ds.terenfunkcje.MapConsts; import pl.wat.ms4ds.terenfunkcje.Teren; import org.slf4j.Logger; @@ -98,8 +98,8 @@ public class EsriFileReader { currNode.lat = Math.min(currNode.lat, MapConsts.Y_REF + MapConsts.DY_REF); currNode.lat -= 90; - currNode.idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon); - currNode.idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat); + currNode.idX = Coord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon); + currNode.idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat); if (currNode.idX > 0 || currNode.idY > 0) { currWay.nodes.add(currNode); } diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java index 879a512..df3224f 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java @@ -1,20 +1,20 @@ package pl.wat.ms4ds.terenfunkcje.konwersja; -import pl.wat.ms4ds.terenfunkcje.GridCoord; +import pl.wat.ms4ds.terenfunkcje.Coord; /** * */ public class NMTData { - GridCoord idKw; + public Coord.Grid gridCoord; - double suma; + public double suma; - int licz; + public int licz; - public NMTData(GridCoord idKw, double suma, int licz) { - this.idKw = idKw; + public NMTData(Coord.Grid gridCoord, double suma, int licz) { + this.gridCoord = gridCoord; this.suma = suma; this.licz = licz; } diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java index 4c2053f..efa65bb 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java @@ -1,6 +1,6 @@ package pl.wat.ms4ds.terenfunkcje.konwersja; -import pl.wat.ms4ds.terenfunkcje.GridCoord; +import pl.wat.ms4ds.terenfunkcje.Coord; import pl.wat.ms4ds.terenfunkcje.Teren; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -238,8 +238,8 @@ public class OpenStreetMapReader { switch (reader.getLocalName()) { case "node": if (currNode != null) { - currNode.idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon); - currNode.idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat); + currNode.idX = Coord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon); + currNode.idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat); if ("zabudowa".equals(genGoal) && currNode.buildingsCount > 0) { buildingNodesMap.put(currNode.id, currNode); } diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/UTMCoord.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/UTMCoord.java deleted file mode 100644 index 54e246c..0000000 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/UTMCoord.java +++ /dev/null @@ -1,34 +0,0 @@ -package pl.wat.ms4ds.terenfunkcje.konwersja; - -/** - * Współrzędna w układzie UTM.

- * Przykład: 17T 630084 4833438, - * gdzie: xZone = 17, yZone = T, easting = 630084, northing = 4833438 - *

- * xZone - nr strefy UTM wg. podziału południkowego (zwracane numery od 1 do 60, każda strefa ma sześć stopni); - *

- * yZone - nr strefy wg. podziału równoleżnikowego (zwracane wartości: CDEFGHJKLMNPQRSTUVWX). - *

- * easting - odległość w kierunku wschodnim od początku układu współrzędnych w danej strefie UTM [metr]. - *

- * northing - odległość w kierunku północnym od początku układu współrzędnych w danej strefie UTM [metr]. - */ -public class UTMCoord { - - /** - * Nr strefy UTM wg. podziału południkowego (zwracane numery od 1 do 60, każda strefa ma sześć stopni). - */ - public int xZone; - /** - * Nr strefy wg. podziału równoleżnikowego (zwracane wartości: CDEFGHJKLMNPQRSTUVWX). - */ - public char yZone; - /** - * Odległość w kierunku wschodnim od początku układu współrzędnych w danej strefie UTM [metr]. - */ - public double easting; - /** - * Odległość w kierunku północnym od początku układu współrzędnych w danej strefie UTM [metr]. - */ - public double northing; -} diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java index b5c1856..f5c98ce 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java @@ -4,6 +4,7 @@ import pl.wat.ms4ds.common.EGeoDirection; import pl.wat.ms4ds.terenfunkcje.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + import java.util.ArrayList; /** @@ -243,16 +244,16 @@ public class Way { if (nodes.size() == 0) { return; } - GridCoord[] punktyLamanej = new GridCoord[nodes.size()]; + Coord.Grid[] punktyLamanej = new Coord.Grid[nodes.size()]; for (int i = 0; i < nodes.size(); i++) { - punktyLamanej[i] = new GridCoord(nodes.get(i).idX, nodes.get(i).idY); + punktyLamanej[i] = new Coord.Grid(nodes.get(i).idX, nodes.get(i).idY); } Square kw0; Square kw1; - GridCoord id0; - GridCoord id1; + Coord.Grid id0; + Coord.Grid id1; EGeoDirection kier; - GridCoord[] kwadraty = GeomUtils.kwadratyLamanej2(punktyLamanej); + Coord.Grid[] kwadraty = GeomUtils.kwadratyLamanej2(punktyLamanej); // float dlug = GeomUtils.dlugoscDrogiPoKwadratch(kwadraty); for (int i = 0; i < kwadraty.length - 1; i++) { try { @@ -263,16 +264,16 @@ public class Way { kier = GeomUtils.kierunekDlaSasiada(id0, id1); switch (type) { case ROAD: - kw0.jestDroga[kier.id]= true; - kw0.jestDroga[kier.oppositeDirect().id]= true; + kw0.jestDroga[kier.id] = true; + kw0.jestDroga[kier.oppositeDirect().id] = true; break; case WATER_WAY: - kw0.jestPrzeszkodaWodna[kier.id]= true; - kw0.jestPrzeszkodaWodna[kier.oppositeDirect().id]= true; + kw0.jestPrzeszkodaWodna[kier.id] = true; + kw0.jestPrzeszkodaWodna[kier.oppositeDirect().id] = true; break; case DITCH: - kw0.jestRow[kier.id]= true; - kw0.jestRow[kier.oppositeDirect().id]= true; + kw0.jestRow[kier.id] = true; + kw0.jestRow[kier.oppositeDirect().id] = true; break; default: } @@ -282,25 +283,25 @@ public class Way { } } - public static void writeAreaFeatureIntoSquares2(EAreaFeature type, boolean clearFeature, GridCoord[] polygon) { + public static void writeAreaFeatureIntoSquares2(EAreaFeature type, boolean clearFeature, Coord.Grid[] polygon) { if (polygon.length > 20) { // podział wielokata na dwa mniejsze int m = 2; - GridCoord pocz = polygon[0]; + Coord.Grid pocz = polygon[0]; boolean poprawnyPodzial = false; while (m < polygon.length - 1 && !poprawnyPodzial) { // sprawdzenie, czy punkty wielokata po podziale sa po jednej stronie wektora podzialu poprawnyPodzial = true; - GridCoord kon = polygon[m]; + Coord.Grid kon = polygon[m]; for (int i = 0; i < polygon.length; i++) { int i_puls_1 = (i + 1) % polygon.length; boolean przeciecie = GeomUtils.intersection(pocz, kon, polygon[i], polygon[i_puls_1]); if (przeciecie) { // sprawdzenie, czy jakiś koniec jednego odcinka jest równy końcowi drugiego odcinka - boolean b = pocz.rowne(polygon[i].x, polygon[i].y) || - pocz.rowne(polygon[i_puls_1].x, polygon[i_puls_1].y) || - kon.rowne(polygon[i].x, polygon[i].y) || - kon.rowne(polygon[i_puls_1].x, polygon[i_puls_1].y); + boolean b = pocz.equals(polygon[i]) || + pocz.equals(polygon[i_puls_1]) || + kon.equals(polygon[i]) || + kon.equals(polygon[i_puls_1]); if (!b) { poprawnyPodzial = false; m++; @@ -311,13 +312,13 @@ public class Way { } if (poprawnyPodzial) { // punkt podziału wielokąta jest poprawny, zatem dzielę wielokąt na dwa - GridCoord[] polygon1 = new GridCoord[m + 1]; + Coord.Grid[] polygon1 = new Coord.Grid[m + 1]; for (int i = 0; i < polygon1.length; i++) { polygon1[i] = polygon[i]; } writeAreaFeatureIntoSquares2(type, clearFeature, polygon1); - GridCoord[] polygon2 = new GridCoord[polygon.length - m + 1]; + Coord.Grid[] polygon2 = new Coord.Grid[polygon.length - m + 1]; polygon2[0] = polygon[0]; for (int i = m; i < polygon.length; i++) { polygon2[i - m + 1] = polygon[i]; @@ -326,7 +327,7 @@ public class Way { } else { // nie udało się poprawnie podzielić wielokąta, zatem przesuwam wierzchołki, aby zmienić wierzchołek // startowy, który jest wierchołkiem referencyjnym podziału (drugi wierzchołek podziału jest szukany) - GridCoord temp = polygon[0]; + Coord.Grid temp = polygon[0]; for (int i = 0; i < polygon.length - 1; i++) { polygon[i] = polygon[i + 1]; } @@ -346,7 +347,7 @@ public class Way { maxX = Math.max(polygon[i].x, maxX); maxY = Math.max(polygon[i].y, maxY); } - GridCoord idTest = new GridCoord(); + Coord.Grid idTest = new Coord.Grid(); boolean inside; for (int j = maxY; j >= minY; j--) { for (int i = minX; i <= maxX; i++) { @@ -378,10 +379,10 @@ public class Way { } } - public static void writeAreaFeatureIntoSquares(EAreaFeature type, boolean clearFeature, GridCoord[] polygon, - int minX,int maxX, int minY, int maxY) { + public static void writeAreaFeatureIntoSquares(EAreaFeature type, boolean clearFeature, Coord.Grid[] polygon, + int minX, int maxX, int minY, int maxY) { float val = (clearFeature) ? 0.0f : 1.0f; - GridCoord idTest = new GridCoord(); + Coord.Grid idTest = new Coord.Grid(); boolean inside; for (int i = minX; i <= maxX; i++) { for (int j = minY; j <= maxY; j++) { @@ -439,7 +440,7 @@ public class Way { return; } if (nodes.size() == 2) { - GridCoord[] kwadraty = GeomUtils.kwadratyOdcinka(nodes.get(0).idX, nodes.get(0).idY, + Coord.Grid[] kwadraty = GeomUtils.kwadratyOdcinka(nodes.get(0).idX, nodes.get(0).idY, nodes.get(1).idX, nodes.get(1).idY); for (int i = 0; i < kwadraty.length; i++) { kw = Teren.getKwadrat(kwadraty[i].x, kwadraty[i].y); @@ -461,9 +462,9 @@ public class Way { } return; } - GridCoord[] wielokat = new GridCoord[nodes.size()]; + Coord.Grid[] wielokat = new Coord.Grid[nodes.size()]; for (int i = 0; i < nodes.size(); i++) { - wielokat[i] = new GridCoord(nodes.get(i).idX, nodes.get(i).idY); + wielokat[i] = new Coord.Grid(nodes.get(i).idX, nodes.get(i).idY); } writeAreaFeatureIntoSquares2(type, clearFeature, wielokat); } @@ -494,7 +495,7 @@ public class Way { return; } if (nodes.size() == 2) { - GridCoord[] kwadraty = GeomUtils.kwadratyOdcinka(nodes.get(0).idX, nodes.get(0).idY, + Coord.Grid[] kwadraty = GeomUtils.kwadratyOdcinka(nodes.get(0).idX, nodes.get(0).idY, nodes.get(1).idX, nodes.get(1).idY); for (int i = 0; i < kwadraty.length; i++) { kw = Teren.getKwadrat(kwadraty[i].x, kwadraty[i].y); @@ -516,13 +517,13 @@ public class Way { } return; } - GridCoord[] wielokat = new GridCoord[nodes.size()]; + Coord.Grid[] wielokat = new Coord.Grid[nodes.size()]; int minX = nodes.get(0).idX; int minY = nodes.get(0).idY; int maxX = nodes.get(0).idX; int maxY = nodes.get(0).idY; for (int i = 0; i < nodes.size(); i++) { - wielokat[i] = new GridCoord(nodes.get(i).idX, nodes.get(i).idY); + wielokat[i] = new Coord.Grid(nodes.get(i).idX, nodes.get(i).idY); minX = Math.min(wielokat[i].x, minX); minY = Math.min(wielokat[i].y, minY); maxX = Math.max(wielokat[i].x, maxX); @@ -542,7 +543,7 @@ public class Way { } return; } - GridCoord idTest = new GridCoord(); + Coord.Grid idTest = new Coord.Grid(); boolean nalezyDoWielokata; // int liczKw = 0; // int liczKwObszaru = 0; diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java index 13eb197..bd0e0dd 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java @@ -1,8 +1,9 @@ package pl.wat.ms4ds.terenfunkcje.konwersja; -import pl.wat.ms4ds.terenfunkcje.GridCoord; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import pl.wat.ms4ds.terenfunkcje.Coord; + import java.util.ArrayList; /** @@ -18,13 +19,13 @@ public class Worker extends Thread { EAreaFeature type; boolean clearFeature; - GridCoord[] polygon; + Coord.Grid[] polygon; int minX; int maxX; int minY; int maxY; - public Worker(EAreaFeature type, boolean clearFeature, GridCoord[] polygon, int minX, int maxX, int minY, int maxY) { + public Worker(EAreaFeature type, boolean clearFeature, Coord.Grid[] polygon, int minX, int maxX, int minY, int maxY) { super("Worker_" + nr++); this.type = type; this.clearFeature = clearFeature; diff --git a/src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java b/src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java index 78577de..4bd7c25 100644 --- a/src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java +++ b/src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java @@ -116,22 +116,22 @@ public class NMTReader { data[i][j] = Double.parseDouble(split[j]); } } - GeoCoord geo_ll = new GeoCoord(); + Coord.Geo geo_ll = new Coord.Geo(); CoordUtils.convertPUWG1992ToWGS84(yll, xll, geo_ll); - GeoCoord geo_ur = new GeoCoord(); + Coord.Geo geo_ur = new Coord.Geo(); CoordUtils.convertPUWG1992ToWGS84(yll + nrows + cellsize, xll + ncols * cellsize, geo_ur); int d_x = (int) ((geo_ur.lon - geo_ll.lon) / MapConsts.DELTA_X) + 3; int d_y = (int) ((geo_ur.lat - geo_ll.lat) / MapConsts.DELTA_Y) + 3; Square[][] kwadraty = new Square[d_x][d_y]; - final int x = GridCoord.zamienDlugoscGeoNaIdKwadratuX(geo_ll.lon); - final int y = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo_ll.lat); + final int x = Coord.zamienDlugoscGeoNaIdKwadratuX(geo_ll.lon); + final int y = Coord.zamienSzerokoscGeoNaIdKwadratuY(geo_ll.lat); kwadraty[0][0] = new Square(); // Kwadrat kw = Teren.getKwadrat(x, y); // Wyznacz współrzędne geo środka kwadratu. - GeoCoord geoCoord = new GeoCoord(); - geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(x); - geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(y); + Coord.Geo geoCoord = new Coord.Geo(); + geoCoord.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(x); + geoCoord.lat = Coord.zamienIdKwadratuYNaSzerokoscGeo(y); PUWGCoord puwgCoord = new PUWGCoord(); // Wyznacz współrzędne PUWG lewego dolnego rogu kwadratu. CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat - MapConsts.DELTA_Y / 2, geoCoord.lon - MapConsts.DELTA_X / 2, puwgCoord); @@ -161,8 +161,8 @@ public class NMTReader { if (kwadraty[idX][idY].nur == 0) { // Świeży kwadrat. // Wyznacz współrzędne geo środka kwadratu. - geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX + x); - geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y); + geoCoord.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX + x); + geoCoord.lat = Coord.zamienIdKwadratuYNaSzerokoscGeo(idY + y); // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu. CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat + MapConsts.DELTA_Y / 2, geoCoord.lon + MapConsts.DELTA_X / 2, puwgCoord); kwadraty[idX][idY].eur = (int) puwgCoord.easting; @@ -183,8 +183,8 @@ public class NMTReader { if (kwadraty[idX][idY].eur == 0) { // Świeży kwadrat. // Wyznacz współrzędne geo środka kwadratu. - geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX + x); - geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y); + geoCoord.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX + x); + geoCoord.lat = Coord.zamienIdKwadratuYNaSzerokoscGeo(idY + y); // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu. CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat + MapConsts.DELTA_Y / 2, geoCoord.lon + MapConsts.DELTA_X / 2, puwgCoord); kwadraty[idX][idY].eur = (int) puwgCoord.easting; @@ -226,7 +226,7 @@ public class NMTReader { InputStream inputStream = new FileInputStream(file); Square kw = Square.EMPTY; PUWGCoord puwgCoord = new PUWGCoord(); - GeoCoord geo = new GeoCoord(); + Coord.Geo geo = new Coord.Geo(); HashMap map = new HashMap<>(); try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) { String line; @@ -248,11 +248,11 @@ public class NMTReader { map.put(kw, kw); if (kw.nur == 0) { // Kwadrat jeszcze nie był odczytany (czysty). - int idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(geo.lon); - int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo.lat); + int idX = Coord.zamienDlugoscGeoNaIdKwadratuX(geo.lon); + int idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(geo.lat); // Współrzędne geo środka kwadratu. - geo.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX); - geo.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY); + geo.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX); + geo.lat = Coord.zamienIdKwadratuYNaSzerokoscGeo(idY); // Wyznacz współrzędne PUWG lewego dolnego rogu kwadratu. CoordUtils.convertWGS84ToPUWG1992(geo.lat - MapConsts.DELTA_Y / 2, geo.lon - MapConsts.DELTA_X / 2, puwgCoord); kw.ell = (int) puwgCoord.easting;