changed project structure

2025-07-25 15:06:22 +02:00
commit 46b225430d
24 changed files with 1633 additions and 0 deletions
@@ -0,0 +1,224 @@
+package dev.ksan.travelpathoptimizer.app;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.*;
+
+public class TransportDataGenerator {
+  private static final int SIZE = 10;
+  private int n;
+  private int m;
+
+  private static final int DEPARTURES_PER_STATION = 1;
+  private static final Random random = new Random();
+
+  public static void main(String[] args) {
+    TransportDataGenerator generator = new TransportDataGenerator(2, 2);
+    TransportData data = generator.generateData();
+    generator.saveToJson(data, "transport_data.json");
+    System.out.println("Podaci su generisani i sacuvani kao transport_data.json");
+  }
+
+  TransportDataGenerator() {
+    this.n = SIZE;
+    this.m = SIZE;
+  }
+
+  TransportDataGenerator(int n) {
+    this.n = n;
+    this.m = n;
+  }
+
+  TransportDataGenerator(int n, int m) {
+    this.n = n;
+    this.m = m;
+  }
+
+  // struktura podataka koja sadrzi sve trazene ulazne podatke
+  public static class TransportData {
+    public String[][] countryMap;
+    public List<Station> stations;
+    public List<Departure> departures;
+  }
+
+  public static class Station {
+    public String city;
+    public String busStation;
+    public String trainStation;
+  }
+
+  public static class Departure {
+    public String type; // "autobus" ili "voz"
+    public String from;
+    public String to;
+    public String departureTime;
+    public int duration; // u minutama
+    public int price;
+    public int minTransferTime; // vrijeme potrebno za transfer (u minutama)
+  }
+
+  public TransportData generateData() {
+    TransportData data = new TransportData();
+    data.countryMap = generateCountryMap();
+    data.stations = generateStations();
+    data.departures = generateDepartures(data.stations);
+    return data;
+  }
+
+  // generisanje gradova (G_X_Y)
+  private String[][] generateCountryMap() {
+    String[][] countryMap = new String[n][m];
+    for (int x = 0; x < n; x++) {
+      for (int y = 0; y < m; y++) {
+        countryMap[x][y] = "G_" + x + "_" + y;
+      }
+    }
+    return countryMap;
+  }
+
+  // generisanje autobuskih i zeljeznickih stanica
+  private List<Station> generateStations() {
+    List<Station> stations = new ArrayList<>();
+    for (int x = 0; x < n; x++) {
+      for (int y = 0; y < m; y++) {
+        Station station = new Station();
+        station.city = "G_" + x + "_" + y;
+        station.busStation = "A_" + x + "_" + y;
+        station.trainStation = "Z_" + x + "_" + y;
+        stations.add(station);
+      }
+    }
+    return stations;
+  }
+
+  // generisanje vremena polazaka
+  private List<Departure> generateDepartures(List<Station> stations) {
+    List<Departure> departures = new ArrayList<>();
+
+    for (Station station : stations) {
+      int x = Integer.parseInt(station.city.split("_")[1]);
+      int y = Integer.parseInt(station.city.split("_")[2]);
+
+      // generisanje polazaka autobusa
+      for (int i = 0; i < DEPARTURES_PER_STATION; i++) {
+        departures.add(generateDeparture("autobus", station.busStation, x, y));
+      }
+
+      // generisanje polazaka vozova
+      for (int i = 0; i < DEPARTURES_PER_STATION; i++) {
+        departures.add(generateDeparture("voz", station.trainStation, x, y));
+      }
+    }
+    return departures;
+  }
+
+  private Departure generateDeparture(String type, String from, int x, int y) {
+    Departure departure = new Departure();
+    departure.type = type;
+    departure.from = from;
+
+    // generisanje susjeda
+    List<String> neighbors = getNeighbors(x, y);
+    departure.to = neighbors.isEmpty() ? from : neighbors.get(random.nextInt(neighbors.size()));
+
+    // generisanje vremena
+    int hour = random.nextInt(24);
+    int minute = random.nextInt(4) * 15; // 0, 15, 30, 45
+    departure.departureTime = String.format("%02d:%02d", hour, minute);
+
+    // geneirsanje cijene
+    departure.duration = 30 + random.nextInt(151);
+    departure.price = 100 + random.nextInt(901);
+
+    // generisanje vremena transfera
+    departure.minTransferTime = 5 + random.nextInt(26);
+
+    return departure;
+  }
+
+  // pronalazak susjednih gradova
+  private List<String> getNeighbors(int x, int y) {
+    List<String> neighbors = new ArrayList<>();
+    int[][] directions = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
+
+    for (int[] dir : directions) {
+      int nx = x + dir[0];
+      int ny = y + dir[1];
+      if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
+        neighbors.add("G_" + nx + "_" + ny);
+      }
+    }
+    return neighbors;
+  }
+
+  // cuvanje podataka u JSON mapu
+  private void saveToJson(TransportData data, String filename) {
+    try (FileWriter file = new FileWriter(filename)) {
+      StringBuilder json = new StringBuilder();
+      json.append("{\n");
+
+      // mapa drzave
+      json.append("  \"countryMap\": [\n");
+      for (int i = 0; i < n; i++) {
+        json.append("    [");
+        for (int j = 0; j < m; j++) {
+          json.append("\"").append(data.countryMap[i][j]).append("\"");
+          if (j < m - 1)
+            json.append(", ");
+        }
+        json.append("]");
+        if (i < n - 1)
+          json.append(",");
+        json.append("\n");
+      }
+      json.append("  ],\n");
+
+      // stanice
+      json.append("  \"stations\": [\n");
+      for (int i = 0; i < data.stations.size(); i++) {
+        Station s = data.stations.get(i);
+        json.append("    {\"city\": \"")
+            .append(s.city)
+            .append("\", \"busStation\": \"")
+            .append(s.busStation)
+            .append("\", \"trainStation\": \"")
+            .append(s.trainStation)
+            .append("\"}");
+        if (i < data.stations.size() - 1)
+          json.append(",");
+        json.append("\n");
+      }
+      json.append("  ],\n");
+
+      // vremena polazaka
+      json.append("  \"departures\": [\n");
+      for (int i = 0; i < data.departures.size(); i++) {
+        Departure d = data.departures.get(i);
+        json.append("    {\"type\": \"")
+            .append(d.type)
+            .append("\", \"from\": \"")
+            .append(d.from)
+            .append("\", \"to\": \"")
+            .append(d.to)
+            .append("\", \"departureTime\": \"")
+            .append(d.departureTime)
+            .append("\", \"duration\": ")
+            .append(d.duration)
+            .append(", \"price\": ")
+            .append(d.price)
+            .append(", \"minTransferTime\": ")
+            .append(d.minTransferTime)
+            .append("}");
+        if (i < data.departures.size() - 1)
+          json.append(",");
+        json.append("\n");
+      }
+      json.append("  ]\n");
+
+      json.append("}");
+      file.write(json.toString());
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+}
@@ -0,0 +1,23 @@
+package dev.ksan.travelpathoptimizer.app;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+import java.io.IOException;
+
+public class TravelPathOptimizerApplication extends Application {
+    @Override
+    public void start(Stage stage) throws IOException {
+        FXMLLoader fxmlLoader = new FXMLLoader(TravelPathOptimizerApplication.class.getResource("hello-view.fxml"));
+        Scene scene = new Scene(fxmlLoader.load(), 320, 240);
+        stage.setTitle("Hello!");
+        stage.setScene(scene);
+        stage.show();
+    }
+
+    public static void main(String[] args) {
+        launch();
+    }
+}
@@ -0,0 +1,14 @@
+package dev.ksan.travelpathoptimizer.controller;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+
+public class TransportPathOptimizerController {
+    @FXML
+    private Label welcomeText;
+
+    @FXML
+    protected void onHelloButtonClick() {
+        welcomeText.setText("Welcome to JavaFX Application!");
+    }
+}
@@ -0,0 +1,100 @@
+package dev.ksan.travelpathoptimizer.graph;
+
+import dev.ksan.travelpathoptimizer.model.City;
+import dev.ksan.travelpathoptimizer.model.Departure;
+import dev.ksan.travelpathoptimizer.model.Location;
+import dev.ksan.travelpathoptimizer.service.CityManager;
+import dev.ksan.travelpathoptimizer.util.JsonParser;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class Graph {
+  private City[][] matrix;
+
+  public static void main(String[] args) {
+    List<City> cities = JsonParser.parseCities("transport_data.json", "stations");
+    List<Departure> departures = JsonParser.getDeparturesList("transport_data.json", "departures");
+    cities = JsonParser.loadDepartures(cities, departures);
+    City[][] map = JsonParser.loadMap("transport_data.json", "countryMap", cities);
+
+    Graph graph = new Graph(map);
+    cities = JsonParser.loadDepartures(cities, departures);
+    System.out.println(cities.getFirst().getName() + " do " + cities.getLast().getName());
+    for (City city : cities) {
+      CityManager.addCity(city);
+    }
+    Map<Location, Double> result =
+        graph.calculateShortestPath(cities.getFirst(), cities.get(3), "hops");
+    System.out.println(
+        cities.getLast().getName() + " = " + result.get(cities.get(3).getLocation()));
+  }
+
+  public Map<Location, Double> calculateShortestPath(City startCity, City endCity, String type) {
+    int n = matrix.length;
+    int m = matrix[0].length;
+
+    Map<Location, Double> distances = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < m; j++) {
+        distances.put(new Location(i, j), Double.MAX_VALUE);
+      }
+    }
+
+    distances.put(startCity.getLocation(), 0.0);
+
+    PriorityQueue<City> pq =
+        new PriorityQueue<>(Comparator.comparingDouble(city -> distances.get(city.getLocation())));
+    pq.add(startCity);
+
+    while (!pq.isEmpty()) {
+      City current = pq.poll();
+
+      // If we reached the end city, we can stop early
+      if (current == endCity) {
+        break;
+      }
+
+      for (Departure dep : current.getDestinations()) {
+        City neighborCity = dep.getDestinationCity();
+        Location neighborLocation = neighborCity.getLocation();
+
+        double newCost = 0.0;
+        double currentCost = distances.get(current.getLocation());
+        if (type.equals("price")) {
+          newCost = distances.get(current.getLocation()) + dep.getPrice();
+        } else if (type.equals("time")) {
+          newCost = distances.get(current.getLocation()) + dep.getDuration();
+        } else if (type.equals("hops")) {
+          newCost = currentCost + 1;
+        }
+
+        if (newCost < distances.get(neighborLocation)) {
+          distances.put(neighborLocation, newCost);
+          pq.add(neighborCity);
+        }
+      }
+    }
+
+    return distances;
+  }
+
+  public Graph(City[][] matrix) {
+    this.matrix = matrix;
+  }
+
+  public void updateMatrix(City[][] matrix) {
+    this.matrix = matrix;
+  }
+
+  public City[][] getMatrix() {
+    return matrix;
+  }
+
+  public City getCity(Location loc) {
+    return matrix[loc.getX()][loc.getY()];
+  }
+}
@@ -0,0 +1,71 @@
+package dev.ksan.travelpathoptimizer.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class City {
+  private String name;
+  private Station trainStation;
+  private Station busStation;
+  private Location location;
+
+  City(String name, String bus, String train, int row, int col) {
+    this.name = name;
+    this.trainStation = new Station(TransportType.TRAIN, train);
+    this.busStation = new Station(TransportType.BUS, bus);
+    this.location = new Location(row, col);
+  }
+
+  City(String name, Station bus, Station train, int row, int col) {
+    this.name = name;
+    this.trainStation = train;
+    this.busStation = bus;
+    this.location = new Location(row, col);
+  }
+
+  public List<Departure> getDestinations() {
+    List<Departure> departures = new ArrayList<>();
+
+    for (Departure dep : busStation.getDepartures()) {
+      departures.add(dep);
+    }
+    for (Departure dep : trainStation.getDepartures()) {
+      departures.add(dep);
+    }
+
+    return departures;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Station getTrainStation() {
+    return trainStation;
+  }
+
+  public void setTrainStation(Station trainStation) {
+    this.trainStation = trainStation;
+  }
+
+  public Station getBusStation() {
+    return busStation;
+  }
+
+  public void setBusStation(Station busStation) {
+    this.busStation = busStation;
+  }
+
+  public Location getLocation() {
+    return this.location;
+  }
+
+  @Override
+  public String toString() {
+    return name + "\n\tTrain Station: " + trainStation + "\n\tBus Station: " + busStation;
+  }
+}
@@ -0,0 +1,84 @@
+package dev.ksan.travelpathoptimizer.model;
+
+import dev.ksan.travelpathoptimizer.service.CityManager;
+
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+
+public class Departure {
+  private TransportType type;
+  private String from;
+  private String to;
+  private int duration;
+  private LocalTime departureTime;
+  private double price;
+  private int minTransferTime;
+
+  public Departure(
+      TransportType type,
+      String from,
+      String to,
+      String departureTime,
+      int duration,
+      double price,
+      int minTransferTime) {
+    this.type = type;
+    this.from = from;
+    this.to = to;
+    this.departureTime = LocalTime.parse(departureTime, DateTimeFormatter.ofPattern("HH:mm"));
+    this.duration = duration;
+    this.price = price;
+    this.minTransferTime = minTransferTime;
+  }
+
+  public City getDestinationCity() {
+
+    return CityManager.getCityByName(to);
+  }
+
+  public TransportType getType() {
+    return type;
+  }
+
+  public String getFrom() {
+    return from;
+  }
+
+  public String getTo() {
+    return to;
+  }
+
+  public int getDuration() {
+    return duration;
+  }
+
+  public double getPrice() {
+    return price;
+  }
+
+  public int getMinTransferTime() {
+    return minTransferTime;
+  }
+
+  @Override
+  public String toString() {
+    return "Departure{"
+        + "type="
+        + type
+        + ", from='"
+        + from
+        + '\''
+        + ", to='"
+        + to
+        + '\''
+        + ", departureTime="
+        + departureTime.format(DateTimeFormatter.ofPattern("HH:mm"))
+        + ", duration="
+        + duration
+        + ", price="
+        + price
+        + ", minTransferTime="
+        + minTransferTime
+        + "}";
+  }
+}
@@ -0,0 +1,43 @@
+package dev.ksan.travelpathoptimizer.model;
+
+import java.util.Objects;
+
+public class Location {
+
+  private int x;
+  private int y;
+
+  public Location(int x, int y) {
+    this.x = x;
+    this.y = 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;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Location location = (Location) o;
+    return x == location.x && y == location.y;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(x, y);
+  }
+}
@@ -0,0 +1,38 @@
+package dev.ksan.travelpathoptimizer.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Station {
+
+  private TransportType type = TransportType.NOT_ASSIGNED;
+  private String name;
+  private List<Departure> departures = new ArrayList<Departure>();
+
+  Station() {}
+
+  Station(TransportType type, String name) {
+    this.type = type;
+    this.name = name;
+  }
+
+  public TransportType getType() {
+    return type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public List<Departure> getDepartures() {
+    return departures;
+  }
+
+  public void addDeparture(Departure departure) {
+    departures.add(departure);
+  }
+  @Override
+  public String toString() {
+    return "Station{" + "type=" + type + ", name=" + name + ", departures=" + departures;
+  }
+}
@@ -0,0 +1,18 @@
+package dev.ksan.travelpathoptimizer.model;
+
+public enum TransportType {
+  NOT_ASSIGNED("null"),
+  BUS("autobus"),
+  TRAIN("voz");
+
+  private final String type;
+
+  TransportType(String type) {
+    this.type = type;
+  }
+
+  @Override
+  public String toString() {
+    return this.type;
+  }
+}
@@ -0,0 +1,50 @@
+package dev.ksan.travelpathoptimizer.model;
+
+public class User {
+  private String name;
+  private int id;
+  private Location location;
+  private Location destination;
+
+  private static int idCounter = 1;
+  // :TODO:
+  private static final String ID_FILE = "id_counter.txt";
+
+  public User(String name) {
+    this.name = name;
+    this.id = idCounter++;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public Location getLocation() {
+    return location;
+  }
+
+  public void setLocation(Location location) {
+    this.location = location;
+  }
+
+  public Location getDestination() {
+    return destination;
+  }
+
+  public void setDestination(Location destination) {
+    this.destination = destination;
+  }
+
+  @Override
+  public String toString() {
+    return "User{id=" + id + ", name='" + name + "'}";
+  }
+}
@@ -0,0 +1,18 @@
+package dev.ksan.travelpathoptimizer.service;
+
+import dev.ksan.travelpathoptimizer.model.City;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CityManager {
+  private static Map<String, City> cities = new HashMap<>();
+
+  public static void addCity(City city) {
+    cities.put(city.getName(), city);
+  }
+
+  public static City getCityByName(String cityName) {
+    return cities.get(cityName);
+  }
+}
@@ -0,0 +1,255 @@
+package dev.ksan.travelpathoptimizer.util;
+
+import dev.ksan.travelpathoptimizer.model.City;
+import dev.ksan.travelpathoptimizer.model.Departure;
+import dev.ksan.travelpathoptimizer.model.TransportType;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class JsonParser {
+  /*
+    public static void main(String[] args) {
+      String[][] map = JsonParser.parseCountryMap("transport_data.json", "countryMap");
+      List<City> cities = JsonParser.parseCities("transport_data.json", "stations");
+      List<Departure> departures = JsonParser.getDeparturesList("transport_data.json", "departures");
+
+      cities = JsonParser.loadDepartures(cities, departures);
+      for (City city : cities) {
+        System.out.println(city);
+      }
+    }
+  */
+  public static String getValue(String fileName, String key) {
+    StringBuilder json = new StringBuilder();
+    try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
+      String line;
+      while ((line = reader.readLine()) != null) {
+        json.append(line.trim());
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    String searchKey = "\"" + key + "\": [";
+    int keyIndex = json.indexOf(searchKey);
+
+    if (keyIndex == -1) return null;
+
+    String jsonString = json.toString();
+    int startIndex = keyIndex + searchKey.length() - 1;
+
+    int endIndex = findPair(jsonString, startIndex);
+
+    if (endIndex == -1) return null;
+
+    return jsonString.substring(startIndex, endIndex);
+  }
+
+  public static City[][] loadMap(String fileName, String key, List<City> cities) {
+    String[][] cityMap = parseCountryMap(fileName, key);
+    City[][] map = new City[cityMap.length][cityMap[0].length];
+
+    for (City city : cities) {
+      map[city.getLocation().getX()][city.getLocation().getY()] = city;
+    }
+
+    return map;
+  }
+
+  public static String[][] parseCountryMap(String fileName, String key) {
+
+    String mapData = getValue(fileName, key);
+
+    mapData = mapData.replaceAll("[\\[\\]]+", "|");
+    String[] rows = mapData.split("\\|");
+
+    List<String[]> matrixList = new ArrayList<>();
+
+    for (String row : rows) {
+      if (row.trim().isEmpty()) continue;
+      String[] cities =
+          Arrays.stream(row.split(","))
+              .map(s -> s.replaceAll("\"", "").trim())
+              .filter(s -> !s.isEmpty())
+              .toArray(String[]::new);
+      if (cities.length > 0) matrixList.add(cities);
+    }
+    String[][] result = new String[matrixList.size()][];
+    for (int i = 0; i < matrixList.size(); i++) {
+
+      result[i] = matrixList.get(i);
+    }
+    /*
+        for (int i = 0; i < result.length; i++) {
+          for (int j = 0; j < result[i].length; j++) {
+            System.out.println("result[" + i + "][" + j + "] = " + result[i][j]);
+          }
+        }
+    */
+    return result;
+  }
+
+  public static List<Departure> getDeparturesList(String fileName, String key) {
+    List<Departure> departures = new ArrayList<>();
+
+    String departuresJson = getValue(fileName, key);
+
+    String res =
+        departuresJson
+            .replaceAll("[\\{\\[\\]]", "")
+            .replaceAll("\\},", "\\|")
+            .replaceAll("\\}", "")
+            .replaceAll("\\\"", "")
+            .replaceAll(
+                "type:\\s|\\sfrom:\\s|\\sto:\\s|\\sdepartureTime:\\s|\\sduration:\\s|\\sprice:\\s|\\sminTransferTime:\\s",
+                "");
+
+    String[] arr = res.split("\\|");
+    for (String a : arr) {
+      String[] temp = a.split(",");
+      departures.add(
+          new Departure(
+              parseTransportType(temp[0]),
+              temp[1],
+              temp[2],
+              temp[3],
+              Integer.parseInt(temp[4]),
+              Double.parseDouble(temp[5]),
+              Integer.parseInt(temp[6])));
+    }
+
+    return departures;
+  }
+
+  public static List<City> parseCities(String fileName, String key) {
+    String cityData = getValue(fileName, key);
+    String res =
+        cityData
+            .replaceAll("[\\[\\]]+", "")
+            .replaceAll("\\},\\{", "\n")
+            .replaceAll("[\\{\\}]", "")
+            .replaceAll("\\n", "|");
+
+    String[] arr = res.split("\\|");
+
+    List<City> cities = new ArrayList<>();
+    List<String[]> list = new ArrayList<>();
+    for (int i = 0; i < arr.length; i++) {
+      String[] temp = arr[i].split(",");
+      list.add(temp);
+    }
+    List<String> temp = new ArrayList<>();
+    List<String> formatedList = new ArrayList<>();
+    for (String[] a : list) {
+      temp.clear();
+      formatedList.clear();
+      for (String b : a) {
+        temp.add(b);
+      }
+      for (String item : temp) {
+        item = (item.replaceAll("\\\"[a-zA-Z]+\\\":\\s", "").trim().replaceAll("\\\"", ""));
+      }
+
+      for (int j = 0; j < temp.size(); j++) {
+        formatedList.add(
+            temp.get(j).replaceAll("\\\"[a-zA-Z]+\\\":\\s", "").trim().replaceAll("\\\"", ""));
+      }
+
+      String[] parts = formatedList.get(0).split("_");
+      String name = formatedList.get(0);
+      String bus = formatedList.get(1);
+      String train = formatedList.get(2);
+      int x = Integer.parseInt(parts[1]);
+      int y = Integer.parseInt(parts[2]);
+      cities.add(new City(name, bus, train, x, y));
+    }
+    return cities;
+  }
+
+  // Way to slow for big sets of data because it has O(n*m)
+  public static List<City> loadDeparturesOld(List<City> cities, List<Departure> departures) {
+
+    for (Departure dep : departures) {
+
+      for (City city : cities) {
+
+        if (dep.getType() == TransportType.BUS) {
+          if (dep.getFrom().equals(city.getBusStation().getName())) {
+            city.getBusStation().addDeparture(dep);
+          }
+        } else if (dep.getType() == TransportType.TRAIN) {
+
+          if (dep.getFrom().equals(city.getTrainStation().getName())) {
+            city.getTrainStation().addDeparture(dep);
+          }
+        }
+      }
+    }
+    return cities;
+  }
+
+  public static List<City> loadDepartures(List<City> cities, List<Departure> departures) {
+
+    Map<String, City> stationToCityMap = new HashMap();
+
+    for (City city : cities) {
+      if (city.getBusStation() != null) {
+        stationToCityMap.put(city.getBusStation().getName(), city);
+      }
+      if (city.getBusStation() != null) {
+        stationToCityMap.put(city.getTrainStation().getName(), city);
+      }
+    }
+
+    for (Departure dep : departures) {
+      City city = stationToCityMap.get(dep.getFrom());
+
+      if (city != null) {
+        if (dep.getType() == TransportType.BUS
+            && city.getBusStation().getName().equals(dep.getFrom())) {
+
+          city.getBusStation().addDeparture(dep);
+        } else if (dep.getType() == TransportType.TRAIN
+            && city.getTrainStation().getName().equals(dep.getFrom())) {
+          city.getTrainStation().addDeparture(dep);
+        }
+      }
+    }
+    return cities;
+  }
+
+  private static int findPair(String str, int startIndex) {
+
+    char open = str.charAt(startIndex);
+    char closed = (open == '[') ? ']' : '}';
+
+    int depth = 0;
+    for (int i = startIndex; i < str.length(); i++) {
+      char c = str.charAt(i);
+      if (c == open) {
+        depth++;
+      } else if (c == closed) {
+        depth--;
+        if (depth == 0) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+
+  public static TransportType parseTransportType(String str) {
+    for (TransportType t : TransportType.values()) {
+      if (t.toString().equalsIgnoreCase(str)) {
+        return t;
+      }
+    }
+    return TransportType.NOT_ASSIGNED;
+  }
+}
@@ -0,0 +1,20 @@
+module dev.ksan.travelpathoptimizer {
+    requires javafx.controls;
+    requires javafx.fxml;
+
+
+    opens dev.ksan.travelpathoptimizer to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer;
+    exports dev.ksan.travelpathoptimizer.app;
+    opens dev.ksan.travelpathoptimizer.app to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer.controller;
+    opens dev.ksan.travelpathoptimizer.controller to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer.model;
+    opens dev.ksan.travelpathoptimizer.model to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer.util;
+    opens dev.ksan.travelpathoptimizer.util to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer.service;
+    opens dev.ksan.travelpathoptimizer.service to javafx.fxml;
+    exports dev.ksan.travelpathoptimizer.graph;
+    opens dev.ksan.travelpathoptimizer.graph to javafx.fxml;
+}
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.VBox?>
+
+<?import javafx.scene.control.Button?>
+<VBox alignment="CENTER" spacing="20.0" xmlns:fx="http://javafx.com/fxml"
+      fx:controller="dev.ksan.travelpathoptimizer.controller.TransportPathOptimizerController">
+    <padding>
+        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0"/>
+    </padding>
+
+    <Label fx:id="welcomeText"/>
+    <Button text="Hello!" onAction="#onHelloButtonClick"/>
+</VBox>