Refactor: Adjust TransportationObject rendering

Changes the construction of the TreeLists and the renderer handling to
reflect the new model of TransportationObjects.

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java

@@ -399,7 +399,7 @@ public class CityDoctorController {
         TreeItem<Renderable> transRoot = new TreeItem<>(new AllTransportationNode(model.getTransportation()));
         transRoot.setExpanded(true);
         transView.setRoot(transRoot);
-        buildTreeFromList(trans, transView.getRoot(), transportationChunkNr);
+        buildTransportationTreeFromList(trans, transView.getRoot());
         addMoreButtonIfNecessary(trans, transView, transRoot, transportationChunkNr);
     }
 
@@ -597,6 +597,111 @@ public class CityDoctorController {
 
     }
 
+    private void buildTransportationTreeFromList(List<TransportationObject> list, TreeItem<Renderable> root) {
+        int transportChunk = transportationChunkNr.get();
+        for (int i = transportChunk * MAX_FEATURES_PER_CHUNK; i < (transportChunk + 1) * MAX_FEATURES_PER_CHUNK
+                && i < list.size(); i++) {
+            TransportationObject t = list.get(i);
+            TransportationObjectNode node = new TransportationObjectNode(t);
+            TreeItem<Renderable> item = new TreeItem<>(node);
+            item.setExpanded(true);
+            root.getChildren().add(item);
+            createGeometryNodes(t, item);
+            createTransportSectionNodes(t, item);
+            createTrafficSpacesNodes(t, item);
+        }
+    }
+
+    private void createTransportSectionNodes(TransportationObject t, TreeItem<Renderable> root) {
+        if (t instanceof TopLevelTransportFeature top) {
+            if (!top.getSections().isEmpty()) {
+                AllTransportSectionNode allSectionsNode = new AllTransportSectionNode(top.getSections(),
+                        TransportSection.SectionType.SECTION);
+                TreeItem<Renderable> allSectionsNodeTextItem = new TreeItem<>(allSectionsNode);
+                root.getChildren().add(allSectionsNodeTextItem);
+
+                for (TransportSection ts : top.getSections()) {
+                    TransportationObjectNode tsNode = new TransportationObjectNode(ts);
+                    TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
+                    tsNodeItem.setExpanded(false);
+                    allSectionsNodeTextItem.getChildren().add(tsNodeItem);
+                    createGeometryNodes(ts, tsNodeItem);
+                    createTrafficSpacesNodes(ts, tsNodeItem);
+                }
+
+            }
+            if (!top.getIntersections().isEmpty()) {
+                AllTransportSectionNode allIntersectionsNode = new AllTransportSectionNode(top.getIntersections(),
+                        TransportSection.SectionType.INTERSECTION);
+                TreeItem<Renderable> allIntersectionsNodeTextItem = new TreeItem<>(allIntersectionsNode);
+                root.getChildren().add(allIntersectionsNodeTextItem);
+
+                for (TransportSection ts : top.getIntersections()) {
+                    TransportationObjectNode tsNode = new TransportationObjectNode(ts);
+                    TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
+                    tsNodeItem.setExpanded(false);
+                    allIntersectionsNodeTextItem.getChildren().add(tsNodeItem);
+                    createGeometryNodes(ts, tsNodeItem);
+                    createTrafficSpacesNodes(ts, tsNodeItem);
+                }
+            }
+        }
+    }
+
+    private void createTrafficSpacesNodes(TransportationObject t, TreeItem<Renderable> root) {
+        if (t instanceof TransportationSpace space) {
+            if (!space.getTrafficSpaces().isEmpty()) {
+                AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getTrafficSpaces(),
+                        TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+                TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode);
+                root.getChildren().add(allTSNodeTextItem);
+                allTSNodeTextItem.setExpanded(true);
+
+                for (TrafficSpaceObject tso : space.getTrafficSpaces()) {
+                    TransportationObjectNode tsoNode = new TransportationObjectNode(tso);
+                    TreeItem<Renderable> tsoNodeItem = new TreeItem<>(tsoNode);
+                    tsoNodeItem.setExpanded(false);
+                    allTSNodeTextItem.getChildren().add(tsoNodeItem);
+                    createGeometryNodes(tso, tsoNodeItem);
+                    createTrafficAreaNodes(tso, tsoNodeItem, TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+                }
+            }
+            if (!space.getAuxTrafficSpaces().isEmpty()) {
+                AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getAuxTrafficSpaces(),
+                        TrafficSpaceObject.TrafficSpaceType.AUXILIARY_TRAFFIC_SPACE);
+                TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode);
+                root.getChildren().add(allTSNodeTextItem);
+                allTSNodeTextItem.setExpanded(true);
+
+                for (TrafficSpaceObject atso : space.getAuxTrafficSpaces()) {
+                    TransportationObjectNode atsoNode = new TransportationObjectNode(atso);
+                    TreeItem<Renderable> atsoNodeItem = new TreeItem<>(atsoNode);
+                    atsoNodeItem.setExpanded(false);
+                    allTSNodeTextItem.getChildren().add(atsoNodeItem);
+                    createGeometryNodes(atso, atsoNodeItem);
+                    createTrafficAreaNodes(atso, atsoNodeItem, TrafficAreaObject.TrafficAreaType.AUXILIARY_TRAFFIC_AREA);
+                }
+            }
+        }
+    }
+
+    public void createTrafficAreaNodes(TransportationObject t, TreeItem<Renderable> root, TrafficAreaObject.TrafficAreaType type) {
+        if (t instanceof TrafficSpaceObject space && !space.getTrafficAreas().isEmpty()) {
+            AllTrafficAreaNode allTANode = new AllTrafficAreaNode(space.getTrafficAreas(), type);
+            TreeItem<Renderable> allTANodeTextItem = new TreeItem<>(allTANode);
+            root.getChildren().add(allTANodeTextItem);
+            allTANodeTextItem.setExpanded(true);
+            for (TrafficAreaObject tao : space.getTrafficAreas()) {
+                TransportationObjectNode taoNode = new TransportationObjectNode(tao);
+                TreeItem<Renderable> taoNodeTextItem = new TreeItem<>(taoNode);
+                taoNodeTextItem.setExpanded(true);
+                allTANodeTextItem.getChildren().add(taoNodeTextItem);
+                createGeometryNodes(tao, taoNodeTextItem);
+            }
+        }
+
+    }
+
     private void buildTunnelTreeFromList(List<Tunnel> list, TreeItem<Renderable> root) {
         int tunnelChunk = tunnelChunkNr.get();
         for (int i = tunnelChunk * MAX_FEATURES_PER_CHUNK; i < (tunnelChunk + 1) * MAX_FEATURES_PER_CHUNK && i < list.size(); i++) {
@@ -1484,7 +1589,9 @@ public class CityDoctorController {
             case TUNNEL:
                 buildTunnel(model.getTunnels());
                 updateTree(mainWindow.getTunnelView().getRoot());
+                break;
             case WATER:
+
                 buildWater(model);
                 updateTree(mainWindow.getWaterView().getRoot());
                 break;

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/Renderer.java

@@ -366,6 +366,35 @@ public class Renderer {
         return polygons;
     }
 
+    private Set<ConcretePolygon> setupTransportationObjectPolygons(TransportationObject to) {
+        Set<ConcretePolygon> polygons = new HashSet<>();
+        addPolygons(to, polygons);
+
+        if (to instanceof TransportationSpace ts) {
+            if (ts instanceof TopLevelTransportFeature top) {
+                for (TransportSection sect : top.getSections()) {
+                    polygons.addAll(setupTransportationObjectPolygons(sect));
+                }
+                for (TransportSection isect : top.getIntersections()) {
+                    polygons.addAll(setupTransportationObjectPolygons(isect));
+                }
+            }
+            for (TrafficSpaceObject tso : ts.getTrafficSpaces()) {
+                polygons.addAll(setupTransportationObjectPolygons(tso));
+            }
+            for (TrafficSpaceObject atso : ts.getAuxTrafficSpaces()) {
+                polygons.addAll(setupTransportationObjectPolygons(atso));
+            }
+        }
+
+        if (to instanceof TrafficSpaceObject tso) {
+            for (TrafficAreaObject tao : tso.getTrafficAreas()) {
+                polygons.addAll(setupTransportationObjectPolygons(tao));
+            }
+        }
+        return polygons;
+    }
+
     public void render(Tunnel tunnel) {
         refresher = () -> {
             Set<ConcretePolygon> setupTunnelPolygons = setupTunnelPolygons(tunnel);
@@ -578,6 +607,20 @@ public class Renderer {
         return polygons;
     }
 
+    public void render(TransportationObject to) {
+        refresher = () -> {
+            Set<ConcretePolygon> setupTransportationPolygons = setupTransportationObjectPolygons(to);
+            mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupTransportationPolygons));
+            render(setupTransportationPolygons);
+            Platform.runLater(() -> {
+                errorUpdater = () -> displayErrors(to);
+                errorUpdater.run();
+                addGenericAttributesToView(to);
+            });
+        };
+        refresher.run();
+    }
+
     public void render(BoundarySurface bs) {
         refresher = () -> {
             Set<ConcretePolygon> setupBoundarySurfacePolygons = setupBoundarySurfacePolygons(bs);
@@ -827,8 +870,34 @@ public class Renderer {
         renderCityObjects(vegetation, Color.LIGHTGREEN);
     }
 
-    public void renderTransportation(List<TransportationObject> transportation) {
-        renderCityObjects(transportation, Color.YELLOW);
+    public void renderTransportation(List<? extends TransportationObject> transportation) {
+        errorUpdater = null;
+        refresher = () -> {
+            Platform.runLater(() -> {
+                loadingDialog.show();
+                clearGeometryTrees();
+                clearAttributes();
+            });
+            Thread t = new Thread(() -> {
+                Set<ConcretePolygon> polygons = new HashSet<>();
+                for (TransportationObject to : transportation) {
+                    polygons.addAll(setupTransportationObjectPolygons(to));
+                }
+                currentTriGeom = TriangulatedGeometry.of(polygons, Color.YELLOW);
+                errVisitor.setGeometry(currentTriGeom);
+                Platform.runLater(() -> {
+                    setupRenderState();
+                    mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
+                    loadingDialog.hide();
+                });
+            });
+            t.setUncaughtExceptionHandler((thread, e) -> {
+                Platform.runLater(() -> loadingDialog.hide());
+                logger.catching(e);
+            });
+            t.start();
+        };
+        refresher.run();
     }
 
     public void renderBridges(List<BridgeObject> bridges) {

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/AllTrafficAreaNode.java

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.TrafficAreaObject;
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+import java.util.List;
+
+public class AllTrafficAreaNode extends Renderable {
+
+    private final List<TrafficAreaObject> areas;
+
+    private final String text;
+
+    public AllTrafficAreaNode(List<TrafficAreaObject> areas, TrafficAreaObject.TrafficAreaType type) {
+        this.areas = areas;
+        this.text = type.toString();
+
+    }
+
+    @Override
+    public void refreshTextColor() {
+        // no use
+    }
+
+    @Override
+    public String getText() {
+        return this.text;
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.renderTransportation(areas);
+    }
+
+}

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/AllTrafficSpacesNode.java

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.TrafficSpaceObject;
+
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+import java.util.List;
+
+public class AllTrafficSpacesNode extends Renderable {
+
+    private final List<TrafficSpaceObject> spaces;
+
+    private final String text;
+
+    public AllTrafficSpacesNode(List<TrafficSpaceObject> sections, TrafficSpaceObject.TrafficSpaceType type) {
+        this.spaces = sections;
+        this.text = type.toString();
+
+    }
+
+    @Override
+    public void refreshTextColor() {
+        // no use
+    }
+
+    @Override
+    public String getText() {
+        return this.text;
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.renderTransportation(spaces);
+    }
+}

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/AllTransportSectionNode.java

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.TransportSection;
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+import java.util.List;
+
+public class AllTransportSectionNode extends Renderable {
+
+    private final List<TransportSection> sections;
+
+    private final String text;
+
+    public AllTransportSectionNode(List<TransportSection> sections, TransportSection.SectionType type) {
+        this.sections = sections;
+        this.text = type.toString();
+
+    }
+
+    @Override
+    public void refreshTextColor() {
+        // no use
+    }
+
+    @Override
+    public String getText() {
+        return this.text;
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.renderTransportation(sections);
+    }
+}

CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/TransportationObjectNode.java

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject;
+import de.hft.stuttgart.citydoctor2.gui.CheckStatus;
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+public class TransportationObjectNode extends Renderable {
+
+    private final TransportationObject to;
+
+    public TransportationObjectNode(TransportationObject to) {
+        this.to = to;
+    }
+
+    @Override
+    public String getText() {
+        return to.getGmlId().getGmlString();
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.render(to);
+    }
+
+    @Override
+    public void refreshTextColor() {
+        if (!to.isValidated()) {
+            setStatus(CheckStatus.NOT_CHECKED);
+        } else if (to.containsAnyError()) {
+            setStatus(CheckStatus.ERROR);
+        } else {
+            setStatus(CheckStatus.OK);
+        }
+    }
+}