Add rendering of Tunnel

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

@@ -251,7 +251,7 @@ public class Renderer {
 		refresher.run();
 	}
 
-	public Set<ConcretePolygon> setupRoomPolygons(AbstractRoom room) {
+	private Set<ConcretePolygon> setupRoomPolygons(AbstractRoom room) {
 		Set<ConcretePolygon> polygons = new HashSet<>();
 		addPolygons(room, polygons);
 		for (BoundarySurface bs : room.getBoundarySurfaceList()) {
@@ -276,7 +276,7 @@ public class Renderer {
 		refresher.run();
 	}
 
-	public Set<ConcretePolygon> setupFurniturePolygons(AbstractFurniture furniture) {
+	private Set<ConcretePolygon> setupFurniturePolygons(AbstractFurniture furniture) {
 		Set<ConcretePolygon> polygons = new HashSet<>();
 		addPolygons(furniture, polygons);
 		for (BoundarySurface bs : furniture.getBoundarySurfaceList()) {
@@ -301,7 +301,7 @@ public class Renderer {
 		refresher.run();
 	}
 
-	public Set<ConcretePolygon> setupStoreyPolygons(Storey storey) {
+	private Set<ConcretePolygon> setupStoreyPolygons(Storey storey) {
 		Set<ConcretePolygon> polygons = new HashSet<>();
 		addPolygons(storey, polygons);
 		for (BoundarySurface bs : storey.getBoundarySurfaces()) {
@@ -326,7 +326,7 @@ public class Renderer {
 		refresher.run();
 	}
 
-	public Set<ConcretePolygon> setupBuildingUnitPolygons(BuildingUnit buildingUnit) {
+	private Set<ConcretePolygon> setupBuildingUnitPolygons(BuildingUnit buildingUnit) {
 		Set<ConcretePolygon> polygons = new HashSet<>();
 		addPolygons(buildingUnit, polygons);
 		for (BoundarySurface bs : buildingUnit.getBoundarySurfaces()) {
@@ -338,6 +338,73 @@ public class Renderer {
 		return polygons;
 	}
 
+	public void render(Tunnel tunnel){
+		refresher = () -> {
+			Set<ConcretePolygon> setupTunnelPolygons = setupTunnelPolygons(tunnel);
+			mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupTunnelPolygons));
+			render(setupTunnelPolygons);
+			Platform.runLater(() -> {
+				errorUpdater = () -> displayErrors(tunnel);
+				errorUpdater.run();
+			});
+		};
+		refresher.run();
+	}
+
+	private Set<ConcretePolygon> setupTunnelPolygons(Tunnel tunnel) {
+		Set<ConcretePolygon> polygons = new HashSet<>();
+		addPolygons(tunnel, polygons);
+		for (BoundarySurface bs : tunnel.getBoundarySurfaces()) {
+			addPolygons(bs, polygons);
+		}
+		for (Installation ti : tunnel.getTunnelInstallations()) {
+			addPolygons(ti, polygons);
+			for (BoundarySurface bs : ti.getBoundarySurfaces()) {
+				addPolygons(bs, polygons);
+				for (Opening op : bs.getOpenings()) {
+					addPolygons(op, polygons);
+				}
+			}
+		}
+		for (TunnelHollow th : tunnel.getTunnelHollows()) {
+			addPolygons(th, polygons);
+			for (BoundarySurface bs : th.getBoundarySurfaceList()){
+				addPolygons(bs, polygons);
+			}
+		}
+		for (TunnelFurniture tf : tunnel.getTunnelFurnitureList()){
+			addPolygons(tf, polygons);
+			for (BoundarySurface bs : tf.getBoundarySurfaceList()){
+				addPolygons(bs, polygons);
+			}
+		}
+		for (TunnelPart tp : tunnel.getTunnelParts()) {
+			polygons.addAll(setupTunnelPartPolygons(tp));
+		}
+		return polygons;
+	}
+
+	private Set<ConcretePolygon> setupTunnelPartPolygons(TunnelPart tp) {
+		Set<ConcretePolygon> polygons = new HashSet<>();
+		addPolygons(tp, polygons);
+		for (BoundarySurface bs : tp.getBoundarySurfaces()) {
+			addPolygons(bs, polygons);
+			for (Opening op : bs.getOpenings()) {
+				addPolygons(op, polygons);
+			}
+		}
+		for (Installation bi : tp.getTunnelInstallations()) {
+			addPolygons(bi, polygons);
+			for (BoundarySurface bs : bi.getBoundarySurfaces()) {
+				addPolygons(bs, polygons);
+				for (Opening op : bs.getOpenings()) {
+					addPolygons(op, polygons);
+				}
+			}
+		}
+		return polygons;
+	}
+
 	public void render(BridgeObject bridge) {
 		refresher = () -> {
 			Set<ConcretePolygon> setupBridgePolygons = setupBridgePolygons(bridge);
@@ -655,9 +722,9 @@ public class Renderer {
 			Thread t = new Thread(() -> {
 				Set<ConcretePolygon> polygons = new HashSet<>();
 				for (Building b : objects) {
-					collectPolygons(polygons, b);
+					collectBuildingPolygons(polygons, b);
 					for (BuildingPart bp : b.getBuildingParts()) {
-						collectPolygons(polygons, bp);
+						collectBuildingPolygons(polygons, bp);
 					}
 				}
 				currentTriGeom = TriangulatedGeometry.of(polygons);
@@ -810,7 +877,39 @@ public class Renderer {
 		refresher.run();
 	}
 
-	private void collectPolygons(Set<ConcretePolygon> polygons, AbstractBuilding ab) {
+	public void renderTunnels(List<Tunnel> objects){
+		errorUpdater = null;
+		refresher = () -> {
+			Platform.runLater(() -> {
+				loadingDialog.show();
+				clearGeometryTrees();
+			});
+			Thread t = new Thread(() -> {
+				Set<ConcretePolygon> polygons = new HashSet<>();
+				for (Tunnel tunnel : objects) {
+					collectTunnelPolygons(polygons, tunnel);
+					for (TunnelPart tp : tunnel.getTunnelParts()) {
+						collectTunnelPolygons(polygons, tp);
+					}
+				}
+				currentTriGeom = TriangulatedGeometry.of(polygons);
+				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();
+	}
+
+	private void collectBuildingPolygons(Set<ConcretePolygon> polygons, AbstractBuilding ab) {
 		addPolygons(ab, polygons);
 		for (Installation bi : ab.getBuildingInstallations()) {
 			addPolygons(bi, polygons);
@@ -835,6 +934,8 @@ public class Renderer {
 		}
 	}
 
+	public void collectTunnelPolygons(Set<ConcretePolygon> polygons, AbstractTunnel at) {}
+
 	private void collectCityFurniture(Set<ConcretePolygon> polygons, CityFurniture cf) {
 		addPolygons(cf, polygons);
 	}

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

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.TunnelPart;
+import de.hft.stuttgart.citydoctor2.gui.CheckStatus;
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+import java.util.List;
+
+public class AllTunnelPartsNode extends Renderable{
+
+    private final List<TunnelPart> tunnelParts;
+
+    public AllTunnelPartsNode(List<TunnelPart> tunnelParts) {
+        this.tunnelParts = tunnelParts;
+    }
+
+    @Override
+    public String getText() {
+        return "Tunnel Parts";
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.clearCurrentRender();
+    }
+
+    @Override
+    public void refreshTextColor() {
+        boolean wasChecked = false;
+        for (TunnelPart tp : tunnelParts) {
+            if (tp.isValidated()) {
+                wasChecked = true;
+                if (tp.containsAnyError()) {
+                    setStatus(CheckStatus.ERROR);
+                    return;
+                }
+            }
+        }
+        if (wasChecked) {
+            setStatus(CheckStatus.OK);
+        } else {
+            setStatus(CheckStatus.NOT_CHECKED);
+        }
+    }
+}

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

+package de.hft.stuttgart.citydoctor2.gui.tree;
+
+import de.hft.stuttgart.citydoctor2.datastructure.Tunnel;
+import de.hft.stuttgart.citydoctor2.gui.Renderer;
+
+import java.util.List;
+
+public class AllTunnelsNode extends Renderable{
+
+    private final List<Tunnel> tunnels;
+
+    public AllTunnelsNode(List<Tunnel> tunnels) {
+        this.tunnels = tunnels;
+    }
+
+    @Override
+    public void refreshTextColor() {
+        // no color changes
+    }
+
+    @Override
+    public String getText() {
+        return "Tunnels";
+    }
+
+    @Override
+    public void visit(Renderer renderer) {
+        renderer.renderTunnels(tunnels);
+    }
+
+}

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

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

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

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