Skip to content
GitLab
Commit 127d8834 authored by Riegel's avatar Riegel
Browse files

Refactor: Decouple Renderer setup from data model

parent 7810d1f0
Pipeline #11041 passed with stage
in 1 minute and 27 seconds
Hide whitespace changes
Inline Side-by-side
CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/checks/util/CityObjectCollector.java
View file @ 127d8834
...@@ -6,13 +6,12 @@ import de.hft.stuttgart.citydoctor2.check.Requirement; ...@@ -6,13 +6,12 @@ import de.hft.stuttgart.citydoctor2.check.Requirement;
import de.hft.stuttgart.citydoctor2.check.RequirementType; import de.hft.stuttgart.citydoctor2.check.RequirementType;
import de.hft.stuttgart.citydoctor2.datastructure.CityObject; import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
import java.util.ArrayList; import java.util.HashSet;
import java.util.List;
import java.util.Set; import java.util.Set;
public class CityObjectCollector extends Check { public class CityObjectCollector extends Check {
private final List<CityObject> objects = new ArrayList<>(); private final Set<CityObject> objects = new HashSet<>();
@Override @Override
public Set<Requirement> appliesToRequirements() { public Set<Requirement> appliesToRequirements() {
...@@ -39,7 +38,7 @@ public class CityObjectCollector extends Check { ...@@ -39,7 +38,7 @@ public class CityObjectCollector extends Check {
return false; return false;
} }
public List<CityObject> getCityObjects() { public Set<CityObject> getCityObjects() {
return objects; return objects;
} }
......
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/Renderer.java
View file @ 127d8834
...@@ -2,6 +2,7 @@ package de.hft.stuttgart.citydoctor2.gui; ...@@ -2,6 +2,7 @@ package de.hft.stuttgart.citydoctor2.gui;
import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.Checkable; import de.hft.stuttgart.citydoctor2.check.Checkable;
import de.hft.stuttgart.citydoctor2.checks.util.CityObjectCollector;
import de.hft.stuttgart.citydoctor2.datastructure.*; import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter; import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter;
import de.hft.stuttgart.citydoctor2.gui.tree.*; import de.hft.stuttgart.citydoctor2.gui.tree.*;
...@@ -177,56 +178,6 @@ public class Renderer { ...@@ -177,56 +178,6 @@ public class Renderer {
} }
} }
public void render(Building building) {
refresher = () -> {
Set<ConcretePolygon> setupBuildingPolygons = setupBuildingPolygons(building);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPolygons));
render(setupBuildingPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(building);
errorUpdater.run();
addGenericAttributesToView(building);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupBuildingPolygons(Building b) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(b, polygons);
for (BoundarySurface bs : b.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
for (Installation bi : b.getBuildingInstallations()) {
addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
}
for (BuildingRoom br : b.getBuildingRooms()) {
addPolygons(br, polygons);
for (BoundarySurface bs : br.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (BuildingRoomFurniture brf : b.getBuildingRoomFurnitureList()) {
addPolygons(brf, polygons);
for (BoundarySurface bs : brf.getBoundarySurfaceList()) {
addPolygons(bs, polygons);
}
}
for (BuildingPart bp : b.getBuildingParts()) {
polygons.addAll(setupBuildingPartPolygons(bp));
}
return polygons;
}
public void setupRefresher(CityObject co) { public void setupRefresher(CityObject co) {
refresher = () -> { refresher = () -> {
CityObjectCollector collector = new CityObjectCollector(); CityObjectCollector collector = new CityObjectCollector();
...@@ -244,428 +195,8 @@ public class Renderer { ...@@ -244,428 +195,8 @@ public class Renderer {
refresher.run(); refresher.run();
} }
public void render(BuildingPart bp) {
// refresher = () -> {
// Set<ConcretePolygon> setupBuildingPartPolygons = setupBuildingPartPolygons(bp);
// mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPartPolygons));
// render(setupBuildingPartPolygons);
// Platform.runLater(() -> {
// errorUpdater = () -> displayErrors(bp);
// errorUpdater.run();
// addGenericAttributesToView(bp);
// });
// };
// refresher.run();
setupRefresher(bp);
}
private Set<ConcretePolygon> setupBuildingPartPolygons(BuildingPart bp) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bp, polygons);
for (BoundarySurface bs : bp.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
for (Installation bi : bp.getBuildingInstallations()) {
addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
}
return polygons;
}
public void render(AbstractRoom room) {
refresher = () -> {
Set<ConcretePolygon> setupRoomPolygons = setupRoomPolygons(room);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupRoomPolygons));
render(setupRoomPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(room);
errorUpdater.run();
addGenericAttributesToView(room);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupRoomPolygons(AbstractRoom room) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(room, polygons);
for (BoundarySurface bs : room.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
return polygons;
}
public void render(AbstractFurniture furniture) {
refresher = () -> {
Set<ConcretePolygon> setupFurniturePolygons = setupFurniturePolygons(furniture);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupFurniturePolygons));
render(setupFurniturePolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(furniture);
errorUpdater.run();
addGenericAttributesToView(furniture);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupFurniturePolygons(AbstractFurniture furniture) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(furniture, polygons);
for (BoundarySurface bs : furniture.getBoundarySurfaceList()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
return polygons;
}
public void render(Storey storey) {
refresher = () -> {
Set<ConcretePolygon> setupStoreyPolygons = setupStoreyPolygons(storey);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupStoreyPolygons));
render(setupStoreyPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(storey);
errorUpdater.run();
addGenericAttributesToView(storey);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupStoreyPolygons(Storey storey) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(storey, polygons);
for (BoundarySurface bs : storey.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
return polygons;
}
public void render(BuildingUnit buildingUnit) {
refresher = () -> {
Set<ConcretePolygon> setupBuildingUnitPolgons = setupBuildingUnitPolygons(buildingUnit);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingUnitPolgons));
render(setupBuildingUnitPolgons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(buildingUnit);
errorUpdater.run();
addGenericAttributesToView(buildingUnit);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupBuildingUnitPolygons(BuildingUnit buildingUnit) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(buildingUnit, polygons);
for (BoundarySurface bs : buildingUnit.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
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);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupTunnelPolygons));
render(setupTunnelPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(tunnel);
errorUpdater.run();
addGenericAttributesToView(tunnel);
});
};
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.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (TunnelFurniture tf : tunnel.getTunnelFurniture()) {
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);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBridgePolygons));
render(setupBridgePolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bridge);
errorUpdater.run();
addGenericAttributesToView(bridge);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupBridgePolygons(BridgeObject bridge) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bridge, polygons);
for (BoundarySurface bs : bridge.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
for (BridgeConstructiveElement consElement : bridge.getConstructiveElements()) {
addPolygons(consElement, polygons);
for (BoundarySurface bs : consElement.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (Installation inst : bridge.getBridgeInstallations()) {
addPolygons(inst, polygons);
for (BoundarySurface bs : inst.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
return polygons;
}
public void render(CityObject co) { public void render(CityObject co) {
refresher = () -> { setupRefresher(co);
Set<ConcretePolygon> setupCityObjectPolygons = setupCityObjectPolygons(co);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(co);
errorUpdater.run();
addGenericAttributesToView(co);
});
};
refresher.run();
}
public void render(ReliefObject relief) {
refresher = () -> {
Set<ConcretePolygon> setupCityObjectPolygons = setupReliefPolygons(relief);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(relief);
errorUpdater.run();
addGenericAttributesToView(relief);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupReliefPolygons(ReliefObject relief) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(relief, polygons);
for (TinObject tin : relief.getComponents()) {
addPolygons(tin, polygons);
}
return polygons;
}
public void render(Installation bi) {
refresher = () -> {
Set<ConcretePolygon> setupCityObjectPolygons = setupBuildingInstallationPolygons(bi);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bi);
errorUpdater.run();
addGenericAttributesToView(bi);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupBuildingInstallationPolygons(Installation bi) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
return polygons;
}
public void render(CityFurniture cf) {
refresher = () -> {
Set<ConcretePolygon> setupCityFurniturePolygons = setupCityFurniturePolygons(cf);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityFurniturePolygons));
render(setupCityFurniturePolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(cf);
errorUpdater.run();
addGenericAttributesToView(cf);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupCityFurniturePolygons(CityFurniture cf) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(cf, polygons);
return polygons;
}
public void render(GenericCityObject gco) {
refresher = () -> {
Set<ConcretePolygon> setupGenericCityObjectPolygons = setupGenericCityObjectPolygons(gco);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupGenericCityObjectPolygons));
render(setupGenericCityObjectPolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(gco);
errorUpdater.run();
addGenericAttributesToView(gco);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupGenericCityObjectPolygons(GenericCityObject gco) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(gco, polygons);
for (BoundarySurface bs : gco.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
}
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);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBoundarySurfacePolygons));
render(setupBoundarySurfacePolygons);
Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bs);
errorUpdater.run();
addGenericAttributesToView(bs);
});
};
refresher.run();
}
private Set<ConcretePolygon> setupBoundarySurfacePolygons(BoundarySurface bs) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons);
}
return polygons;
}
private Set<ConcretePolygon> setupCityObjectPolygons(CityObject co) {
Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(co, polygons);
return polygons;
} }
private void addPolygons(CityObject co, Set<ConcretePolygon> polygons) { private void addPolygons(CityObject co, Set<ConcretePolygon> polygons) {
...@@ -826,36 +357,7 @@ public class Renderer { ...@@ -826,36 +357,7 @@ public class Renderer {
} }
public void renderBuildings(List<Building> objects) { public void renderBuildings(List<Building> objects) {
errorUpdater = null; renderCityObjects(objects, null);
refresher = () -> {
Platform.runLater(() -> {
loadingDialog.show();
clearGeometryTrees();
clearAttributes();
});
Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>();
for (Building b : objects) {
collectBuildingPolygons(polygons, b);
for (BuildingPart bp : b.getBuildingParts()) {
collectBuildingPolygons(polygons, bp);
}
}
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();
} }
public void render(CityDoctorModel model) { public void render(CityDoctorModel model) {
...@@ -889,66 +391,11 @@ public class Renderer { ...@@ -889,66 +391,11 @@ public class Renderer {
} }
public void renderTransportation(List<? extends TransportationObject> transportation) { public void renderTransportation(List<? extends TransportationObject> transportation) {
errorUpdater = null; renderCityObjects(transportation, Color.YELLOW);
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) { public void renderBridges(List<BridgeObject> bridges) {
errorUpdater = null; renderCityObjects(bridges, Color.CORAL);
refresher = () -> {
Platform.runLater(() -> {
loadingDialog.show();
clearGeometryTrees();
clearAttributes();
});
Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>();
for (BridgeObject b : bridges) {
collectBridgePolygons(polygons, b);
for (BridgeObject bp : b.getParts()) {
collectBridgePolygons(polygons, bp);
}
}
currentTriGeom = TriangulatedGeometry.of(polygons, Color.CORAL);
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 renderWater(List<WaterObject> water) { public void renderWater(List<WaterObject> water) {
...@@ -956,72 +403,13 @@ public class Renderer { ...@@ -956,72 +403,13 @@ public class Renderer {
} }
public void renderCityFurniture(List<CityFurniture> cityFurniture) { public void renderCityFurniture(List<CityFurniture> cityFurniture) {
errorUpdater = null; renderCityObjects(cityFurniture, Color.BLUEVIOLET);
refresher = () -> {
Platform.runLater(() -> {
loadingDialog.show();
clearGeometryTrees();
clearAttributes();
});
Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>();
for (CityFurniture cf : cityFurniture) {
collectCityFurniture(polygons, cf);
}
currentTriGeom = TriangulatedGeometry.of(polygons, Color.BLUEVIOLET);
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 renderTerrain(List<CityObject> land) { public void renderTerrain(List<CityObject> land) {
renderLandObjects(land, Color.BROWN); renderCityObjects(land, Color.BROWN);
} }
private void renderLandObjects(List<CityObject> cos, Color baseColor) {
errorUpdater = null;
refresher = () -> {
Platform.runLater(() -> {
loadingDialog.show();
clearGeometryTrees();
clearAttributes();
});
Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>();
for (CityObject co : cos) {
addPolygons(co, polygons);
if (co instanceof ReliefObject) {
ReliefObject relief = (ReliefObject) co;
for (TinObject tin : relief.getComponents()) {
addPolygons(tin, polygons);
}
}
}
currentTriGeom = TriangulatedGeometry.of(polygons, baseColor);
errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> {
setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide();
});
});
t.setUncaughtExceptionHandler((thread, e) -> Platform.runLater(() -> loadingDialog.hide()));
t.start();
};
refresher.run();
}
public void renderCityObjects(List<? extends CityObject> cos, Color baseColor) { public void renderCityObjects(List<? extends CityObject> cos, Color baseColor) {
errorUpdater = null; errorUpdater = null;
...@@ -1033,10 +421,14 @@ public class Renderer { ...@@ -1033,10 +421,14 @@ public class Renderer {
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (CityObject co : cos) { CityObjectCollector collector = new CityObjectCollector();
addPolygons(co, polygons); cos.forEach(cityObject -> cityObject.accept(collector));
collector.getCityObjects().forEach(cityObject -> addPolygons(cityObject, polygons));
if (baseColor != null) {
currentTriGeom = TriangulatedGeometry.of(polygons, baseColor);
} else {
currentTriGeom = TriangulatedGeometry.of(polygons);
} }
currentTriGeom = TriangulatedGeometry.of(polygons, baseColor);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
...@@ -1051,129 +443,9 @@ public class Renderer { ...@@ -1051,129 +443,9 @@ public class Renderer {
} }
public void renderTunnels(List<Tunnel> objects) { public void renderTunnels(List<Tunnel> objects) {
errorUpdater = null; renderCityObjects(objects, Color.DARKGRAY);
refresher = () -> {
Platform.runLater(() -> {
loadingDialog.show();
clearGeometryTrees();
clearAttributes();
});
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);
for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
}
for (BuildingRoom br : ab.getBuildingRooms()) {
addPolygons(br, polygons);
for (BoundarySurface bs : br.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (BoundarySurface bs : ab.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
} }
private void collectBridgePolygons(Set<ConcretePolygon> polygons, BridgeObject br) {
addPolygons(br, polygons);
for (Installation bi : br.getBridgeInstallations()) {
addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
}
for (BridgeRoom r : br.getBridgeRooms()) {
addPolygons(r, polygons);
for (BoundarySurface bs : r.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (BridgeConstructiveElement bce : br.getConstructiveElements()) {
addPolygons(bce, polygons);
for (BoundarySurface bs : bce.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (BoundarySurface bs : br.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
}
public void collectTunnelPolygons(Set<ConcretePolygon> polygons, AbstractTunnel at) {
addPolygons(at, polygons);
for (Installation ti : at.getTunnelInstallations()) {
addPolygons(ti, polygons);
for (BoundarySurface bs : ti.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
}
for (TunnelHollow th : at.getTunnelHollows()) {
addPolygons(th, polygons);
for (BoundarySurface bs : th.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (TunnelConstructiveElement tce : at.getTunnelConstructiveElements()) {
addPolygons(tce, polygons);
for (BoundarySurface bs : tce.getBoundarySurfaces()) {
addPolygons(bs, polygons);
}
}
for (BoundarySurface bs : at.getBoundarySurfaces()) {
addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons);
}
}
}
private void collectCityFurniture(Set<ConcretePolygon> polygons, CityFurniture cf) {
addPolygons(cf, polygons);
}
private void addConcretePolygons(Set<ConcretePolygon> polygons, Geometry geom) { private void addConcretePolygons(Set<ConcretePolygon> polygons, Geometry geom) {
for (Polygon p : geom.getPolygons()) { for (Polygon p : geom.getPolygons()) {
......
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/TriangulatedGeometry.java
View file @ 127d8834
package de.hft.stuttgart.citydoctor2.gui; package de.hft.stuttgart.citydoctor2.gui;
import de.hft.stuttgart.citydoctor2.checks.util.CityObjectCollector;
import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
import de.hft.stuttgart.citydoctor2.datastructure.*; import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter; import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter;
...@@ -12,6 +13,7 @@ import javafx.scene.paint.PhongMaterial; ...@@ -12,6 +13,7 @@ import javafx.scene.paint.PhongMaterial;
import javafx.scene.shape.*; import javafx.scene.shape.*;
import java.util.*; import java.util.*;
import java.util.stream.Collectors;
public class TriangulatedGeometry { public class TriangulatedGeometry {
...@@ -75,22 +77,17 @@ public class TriangulatedGeometry { ...@@ -75,22 +77,17 @@ public class TriangulatedGeometry {
public static TriangulatedGeometry of(CityDoctorModel model, List<ViewFilter> filters) { public static TriangulatedGeometry of(CityDoctorModel model, List<ViewFilter> filters) {
List<Vector3d> points = new ArrayList<>(); List<Vector3d> points = new ArrayList<>();
addPointsFromBuildings(model.getBuildings(), points); addPointsFromCityObject(model.createFeatureStream().toList(), points);
addPointsFromCityObject(model.getBridges(), points);
addPointsFromCityObject(model.getLand(), points);
addPointsFromTransportationObjects(model.getTransportation(), points);
addPointsFromCityObject(model.getVegetation(), points);
addPointsFromCityObject(model.getWater(), points);
TriangulatedGeometry triGeom = new TriangulatedGeometry(); TriangulatedGeometry triGeom = new TriangulatedGeometry();
triGeom.materials = new ArrayList<>(); triGeom.materials = new ArrayList<>();
triGeom.meshes = new ArrayList<>(); triGeom.meshes = new ArrayList<>();
triGeom.movedBy = triGeom.findCenter(points); triGeom.movedBy = triGeom.findCenter(points);
addPolygonDataFromBuildings(model.getBuildings(), triGeom, filters); addPolygonDataFromCityObjects(model.getBuildings(), triGeom, Color.WHITE, filters);
addPolygonDataFromBridges(model.getBridges(), triGeom, filters); addPolygonDataFromCityObjects(model.getBridges(), triGeom, Color.CORAL, filters);
addPolygonDataFromCityObjects(model.getLand(), triGeom, Color.BROWN, filters); addPolygonDataFromCityObjects(model.getLand(), triGeom, Color.BROWN, filters);
addPolygonDataFromTransportationObjects(model.getTransportation(), triGeom, filters); addPolygonDataFromCityObjects(model.getTransportation(), triGeom, Color.YELLOW, filters);
addPolygonDataFromCityObjects(model.getVegetation(), triGeom, Color.LIGHTGREEN, filters); addPolygonDataFromCityObjects(model.getVegetation(), triGeom, Color.LIGHTGREEN, filters);
addPolygonDataFromCityObjects(model.getWater(), triGeom, Color.LIGHTSKYBLUE, filters); addPolygonDataFromCityObjects(model.getWater(), triGeom, Color.LIGHTSKYBLUE, filters);
addPolygonDataFromCityObjects(model.getCityFurniture(), triGeom, Color.BLUEVIOLET, filters); addPolygonDataFromCityObjects(model.getCityFurniture(), triGeom, Color.BLUEVIOLET, filters);
...@@ -98,94 +95,14 @@ public class TriangulatedGeometry { ...@@ -98,94 +95,14 @@ public class TriangulatedGeometry {
return triGeom; return triGeom;
} }
private static void addPolygonDataFromBuildings(List<Building> buildings, TriangulatedGeometry triGeom, List<ViewFilter> filters) {
for (Building b : buildings) {
addPolygonData(b, triGeom, Color.WHITE, filters);
addPolygonDataFromBoundarySurfaces(b.getBoundarySurfaces(), triGeom, filters);
addPolygonDataFromCityObjects(b.getBuildingInstallations(), triGeom, Color.WHITE, filters);
for (Installation bi : b.getBuildingInstallations()) {
addPolygonDataFromCityObjects(bi.getBoundarySurfaces(), triGeom, Color.WHITE, filters);
}
for (BuildingPart bp : b.getBuildingParts()) {
addPolygonData(bp, triGeom, Color.WHITE, filters);
addPolygonDataFromBoundarySurfaces(bp.getBoundarySurfaces(), triGeom, filters);
addPolygonDataFromCityObjects(bp.getBuildingInstallations(), triGeom, Color.WHITE, filters);
}
}
}
private static void addPolygonDataFromBridges(List<BridgeObject> bridges, TriangulatedGeometry triGeom, List<ViewFilter> filters) {
for (BridgeObject b : bridges) {
addPolygonData(b, triGeom, Color.CORAL, filters);
addPolygonDataFromBoundarySurfaces(b.getBoundarySurfaces(), triGeom, filters);
addPolygonDataFromCityObjects(b.getBridgeInstallations(), triGeom, Color.CORAL, filters);
for (Installation bi : b.getBridgeInstallations()) {
addPolygonData(bi, triGeom, Color.CORAL, filters);
addPolygonDataFromCityObjects(bi.getBoundarySurfaces(), triGeom, Color.CORAL, filters);
}
for (BridgeConstructiveElement bce : b.getConstructiveElements()) {
addPolygonData(bce, triGeom, Color.CORAL, filters);
addPolygonDataFromCityObjects(bce.getBoundarySurfaces(), triGeom, Color.CORAL, filters);
}
addPolygonDataFromBridges(b.getParts(), triGeom, filters);
}
}
private static void addPolygonDataFromTransportationObjects(List<TransportationObject> tos, TriangulatedGeometry triGeom,
List<ViewFilter> filters) {
for (TransportationObject to : tos) {
if (to instanceof TransportationSpace tsp) {
addPolygonDataFromTransportationSpace(tsp, triGeom, filters);
if (tsp instanceof TopLevelTransportFeature top) {
for (TransportSection tse : top.getSections()) {
addPolygonDataFromTransportationSpace(tse, triGeom, filters);
}
for (TransportSection tse : top.getIntersections()) {
addPolygonDataFromTransportationSpace(tse, triGeom, filters);
}
}
} else {
addPolygonData(to, triGeom, Color.YELLOW, filters);
}
}
}
private static void addPolygonDataFromTransportationSpace(TransportationSpace ts, TriangulatedGeometry triGeom,
List<ViewFilter> filters) {
addPolygonData(ts, triGeom, Color.YELLOW, filters);
addPolygonDataFromTrafficSpaces(ts.getTrafficSpaces(), triGeom, filters);
addPolygonDataFromTrafficSpaces(ts.getAuxTrafficSpaces(), triGeom, filters);
}
private static void addPolygonDataFromTrafficSpaces(List<TrafficSpaceObject> spaces, TriangulatedGeometry triGeom,
List<ViewFilter> filters) {
for (TrafficSpaceObject space : spaces) {
addPolygonData(space, triGeom, Color.YELLOW, filters);
for (TrafficAreaObject area : space.getTrafficAreas()) {
addPolygonData(area, triGeom, Color.YELLOW, filters);
}
}
}
private static void addPolygonDataFromBoundarySurfaces(List<BoundarySurface> boundarySurfaces,
TriangulatedGeometry triGeom, List<ViewFilter> filters) {
for (BoundarySurface bs : boundarySurfaces) {
addPolygonData(bs, triGeom, Color.WHITE, filters);
for (Opening o : bs.getOpenings()) {
addPolygonData(o, triGeom, Color.WHITE, filters);
}
}
}
private static void addPolygonDataFromCityObjects(List<? extends CityObject> cos, private static void addPolygonDataFromCityObjects(List<? extends CityObject> cos,
TriangulatedGeometry triGeom, Color color, List<ViewFilter> filters) { TriangulatedGeometry triGeom, Color color, List<ViewFilter> filters) {
for (CityObject co : cos) { CityObjectCollector collector = new CityObjectCollector();
addPolygonData(co, triGeom, color, filters); cos.forEach(cityObject -> cityObject.accept(collector));
} collector.getCityObjects().forEach(cityObject -> addPolygonData(cityObject, triGeom, color, filters));
} }
private static void addPolygonData(CityObject co, TriangulatedGeometry triGeom, Color color, List<ViewFilter> filters) { private static void addPolygonData(CityObject co, TriangulatedGeometry triGeom, Color color, List<ViewFilter> filters) {
...@@ -213,46 +130,10 @@ public class TriangulatedGeometry { ...@@ -213,46 +130,10 @@ public class TriangulatedGeometry {
return true; return true;
} }
private static void addPointsFromBuildings(List<Building> buildings, List<Vector3d> points) {
for (Building b : buildings) {
addPoints(b, points);
for (BuildingPart bp : b.getBuildingParts()) {
addPoints(bp, points);
addPointsFromCityObject(bp.getBoundarySurfaces(), points);
addPointsFromCityObject(bp.getBuildingInstallations(), points);
}
addPointsFromCityObject(b.getBoundarySurfaces(), points);
addPointsFromCityObject(b.getBuildingInstallations(), points);
}
}
private static void addPointsFromTransportationObjects(List<? extends TransportationObject> tos, List<Vector3d> points) {
for (TransportationObject to : tos) {
addPoints(to, points);
if (to instanceof TransportationSpace ts) {
addPointsFromTrafficSpace(ts.getTrafficSpaces(), points);
addPointsFromTrafficSpace(ts.getAuxTrafficSpaces(), points);
if (ts instanceof TopLevelTransportFeature top) {
addPointsFromTransportationObjects(top.getSections(), points);
addPointsFromTransportationObjects(top.getIntersections(), points);
}
}
}
}
private static void addPointsFromTrafficSpace(List<TrafficSpaceObject> tos, List<Vector3d> points) {
for (TrafficSpaceObject to : tos) {
addPoints(to, points);
for (TrafficAreaObject area : to.getTrafficAreas()) {
addPoints(area, points);
}
}
}
private static void addPointsFromCityObject(List<? extends CityObject> cos, List<Vector3d> points) { private static void addPointsFromCityObject(List<? extends CityObject> cos, List<Vector3d> points) {
for (CityObject co : cos) { CityObjectCollector collector = new CityObjectCollector();
addPoints(co, points); cos.forEach(cityObject -> cityObject.accept(collector));
} collector.getCityObjects().forEach(cityObject -> addPoints(cityObject, points));
} }
private static void addPoints(CityObject co, List<Vector3d> points) { private static void addPoints(CityObject co, List<Vector3d> points) {
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Dies ist die Gitlab-Instanz des Transferportals der Hochschule für Technik Stuttgart. Hier geht es zurück zum Portal