Add design spec for OpenGL 3D view

Replaces the JavaFX SubScene/MeshView rendering with an OpenGL viewport
(openglfx-jogl, GL 3.3 core), single global VBO, GPU color-picking, and
baked fake shading. Windows/Linux targets; JavaFX 3D path removed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingConstructiveElement.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.Solid;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import javafx.scene.paint.Color;
+
+public class BuildingConstructiveElement extends CityObject {
+
+    private static final Logger logger = LogManager.getLogger(BuildingConstructiveElement.class);
+
+    private static final String CANNOT_ADD = "Cannot add ";
+
+    @Serial
+    private static final long serialVersionUID = 7353233899458901155L;
+
+    private final org.citygml4j.core.model.building.BuildingConstructiveElement gmlBuildingElement;
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+    private AbstractBuilding parent;
+
+    public BuildingConstructiveElement(org.citygml4j.core.model.building.BuildingConstructiveElement gmlObject) {
+        this.gmlBuildingElement = gmlObject;
+    }
+
+    public void setParent(AbstractBuilding parent) {
+        this.parent = parent;
+    }
+
+    public AbstractBuilding getParent() {
+        return parent;
+    }
+
+    @Override
+    public Color getRenderColor() {
+        return parent.getRenderColor().brighter();
+    }
+
+    @Override
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
+        // only handles CityGML2 for now
+        // unknown which CityGML is handled here
+        // need context information to decide
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            switch (geom.getType()) {
+                case SOLID:
+                    Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                    setSolidAccordingToLod(geom, solid);
+                    break;
+                case MULTI_SURFACE:
+                    MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                    setMultiSurfaceAccordingToLod(geom, ms);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void accept(CheckableVisitor c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : gmlBuildingElement.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from BridgeConstructiveElement", bs.getGmlId());
+                    gmlBuildingElement.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                gmlBuildingElement.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                gmlBuildingElement.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                gmlBuildingElement.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                gmlBuildingElement.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                gmlBuildingElement.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                gmlBuildingElement.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    @Override
+    public org.citygml4j.core.model.building.BuildingConstructiveElement getGmlObject() {
+        return gmlBuildingElement;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        gmlBuildingElement.setLod0MultiSurface(null);
+        gmlBuildingElement.setLod2MultiSurface(null);
+        gmlBuildingElement.setLod3MultiSurface(null);
+        gmlBuildingElement.setLod1Solid(null);
+        gmlBuildingElement.setLod2Solid(null);
+        gmlBuildingElement.setLod3Solid(null);
+    }
+
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return getParent().getTopLevelCityObject();
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BRIDGE_CONSTRUCTION_ELEMENT;
+    }
+
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
+
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingPart.java

@@ -18,9 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
-
 import java.io.Serial;
 
 public class BuildingPart extends AbstractBuilding {
@@ -42,6 +39,11 @@ public class BuildingPart extends AbstractBuilding {
         return parent;
     }
 
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return getParent().getTopLevelCityObject();
+    }
+
     @Override
     public FeatureType getFeatureType() {
         return FeatureType.BUILDING_PART;
@@ -52,22 +54,4 @@ public class BuildingPart extends AbstractBuilding {
         return "BuildingPart [id=" + getGmlId() + "]";
     }
 
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        BuildingPart originalPart = (BuildingPart) original;
-        parent = handler.getCopyInstance(originalPart.parent);
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        super.collectInstances(handler);
-        handler.addInstance(parent);
-    }
-
-    @Override
-    public Copyable createCopyInstance() {
-        return new BuildingPart();
-    }
-
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingRoom.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
 import org.citygml4j.core.model.building.BuildingFurnitureProperty;
 
 import java.io.Serial;
@@ -43,21 +42,12 @@ public class BuildingRoom extends AbstractRoom {
     }
 
     @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-
-        BuildingRoom oRoom = (BuildingRoom) original;
-        parent = handler.getCopyInstance(oRoom.getParent());
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        super.collectInstances(handler);
-        handler.addInstance(parent);
+    public CityObject getTopLevelCityObject() {
+        return getParent().getTopLevelCityObject();
     }
 
     @Override
-    public Copyable createCopyInstance() {
-        return new BuildingRoom();
+    public Color getRenderColor() {
+        return parent.getRenderColor();
     }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingRoomFurniture.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
 
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import org.citygml4j.core.model.building.BuildingFurniture;
 
 import java.io.Serial;
@@ -15,10 +14,5 @@ public class BuildingRoomFurniture extends AbstractFurniture {
         super.setGmlObject(gmlObject);
     }
 
-    @Override
-    public Copyable createCopyInstance() {
-        return new BuildingRoomFurniture();
-    }
-
 }
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingUnit.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
-import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
-import org.citygml4j.core.util.geometry.GeometryFactory;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 
 import java.io.Serial;
 import java.util.ArrayList;
@@ -20,110 +14,16 @@ public class BuildingUnit extends AbstractBuildingSubdivision {
     private final List<Storey> storeys = new ArrayList<>();
 
     @Override
-    public Copyable createCopyInstance() {
-        return new BuildingUnit();
-    }
-
-
-    @Override
-    public void unsetGmlGeometries() {
-        super.unsetGmlGeometries();
-        for (Storey storey : storeys) {
-            storey.unsetGmlGeometries();
-        }
-    }
-
-    @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-        super.reCreateGeometries(factory, config);
-        for (Storey storey : storeys) {
-            storey.reCreateGeometries(factory, config);
-        }
-    }
-
-    @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         for (Storey storey : storeys) {
             storey.accept(c);
         }
     }
 
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        super.collectContainedErrors(errors);
-        for (Storey storey : storeys) {
-            storey.collectContainedErrors(errors);
-        }
-    }
 
