jrulka/terrain-utilities
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Porządki polegające na wrzuceniu do klasy Coord klas współrzędnych w różnych układach (grid, geo/wgs84, puwg).

Browse Source
This commit is contained in:
Jarosław Rulka
2026-01-14 14:29:28 +01:00
parent 119658de07
commit f4d2d60286
22 changed files with 743 additions and 1796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java
View File

@@ -36,10 +36,6 @@ public final class AStar {
return node;
}
static Node dajAStarNode(GridCoord gridCoord) {
return dajAStarNode(gridCoord.x, gridCoord.y);
}
ArrayList<Node> dajNiezamknietychSasiadow() {
ArrayList<Node> 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<GridCoord> wyznaczDroge(GridCoord[] punktyProfilujace, EGeoDirection staryKierunek,
public static ArrayList<Coord.Grid> wyznaczDroge(Coord.Grid[] punktyProfilujace, EGeoDirection staryKierunek,
ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) {
if (null == punktyProfilujace || 0 == punktyProfilujace.length) {
return null;
}
Node.reset();
ArrayList<GridCoord> wynik = new ArrayList<>();
GridCoord start;
GridCoord stop = punktyProfilujace[0];
ArrayList<GridCoord> odcinek;
ArrayList<Coord.Grid> wynik = new ArrayList<>();
Coord.Grid start;
Coord.Grid stop = punktyProfilujace[0];
ArrayList<Coord.Grid> odcinek;
for (int i = 1; i < punktyProfilujace.length; i++) {
start = stop;
stop = punktyProfilujace[i];
@@ -178,7 +174,7 @@ 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<GridCoord> wyznaczDroge(GridCoord start, GridCoord stop, EGeoDirection staryKierunek,
public static ArrayList<Coord.Grid> wyznaczDroge(Coord.Grid start, Coord.Grid stop, EGeoDirection staryKierunek,
boolean zawieraStartowy, ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) {
PriorityQueue<Node> listaOtwarta = new PriorityQueue<>(100, (o1, o2) -> Double.compare(o1.kosztZHeurystyka, o2.kosztZHeurystyka));
@@ -204,13 +200,13 @@ public final class AStar {
aktualny = Node.dajAStarNode(start.x, start.y);
aktualny.zKierunku = staryKierunek;
listaOtwarta.add(aktualny);
ArrayList<GridCoord> wynik = new ArrayList<GridCoord>();
ArrayList<Coord.Grid> wynik = new ArrayList<Coord.Grid>();
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,7 +255,7 @@ 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<GridCoord> wyznaczDrogeNew(GridCoord start, GridCoord stop, EGeoDirection staryKierunek,
public static ArrayList<Coord.Grid> wyznaczDrogeNew(Coord.Grid start, Coord.Grid stop, EGeoDirection staryKierunek,
boolean zawieraStartowy, ERodzajPodwozia podwozie,
ERodzajDzialania rodzajDzialania,
double szerokoscPokonywRowow,
@@ -293,13 +289,13 @@ public final class AStar {
aktualny = Node.dajAStarNode(start.x, start.y);
aktualny.zKierunku = staryKierunek;
listaOtwarta.add(aktualny);
ArrayList<GridCoord> wynik = new ArrayList<GridCoord>();
ArrayList<Coord.Grid> wynik = new ArrayList<Coord.Grid>();
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;

35
src/main/java/pl/wat/ms4ds/terenfunkcje/Arkusz.java
View File

@@ -1,35 +0,0 @@
package pl.wat.ms4ds.terenfunkcje;
import java.util.ArrayList;
public class Arkusz {
ArrayList<WezelDrogowy> wezly = new ArrayList<>();
// arkusz mapy zawiera luki rozlacznie (jeden luk moze nalezec tylko do jednego arkusza)
ArrayList<LukDrogowy> 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;
}
}

14
src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java
View File

@@ -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;

353
src/main/java/pl/wat/ms4ds/terenfunkcje/Coord.java Normal file
View File

@@ -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.
* <p>
* 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;
}

467
src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java
View File

@@ -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);
/**
* <p> 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<GridCoord> 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<GridCoord> kwadratyLamanej(GridCoord[] punktyLamanej) {
ArrayList<GridCoord> kwadratyWyj = new ArrayList<GridCoord>();
public static ArrayList<Coord.Grid> kwadratyLamanej(Coord.Grid[] punktyLamanej) {
ArrayList<Coord.Grid> kwadratyWyj = new ArrayList<Coord.Grid>();
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<GridCoord> droga, int pocz) {
public static float wyznaczPozostalaDlugoscDrogi(ArrayList<Coord.Grid> 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<GridCoord> 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);

689
src/main/java/pl/wat/ms4ds/terenfunkcje/GridCoord.java
View File

@@ -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;
}
}

113
src/main/java/pl/wat/ms4ds/terenfunkcje/LukDrogowy.java
View File

@@ -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;
}
}

148
src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java
View File

@@ -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;
}
}
}

365
src/main/java/pl/wat/ms4ds/terenfunkcje/SiecDrogowa.java
View File

@@ -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<LukDrogowy> luki;
ArrayList<WezelDrogowy> 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<WezelDrogowy>(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<LukDrogowy>(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<LukDrogowy>();
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<LukDrogowy> 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<LukDrogowy> luki = new ArrayList<LukDrogowy>();
// 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();
}
}

6
src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java
View File

@@ -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;
////////////////////////////////////////

14
src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java
View File

@@ -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"));

10
src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java
View File

@@ -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++)

96
src/main/java/pl/wat/ms4ds/terenfunkcje/WezelDrogowy.java
View File

@@ -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<LukDrogowy> luki = new ArrayList<LukDrogowy>();
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;
}
}

3
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java
View File

@@ -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);

14
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java
View File

@@ -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<GridCoord, NMTData> daneWysokHashMap = new HashMap<GridCoord, NMTData>();
HashMap<Coord.Grid, NMTData> daneWysokHashMap = new HashMap();
if (args.length > 0) {
dataDir = args[0];
}
@@ -64,7 +62,7 @@ public class CoordUtils {
}
private static void readData(String fileName, HashMap<GridCoord, NMTData> daneWysokHashMap) throws IOException {
private static void readData(String fileName, HashMap<Coord.Grid, NMTData> 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;

6
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java
View File

@@ -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);
}

12
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java
View File

@@ -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;
}

6
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java
View File

@@ -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);
}

34
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/UTMCoord.java
View File

@@ -1,34 +0,0 @@
package pl.wat.ms4ds.terenfunkcje.konwersja;
/**
* Współrzędna w układzie UTM. <p>
* Przykład: 17T 630084 4833438,
* gdzie: xZone = 17, yZone = T, easting = 630084, northing = 4833438
* <p>
* xZone - nr strefy UTM wg. podziału południkowego (zwracane numery od 1 do 60, każda strefa ma sześć stopni);
* <p>
* yZone - nr strefy wg. podziału równoleżnikowego (zwracane wartości: CDEFGHJKLMNPQRSTUVWX).
* <p>
* easting - odległość w kierunku wschodnim od początku układu współrzędnych w danej strefie UTM [metr].
* <p>
* 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;
}

65
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java
View File

@@ -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;

7
src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java
View File

@@ -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;

32
src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java
View File

@@ -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<Square, Square> 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;