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

src/main/java/pl/wat/ms4ds/terenfunkcje/AStar.java

@@ -36,10 +36,6 @@ public final class AStar {
             return node;
         }
 
-        static Node dajAStarNode(GridCoord gridCoord) {
-            return dajAStarNode(gridCoord.x, gridCoord.y);
-        }
-
         ArrayList<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) {
+                                                     ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) {
         if (null == punktyProfilujace || 0 == punktyProfilujace.length) {
             return null;
         }
         Node.reset();
-        ArrayList<GridCoord> wynik = new ArrayList<>();
+        ArrayList<Coord.Grid> wynik = new ArrayList<>();
-        GridCoord start;
+        Coord.Grid start;
-        GridCoord stop = punktyProfilujace[0];
+        Coord.Grid stop = punktyProfilujace[0];
-        ArrayList<GridCoord> odcinek;
+        ArrayList<Coord.Grid> odcinek;
         for (int i = 1; i < punktyProfilujace.length; i++) {
             start = stop;
             stop = punktyProfilujace[i];
@@ -178,8 +174,8 @@ public final class AStar {
      * @param zawieraStartowy parametr wskazujący, czy wyznaczona droga ma zawierać kwadrat startowy
      * @return uporządkowana kolekcja współrzędnych kolejnych kwadratów drogi zawierająca kwadrat startowy (jeśli zawieraStartowy==true) i docelowy lub kolekcja pusta, gdy nie istnieje droga
      */
-    public static ArrayList<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) {
+                                                     boolean zawieraStartowy, ERodzajPodwozia podwozie, ERodzajDzialania rodzajDzialania) {
 
         PriorityQueue<Node> listaOtwarta = new PriorityQueue<>(100, (o1, o2) -> Double.compare(o1.kosztZHeurystyka, o2.kosztZHeurystyka));
         boolean naPrzelaj = false;
@@ -204,13 +200,13 @@ public final class AStar {
         aktualny = Node.dajAStarNode(start.x, start.y);
         aktualny.zKierunku = staryKierunek;
         listaOtwarta.add(aktualny);
-        ArrayList<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 nowyKosztOdStartu = aktualny.kosztOdStartu + Coord.Grid.distance(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci;
-                double nowyKosztZHeurystyka = nowyKosztOdStartu + GridCoord.odleglosc(sasiad.x, sasiad.y, stop.x, stop.y);
+                double nowyKosztZHeurystyka = nowyKosztOdStartu + Coord.Grid.distance(sasiad.x, sasiad.y, stop.x, stop.y);
                 if (sasiad.kosztZHeurystyka > nowyKosztZHeurystyka) {
                     //UPDATE kosztow i zmiany w kolejce
                     sasiad.kosztOdStartu = nowyKosztOdStartu;
@@ -259,12 +255,12 @@ public final class AStar {
      * @param zawieraStartowy parametr wskazujący, czy wyznaczona droga ma zawierać kwadrat startowy
      * @return uporządkowana kolekcja współrzędnych kolejnych kwadratów drogi zawierająca kwadrat startowy (jeśli zawieraStartowy==true) i docelowy lub kolekcja pusta, gdy nie istnieje droga
      */
-    public static ArrayList<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,
+                                                        boolean zawieraStartowy, ERodzajPodwozia podwozie,
-                                                       ERodzajDzialania rodzajDzialania,
+                                                        ERodzajDzialania rodzajDzialania,
-                                                       double szerokoscPokonywRowow,
+                                                        double szerokoscPokonywRowow,
-                                                       double glebokoscBrodzenia,
+                                                        double glebokoscBrodzenia,
-                                                       double predkoscPlywania) {
+                                                        double predkoscPlywania) {
         PriorityQueue<Node> listaOtwarta = new PriorityQueue<>(100, new Comparator<Node>() {
             public int compare(Node o1, Node o2) {
                 return Double.compare(o1.kosztZHeurystyka, o2.kosztZHeurystyka);
@@ -293,13 +289,13 @@ public final class AStar {
         aktualny = Node.dajAStarNode(start.x, start.y);
         aktualny.zKierunku = staryKierunek;
         listaOtwarta.add(aktualny);
-        ArrayList<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 nowyKosztOdStartu = aktualny.kosztOdStartu + Coord.Grid.distance(aktualny.x, aktualny.y, sasiad.x, sasiad.y) / stopienPrzejezdnosci;
-                double nowyKosztZHeurystyka = nowyKosztOdStartu + GridCoord.odleglosc(sasiad.x, sasiad.y, stop.x, stop.y);
+                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;

src/main/java/pl/wat/ms4ds/terenfunkcje/Arkusz.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/Bresenham.java

@@ -1,6 +1,5 @@
 package pl.wat.ms4ds.terenfunkcje;
 
-
 /**
  * Klasa algorytmiczna do wyznaczania kwadratów odcinka (dyskretyzacja odcinka kwadratami/pikselami).
  */
@@ -25,7 +24,7 @@ public class Bresenham {
      * @param y2 współrzędna y końca
      * @return tablicę kolejnych kwadratów tworzących odcinek o zadanych końcach
      */
-    public static GridCoord[] generateSegment(int x1, int y1, int x2, int y2) {
+    public static Coord.Grid[] generateSegment(int x1, int y1, int x2, int y2) {
         int x = x1;
         int y = y1;
         int dx = x2 - x1;
@@ -44,9 +43,9 @@ public class Bresenham {
         if (dx >= dy) {
             // poruszamy się po x
             p = ddy - dx;
-            GridCoord[] res = new GridCoord[dx + 1];
+            Coord.Grid[] res = new Coord.Grid[dx + 1];
             for (int i = 0; i <= dx; i++) {
-                res[i] = new GridCoord(x, y);
+                res[i] = new Coord.Grid(x, y);
                 if (p > 0) {
                     y += sy;
                     p -= ddx;
@@ -58,9 +57,9 @@ public class Bresenham {
         } else {
             // poruszamy sie po y
             p = ddx - dy;
-            GridCoord[] res = new GridCoord[dy + 1];
+            Coord.Grid[] res = new Coord.Grid[dy + 1];
             for (int i = 0; i <= dy; i++) {
-                res[i] = new GridCoord(x, y);
+                res[i] = new Coord.Grid(x, y);
                 if (p > 0) {
                     x += sx;
                     p -= ddy;
@@ -72,8 +71,7 @@ public class Bresenham {
         }
     }
 
-
+    static void print(Coord.Grid[] segment) {
-    static void print(GridCoord[] segment) {
         StringBuilder sb = new StringBuilder(300);
         sb.append('[');
         int last = segment.length - 1;

src/main/java/pl/wat/ms4ds/terenfunkcje/Coord.java

@@ -0,0 +1,353 @@
+package pl.wat.ms4ds.terenfunkcje;
+
+public class Coord {
+
+    public static class Geo {
+        public double lat;
+        public double lon;
+
+        public Geo() {
+        }
+
+        public Geo(double lat, double lon) {
+            this.lat = lat;
+            this.lon = lon;
+        }
+
+        public Geo(GeoCoord other) {
+            lat = other.lat;
+            lon = other.lon;
+        }
+    }
+
+    /**
+     * Współrzędne punktu odwzorowania kartograficznego PUWG 1992.
+     * <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;
+
+
+}

src/main/java/pl/wat/ms4ds/terenfunkcje/GeomUtils.java

@@ -1,13 +1,14 @@
 package pl.wat.ms4ds.terenfunkcje;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import pl.wat.ms4ds.common.EGeoDirection;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 
 public class GeomUtils {
 
+    private static final Logger logger = LoggerFactory.getLogger(GeomUtils.class);
 
     /**
      * <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++) {
+        for (int i = 1; i < road.length; i++) {
-            dl += GridCoord.odleglosc(kwadraty[i - 1], kwadraty[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) {
+    public static ArrayList<Coord.Grid> kwadratyLamanej(Coord.Grid[] punktyLamanej) {
-        ArrayList<GridCoord> kwadratyWyj = new ArrayList<GridCoord>();
+        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) {
+    public static Coord.Grid[] kwadratyLamanej2(Coord.Grid[] punktyLamanej) {
-        GridCoord[] kwadratyWyj;
+        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) {
+    public static Coord.Grid[] kwadratyOdcinka(int xp, int yp, int xk, int yk) {
-        GridCoord[] kwadraty;
+        Coord.Grid[] kwadraty;
         if ((xp == xk) && (yp == yk)) {
             // odcinek skladajacy sie z jednego kwadratu
-            kwadraty = new GridCoord[1];
+            kwadraty = new Coord.Grid[1];
-            kwadraty[0] = new GridCoord(xp, yp);
+            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) {
+    private static Coord.Grid[] kwadratyOdcinkaPionowego(int xp, int yp, int xk, int yk) {
-        GridCoord[] kwadraty = new GridCoord[Math.abs(yp - yk) + 1];
+        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) {
+    private static Coord.Grid[] kwadratyOdcinkaPoziomego(int xp, int yp, int xk, int yk) {
-        GridCoord[] kwadraty = new GridCoord[Math.abs(xp - xk) + 1];
+        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);
+                Coord.Grid[] temp = kwadratyOdcinkaDowolnego2(xk, yk, xp, yp);
-                GridCoord[] kwadraty = new GridCoord[temp.length];
+                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;
+        Coord.Grid[] kwadraty = null;
-        GridCoord[] rejon = poprawRejon(rej);
+        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);
+        Coord.Grid kw_min = wspXYOgranDolne(rejon);
-        GridCoord kw_max = wspXYOgranGorne(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) {
+    public static Coord.Grid srodekOdcinka(Coord.Grid[] odc) {
-        GridCoord srodek = null;
+        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) {
+    public static Coord.Grid srodekOdcinka(Coord.Grid pocz, Coord.Grid kon) {
-        GridCoord srodek = null;
+        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,
+    public static Coord.Grid srodekOdcinkaWazony(Coord.Grid pocz,
-                                                GridCoord kon, float waga) {
+                                                 Coord.Grid kon, float waga) {
-        GridCoord srodek = null;
+        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;
+        double dl = 0.0f;
-        GridCoord idkw1 = droga.get(pocz);
+        Coord.Grid idkw1 = droga.get(pocz);
-        GridCoord idkw2;
+        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);
+        double odl = Coord.Grid.distance(1, 1, 2, 2);
-        float odl2 = GridCoord.odlegloscApprox(1, 1, 2, 2);
+        double odl2 = Coord.Grid.distanceApprox(1, 1, 2, 2);
-        System.out.print("dist = " + odl + ", DELTA = " + (odl - odl2));
+        logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl);
-        System.out.println(", delta = " + (odl - odl2) / odl);
+        odl = Coord.Grid.distance(1, 1, 21, 21);
-        odl = GridCoord.odleglosc(1, 1, 21, 21);
+        odl2 = Coord.Grid.distanceApprox(1, 1, 21, 21);
-        odl2 = GridCoord.odlegloscApprox(1, 1, 21, 21);
+        logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl);
-        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);
 
-        GridCoord p = new GridCoord(4, 6);
+        odl = Coord.Grid.distance(1, 1, 1, 21);
-        GridCoord q = new GridCoord(8, 2);
+        odl2 = Coord.Grid.distanceApprox(1, 1, 1, 21);
-        GridCoord r = new GridCoord(6, 4);
+        logger.debug("dist = {}, dist2 = {}, DELTA = {}, delta = {}", odl, odl2, odl - odl2, (odl - odl2) / odl);
-        GridCoord s = new GridCoord(8, 6);
 
-        GridCoord startCoord = new GridCoord(10, 10);
+        odl = Coord.Grid.distance(1, 1, 10, 21);
-        GridCoord stopCoord = new GridCoord();
+        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)};
+        Coord.Grid[] lamana = {new Coord.Grid(8, 8), new Coord.Grid(3, 4), new Coord.Grid(6, 11)};
-        GridCoord[] tab = kwadratyLamanej2(lamana);
+        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];
+//         Coord.GridCoord[] polygon = new  Coord.GridCoord[21];
-//        polygon[0] = new GridCoord(12, 18);
+//        polygon[0] = new  Coord.GridCoord(12, 18);
-//        polygon[1] = new GridCoord(16, 18);
+//        polygon[1] = new  Coord.GridCoord(16, 18);
-//        polygon[2] = new GridCoord(18, 13);
+//        polygon[2] = new  Coord.GridCoord(18, 13);
-//        polygon[3] = new GridCoord(21, 13);
+//        polygon[3] = new  Coord.GridCoord(21, 13);
-//        polygon[4] = new GridCoord(22, 9);
+//        polygon[4] = new  Coord.GridCoord(22, 9);
-//        polygon[5] = new GridCoord(20, 7);
+//        polygon[5] = new  Coord.GridCoord(20, 7);
-//        polygon[6] = new GridCoord(17, 7);
+//        polygon[6] = new  Coord.GridCoord(17, 7);
-//        polygon[7] = new GridCoord(15, 9);
+//        polygon[7] = new  Coord.GridCoord(15, 9);
-//        polygon[8] = new GridCoord(13, 7);
+//        polygon[8] = new  Coord.GridCoord(13, 7);
-//        polygon[9] = new GridCoord(15, 5);
+//        polygon[9] = new  Coord.GridCoord(15, 5);
-//        polygon[10] = new GridCoord(17, 5);
+//        polygon[10] = new  Coord.GridCoord(17, 5);
-//        polygon[11] = new GridCoord(14, 2);
+//        polygon[11] = new  Coord.GridCoord(14, 2);
-//        polygon[12] = new GridCoord(8, 8);
+//        polygon[12] = new  Coord.GridCoord(8, 8);
-//        polygon[13] = new GridCoord(9, 3);
+//        polygon[13] = new  Coord.GridCoord(9, 3);
-//        polygon[14] = new GridCoord(6, 4);
+//        polygon[14] = new  Coord.GridCoord(6, 4);
-//        polygon[15] = new GridCoord(3, 4);
+//        polygon[15] = new  Coord.GridCoord(3, 4);
-//        polygon[16] = new GridCoord(2, 10);
+//        polygon[16] = new  Coord.GridCoord(2, 10);
-//        polygon[17] = new GridCoord(6, 11);
+//        polygon[17] = new  Coord.GridCoord(6, 11);
-//        polygon[18] = new GridCoord(6, 13);
+//        polygon[18] = new  Coord.GridCoord(6, 13);
-//        polygon[19] = new GridCoord(7, 15);
+//        polygon[19] = new  Coord.GridCoord(7, 15);
-//        polygon[20] = new GridCoord(10, 13);
+//        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];
+//		 Coord.GridCoord[] rejon = new  Coord.GridCoord[4];
-//		rejon[0] = new GridCoord(20, 18);
+//		rejon[0] = new  Coord.GridCoord(20, 18);
-//		rejon[1] = new GridCoord(27, 9);
+//		rejon[1] = new  Coord.GridCoord(27, 9);
-//		rejon[2] = new GridCoord(9, 1);
+//		rejon[2] = new  Coord.GridCoord(9, 1);
-//		rejon[3] = new GridCoord(2, 15);
+//		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];
+//             Coord.GridCoord[] rejon = new  Coord.GridCoord[4];
-//			rejon[0] = new GridCoord();
+//			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);

src/main/java/pl/wat/ms4ds/terenfunkcje/GridCoord.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/LukDrogowy.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/RightBigSquare.java

@@ -9,10 +9,10 @@ public class RightBigSquare extends BigSquare implements Serializable {
 
     private static final Logger logger = LoggerFactory.getLogger(RightBigSquare.class);
 
-    private Square kwadraty[][];
+    private Square squares[][];
 
     Square getKwadrat(int ssX, int ssY) {
-        return kwadraty[ssX][ssY];
+        return squares[ssX][ssY];
     }
 
     /**
@@ -46,34 +46,34 @@ public class RightBigSquare extends BigSquare implements Serializable {
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(sb.toString()));
         for (int x = 0; x < MapConsts.SS_PER_BS_X; x++) {
             for (int y = 0; y < MapConsts.SS_PER_BS_Y; y++) {
-                float f = kwadraty[x][y].stopienZalesienia * 100.0f;
+                float f = squares[x][y].stopienZalesienia * 100.0f;
                 int hex = (int) f;
                 hex = (hex > 100) ? 100 : hex;
                 hex = (hex < 0) ? 0 : hex;
                 out.writeByte(hex);
-                f = kwadraty[x][y].stopienZawodnienia * 100.0f;
+                f = squares[x][y].stopienZawodnienia * 100.0f;
                 hex = (int) f;
                 hex = (hex > 100) ? 100 : hex;
                 hex = (hex < 0) ? 0 : hex;
                 out.writeByte(hex);
-                f = kwadraty[x][y].stopienZabudowy * 100.0f;
+                f = squares[x][y].stopienZabudowy * 100.0f;
                 hex = (int) f;
                 hex = (hex > 100) ? 100 : hex;
                 hex = (hex < 0) ? 0 : hex;
                 out.writeByte(hex);
-                f = kwadraty[x][y].stopienZabagnienia * 100.0f;
+                f = squares[x][y].stopienZabagnienia * 100.0f;
                 hex = (int) f;
                 hex = (hex > 100) ? 100 : hex;
                 hex = (hex < 0) ? 0 : hex;
                 out.writeByte(hex);
-                out.writeInt(kwadraty[x][y].wysokoscSrednia);
+                out.writeInt(squares[x][y].wysokoscSrednia);
-                out.writeInt(kwadraty[x][y].roznicaWzniesien);
+                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;
+                squares[x][y].stopienZalesienia = (zalesienie) ? 0 : squares[x][y].stopienZalesienia;
-                kwadraty[x][y].stopienZawodnienia = (zawodnienie) ? 0 : kwadraty[x][y].stopienZawodnienia;
+                squares[x][y].stopienZawodnienia = (zawodnienie) ? 0 : squares[x][y].stopienZawodnienia;
-                kwadraty[x][y].stopienZabudowy = (zabudowa) ? 0 : kwadraty[x][y].stopienZabudowy;
+                squares[x][y].stopienZabudowy = (zabudowa) ? 0 : squares[x][y].stopienZabudowy;
-                kwadraty[x][y].stopienZabagnienia = (zabagnienie) ? 0 : kwadraty[x][y].stopienZabagnienia;
+                squares[x][y].stopienZabagnienia = (zabagnienie) ? 0 : squares[x][y].stopienZabagnienia;
-                kwadraty[x][y].wysokoscSrednia = (wysokosc) ? 0 : kwadraty[x][y].wysokoscSrednia;
+                squares[x][y].wysokoscSrednia = (wysokosc) ? 0 : squares[x][y].wysokoscSrednia;
-                kwadraty[x][y].roznicaWzniesien = (roznicaWzniesien) ? 0 : kwadraty[x][y].roznicaWzniesien;
+                squares[x][y].roznicaWzniesien = (roznicaWzniesien) ? 0 : squares[x][y].roznicaWzniesien;
                 if (drogi) {
-                    for (int i = 0; i < kwadraty[x][y].jestDroga.length; i++) {
+                    for (int i = 0; i < squares[x][y].jestDroga.length; i++) {
-                        kwadraty[x][y].jestDroga[i] = false;
+                        squares[x][y].jestDroga[i] = false;
                     }
                 }
                 if (rzeki) {
-                    for (int i = 0; i < kwadraty[x][y].jestPrzeszkodaWodna.length; i++) {
+                    for (int i = 0; i < squares[x][y].jestPrzeszkodaWodna.length; i++) {
-                        kwadraty[x][y].jestPrzeszkodaWodna[i] = false;
+                        squares[x][y].jestPrzeszkodaWodna[i] = false;
                     }
                 }
                 if (rowy) {
-                    for (int i = 0; i < kwadraty[x][y].jestRow.length; i++) {
+                    for (int i = 0; i < squares[x][y].jestRow.length; i++) {
-                        kwadraty[x][y].jestRow[i] = false;
+                        squares[x][y].jestRow[i] = false;
                     }
                 }
             }

src/main/java/pl/wat/ms4ds/terenfunkcje/SiecDrogowa.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/Square.java

@@ -44,9 +44,9 @@ public class Square {
     public float stopienZalesienia;
     public float stopienZawodnienia;
     public float stopienZabagnienia;
-    public boolean jestDroga[];
+    public boolean[] jestDroga;
-    public boolean jestRow[];
+    public boolean[] jestRow;
-    public boolean jestPrzeszkodaWodna[];
+    public boolean[] jestPrzeszkodaWodna;
     public int roznicaWzniesien;
     public int wysokoscSrednia;
     ////////////////////////////////////////

src/main/java/pl/wat/ms4ds/terenfunkcje/Teren.java

@@ -184,8 +184,8 @@ public class Teren {
      * @return Nazwa zwracanego pliku z danymi (null - gdy niepoprawne współrzędne).
      */
     public static String getFileName(double lat, double lon) {
-        int idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(lon);
+        int idX =  Coord.zamienDlugoscGeoNaIdKwadratuX(lon);
-        int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(lat);
+        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 idX =  Coord.zamienDlugoscGeoNaIdKwadratuX(lon);
-        int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(lat);
+        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"));

src/main/java/pl/wat/ms4ds/terenfunkcje/TerrainUtils.java

@@ -48,9 +48,9 @@ public class TerrainUtils {
         } else {
             wysBezwzgObserwatora = kwOd.wysokoscSrednia + ho;
         }
-        GridCoord[] kwadratyNaOdcinku = Bresenham.generateSegment(x1, y1, x2, y2);
+        Coord.Grid[] kwadratyNaOdcinku = Bresenham.generateSegment(x1, y1, x2, y2);
-        float dlugoscOdcinka = GridCoord.odleglosc(x1, y1, x2, y2);
+        double dlugoscOdcinka = Coord.Grid.distance(x1, y1, x2, y2);
-        float tangAlfa0 = roznicaWysokosci / dlugoscOdcinka;
+        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++)

src/main/java/pl/wat/ms4ds/terenfunkcje/WezelDrogowy.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordTest.java

@@ -2,6 +2,7 @@ package pl.wat.ms4ds.terenfunkcje.konwersja;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import pl.wat.ms4ds.terenfunkcje.Coord;
 import pl.wat.ms4ds.terenfunkcje.GeoCoord;
 
 public class CoordTest {
@@ -14,7 +15,7 @@ public class CoordTest {
         logger.debug(" ");
 
         PUWGCoord puwgCoord = new PUWGCoord();
-        GeoCoord geoCoord = new GeoCoord();
+        Coord.Geo geoCoord = new Coord.Geo();
         geoCoord.lon = 19;
         geoCoord.lat = 50;
         CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat, geoCoord.lon, puwgCoord);

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/CoordUtils.java

@@ -1,8 +1,6 @@
 package pl.wat.ms4ds.terenfunkcje.konwersja;
 
-import pl.wat.ms4ds.terenfunkcje.GeoCoord;
+import pl.wat.ms4ds.terenfunkcje.Coord;
-import pl.wat.ms4ds.terenfunkcje.GridCoord;
-import pl.wat.ms4ds.terenfunkcje.Square;
 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;

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/EsriFileReader.java

@@ -10,7 +10,7 @@ import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.MultiPointZShape;
 import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PointShape;
 import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PolygonShape;
 import org.nocrala.tools.gis.data.esri.shapefile.shape.shapes.PolylineShape;
-import pl.wat.ms4ds.terenfunkcje.GridCoord;
+import pl.wat.ms4ds.terenfunkcje.Coord;
 import pl.wat.ms4ds.terenfunkcje.MapConsts;
 import pl.wat.ms4ds.terenfunkcje.Teren;
 import org.slf4j.Logger;
@@ -98,8 +98,8 @@ public class EsriFileReader {
                                 currNode.lat = Math.min(currNode.lat, MapConsts.Y_REF + MapConsts.DY_REF);
                                 currNode.lat -= 90;
 
-                                currNode.idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon);
+                                currNode.idX = Coord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon);
-                                currNode.idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat);
+                                currNode.idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat);
                                 if (currNode.idX > 0 || currNode.idY > 0) {
                                     currWay.nodes.add(currNode);
                                 }

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/NMTData.java

@@ -1,20 +1,20 @@
 package pl.wat.ms4ds.terenfunkcje.konwersja;
 
-import pl.wat.ms4ds.terenfunkcje.GridCoord;
+import pl.wat.ms4ds.terenfunkcje.Coord;
 
 /**
  *
  */
 public class NMTData {
 
-    GridCoord idKw;
+    public Coord.Grid gridCoord;
 
-    double suma;
+    public double suma;
 
-    int licz;
+    public int licz;
 
-    public NMTData(GridCoord idKw, double suma, int licz) {
+    public NMTData(Coord.Grid gridCoord, double suma, int licz) {
-        this.idKw = idKw;
+        this.gridCoord = gridCoord;
         this.suma = suma;
         this.licz = licz;
     }

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/OpenStreetMapReader.java

@@ -1,6 +1,6 @@
 package pl.wat.ms4ds.terenfunkcje.konwersja;
 
-import pl.wat.ms4ds.terenfunkcje.GridCoord;
+import pl.wat.ms4ds.terenfunkcje.Coord;
 import pl.wat.ms4ds.terenfunkcje.Teren;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -238,8 +238,8 @@ public class OpenStreetMapReader {
                     switch (reader.getLocalName()) {
                         case "node":
                             if (currNode != null) {
-                                currNode.idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon);
+                                currNode.idX = Coord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon);
-                                currNode.idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat);
+                                currNode.idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat);
                                 if ("zabudowa".equals(genGoal) && currNode.buildingsCount > 0) {
                                     buildingNodesMap.put(currNode.id, currNode);
                                 }

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/UTMCoord.java

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

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Way.java

@@ -4,6 +4,7 @@ import pl.wat.ms4ds.common.EGeoDirection;
 import pl.wat.ms4ds.terenfunkcje.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import java.util.ArrayList;
 
 /**
@@ -243,16 +244,16 @@ public class Way {
         if (nodes.size() == 0) {
             return;
         }
-        GridCoord[] punktyLamanej = new GridCoord[nodes.size()];
+        Coord.Grid[] punktyLamanej = new Coord.Grid[nodes.size()];
         for (int i = 0; i < nodes.size(); i++) {
-            punktyLamanej[i] = new GridCoord(nodes.get(i).idX, nodes.get(i).idY);
+            punktyLamanej[i] = new Coord.Grid(nodes.get(i).idX, nodes.get(i).idY);
         }
         Square kw0;
         Square kw1;
-        GridCoord id0;
+        Coord.Grid id0;
-        GridCoord id1;
+        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.id] = true;
-                        kw0.jestDroga[kier.oppositeDirect().id]= true;
+                        kw0.jestDroga[kier.oppositeDirect().id] = true;
                         break;
                     case WATER_WAY:
-                        kw0.jestPrzeszkodaWodna[kier.id]= true;
+                        kw0.jestPrzeszkodaWodna[kier.id] = true;
-                        kw0.jestPrzeszkodaWodna[kier.oppositeDirect().id]= true;
+                        kw0.jestPrzeszkodaWodna[kier.oppositeDirect().id] = true;
                         break;
                     case DITCH:
-                        kw0.jestRow[kier.id]= true;
+                        kw0.jestRow[kier.id] = true;
-                        kw0.jestRow[kier.oppositeDirect().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) ||
+                        boolean b = pocz.equals(polygon[i]) ||
-                                pocz.rowne(polygon[i_puls_1].x, polygon[i_puls_1].y) ||
+                                pocz.equals(polygon[i_puls_1]) ||
-                                kon.rowne(polygon[i].x, polygon[i].y) ||
+                                kon.equals(polygon[i]) ||
-                                kon.rowne(polygon[i_puls_1].x, polygon[i_puls_1].y);
+                                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,
+    public static void writeAreaFeatureIntoSquares(EAreaFeature type, boolean clearFeature, Coord.Grid[] polygon,
-                                                   int minX,int maxX, int minY, int maxY) {
+                                                   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;

src/main/java/pl/wat/ms4ds/terenfunkcje/konwersja/Worker.java

@@ -1,8 +1,9 @@
 package pl.wat.ms4ds.terenfunkcje.konwersja;
 
-import pl.wat.ms4ds.terenfunkcje.GridCoord;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import pl.wat.ms4ds.terenfunkcje.Coord;
+
 import java.util.ArrayList;
 
 /**
@@ -18,13 +19,13 @@ public class Worker extends Thread {
 
     EAreaFeature type;
     boolean clearFeature;
-    GridCoord[] polygon;
+    Coord.Grid[] polygon;
     int minX;
     int maxX;
     int minY;
     int maxY;
 
-    public Worker(EAreaFeature type, boolean clearFeature, GridCoord[] polygon, int minX, int maxX, int minY, int maxY) {
+    public Worker(EAreaFeature type, boolean clearFeature, Coord.Grid[] polygon, int minX, int maxX, int minY, int maxY) {
         super("Worker_" + nr++);
         this.type = type;
         this.clearFeature = clearFeature;

src/main/java/pl/wat/ms4ds/terenfunkcje/nmt/NMTReader.java

@@ -116,22 +116,22 @@ public class NMTReader {
                     data[i][j] = Double.parseDouble(split[j]);
                 }
             }
-            GeoCoord geo_ll = new GeoCoord();
+            Coord.Geo geo_ll = new Coord.Geo();
             CoordUtils.convertPUWG1992ToWGS84(yll, xll, geo_ll);
-            GeoCoord geo_ur = new GeoCoord();
+            Coord.Geo geo_ur = new Coord.Geo();
             CoordUtils.convertPUWG1992ToWGS84(yll + nrows + cellsize, xll + ncols * cellsize, geo_ur);
             int d_x = (int) ((geo_ur.lon - geo_ll.lon) / MapConsts.DELTA_X) + 3;
             int d_y = (int) ((geo_ur.lat - geo_ll.lat) / MapConsts.DELTA_Y) + 3;
             Square[][] kwadraty = new Square[d_x][d_y];
-            final int x = GridCoord.zamienDlugoscGeoNaIdKwadratuX(geo_ll.lon);
+            final int x = Coord.zamienDlugoscGeoNaIdKwadratuX(geo_ll.lon);
-            final int y = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo_ll.lat);
+            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();
+            Coord.Geo geoCoord = new Coord.Geo();
-            geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(x);
+            geoCoord.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(x);
-            geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(y);
+            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.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX + x);
-                        geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y);
+                        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.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX + x);
-                            geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y);
+                            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 idX = Coord.zamienDlugoscGeoNaIdKwadratuX(geo.lon);
-                        int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo.lat);
+                        int idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(geo.lat);
                         // Współrzędne geo środka kwadratu.
-                        geo.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX);
+                        geo.lon = Coord.zamienIdKwadratuXNaDlugoscGeo(idX);
-                        geo.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY);
+                        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;