-    @Override
-    public void clearAllContainedCheckResults() {
-        super.clearAllContainedCheckResults();
-        for (Storey storey : storeys) {
-            storey.clearAllContainedCheckResults();
-        }
-    }
 
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        boolean hasError = super.containsError(checkIdentifier);
-        if (hasError) {
-            return true;
-        }
-        for (Storey storey : storeys) {
-            if (storey.containsError(checkIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        boolean hasError = super.containsAnyError();
-        if (hasError) {
-            return true;
-        }
-        for (Storey storey : storeys) {
-            if (storey.containsAnyError()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void prepareForChecking() {
-        super.prepareForChecking();
-        for (Storey storey : storeys) {
-            storey.prepareForChecking();
-        }
-    }
-
-    @Override
-    public void clearMetaInformation() {
-        super.clearMetaInformation();
-        for (Storey storey : storeys) {
-            storey.clearMetaInformation();
-        }
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        super.collectInstances(handler);
-        for (Storey storey : storeys) {
-            storey.collectInstances(handler);
-        }
-    }
-
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        BuildingUnit originalBu = (BuildingUnit) original;
-        for (Storey storey : originalBu.storeys) {
-            storeys.add(handler.getCopyInstance(storey));
-        }
-        this.abs = originalBu.abs;
+    public List<Storey> getStoreys() {
+        return storeys;
     }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java

@@ -18,9 +18,10 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
-import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.database.CityObjectCache;
 import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.writer.CityGMLWriterUtils;
@@ -46,15 +47,15 @@ import java.util.stream.Stream;
 public class CityDoctorModel {
 
     private static final String COULD_NOT_FIND_FEATURE = "Could not find feature: ";
-    private final List<Building> buildings;
-    private final List<Vegetation> vegetation;
-    private final List<BridgeObject> bridges;
-    private final List<CityFurniture> cityfurniture;
-    private final List<GenericCityObject> genericObjects;
-    private final List<CityObject> land;
-    private final List<TransportationObject> roads;
-    private final List<Tunnel> tunnels;
-    private final List<WaterObject> water;
+    private final List<GmlId> buildings;
+    private final List<GmlId> vegetation;
+    private final List<GmlId> bridges;
+    private final List<GmlId> cityfurniture;
+    private final List<GmlId> genericObjects;
+    private final List<GmlId> land;
+    private final List<GmlId> roads;
+    private final List<GmlId> tunnels;
+    private final List<GmlId> water;
     private CityModel cModel;
     private final ParserConfiguration config;
     private final String fileName;
@@ -63,11 +64,15 @@ public class CityDoctorModel {
     private boolean isValidated = false;
     private ValidationPlan plan;
     private CityGMLVersion cityGMLVersion;
+    private final CityObjectCache cache;
 
-    public CityDoctorModel(ParserConfiguration config, File file) {
+    public CityDoctorModel(ParserConfiguration config, File file, CityObjectCache cache) {
         if (config == null) {
             throw new IllegalArgumentException("Parser configuration may not be null");
         }
+        if( file == null ) {
+            throw new IllegalArgumentException("File may not be null");
+        }
         this.fileName = file.getName();
         this.config = config;
         this.file = file;
@@ -81,6 +86,7 @@ public class CityDoctorModel {
         cityfurniture = new ArrayList<>();
         genericObjects = new ArrayList<>();
         globalErrors = new ArrayList<>();
+        this.cache = cache;
     }
 
     public boolean isValidated() {
@@ -118,8 +124,59 @@ public class CityDoctorModel {
     }
 
     public Stream<CityObject> createFeatureStream() {
-        return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
-                tunnels.stream(), water.stream(), cityfurniture.stream(), genericObjects.stream()).flatMap(co -> co);
+        return Stream.of(getBuildings(), getVegetation(), getBridges(), getLand(), getTransportation(),
+                getTunnels(), getWater(), getCityFurniture(), getOtherCityObjects()).flatMap(co -> co);
+    }
+
+    public List<GmlId> getFeatureIds() {
+        List<GmlId> featureIds = new ArrayList<>();
+        featureIds.addAll(buildings);
+        featureIds.addAll(vegetation);
+        featureIds.addAll(bridges);
+        featureIds.addAll(land);
+        featureIds.addAll(roads);
+        featureIds.addAll(tunnels);
+        featureIds.addAll(water);
+        featureIds.addAll(cityfurniture);
+        featureIds.addAll(genericObjects);
+        return featureIds;
+
+    }
+
+    public boolean containsGmlId(String id) {
+        if (id == null) {
+            return false;
+        }
+        GmlId gmlId = new GmlId(id);
+        if (buildings.contains(gmlId)) {
+            return true;
+        }
+        if (vegetation.contains(gmlId)) {
+            return true;
+        }
+        if (bridges.contains(gmlId)) {
+            return true;
+        }
+        if (land.contains(gmlId)) {
+            return true;
+        }
+        if (roads.contains(gmlId)) {
+            return true;
+        }
+        if (tunnels.contains(gmlId)) {
+            return true;
+        }
+        if (water.contains(gmlId)) {
+            return true;
+        }
+        if (cityfurniture.contains(gmlId)) {
+            return true;
+        }
+        return genericObjects.contains(gmlId);
+    }
+
+    public void accept(CheckableVisitor visitor) {
+        createFeatureStream().forEach(cityObject -> cityObject.accept(visitor));
     }
 
     public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
@@ -137,6 +194,7 @@ public class CityDoctorModel {
         }
     }
 
+
     private void exportAsGML(String file) throws CityDoctorWriteException {
         CityGMLWriterUtils.writeCityModel(file, this);
     }
@@ -147,7 +205,7 @@ public class CityDoctorModel {
         folder.mkdirs();
         createFeatureStream().forEach(co -> {
             Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
-            Check c = new AbstractCheck() {
+            CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
 
                 @Override
                 public void check(Geometry geom) {
@@ -216,106 +274,201 @@ public class CityDoctorModel {
 
     public Set<CheckError> collectErrors() {
         List<CheckError> errors = new ArrayList<>();
-        collectErrorsFromList(errors, buildings);
-        collectErrorsFromList(errors, vegetation);
-        collectErrorsFromList(errors, bridges);
-        collectErrorsFromList(errors, land);
-        collectErrorsFromList(errors, roads);
-        collectErrorsFromList(errors, tunnels);
-        collectErrorsFromList(errors, water);
-        collectErrorsFromList(errors, cityfurniture);
-        collectErrorsFromList(errors, genericObjects);
+        createFeatureStream().forEach(cityObject -> cityObject.collectErrors(errors));
         return new HashSet<>(errors);
     }
 
-    private void collectErrorsFromList(List<CheckError> errors, List<? extends CityObject> cos) {
-        for (CityObject co : cos) {
-            co.collectContainedErrors(errors);
-        }
-    }
 
     public String getFileName() {
         return fileName;
     }
 
-    public void addBridge(BridgeObject coBridge) {
-        bridges.add(coBridge);
-    }
 
     public void addBuilding(Building coBuilding) {
-        buildings.add(coBuilding);
+        buildings.add(coBuilding.getGmlId());
+        cache.put(coBuilding);
     }
 
-    public List<Building> getBuildings() {
+    public void removeFeature(GmlId id){
+        buildings.remove(id);
+        vegetation.remove(id);
+        bridges.remove(id);
+        land.remove(id);
+        roads.remove(id);
+        tunnels.remove(id);
+        water.remove(id);
+        cityfurniture.remove(id);
+        genericObjects.remove(id);
+    }
+
+    public Stream<Building> getBuildings() {
+        return buildings.stream().map(co -> (Building) cache.get(co));
+    }
+
+    public List<GmlId> getBuildingIds() {
         return buildings;
     }
 
-    public List<BridgeObject> getBridges() {
+    public int getBuildingCount(){
+        return buildings.size();
+    }
+
+    public void addBridge(BridgeObject coBridge) {
+        bridges.add(coBridge.getGmlId());
+        cache.put(coBridge);
+    }
+
+    public Stream<BridgeObject> getBridges() {
+        return bridges.stream().map(co -> (BridgeObject) cache.get(co));
+    }
+
+    public List<GmlId> getBridgeIds() {
         return bridges;
     }
 
-    public List<CityFurniture> getCityFurniture() {
-        return cityfurniture;
+    public int getBridgeCount(){
+        return bridges.size();
     }
 
     public void addCityFurniture(CityFurniture coFurniture) {
-        cityfurniture.add(coFurniture);
+        cityfurniture.add(coFurniture.getGmlId());
+        cache.put(coFurniture);
+    }
+
+    public Stream<CityFurniture> getCityFurniture() {
+        return cityfurniture.stream().map(co -> (CityFurniture) cache.get(co));
+    }
+
+    public List<GmlId> getCityFurnitureIds() {
+        return cityfurniture;
+    }
+
+    public int getCityFurnitureCount(){
+        return cityfurniture.size();
+    }
+
+    public void addOtherCityObject(CityObject otherCityObject) {
+        genericObjects.add(otherCityObject.getGmlId());
+         cache.put(otherCityObject);
     }
 
-    public List<GenericCityObject> getGenericCityObjects() {
+    public Stream<CityObject> getOtherCityObjects() {
+        return genericObjects.stream().map(cache::get);
+    }
+
+    public List<GmlId> getOtherCityObjectsIds() {
         return genericObjects;
     }
 
-    public void addGenericCityObject(GenericCityObject coGenericCityObject) {
-        genericObjects.add(coGenericCityObject);
+    public int getOtherCityObjectsCount(){
+        return genericObjects.size();
     }
 
-    public void setCityModel(CityModel cModel) {
-        this.cModel = cModel;
+    public void addTransportation(TransportationObject to) {
+        roads.add(to.getGmlId());
+        cache.put(to);
     }
 
-    public CityModel getCityModel() {
-        return cModel;
+    public Stream<TransportationObject> getTransportation() {
+        return roads.stream().map(co -> (TransportationObject) cache.get(co));
     }
 
-    public List<TransportationObject> getTransportation() {
+    public List<GmlId> getTransportationIds() {
         return roads;
     }
 
-    public List<Tunnel> getTunnels() {
-        return tunnels;
+    public int getTransportationCount(){
+        return roads.size();
     }
 
-    public List<WaterObject> getWater() {
-        return water;
+    public void addTunnel(Tunnel tunnel) {
+        tunnels.add(tunnel.getGmlId());
+        cache.put(tunnel);
     }
 
-    public List<CityObject> getLand() {
-        return land;
+    public Stream<Tunnel> getTunnels() {
+        return tunnels.stream().map(co -> (Tunnel) cache.get(co));
     }
 
-    public List<Vegetation> getVegetation() {
-        return vegetation;
+    public List<GmlId> getTunnelIds() {
+        return tunnels;
+    }
+
+    public int getTunnelCount(){
+        return tunnels.size();
     }
 
     public void addWater(WaterObject wo) {
-        water.add(wo);
+        water.add(wo.getGmlId());
+        cache.put(wo);
+    }
+
+    public Stream<WaterObject> getWater() {
+        return water.stream().map(co -> (WaterObject) cache.get(co));
+    }
+
+    public List<GmlId> getWaterIds() {
+        return water;
+    }
+
+    public int getWaterCount(){
+        return water.size();
     }
 
     public void addLand(LandObject lo) {
-        land.add(lo);
+        land.add(lo.getGmlId());
+        cache.put(lo);
+    }
+
+    public void addRelief(ReliefObject relief) {
+        land.add(relief.getGmlId());
+        cache.put(relief);
+    }
+
+    public void addTin(TinObject tin) {
+        land.add(tin.getGmlId());
+        cache.put(tin);
+    }
+
+    public Stream<CityObject> getLand() {
+        return land.stream().map(cache::get);
+    }
+
+    public List<GmlId> getLandIds() {
+        return land;
+    }
+
+    public int getLandCount(){
+        return land.size();
     }
 
     public void addVegetation(Vegetation veg) {
-        vegetation.add(veg);
+        vegetation.add(veg.getGmlId());
+        cache.put(veg);
     }
 
-    public void addTransportation(TransportationObject to) {
-        roads.add(to);
+    public Stream<Vegetation> getVegetation() {
+        return vegetation.stream().map(co -> (Vegetation) cache.get(co));
     }
 
-    public void addTunnel(Tunnel tunnel) {
-        tunnels.add(tunnel);
+    public List<GmlId> getVegetationIds() {
+        return vegetation;
+    }
+
+    public int getVegetationCount(){
+        return vegetation.size();
+    }
+
+    public void setCityModel(CityModel cModel) {
+        this.cModel = cModel;
+    }
+
+    public CityModel getCityModel() {
+        return cModel;
+    }
+
+    public CityObjectCache getCache(){
+        return cache;
     }
 
     public int getNumberOfFeatures() {
@@ -350,100 +503,109 @@ public class CityDoctorModel {
     }
 
     private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
-        int index = water.indexOf(currentFeature);
+        int index = water.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
         }
-        water.set(index, (WaterObject) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        water.set(index, nextFeature.getGmlId());
     }
 
     private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
-        int index = land.indexOf(currentFeature);
+        int index = land.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
         }
-        land.set(index, nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        land.set(index, nextFeature.getGmlId());
     }
 
     private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
-        int index = vegetation.indexOf(currentFeature);
+        int index = vegetation.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
         }
-        vegetation.set(index, (Vegetation) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        vegetation.set(index, nextFeature.getGmlId());
     }
 
     private void replaceCityFurniture(CityObject currentFeature, CityObject nextFeature) {
-        int index = cityfurniture.indexOf(currentFeature);
+        int index = cityfurniture.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
         }
-        cityfurniture.set(index, (CityFurniture) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        cityfurniture.set(index, nextFeature.getGmlId());
     }
 
     private void replaceGenericCityObject(CityObject currentFeature, CityObject nextFeature) {
-        int index = genericObjects.indexOf(currentFeature);
+        int index = genericObjects.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in generic city objects");
         }
-        genericObjects.set(index, (GenericCityObject) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        genericObjects.set(index, nextFeature.getGmlId());
     }
 
     private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
-        int index = roads.indexOf(currentFeature);
+        int index = roads.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
         }
-        roads.set(index, (TransportationObject) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        roads.set(index, nextFeature.getGmlId());
     }
 
     private void replaceTunnel(CityObject currentFeature, CityObject nextFeature) {
-        int index = tunnels.indexOf(currentFeature);
+        int index = tunnels.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in tunnels");
         }
-        tunnels.set(index, (Tunnel) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        tunnels.set(index, nextFeature.getGmlId());
     }
 
     private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
-        int index = bridges.indexOf(currentFeature);
+        int index = bridges.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
         }
-        bridges.set(index, (BridgeObject) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        bridges.set(index, nextFeature.getGmlId());
     }
 
     private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
-        int index = buildings.indexOf(currentFeature);
+        int index = buildings.indexOf(currentFeature.getGmlId());
         if (index == -1) {
             throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
         }
-        buildings.set(index, (Building) nextFeature);
+        cache.replace(currentFeature.getGmlId(), nextFeature);
+        buildings.set(index, nextFeature.getGmlId());
     }
 
     public void addCityObject(CityObject co) {
         if (co instanceof Building b) {
-            buildings.add(b);
+            buildings.add(b.getGmlId());
         } else if (co instanceof BridgeObject bo) {
-            bridges.add(bo);
+            bridges.add(bo.getGmlId());
         } else if (co instanceof TransportationObject to) {
-            roads.add(to);
+            roads.add(to.getGmlId());
         } else if (co instanceof Tunnel tu) {
-            tunnels.add(tu);
+            tunnels.add(tu.getGmlId());
         } else if (co instanceof Vegetation veg) {
-            vegetation.add(veg);
+            vegetation.add(veg.getGmlId());
         } else if (co instanceof LandObject lo) {
-            land.add(lo);
+            land.add(lo.getGmlId());
         } else if (co instanceof WaterObject wo) {
-            water.add(wo);
+            water.add(wo.getGmlId());
         } else if (co instanceof ReliefObject) {
-            land.add(co);
+            land.add(co.getGmlId());
         } else if (co instanceof TinObject) {
-            land.add(co);
+            land.add(co.getGmlId());
         } else if (co instanceof CityFurniture cf) {
-            cityfurniture.add(cf);
+            cityfurniture.add(cf.getGmlId());
         } else if (co instanceof GenericCityObject gco) {
-            genericObjects.add(gco);
+            genericObjects.add(gco.getGmlId());
         }
     }
 
@@ -455,11 +617,4 @@ public class CityDoctorModel {
         return cityGMLVersion;
     }
 
-    public void addRelief(ReliefObject relief) {
-        addCityObject(relief);
-    }
-
-    public void addTin(TinObject tin) {
-        addCityObject(tin);
-    }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
 import org.citygml4j.core.model.core.AbstractCityObject;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
@@ -22,7 +21,7 @@ public class CityFurniture extends CityObject {
     private org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCityFurniture;
 
     @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -35,6 +34,11 @@ public class CityFurniture extends CityObject {
         return cgmlCityFurniture;
     }
 
+    @Override
+    public Color getRenderColor() {
+        return Color.THISTLE;
+    }
+
     public void setGmlObject(org.citygml4j.core.model.cityfurniture.CityFurniture gmlCityFurniture) {
         cgmlCityFurniture = gmlCityFurniture;
     }
@@ -47,11 +51,19 @@ public class CityFurniture extends CityObject {
         cgmlCityFurniture.setLod1Solid(null);
         cgmlCityFurniture.setLod2Solid(null);
         cgmlCityFurniture.setLod3Solid(null);
+        cgmlCityFurniture.getDeprecatedProperties().setLod1Geometry(null);
+        cgmlCityFurniture.getDeprecatedProperties().setLod2Geometry(null);
+        cgmlCityFurniture.getDeprecatedProperties().setLod3Geometry(null);
         cgmlCityFurniture.getDeprecatedProperties().setLod4Geometry(null);
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public CityObject getTopLevelCityObject() {
+        return this;
+    }
+
+    @Override
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;
@@ -71,12 +83,18 @@ public class CityFurniture extends CityObject {
             case LOD0:
                 cgmlCityFurniture.setLod0MultiSurface(new MultiSurfaceProperty(ms));
                 break;
+            case LOD1:
+                cgmlCityFurniture.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
             case LOD2:
                 cgmlCityFurniture.setLod2MultiSurface(new MultiSurfaceProperty(ms));
                 break;
             case LOD3:
                 cgmlCityFurniture.setLod3MultiSurface(new MultiSurfaceProperty(ms));
                 break;
+            case LOD4:
+                cgmlCityFurniture.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty(ms));
+                break;
             default:
                 throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
         }
@@ -93,6 +111,8 @@ public class CityFurniture extends CityObject {
             case LOD3:
                 cgmlCityFurniture.setLod3Solid(new SolidProperty(solid));
                 break;
+            case LOD4:
+                cgmlCityFurniture.getDeprecatedProperties().setLod4Geometry(new SolidProperty(solid));
             default:
                 throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
         }
@@ -103,15 +123,4 @@ public class CityFurniture extends CityObject {
         return FeatureType.CITY_FURNITURE;
     }
 
-    @Override
-    public Copyable createCopyInstance() {
-        return new CityFurniture();
-    }
-
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        CityFurniture originalCF = (CityFurniture) original;
-        cgmlCityFurniture = originalCF.cgmlCityFurniture;
-    }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java

@@ -18,12 +18,11 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder;
+import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
+import javafx.scene.paint.Color;
 import org.citygml4j.core.model.core.AbstractCityObject;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 
@@ -44,20 +43,30 @@ public abstract class CityObject extends GmlElement {
     @Serial
     private static final long serialVersionUID = 651712070755024188L;
 
+    private BoundingBox bbox;
     private final List<Geometry> geometryList = new ArrayList<>();
     private final List<GenericAttribute> genericAttributeList = new ArrayList<>();
+
+    /**
+     * Recreates the CityGML4j geometry in this object's datastructure using the CityDoctor geometries.
+     * The original CityGML4j geometry is deleted after parsing to reduce the memory overhead of {@link CityObject CityObjects}.
+     * <p/>
+     * Recreation of the geometries is needed for writing validation results to the QualityADE, as well as for the export
+     * of repaired geometries from CityDoctor's internal datastructure.
+     * @param factory the GeometryFactory used for creation of CityGml4j geometry objects
+     * @param config the configuration settings of the parser
+     */
+    public final void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        this.accept(new GmlGeometryRebuilder(factory, config));
+    }
+
     /**
-     * Recreates the CityGML4j geometry in this object. The CityGML4j geometry is
-     * deleted from the data structure as was mapped to the city doctor data
-     * structure. For writing CityGML files the geometry has to be restored. Also
-     * maps changes to geometry back to CityGML4j
+     * Rebuilds the CityGML4j geometries of this object.
      *
-     * @param factory needed to create CityGML4j data structures
-     * @param config  contains information whether a city doctor point was
-     *                transformed to a different coordinate system. It would need to
-     *                be transformed to the original coordinate system
+     * @param factory the GeometryFactory used for creation of CityGml4j geometry objects
+     * @param config  the configuration settings of the parser
      */
-    public abstract void reCreateGeometries(GeometryFactory factory, ParserConfiguration config);
+    public abstract void rebuildGeometries(GeometryFactory factory, ParserConfiguration config);
 
     /**
      * Getter for the CityGML4j data object
@@ -67,29 +76,69 @@ public abstract class CityObject extends GmlElement {
     public abstract AbstractCityObject getGmlObject();
 
     /**
-     * Remove the CityGML4j geometries from the data structure to save memory.
+     * Remove the CityGML4j geometries from this CityObject to reduce memory overhead.
      */
     public abstract void unsetGmlGeometries();
 
+    /**
+     * Removes all CityGML4J geometries from this CityObject and child objects of its datastructure to reduce
+     * the memory overhead.
+     */
+    public final void clearGmlGeometries() {
+        this.accept(new UnsetGeometriesVisitor());
+    }
+
+    public void setBbox(BoundingBox bbox){
+        this.bbox = bbox;
+    }
+
+    public synchronized BoundingBox getBbox(){
+        if (bbox == null){
+            this.setBbox(BoundingBox.of(this));
+        }
+        return bbox;
+    }
+
+    /**
+     * Adds a Geometry to this object.
+     * @param geom the Geometry to add.
+     */
     public void addGeometry(Geometry geom) {
         Objects.requireNonNull(geom);
         geometryList.add(geom);
         geom.setParent(this);
     }
 
-
+    /**
+     * Returns all Geometries of this object.
+     * @return a list of the Geometries.
+     */
     public List<Geometry> getGeometries() {
         return geometryList;
     }
 
+    /**
+     * Removes a Geometry from this object.
+     * @param lod the {@link Lod} of the Geometry.
+     */
     public void removeGeometry(Lod lod) {
         geometryList.removeIf(geom -> geom.getLod() == lod);
     }
 
+    /**
+     * Removes a Geometry from this object.
+     * @param lod the {@link Lod} of the Geometry.
+     * @param type the {@link GeometryType} of the Geometry.
+     */
     public void removeGeometry(Lod lod, GeometryType type) {
         geometryList.removeIf(geom -> geom.getLod() == lod && geom.getType() == type);
     }
 
+    /**
+     * Returns the Geometry with the highest LOD of this object. If multiple Geometries share the highest LOD, the one
+     * that was added first will be returned.
+     * @return the Geometry with the highest LOD
+     */
     public Geometry getHighestLodGeometry() {
         Geometry highestLodGeometry = null;
         Lod highestLod = null;
@@ -102,18 +151,52 @@ public abstract class CityObject extends GmlElement {
         return highestLodGeometry;
     }
 
+    /**
+     * Returns the top-level CityObject (e.g. Building, Tunnel, Vegetation etc.) belonging to this object.
+     */
+    public abstract CityObject getTopLevelCityObject();
+
+    /**
+     * Returns a String representation of this object for display in the featuretab TreeViews in the format of
+     * "[FeatureType] Gml-ID"
+     * @return the String representation.
+     */
+    public String getDisplayText() {
+        return String.format("[%s] %s", this.getClass().getSimpleName(), this.getGmlId().toString());
+    }
+
+    /**
+     * Returns the color for rendering of this object's polygons.
+     * @return color for this object
+     */
+    public Color getRenderColor() {
+        return Color.WHITE;
+    }
+
+    /**
+     * Adds a GenericAttribute to this object.
+     * @param genericAttribute the attribute to add.
+     */
     public void addGenericAttribute(GenericAttribute genericAttribute) {
         genericAttributeList.add(genericAttribute);
     }
 
+    /**
+     * Returns all GenericAttributes of this object.
+     * @return a list of the GenericAttributes.
+     */
     public List<GenericAttribute> getGenericAttributes() {
         return genericAttributeList;
     }
 
+    /**
+     * Returns the CityGML FeatureType of this object.
+     * @return this object's FeatureType.
+     */
     public abstract FeatureType getFeatureType();
 
     @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -123,50 +206,6 @@ public abstract class CityObject extends GmlElement {
         }
     }
 
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        boolean hasError = super.containsError(checkIdentifier);
-        if (hasError) {
-            return true;
-        }
-        for (Geometry geom : geometryList) {
-            if (geom.containsError(checkIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void clearAllContainedCheckResults() {
-        super.clearCheckResults();
-        for (Geometry geom : geometryList) {
-            geom.clearAllContainedCheckResults();
-        }
-    }
-
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        super.collectContainedErrors(errors);
-        for (Geometry geom : geometryList) {
-            geom.collectContainedErrors(errors);
-        }
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        boolean hasError = super.containsAnyError();
-        if (hasError) {
-            return true;
-        }
-        for (Geometry geom : geometryList) {
-            if (geom.containsAnyError()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     public Geometry getGeometry(GeometryType type, Lod lod) {
         for (Geometry geom : geometryList) {
             if (geom.getType() == type && geom.getLod() == lod) {
@@ -176,33 +215,5 @@ public abstract class CityObject extends GmlElement {
         return null;
     }
 
-    @Override
-    public void prepareForChecking() {
-        for (Geometry geom : geometryList) {
-            geom.prepareForChecking();
-        }
-    }
-
-    @Override
-    public void clearMetaInformation() {
-        for (Geometry geom : geometryList) {
-            geom.clearMetaInformation();
-        }
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        for (Geometry geom : geometryList) {
-            handler.addInstance(geom);
-        }
-    }
 
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        CityObject originalCo = (CityObject) original;
-        for (Geometry geom : originalCo.geometryList) {
-            geometryList.add(handler.getCopyInstance(geom));
-        }
-    }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CompositeCollection.java

@@ -2,6 +2,7 @@ package de.hft.stuttgart.citydoctor2.datastructure;
 
 
 import java.io.Serial;
+import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -9,7 +10,7 @@ import java.util.List;
  *
  * @author Riegel
  */
-public final class CompositeCollection {
+public final class CompositeCollection implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -1867197873443341287L;
@@ -31,6 +32,7 @@ public final class CompositeCollection {
         return childComposites;
     }
 
+    //TODO stream
     public List<ConcretePolygon> getCompositeMembers() {
         List<ConcretePolygon> copy = new ArrayList<>(compositeMembers);
         for (CompositeCollection c : childComposites) {

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java

@@ -18,15 +18,12 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.tesselation.JoglTesselator;
 import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
 
 import java.io.Serial;
 import java.util.ArrayList;
@@ -50,6 +47,7 @@ public class ConcretePolygon extends Polygon {
 	private BoundarySurface partOfSurface;
 	private Installation partfOfInstallation;
 	private CompositeCollection partOfComposite = null;
+	private PatchCollection partOfPatch = null;
 	private Geometry parent;
 	private LinkedPolygon linkedFromPolygon;
 	
@@ -141,6 +139,18 @@ public class ConcretePolygon extends Polygon {
 		this.partOfComposite = comp;
 	}
 
+	protected void setPartOfPatch(PatchCollection pc) {
+		this.partOfPatch = pc;
+	}
+
+	public PatchCollection getPartOfPatch(PatchCollection pc) {
+		return partOfPatch;
+	}
+
+	public boolean isPatchMember() {
+		return partOfPatch != null;
+	}
+
 	public CompositeCollection getPartOfComposite() {
 		return partOfComposite;
 	}
@@ -170,7 +180,8 @@ public class ConcretePolygon extends Polygon {
 	 * citydoctor2.check.Check)
 	 */
 	@Override
-	public void accept(Check c) {
+	public void accept(CheckableVisitor c) {
+		super.accept(c);
 		if (c.canExecute(this)) {
 			c.check(this);
 		}
@@ -182,7 +193,6 @@ public class ConcretePolygon extends Polygon {
 				lr.accept(c);
 			}
 		}
-		setValidated(true);
 	}
 
 	@Override
@@ -202,93 +212,6 @@ public class ConcretePolygon extends Polygon {
 		return exterior.isRingConnectedViaPoint(other.getExteriorRing());
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see de.hft.stuttgart.citydoctor2.datastructure.Polygon#containsAnyError()
-	 */
-	@Override
-	public boolean containsAnyError() {
-		if (super.containsAnyError()) {
-			return true;
-		}
-		if (exterior != null && exterior.containsAnyError()) {
-			return true;
-		}
-		if (innerRings != null) {
-			for (LinearRing lr : innerRings) {
-				if (lr.containsAnyError()) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see
-	 * de.hft.stuttgart.citydoctor2.datastructure.Polygon#collectContainedErrors(
-	 * java.util.List)
-	 */
-	@Override
-	public void collectContainedErrors(List<CheckError> errors) {
-		super.collectContainedErrors(errors);
-		if (exterior != null) {
-			exterior.collectContainedErrors(errors);
-		}
-		if (innerRings != null) {
-			for (LinearRing lr : innerRings) {
-				lr.collectContainedErrors(errors);
-			}
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see de.hft.stuttgart.citydoctor2.datastructure.Polygon#
-	 * clearAllContainedCheckResults()
-	 */
-	@Override
-	public void clearAllContainedCheckResults() {
-		super.clearCheckResults();
-		if (exterior != null) {
-			exterior.clearAllContainedCheckResults();
-		}
-		if (innerRings != null) {
-			for (LinearRing lr : innerRings) {
-				lr.clearAllContainedCheckResults();
-			}
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see de.hft.stuttgart.citydoctor2.datastructure.Polygon#containsError(de.hft.
-	 * stuttgart.citydoctor2.check.CheckId)
-	 */
-	@Override
-	public boolean containsError(CheckId checkIdentifier) {
-		boolean hasError = super.containsError(checkIdentifier);
-		if (hasError) {
-			return true;
-		}
-		if (exterior != null && exterior.containsError(checkIdentifier)) {
-			return true;
-		}
-		if (innerRings != null) {
-			for (LinearRing lr : innerRings) {
-				if (lr.containsError(checkIdentifier)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -466,51 +389,10 @@ public class ConcretePolygon extends Polygon {
 	}
 	
 	@Override
-	public void prepareForChecking() {
-		parent.prepareForChecking();
-	}
-	
-	@Override
-	public void clearMetaInformation() {
-		parent.clearMetaInformation();
-	}
-
-	@Override
-	public void collectInstances(CopyHandler handler) {
-		handler.addInstance(exterior);
-		if (innerRings != null) {
-			for (LinearRing lr : innerRings) {
-				handler.addInstance(lr);
-			}
-		}
-		handler.addInstance(partOfSurface);
-		handler.addInstance(partfOfInstallation);
-		handler.addInstance(parent);
-		handler.addInstance(linkedFromPolygon);
+	public void prepareLowMemoryUsageMode() {
+		parent.updateEdgesAndVertices();
 	}
-	
 
-	@Override
-	public Copyable createCopyInstance() {
-		return new ConcretePolygon();
-	}
-	
-	@Override
-	public void fillValues(Copyable original, CopyHandler handler) {
-		super.fillValues(original, handler);
-		ConcretePolygon originalPoly = (ConcretePolygon) original;
-		exterior = handler.getCopyInstance(originalPoly.exterior);
-		if (originalPoly.innerRings != null) {
-			innerRings = new ArrayList<>(originalPoly.innerRings.size());
-			for (LinearRing originalRing : originalPoly.innerRings) {
-				innerRings.add(handler.getCopyInstance(originalRing));
-			}
-		}
-		parent = handler.getCopyInstance(originalPoly.parent);
-		partfOfInstallation = handler.getCopyInstance(originalPoly.partfOfInstallation);
-		partOfSurface = handler.getCopyInstance(originalPoly.partOfSurface);
-		linkedFromPolygon = handler.getCopyInstance(originalPoly.linkedFromPolygon);
-	}
 
 	@Override
 	public void remove() {
@@ -531,6 +413,11 @@ public class ConcretePolygon extends Polygon {
 		}
 		return area;
 	}
+
+	@Override
+	public Color getRenderColor() {
+		return parent.getRenderColor();
+	}
 	
 	
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java

@@ -18,9 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
-
 import java.io.Serial;
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -31,7 +28,7 @@ import java.util.List;
  *
  * @author Matthias Betz
  */
-public class Edge implements Serializable, Copyable {
+public class Edge implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -504694863498128296L;
@@ -51,9 +48,6 @@ public class Edge implements Serializable, Copyable {
         this.to = to;
     }
 
-    private Edge() {
-    }
-
     public Vertex getFrom() {
         return from;
     }
@@ -186,33 +180,7 @@ public class Edge implements Serializable, Copyable {
         }
         return null;
     }
+}
 
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        handler.addInstance(from);
-        handler.addInstance(to);
-        handler.addInstance(adjacentPolygons);
-        handler.addInstance(adjacentRings);
-    }
-
-    @Override
-    public Copyable createCopyInstance() {
-        return new Edge();
-    }
 
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        Edge originalEdge = (Edge) original;
-        from = handler.getCopyInstance(originalEdge.from);
-        to = handler.getCopyInstance(originalEdge.to);
-        numberOfHalfEdges = originalEdge.numberOfHalfEdges;
-        numberOfOppositeHalfEdges = originalEdge.numberOfOppositeHalfEdges;
-        for (Polygon originalPoly : originalEdge.adjacentPolygons) {
-            adjacentPolygons.add(handler.getCopyInstance(originalPoly));
-        }
-        for (LinearRing originalRing : originalEdge.adjacentRings) {
-            adjacentRings.add(handler.getCopyInstance(originalRing));
-        }
-    }
 
-}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/FeatureType.java

@@ -27,5 +27,5 @@ public enum FeatureType {
 
     BUILDING, TRANSPORTATION, VEGETATION, BRIDGE, LAND, WATER, BOUNDARY_SURFACE, INSTALLATION, OPENING,
     BUILDING_PART, BUILDING_SUBDIVISION, BRIDGE_CONSTRUCTION_ELEMENT, BRIDGE_INSTALLATION, ROOM, FURNITURE, CITY_FURNITURE,
-    GENERIC_CITY_OBJECT, TUNNEL, TUNNEL_PART, TUNNEL_CONSTRUCTION_ELEMENT, TUNNEL_INSTALLATION,
+    OTHER_CITY_OBJECT, TUNNEL, TUNNEL_PART, TUNNEL_CONSTRUCTION_ELEMENT, TUNNEL_INSTALLATION,
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericAttribute.java

@@ -5,10 +5,21 @@ import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.AbstractGenericAttributeProperty;
 import org.citygml4j.core.model.generics.*;
 
+import java.io.Serial;
+import java.io.Serializable;
 
-public class GenericAttribute {
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.function.Supplier;
+
+
+public class GenericAttribute implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -4101408947632132328L;
 
     private static final Logger logger = LogManager.getLogger(GenericAttribute.class);
+    private static final String NULL_VALUE_STRING= "NULL OR INVALID VALUE";
 
     private final AbstractGenericAttributeProperty original;
 
@@ -16,6 +27,7 @@ public class GenericAttribute {
     private String name;
     private String value;
 
+
     public GenericAttribute(AbstractGenericAttributeProperty attributeProperty) {
         original = attributeProperty;
         if (attributeProperty.getObject() == null) {
@@ -26,25 +38,43 @@ public class GenericAttribute {
 
         if (attributeProperty.getObject() instanceof StringAttribute sa) {
             type = "StringAttribute";
-            value = sa.getValue();
+            value = extractValue(() -> String.format("\"%s\"", sa.getValue()));
         } else if (attributeProperty.getObject() instanceof IntAttribute ia) {
             type = "IntAttribute";
-            value = ia.getValue().toString();
+            value = extractValue(() -> ia.getValue().toString());
         } else if (attributeProperty.getObject() instanceof DoubleAttribute da) {
             type = "DoubleAttribute";
-            value = da.getValue().toString();
+            value = extractValue(() -> da.getValue().toString());
         } else if (attributeProperty.getObject() instanceof DateAttribute date) {
             type = "DateAttribute";
-            value = date.getValue().toString();
+            value = extractValue(() -> date.getValue().toString());
         } else if (attributeProperty.getObject() instanceof UriAttribute ua) {
             type = "UriAttribute";
-            value = ua.getValue();
+            value = extractValue(ua::getValue);
         } else if (attributeProperty.getObject() instanceof MeasureAttribute ma) {
             type = "MeasureAttribute";
-            value = ma.getValue().toString();
+            value = extractValue(() ->
+                    String.format("%s %s", ma.getValue().getValue().toString(), ma.getValue().getUom()));
         } else if (attributeProperty.getObject() instanceof CodeAttribute ca) {
-            type = "CodeAttribute";
-            value = ca.getValue().toString();
+            type = String.format("CodeAttribute (%s)", ca.getValue().getLanguage());
+            value = extractValue(() ->
+                    String.format("'''%s''' %n CodeSpace: %s", ca.getValue().getValue(), ca.getValue().getCodeSpace()));
+        } else if (attributeProperty.getObject() instanceof GenericAttributeSet gas) {
+            type = "GenericAttributeSet";
+            List<AbstractGenericAttributeProperty> attributes = gas.getValue();
+            if(attributes == null || attributes.isEmpty()){
+                value = NULL_VALUE_STRING;
+                return;
+            }
+            StringJoiner sj = new StringJoiner("; ","{","}");
+            sj.setEmptyValue("EMPTY_SET");
+            for (AbstractGenericAttributeProperty attribute : attributes) {
+                if (attribute.getObject() != null) {
+                    sj.add(String.format("%1$s = %2$s",attribute.getObject().getName(), attribute.getObject().getValue()));
+                }
+            }
+            value = sj.toString();
+
         } else {
             logger.warn("GenericAttribute {} is of unknown type {}", attributeProperty, attributeProperty.getObject());
             value = attributeProperty.getObject().getValue().toString();
@@ -53,6 +83,14 @@ public class GenericAttribute {
 
     }
 
+    private String extractValue(Supplier<String> supply){
+        try{
+            return supply.get();
+        }catch (NullPointerException e){
+            return NULL_VALUE_STRING;
+        }
+    }
+
     public AbstractGenericAttributeProperty getOriginal() {
         return original;
     }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.AbstractCityObject;
@@ -36,7 +33,7 @@ public class GenericCityObject extends CityObject {
     private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
 
     @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -47,7 +44,7 @@ public class GenericCityObject extends CityObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;
@@ -60,23 +57,21 @@ public class GenericCityObject extends CityObject {
                 setSolidAccordingToLod(geom, solid);
             }
         }
-        for (BoundarySurface bs : boundarySurfaceList) {
-            reCreateBoundarySurface(factory, config, bs);
-        }
+        removeEmptyBoundarySurfaces();
     }
 
-    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
-        if (bs.getGeometries().isEmpty()) {
-            for (AbstractSpaceBoundaryProperty bsp : cgmlGos.getBoundaries()) {
-                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
-                    logger.warn("Found empty boundary surface: {}, removing from generic object", bs.getGmlId());
-                    cgmlGos.getBoundaries().remove(bsp);
-                    break;
+    private void removeEmptyBoundarySurfaces() {
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.getGeometries().isEmpty()) {
+                for (AbstractSpaceBoundaryProperty bsp : cgmlGos.getBoundaries()) {
+                    if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                        logger.warn("Found empty boundary surface: {}, removing from feature", bs.getGmlId());
+                        cgmlGos.getBoundaries().remove(bsp);
+                        break;
+                    }
                 }
             }
-            return;
         }
-        bs.reCreateGeometries(factory, config);
     }
 
     private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
@@ -84,14 +79,20 @@ public class GenericCityObject extends CityObject {
             case LOD0:
                 cgmlGos.setLod0MultiSurface(new MultiSurfaceProperty(ms));
                 break;
+            case LOD1:
+                cgmlGos.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
             case LOD2:
                 cgmlGos.setLod2MultiSurface(new MultiSurfaceProperty(ms));
                 break;
             case LOD3:
                 cgmlGos.setLod3MultiSurface(new MultiSurfaceProperty(ms));
                 break;
+            case LOD4:
+                cgmlGos.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty(ms));
+                break;
             default:
-                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to generic city object");
         }
     }
 
@@ -106,111 +107,49 @@ public class GenericCityObject extends CityObject {
             case LOD3:
                 cgmlGos.setLod3Solid(new SolidProperty(solid));
                 break;
+            case LOD4:
+                cgmlGos.getDeprecatedProperties().setLod4Geometry(new SolidProperty(solid));
+                break;
             default:
-                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
-        }
-    }
-
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        super.collectContainedErrors(errors);
-        for (BoundarySurface bs : boundarySurfaceList) {
-            bs.collectContainedErrors(errors);
-        }
-    }
-
-    @Override
-    public void clearAllContainedCheckResults() {
-        super.clearAllContainedCheckResults();
-        for (BoundarySurface bs : boundarySurfaceList) {
-            bs.clearAllContainedCheckResults();
-        }
-    }
-
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        boolean hasError = super.containsError(checkIdentifier);
-        if (hasError) {
-            return true;
-        }
-        for (BoundarySurface bs : boundarySurfaceList) {
-            if (bs.containsError(checkIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        boolean hasError = super.containsAnyError();
-        if (hasError) {
-            return true;
-        }
-        for (BoundarySurface bs : boundarySurfaceList) {
-            if (bs.containsAnyError()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void prepareForChecking() {
-        super.prepareForChecking();
-        for (BoundarySurface bs : boundarySurfaceList) {
-            bs.prepareForChecking();
-        }
-    }
-
-    @Override
-    public void clearMetaInformation() {
-        super.clearMetaInformation();
-        for (BoundarySurface bs : boundarySurfaceList) {
-            bs.clearMetaInformation();
-        }
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        super.collectInstances(handler);
-        handler.addInstance(boundarySurfaceList);
-    }
-
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        GenericCityObject originalGos = (GenericCityObject) original;
-        for (BoundarySurface originalBs : originalGos.boundarySurfaceList) {
-            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to generic city object");
         }
-        cgmlGos = originalGos.cgmlGos;
     }
-
     @Override
     public AbstractCityObject getGmlObject() {
-        return null;
+        return cgmlGos;
     }
 
     @Override
     public FeatureType getFeatureType() {
-        return FeatureType.GENERIC_CITY_OBJECT;
+        return FeatureType.OTHER_CITY_OBJECT;
     }
 
     public List<BoundarySurface> getBoundarySurfaces() {
         return boundarySurfaceList;
     }
 
+    @Override
+    public Color getRenderColor() {
+        return Color.DARKGOLDENROD;
+    }
+
     @Override
     public void unsetGmlGeometries() {
         cgmlGos.setLod1Solid(null);
         cgmlGos.setLod2Solid(null);
         cgmlGos.setLod3Solid(null);
+        cgmlGos.setLod0MultiSurface(null);
         cgmlGos.setLod2MultiSurface(null);
         cgmlGos.setLod3MultiSurface(null);
-        for (BoundarySurface bs : boundarySurfaceList) {
-            bs.unsetGmlGeometries();
-        }
+        cgmlGos.getDeprecatedProperties().setLod1Geometry(null);
+        cgmlGos.getDeprecatedProperties().setLod2Geometry(null);
+        cgmlGos.getDeprecatedProperties().setLod3Geometry(null);
+        cgmlGos.getDeprecatedProperties().setLod4Geometry(null);
+    }
+
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return this;
     }
 
     public void setGmlObject(org.citygml4j.core.model.generics.GenericOccupiedSpace gos) {
@@ -222,9 +161,4 @@ public class GenericCityObject extends CityObject {
         bs.setParent(this);
     }
 
-
-    @Override
-    public Copyable createCopyInstance() {
-        return new GenericCityObject();
-    }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java

@@ -18,20 +18,23 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import java.util.Set;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.math.Triangle3d;
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
 import de.hft.stuttgart.citydoctor2.utils.BoundingBoxCalculator;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
-
-import java.io.Serial;
-import java.util.*;
-import java.util.Map.Entry;
+import javafx.scene.paint.Color;
 
 /**
  * Representation of a geometry containing the polygons and edges
@@ -44,6 +47,10 @@ public class Geometry extends GmlElement {
 
     @Serial
     private static final long serialVersionUID = 2539031030917731575L;
+    
+    public enum Orientation {
+    	INWARD, OUTWARD
+    }
 
     private static final Random r = new Random();
 
@@ -56,11 +63,31 @@ public class Geometry extends GmlElement {
     private List<Edge> edges;
     private Map<SerializablePair<Vertex, Vertex>, Edge> edgeMap;
     private List<Vertex> vertices;
+    private Map<Vertex, Set<LinearRing>> adjacentRingsOfVertices = new HashMap<>();
 
-    public Geometry(GeometryType type, Lod lod) {
+    private Orientation orientation;
+
+    public Geometry(GeometryType type, Lod lod, Orientation orientation) {
         this.lod = lod;
         this.type = type;
-    }
+        if (type == GeometryType.SOLID) {
+        	Objects.requireNonNull(orientation);
+        }
+        this.orientation = orientation;
+    }
+    
+    public Set<LinearRing> getAdjacentRingsOfVertex(Vertex v) {
+    	return adjacentRingsOfVertices.compute(v, (vertex, set) -> {
+    		if (set == null) {
+    			return new HashSet<>(4);
+    		}
+    		return set;
+    	});
+    }
+    
+    public Orientation getOrientation() {
+		return orientation;
+	}
 
     void setParent(CityObject parent) {
         this.parent = parent;
@@ -207,52 +234,9 @@ public class Geometry extends GmlElement {
                 + a[0] * b[1] * c[2];
     }
 
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        boolean hasError = super.containsError(checkIdentifier);
-        if (hasError) {
-            return true;
-        }
-        for (Polygon p : polygons) {
-            if (p.containsError(checkIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
 
     @Override
-    public void clearAllContainedCheckResults() {
-        super.clearCheckResults();
-        for (Polygon p : polygons) {
-            p.clearAllContainedCheckResults();
-        }
-    }
-
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        super.collectContainedErrors(errors);
-        for (Polygon p : polygons) {
-            p.collectContainedErrors(errors);
-        }
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        boolean hasError = super.containsAnyError();
-        if (hasError) {
-            return true;
-        }
-        for (Polygon p : polygons) {
-            if (p.containsAnyError()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -378,74 +362,16 @@ public class Geometry extends GmlElement {
         return false;
     }
 
-    @Override
-    public void prepareForChecking() {
-        updateEdgesAndVertices();
-    }
-
-    @Override
-    public void clearMetaInformation() {
+    public void clearMetaData() {
         if (vertices != null) {
-            for (Vertex v : vertices) {
-                v.clearAdjacentRings();
-            }
+            adjacentRingsOfVertices = new HashMap<>();
             vertices = null;
         }
         edges = null;
         edgeMap = null;
     }
 
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        handler.addInstance(parent);
-        handler.addInstance(polygons);
-        handler.addInstance(edges);
-        handler.addInstance(vertices);
-        if (edgeMap != null) {
-            for (Entry<SerializablePair<Vertex, Vertex>, Edge> e : edgeMap.entrySet()) {
-                handler.addInstance(e.getKey().getValue0());
-                handler.addInstance(e.getKey().getValue1());
-                handler.addInstance(e.getValue());
-            }
-        }
-    }
-
-    @Override
-    public Copyable createCopyInstance() {
-        return new Geometry(type, lod);
-    }
-
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        Geometry originalGeometry = (Geometry) original;
-        for (Polygon originalPoly : originalGeometry.polygons) {
-            polygons.add(handler.getCopyInstance(originalPoly));
-        }
-        if (originalGeometry.edges != null) {
-            edges = new ArrayList<>(originalGeometry.edges.size());
-            for (Edge originalEdge : originalGeometry.edges) {
-                edges.add(handler.getCopyInstance(originalEdge));
-            }
-        }
-        if (originalGeometry.edgeMap != null) {
-            edgeMap = new HashMap<>(originalGeometry.edgeMap.size());
-            for (Entry<SerializablePair<Vertex, Vertex>, Edge> originalEntry : originalGeometry.edgeMap.entrySet()) {
-                Vertex copyV0 = handler.getCopyInstance(originalEntry.getKey().getValue0());
-                Vertex copyV1 = handler.getCopyInstance(originalEntry.getKey().getValue1());
-                SerializablePair<Vertex, Vertex> pair = new SerializablePair<>(copyV0, copyV1);
-                Edge copyEdge = handler.getCopyInstance(originalEntry.getValue());
-                edgeMap.put(pair, copyEdge);
-            }
-        }
-        if (originalGeometry.vertices != null) {
-            vertices = new ArrayList<>(originalGeometry.vertices.size());
-            for (Vertex originalVertex : originalGeometry.vertices) {
-                vertices.add(handler.getCopyInstance(originalVertex));
-            }
-        }
-        parent = handler.getCopyInstance(originalGeometry.parent);
-
+    public Color getRenderColor() {
+        return parent.getRenderColor();
     }
-
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GmlElement.java

@@ -19,8 +19,6 @@
 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import de.hft.stuttgart.citydoctor2.check.Checkable;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
 import java.io.Serial;
 
@@ -29,7 +27,7 @@ import java.io.Serial;
  *
  * @author Matthias Betz
  */
-public abstract class GmlElement extends Checkable implements Copyable {
+public abstract class GmlElement extends Checkable {
 
     @Serial
     private static final long serialVersionUID = -3242505393303017359L;
@@ -52,11 +50,5 @@ public abstract class GmlElement extends Checkable implements Copyable {
         return gmlId != null && !gmlId.isGenerated();
     }
 
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        GmlElement originalElement = (GmlElement) original;
-        // generate gml id before copying
-        gmlId = originalElement.getGmlId();
-    }
 
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import java.io.Serial;
-import java.util.List;
-
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.database.CityObjectCache;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.ImplicitGeometry;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.math.TransformationMatrix;
 
 /**
@@ -19,14 +22,20 @@ public class ImplicitGeometryHolder extends Geometry {
 
     @Serial
     private static final long serialVersionUID = -8938931081577196349L;
+    private static final Logger logger = LogManager.getLogger(ImplicitGeometryHolder.class);
+
+    public enum PrototypeGeometryType {
+        LIBRARY_OBJECT, RELATIVE_GEOMETRY
+    }
 
-    private ImplicitGeometry cgmlImplicitGeometry = null;
 
+    private ImplicitGeometry cgmlImplicitGeometry = null;
+    private static ConcurrentHashMap<ImplicitGeometryHolder, ImplicitGeometry> deferredRelGeomObjects = new ConcurrentHashMap<>();
     private final PrototypeGeometryType type;
     private final Geometry prototypeGeometry;
 
     public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, LibraryObject libObject) {
-        super(libObject.getType(), libObject.getLod());
+        super(libObject.getType(), libObject.getLod(), libObject.getOrientation());
         prototypeGeometry = libObject;
         type = PrototypeGeometryType.LIBRARY_OBJECT;
         this.cgmlImplicitGeometry = cgmlImplicitGeometry;
@@ -34,14 +43,59 @@ public class ImplicitGeometryHolder extends Geometry {
     }
 
     public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, RelativeGeometry relativeGeometry) {
-        super(relativeGeometry.getType(), relativeGeometry.getLod());
+        super(relativeGeometry.getType(), relativeGeometry.getLod(), relativeGeometry.getOrientation());
         prototypeGeometry = relativeGeometry;
         type = PrototypeGeometryType.RELATIVE_GEOMETRY;
         this.cgmlImplicitGeometry = cgmlImplicitGeometry;
         applyTransformation();
     }
 
+    public static ImplicitGeometryHolder deferRelativeGeomParsing(ImplicitGeometry ig, Lod lod) {
+        ImplicitGeometryHolder igh = new ImplicitGeometryHolder(lod);
+        deferredRelGeomObjects.put(igh, ig);
+        return igh;
+    }
+
+    public static void resolveDeferredObjects(CityObjectCache cache) {
+        Set<GmlId> missingGeoms = new HashSet<>();
+        if(!deferredRelGeomObjects.isEmpty()) {
+            logger.info("Resolving deferred relative geometries");
+        }
+        Set<GmlId> changedFeatures = new HashSet<>();
+        for (ImplicitGeometryHolder key : deferredRelGeomObjects.keySet()) {
+            ImplicitGeometry ig = deferredRelGeomObjects.get(key);
+            String hrefId = ig.getRelativeGeometry().getHref();
+            hrefId = hrefId.startsWith("#") ? hrefId.substring(1) : hrefId;
+            GmlId gmlId = new GmlId(hrefId);
+            RelativeGeometry relGeom = RelativeGeometry.of(gmlId);
+            if (relGeom != null) {
+                ImplicitGeometryHolder igh = new ImplicitGeometryHolder(ig, relGeom);
+                CityObject parent = cache.get(key.getParent().getGmlId());
+                parent.removeGeometry(igh.getLod(), igh.getType());
+                parent.addGeometry(igh);
+                changedFeatures.add(parent.getTopLevelCityObject().getGmlId());
+            } else {
+                missingGeoms.add(gmlId);
+            }
+        }
+        changedFeatures.forEach(gmlId -> {
+          CityObject co = cache.get(gmlId);
+          co.setBbox(BoundingBox.of(co));
+        });
+        if (!missingGeoms.isEmpty()) {
+            logger.warn("RelativeGeometries of the following gmlIDs could not be resolved: {}", missingGeoms);
+        }
+        deferredRelGeomObjects.clear();
+        if (logger.isDebugEnabled()) {
+            logger.debug("Resolving HRef geometries finished");
+        }
+    }
 
+    private ImplicitGeometryHolder(Lod lod) {
+        super(null, lod, null);
+        type = null;
+        prototypeGeometry = new Geometry(null, lod, null);
+    }
     /**
      * Applies the transformation matrix of the implicit geometry to a copy of the reference geometry and copies the resulting
      * transformed geometry into this object.
@@ -57,44 +111,14 @@ public class ImplicitGeometryHolder extends Geometry {
         return type;
     }
 
-    @Override
-    public void accept(Check c) {
-        prototypeGeometry.accept(c);
-    }
-
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        return prototypeGeometry.containsError(checkIdentifier);
-    }
-
-    @Override
-    public void clearAllContainedCheckResults() {
-        prototypeGeometry.clearAllContainedCheckResults();
-    }
-
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        prototypeGeometry.clearAllContainedCheckResults();
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        return prototypeGeometry.containsAnyError();
-    }
-
-    @Override
-    public void prepareForChecking() {
-        this.updateEdgesAndVertices();
-        prototypeGeometry.prepareForChecking();
+    /**
+     * Resets the Object maps of {@link RelativeGeometry} and {@link LibraryObject} to prevent memory and data leaks
+     */
+    public static void resetObjectMaps() {
+        RelativeGeometry.resetObjectMap();
+        LibraryObject.resetObjectMap();
     }
 
-    @Override
-    public boolean isValidated() {
-        return prototypeGeometry.isValidated();
-    }
 
-    public enum PrototypeGeometryType {
-        LIBRARY_OBJECT, RELATIVE_GEOMETRY
-    }
 
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java

@@ -18,16 +18,16 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.bridge.BridgeInstallation;
 import org.citygml4j.core.model.construction.AbstractInstallation;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
+import org.citygml4j.core.model.tunnel.TunnelInstallation;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.xmlobjects.gml.model.geometry.GeometryProperty;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
@@ -44,13 +44,15 @@ public class Installation extends CityObject {
     @Serial
     private static final long serialVersionUID = 1576237433322680191L;
 
+    private static final Logger logger = LogManager.getLogger(Installation.class);
+
     private List<BoundarySurface> boundarySurfaces = new ArrayList<>(4);
 
     private AbstractInstallation gmlBi;
 
     private CityObject parent;
 
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
@@ -66,8 +68,20 @@ public class Installation extends CityObject {
                 throw new IllegalStateException("BuildingInstallation not have Solid geometries");
             }
         }
+        removeEmptyBoundarySurfaces();
+    }
+
+    private void removeEmptyBoundarySurfaces() {
         for (BoundarySurface bs : boundarySurfaces) {
-            bs.reCreateGeometries(factory, config);
+            if (bs.getGeometries().isEmpty()) {
+                for (AbstractSpaceBoundaryProperty bsp : gmlBi.getBoundaries()) {
+                    if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                        logger.warn("Found empty boundary surface: {}, removing from feature", bs.getGmlId());
+                        gmlBi.getBoundaries().remove(bsp);
+                        break;
+                    }
+                }
+            }
         }
     }
 
@@ -115,7 +129,7 @@ public class Installation extends CityObject {
     }
 
     @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -125,50 +139,6 @@ public class Installation extends CityObject {
         }
     }
 
-    @Override
-    public void clearAllContainedCheckResults() {
-        super.clearAllContainedCheckResults();
-        for (BoundarySurface bs : boundarySurfaces) {
-            bs.clearAllContainedCheckResults();
-        }
-    }
-
-    @Override
-    public void collectContainedErrors(List<CheckError> errors) {
-        super.collectContainedErrors(errors);
-        for (BoundarySurface bs : boundarySurfaces) {
-            bs.collectContainedErrors(errors);
-        }
-    }
-
-    @Override
-    public boolean containsAnyError() {
-        boolean hasError = super.containsAnyError();
-        if (hasError) {
-            return true;
-        }
-        for (BoundarySurface bs : boundarySurfaces) {
-            if (bs.containsAnyError()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public boolean containsError(CheckId checkIdentifier) {
-        boolean hasError = super.containsError(checkIdentifier);
-        if (hasError) {
-            return true;
-        }
-        for (BoundarySurface bs : boundarySurfaces) {
-            if (bs.containsError(checkIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     public void setParent(CityObject parent) {
         this.parent = parent;
     }
@@ -177,30 +147,45 @@ public class Installation extends CityObject {
         return parent;
     }
 
+    @Override
+    public Color getRenderColor() {
+        return parent.getRenderColor().darker();
+    }
+
     public void addBoundarySurface(BoundarySurface bs) {
         boundarySurfaces.add(bs);
         bs.setParent(this);
     }
 
+    @Override
     public void unsetGmlGeometries() {
-        if (gmlBi instanceof org.citygml4j.core.model.building.BuildingInstallation localBi) {
-            localBi.getDeprecatedProperties().setLod2Geometry(null);
-            localBi.getDeprecatedProperties().setLod3Geometry(null);
-            localBi.getDeprecatedProperties().setLod4Geometry(null);
-        } else if (gmlBi instanceof BridgeInstallation localBi) {
-            removeGeometriesFromBridgeInstallation(localBi);
-        }
-        for (BoundarySurface bs : boundarySurfaces) {
-            bs.unsetGmlGeometries();
+        gmlBi.setLod0MultiSurface(null);
+        gmlBi.setLod2MultiSurface(null);
+        gmlBi.setLod3MultiSurface(null);
+        gmlBi.setLod1Solid(null);
+        gmlBi.setLod2Solid(null);
+        gmlBi.setLod3Solid(null);
+        if (gmlBi instanceof org.citygml4j.core.model.building.BuildingInstallation buildingInstallation) {
+            buildingInstallation.getDeprecatedProperties().setLod2Geometry(null);
+            buildingInstallation.getDeprecatedProperties().setLod3Geometry(null);
+            buildingInstallation.getDeprecatedProperties().setLod4Geometry(null);
+        } else if (gmlBi instanceof BridgeInstallation bridgeInstallation) {
+            bridgeInstallation.getDeprecatedProperties().setLod2Geometry(null);
+            bridgeInstallation.getDeprecatedProperties().setLod3Geometry(null);
+            bridgeInstallation.getDeprecatedProperties().setLod4Geometry(null);
+        } else if (gmlBi instanceof TunnelInstallation tunnelInstallation) {
+            tunnelInstallation.getDeprecatedProperties().setLod2Geometry(null);
+            tunnelInstallation.getDeprecatedProperties().setLod3Geometry(null);
+            tunnelInstallation.getDeprecatedProperties().setLod4Geometry(null);
         }
     }
 
-    private void removeGeometriesFromBridgeInstallation(BridgeInstallation localBi) {
-        localBi.getDeprecatedProperties().setLod2Geometry(null);
-        localBi.getDeprecatedProperties().setLod3Geometry(null);
-        localBi.getDeprecatedProperties().setLod4Geometry(null);
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return getParent().getTopLevelCityObject();
     }
 
+
     public void setGmlObject(AbstractInstallation gmlBi) {
         this.gmlBi = gmlBi;
     }
@@ -237,46 +222,4 @@ public class Installation extends CityObject {
         }
         return boundarySurfaces;
     }
-
-    @Override
-    public void clearMetaInformation() {
-        super.clearMetaInformation();
-        for (BoundarySurface bs : boundarySurfaces) {
-            bs.clearMetaInformation();
-        }
-    }
-
-    @Override
-    public void prepareForChecking() {
-        super.prepareForChecking();
-        for (BoundarySurface bs : boundarySurfaces) {
-            bs.prepareForChecking();
-        }
-    }
-
-    @Override
-    public void fillValues(Copyable original, CopyHandler handler) {
-        super.fillValues(original, handler);
-        Installation originalBi = (Installation) original;
-        for (BoundarySurface originalBs : originalBi.boundarySurfaces) {
-            boundarySurfaces.add(handler.getCopyInstance(originalBs));
-        }
-        gmlBi = originalBi.gmlBi;
-        parent = handler.getCopyInstance(parent);
-    }
-
-    @Override
-    public void collectInstances(CopyHandler handler) {
-        super.collectInstances(handler);
-        for (BoundarySurface bs : boundarySurfaces) {
-            handler.addInstance(bs);
-        }
-        handler.addInstance(parent);
-    }
-
-    @Override
-    public Copyable createCopyInstance() {
-        return new Installation();
-    }
-
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java

@@ -18,10 +18,10 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import javafx.scene.paint.Color;
 import org.citygml4j.core.model.core.AbstractCityObject;
 import org.citygml4j.core.model.landuse.LandUse;
 import org.citygml4j.core.util.geometry.GeometryFactory;
@@ -47,7 +47,7 @@ public class LandObject extends CityObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
@@ -63,6 +63,11 @@ public class LandObject extends CityObject {
         return FeatureType.LAND;
     }
 
+    @Override
+    public Color getRenderColor() {
+        return Color.TAN;
+    }
+
     private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
         switch (geom.getLod()) {
             case LOD0:
@@ -84,7 +89,7 @@ public class LandObject extends CityObject {
     }
 
     @Override
-    public void accept(Check c) {
+    public void accept(CheckableVisitor c) {
         super.accept(c);
         if (c.canExecute(this)) {
             c.check(this);
@@ -105,6 +110,11 @@ public class LandObject extends CityObject {
         lu.getDeprecatedProperties().setLod4MultiSurface(null);
     }
 
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return this;
+    }
+
     public void setGmlObject(LandUse landUse) {
         lu = landUse;
     }
@@ -114,9 +124,4 @@ public class LandObject extends CityObject {
         return "LandObject [id=" + getGmlId() + "]";
     }
 
-    @Override
-    public Copyable createCopyInstance() {
-        return new LandObject(lu);
-    }
-
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java

@@ -4,10 +4,12 @@ import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException;
 import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
 import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.Localization;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.io.Serial;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
@@ -24,56 +26,60 @@ public class LibraryObject extends Geometry {
 	private static final Logger logger = LogManager.getLogger(LibraryObject.class);
 	@Serial
 	private static final long serialVersionUID = -50293435187454911L;
+	private static final Map<String, LibraryObject> libraryObjects = new ConcurrentHashMap<>();
 
-	private static Map<String, LibraryObject> libraryObjects = new ConcurrentHashMap<>();
+    public static LibraryObject of(Path path, ParserConfiguration config) {
+        if (libraryObjects.containsKey(path.toString())) {
+            return libraryObjects.get(path.toString());
+        }
+        Geometry protoGeom = parseFile(path, config);
+        if (protoGeom == null) {
+            return null;
+        }
+        LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod(), protoGeom.getOrientation());
+        protoGeom.getPolygons().forEach(libOb::addPolygon);
+        libOb.updateEdgesAndVertices();
+        libraryObjects.put(path.toString(), libOb);
+        return libOb;
+    }
 
-	public static LibraryObject of(Path path, ParserConfiguration config) {
-		if (libraryObjects.containsKey(path.toString())) {
-			return libraryObjects.get(path.toString());
-		}
-		Geometry protoGeom = parseFile(path, config);
-		if (protoGeom == null) {
-			return null;
-		}
-		LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod());
-		protoGeom.getPolygons().forEach(libOb::addPolygon);
-		libOb.updateEdgesAndVertices();
-		libraryObjects.put(path.toString(), libOb);
-		return libOb;
-	}
+    private LibraryObject(GeometryType type, Lod lod, Orientation orientation) {
+        super(type, lod, orientation);
+    }
 
-	private LibraryObject(GeometryType type, Lod lod) {
-		super(type, lod);
-	}
 
-	private static Geometry parseFile(Path path, ParserConfiguration config) {
-		Geometry geo = null;
-		if (path.toFile().exists()) {
-			try {
-				CityGmlParser.gagLogger(true);
-				CityDoctorModel model = CityGmlParser.parseCityGmlFile(path.toString(), config);
-				List<CityObject> objects = model.createFeatureStream().toList();
-				if (objects.isEmpty()) {
-					throw new InvalidGmlFileException(
-							"Referenced library-object's gml file does not contain a CityGML object!");
-				} else if (objects.size() > 1) {
-					throw new InvalidGmlFileException(
-							"Referenced library-object's gml file contains more than one CityGML object!");
-				}
-				geo = objects.get(0).getHighestLodGeometry();
-			} catch (CityGmlParseException e) {
-				logger.error("Encountered an error while parsing library object {}", path);
-				logger.error(e.getStackTrace());
-			} catch (InvalidGmlFileException e) {
-				logger.error(e.getStackTrace());
-			} finally {
-				// Failsafe to remove gag should parsing fail
-				CityGmlParser.gagLogger(false);
-			}
-		} else {
-			logger.error("Implicit geometry references non-existing library object file {}.", path);
-		}
-		return geo;
-	}
+    private static Geometry parseFile(Path path, ParserConfiguration config) {
+        Geometry geo = null;
+        if (Files.exists(path)) {
+            try {
+                geo = getProtoGeometry(CityGmlParser.nestedCityGmlFileParse(path.toString(), config));
+            } catch (CityGmlParseException e) {
+                logger.error(Localization.getText("LibraryObject.parsingError"), path);
+                logger.error(e.getStackTrace());
+            } catch (InvalidGmlFileException e) {
+                logger.error(e.getStackTrace());
+            }
+        } else {
+            logger.error(Localization.getText("LibraryObject.fileMissing"), path);
+        }
+        return geo;
+    }
+
+    private static Geometry getProtoGeometry(CityDoctorModel model) throws InvalidGmlFileException, CityGmlParseException {
+        if (model == null) {
+            throw new CityGmlParseException("CityDoctorModel of referenced LibraryObject is null");
+        }
+        List<CityObject> objects = model.createFeatureStream().toList();
+        if (objects.isEmpty()) {
+            throw new InvalidGmlFileException("Referenced library-object gml file does not contain any CityGML objects!");
+        } else if (objects.size() > 1) {
+            throw new InvalidGmlFileException("Referenced library-object gml file contains more than one CityGML object!");
+        }
+        return objects.get(0).getHighestLodGeometry();
+    }
+
+    public static void resetObjectMap() {
+        libraryObjects.clear();
+    }
 
 }