Merge branch 'dev_citygml3' into 'dev'

CityGML 3.0. Support

See merge request !10

CHANGELOG.md

@@ -5,6 +5,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Upcoming - [3.16.0]
+
+CityDoctor now supports the import, export and validation of CityGML 3.0 files.
+
+#### CityGML Object parsing
+
+- CityDoctor is now capable of parsing and validating the following CityGML objects:
+
+    - Tunnel, TunnelParts, TunnelHollows and TunnelInstallations
+    - BuildingRooms, BuildingFurniture, BuildingStoreys and BuildingUnits
+    - BridgeRooms and BridgeFurniture
+    - CityFurniture
+    - GenericCityObjects
+
+- CityDoctor now supports ImplicitGeometries and CompositeSurfaces.
+
+- Data from CityDoctor's internal model will now be exported to the same CityGML version as
+the input file, rather than always exporting it to CityGML 2.0.
+
+
+#### CityDoctorGUI
+
+- Featuretabs for Tunnel, CityFurniture and other CityObjects were added.
+
+- QoL improvements:
+  - Added a north arrow to the mesh view.
+  - The camera of the mesh view can now be dragged by holding the right mouse button.
+  - Added a button which resets the camera view back to the initial state.
+  - Added a button to toggle hiding of roof BoundarySurfaces in the mesh view.
+  - Feature-tabs will now be greyed out if they contain no objects.
+  - Added a view-tab for GenericAttributes
+
+
+### Fixed
+
+- Fixed a TreeNode text color bug, which showed unchecked objects as being already validated.
+- Fixed an oversight in the CityGML version number parsing
 
 
 ## [3.15.0] (2024-09-03)

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Check.java

@@ -26,23 +26,7 @@ import java.util.Map;
 import java.util.Set;
 
 import de.hft.stuttgart.citydoctor2.check.error.DependenciesNotMetError;
-import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding;
-import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface;
-import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject;
-import de.hft.stuttgart.citydoctor2.datastructure.Building;
-import de.hft.stuttgart.citydoctor2.datastructure.Installation;
-import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart;
-import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
-import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
-import de.hft.stuttgart.citydoctor2.datastructure.LandObject;
-import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
-import de.hft.stuttgart.citydoctor2.datastructure.Opening;
-import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.citydoctor2.datastructure.ReliefObject;
-import de.hft.stuttgart.citydoctor2.datastructure.TinObject;
-import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject;
-import de.hft.stuttgart.citydoctor2.datastructure.Vegetation;
-import de.hft.stuttgart.citydoctor2.datastructure.WaterObject;
+import de.hft.stuttgart.citydoctor2.datastructure.*;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 
 /**
@@ -313,6 +297,14 @@ public abstract class Check {
 		
 	}
 
+	public void check(CityFurniture cf){
+
+	}
+
+	public void check(GenericCityObject gco) {
+
+	}
+
 	/**
 	 * The initialization method of this check. It will be called before any check
 	 * method will be executed. Override this if you want to have configurable

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

@@ -18,10 +18,13 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
+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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
@@ -31,20 +34,15 @@ 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.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.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Container for attributes of an abstract building. It can be a Building or
  * BuildingPart.
  *
  * @author Matthias Betz
- *
  */
 public abstract class AbstractBuilding extends CityObject {
 
@@ -55,7 +53,10 @@ public abstract class AbstractBuilding extends CityObject {
 
     private final List<Installation> buildingInstallations = new ArrayList<>(2);
     private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
-
+    private final List<BuildingRoom> buildingRooms = new ArrayList<>();
+    private final List<Storey> buildingStoreys = new ArrayList<>();
+    private final List<BuildingUnit> buildingUnits = new ArrayList<>();
+    private final List<BuildingRoomFurniture> buildingRoomFurnitureList = new ArrayList<>();
     private org.citygml4j.core.model.building.AbstractBuilding ab;
 
     /**
@@ -94,11 +95,26 @@ public abstract class AbstractBuilding extends CityObject {
         for (Installation bi : buildingInstallations) {
             bi.unsetGmlGeometries();
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.unsetGmlGeometries();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.unsetGmlGeometries();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.unsetGmlGeometries();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.unsetGmlGeometries();
+        }
     }
 
     @Override
     public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
                 setMultiSurfaceAccordingToLod(geom, ms);
@@ -113,6 +129,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (Installation bi : buildingInstallations) {
             bi.reCreateGeometries(factory, config);
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.reCreateGeometries(factory, config);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.reCreateGeometries(factory, config);
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.reCreateGeometries(factory, config);
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.reCreateGeometries(factory, config);
+        }
     }
 
     private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
@@ -182,6 +210,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.accept(c);
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.accept(c);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.accept(c);
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.accept(c);
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.accept(c);
+        }
     }
 
     @Override
@@ -193,6 +233,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.collectContainedErrors(errors);
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.collectContainedErrors(errors);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.collectContainedErrors(errors);
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.collectContainedErrors(errors);
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.collectContainedErrors(errors);
+        }
     }
 
     @Override
@@ -204,6 +256,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.clearAllContainedCheckResults();
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.clearAllContainedCheckResults();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.clearAllContainedCheckResults();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.clearAllContainedCheckResults();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.clearAllContainedCheckResults();
+        }
     }
 
     @Override
@@ -222,6 +286,26 @@ public abstract class AbstractBuilding extends CityObject {
                 return true;
             }
         }
+        for (BuildingRoom br : buildingRooms) {
+            if (br.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            if (bfr.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (Storey storey : buildingStoreys) {
+            if (storey.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            if (bu.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
         return false;
     }
 
@@ -241,6 +325,26 @@ public abstract class AbstractBuilding extends CityObject {
                 return true;
             }
         }
+        for (BuildingRoom br : buildingRooms) {
+            if (br.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            if (bfr.containsAnyError()) {
+                return true;
+            }
+        }
+        for (Storey storey : buildingStoreys) {
+            if (storey.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            if (bu.containsAnyError()) {
+                return true;
+            }
+        }
         return false;
     }
 
@@ -258,6 +362,24 @@ public abstract class AbstractBuilding extends CityObject {
         coBi.setParent(this);
     }
 
+    public void addBuildingRoom(BuildingRoom room) {
+        buildingRooms.add(room);
+        room.setParent(this);
+    }
+
+    public void addBuildingRoomFurniture(BuildingRoomFurniture roomFurniture) {
+        buildingRoomFurnitureList.add(roomFurniture);
+        roomFurniture.setParent(this);
+    }
+
+    public void addStorey(Storey storey) {
+        buildingStoreys.add(storey);
+    }
+
+    public void addBuildingUnit(BuildingUnit buildingUnit) {
+        buildingUnits.add(buildingUnit);
+    }
+
     public void setGmlObject(org.citygml4j.core.model.building.AbstractBuilding ab) {
         this.ab = ab;
     }
@@ -266,6 +388,22 @@ public abstract class AbstractBuilding extends CityObject {
         return buildingInstallations;
     }
 
+    public List<BuildingRoom> getBuildingRooms() {
+        return buildingRooms;
+    }
+
+    public List<BuildingRoomFurniture> getBuildingRoomFurnitureList() {
+        return buildingRoomFurnitureList;
+    }
+
+    public List<Storey> getBuildingStoreys() {
+        return buildingStoreys;
+    }
+
+    public List<BuildingUnit> getBuildingUnits() {
+        return buildingUnits;
+    }
+
     @Override
     public void prepareForChecking() {
         super.prepareForChecking();
@@ -275,6 +413,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.prepareForChecking();
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.prepareForChecking();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.prepareForChecking();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.prepareForChecking();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.prepareForChecking();
+        }
     }
 
     @Override
@@ -286,6 +436,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.clearMetaInformation();
         }
+        for (BuildingRoom br : buildingRooms) {
+            br.clearMetaInformation();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.clearMetaInformation();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.clearMetaInformation();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.clearMetaInformation();
+        }
     }
 
     @Override
@@ -293,6 +455,10 @@ public abstract class AbstractBuilding extends CityObject {
         super.collectInstances(handler);
         handler.addInstance(boundarySurfaceList);
         handler.addInstance(buildingInstallations);
+        handler.addInstance(buildingRooms);
+        handler.addInstance(buildingRoomFurnitureList);
+        handler.addInstance(buildingStoreys);
+        handler.addInstance(buildingUnits);
     }
 
     @Override
@@ -305,6 +471,18 @@ public abstract class AbstractBuilding extends CityObject {
         for (Installation originalBi : originalAb.buildingInstallations) {
             buildingInstallations.add(handler.getCopyInstance(originalBi));
         }
+        for (BuildingRoom originalBr : originalAb.buildingRooms) {
+            buildingRooms.add(handler.getCopyInstance(originalBr));
+        }
+        for (BuildingRoomFurniture originalBFR : originalAb.buildingRoomFurnitureList) {
+            buildingRoomFurnitureList.add(handler.getCopyInstance(originalBFR));
+        }
+        for (Storey originalBStoreys : originalAb.buildingStoreys) {
+            buildingStoreys.add(handler.getCopyInstance(originalBStoreys));
+        }
+        for (BuildingUnit originalBun : originalAb.buildingUnits) {
+            buildingUnits.add(handler.getCopyInstance(originalBun));
+        }
         ab = originalAb.ab;
     }
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+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 java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractBuildingSubdivision extends CityObject {
+    @Serial
+    private static final long serialVersionUID = 7033994252340571002L;
+
+    private static final Logger logger = LogManager.getLogger(AbstractBuildingSubdivision.class);
+
+    private final List<Installation> buildingInstallations = new ArrayList<>(2);
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+    private final List<BuildingRoom> buildingRooms = new ArrayList<>();
+
+    private final List<BuildingRoomFurniture> buildingRoomFurnitureList = new ArrayList<>();
+    protected org.citygml4j.core.model.building.AbstractBuildingSubdivision abs;
+
+    /**
+     * Getter for all boundary surfaces contained in this building.
+     *
+     * @return the boundary surfaces
+     */
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+
+    @Override
+    public org.citygml4j.core.model.building.AbstractBuildingSubdivision getGmlObject() {
+        return abs;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BUILDING_SUBDIVISION;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        abs.setLod1Solid(null);
+        abs.setLod2Solid(null);
+        abs.setLod3Solid(null);
+        abs.setLod2MultiSurface(null);
+        abs.setLod3MultiSurface(null);
+
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.unsetGmlGeometries();
+        }
+        for (Installation bi : buildingInstallations) {
+            bi.unsetGmlGeometries();
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.unsetGmlGeometries();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.unsetGmlGeometries();
+        }
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            reCreateBoundarySurface(factory, config, bs);
+        }
+        for (Installation bi : buildingInstallations) {
+            bi.reCreateGeometries(factory, config);
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.reCreateGeometries(factory, config);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.reCreateGeometries(factory, config);
+        }
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : abs.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
+                    abs.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                abs.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                abs.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                abs.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                abs.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                abs.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                abs.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (Installation bi : buildingInstallations) {
+            bi.accept(c);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.accept(c);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.accept(c);
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (Installation bi : buildingInstallations) {
+            bi.collectContainedErrors(errors);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.collectContainedErrors(errors);
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.collectContainedErrors(errors);
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (Installation bi : buildingInstallations) {
+            bi.clearAllContainedCheckResults();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearAllContainedCheckResults();
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.clearAllContainedCheckResults();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (Installation bi : buildingInstallations) {
+            if (bi.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BuildingRoom br : buildingRooms) {
+            if (br.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            if (bfr.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (Installation bi : buildingInstallations) {
+            if (bi.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BuildingRoom br : buildingRooms) {
+            if (br.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            if (bfr.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void setCityGmlBuilding(org.citygml4j.core.model.building.AbstractBuildingSubdivision abs) {
+        this.abs = abs;
+    }
+
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
+
+    public void addBuildingInstallation(Installation coBi) {
+        buildingInstallations.add(coBi);
+        coBi.setParent(this);
+    }
+
+    public void addBuildingRoom(BuildingRoom room) {
+        buildingRooms.add(room);
+        room.setParent(this);
+    }
+
+    public void addBuildingRoomFurniture(BuildingRoomFurniture roomFurniture) {
+        buildingRoomFurnitureList.add(roomFurniture);
+        roomFurniture.setParent(this);
+    }
+
+
+    public void setGmlObject(org.citygml4j.core.model.building.AbstractBuildingSubdivision abs) {
+        this.abs = abs;
+    }
+
+    public List<Installation> getBuildingInstallations() {
+        return buildingInstallations;
+    }
+
+    public List<BuildingRoom> getBuildingRooms() {
+        return buildingRooms;
+    }
+
+    public List<BuildingRoomFurniture> getBuildingRoomFurnitureList() {
+        return buildingRoomFurnitureList;
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (Installation bi : buildingInstallations) {
+            bi.prepareForChecking();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.prepareForChecking();
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.prepareForChecking();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (Installation bi : buildingInstallations) {
+            bi.clearMetaInformation();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearMetaInformation();
+        }
+        for (BuildingRoom br : buildingRooms) {
+            br.clearMetaInformation();
+        }
+        for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
+            bfr.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(boundarySurfaceList);
+        handler.addInstance(buildingInstallations);
+        handler.addInstance(buildingRooms);
+        handler.addInstance(buildingRoomFurnitureList);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        AbstractBuildingSubdivision originalAbs = (AbstractBuildingSubdivision) original;
+        for (BoundarySurface originalBs : originalAbs.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+        for (Installation originalBi : originalAbs.buildingInstallations) {
+            buildingInstallations.add(handler.getCopyInstance(originalBi));
+        }
+        for (BuildingRoom originalBr : originalAbs.buildingRooms) {
+            buildingRooms.add(handler.getCopyInstance(originalBr));
+        }
+        for (BuildingRoomFurniture originalBFR : originalAbs.buildingRoomFurnitureList) {
+            buildingRoomFurnitureList.add(handler.getCopyInstance(originalBFR));
+        }
+        abs = originalAbs.abs;
+    }
+
+}
+
+

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractFurniture.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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+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 java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents all types of furniture used inside Buildings.
+ */
+public abstract class AbstractFurniture extends CityObject {
+
+    @Serial
+    private static final long serialVersionUID = -9050689238027190674L;
+
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+
+    private CityObject parent;
+
+    private org.citygml4j.core.model.construction.AbstractFurniture af;
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.accept(c);
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            if (boundarySurface.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            if (boundarySurface.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    @Override
+    public org.citygml4j.core.model.construction.AbstractFurniture getGmlObject() {
+        return af;
+    }
+
+    public void addBoundarySurface(BoundarySurface boundarySurface) {
+        boundarySurfaceList.add(boundarySurface);
+        boundarySurface.setParent(this);
+    }
+
+    public List<BoundarySurface> getBoundarySurfaceList() {
+        return boundarySurfaceList;
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+    }
+
+    protected void setGmlObject(org.citygml4j.core.model.construction.AbstractFurniture af) {
+        this.af = af;
+    }
+
+    public void setParent(CityObject co) {
+        parent = co;
+    }
+
+
+    @Override
+    public void unsetGmlGeometries() {
+        af.setLod0MultiSurface(null);
+        af.setLod2MultiSurface(null);
+        af.setLod3MultiSurface(null);
+        af.setLod1Solid(null);
+        af.setLod2Solid(null);
+        af.setLod3Solid(null);
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                af.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                af.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                af.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                af.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                af.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                af.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
+        }
+    }
+
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.clearMetaInformation();
+        }
+    }
+
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.FURNITURE;
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        AbstractFurniture originalAf = (AbstractFurniture) original;
+        af = originalAf.af;
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoom.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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.core.AbstractCityObject;
+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 java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Abstract base class for rooms inside CityGML 3.0 construction objects.
+ */
+public abstract class AbstractRoom extends CityObject {
+
+    @Serial
+    private static final long serialVersionUID = -1730625513988944329L;
+
+    private final List<Installation> roomInstallations = new ArrayList<>(2);
+    // Rooms have a Href list of furniture, the actual object is saved in the Building
+
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+
+
+    protected org.citygml4j.core.model.core.AbstractUnoccupiedSpace cgmlRoom;
+
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.accept(c);
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.accept(c);
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.collectContainedErrors(errors);
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.clearAllContainedCheckResults();
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (Installation roomInstallation : roomInstallations) {
+            if (roomInstallation.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            if (boundarySurface.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (Installation roomInstallation : roomInstallations) {
+            if (roomInstallation.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            if (boundarySurface.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.reCreateGeometries(factory, config);
+        }
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.reCreateGeometries(factory, config);
+        }
+    }
+
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                cgmlRoom.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                cgmlRoom.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                cgmlRoom.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to rooms");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                cgmlRoom.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                cgmlRoom.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                cgmlRoom.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to rooms");
+        }
+    }
+
+
+    @Override
+    public void unsetGmlGeometries() {
+        cgmlRoom.setLod0MultiSurface(null);
+        cgmlRoom.setLod2MultiSurface(null);
+        cgmlRoom.setLod3MultiSurface(null);
+        cgmlRoom.setLod1Solid(null);
+        cgmlRoom.setLod2Solid(null);
+        cgmlRoom.setLod3Solid(null);
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.unsetGmlGeometries();
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.unsetGmlGeometries();
+        }
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.prepareForChecking();
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (Installation roomInstallation : roomInstallations) {
+            roomInstallation.clearMetaInformation();
+        }
+        for (BoundarySurface boundarySurface : boundarySurfaceList) {
+            boundarySurface.clearMetaInformation();
+        }
+    }
+
+
+    @Override
+    public AbstractCityObject getGmlObject() {
+        return cgmlRoom;
+    }
+
+
+    public List<Installation> getRoomInstallations() {
+        return roomInstallations;
+    }
+
+
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+
+    public void addRoomInstallation(Installation roomInstallation) {
+        roomInstallations.add(roomInstallation);
+        roomInstallation.setParent(this);
+    }
+
+    public void addBoundarySurface(BoundarySurface boundarySurface) {
+        boundarySurfaceList.add(boundarySurface);
+        boundarySurface.setParent(this);
+    }
+
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.ROOM;
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(roomInstallations);
+        handler.addInstance(boundarySurfaceList);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        AbstractRoom originalAr = (AbstractRoom) original;
+        for (BoundarySurface originalBs : originalAr.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+        for (Installation originalRi : originalAr.roomInstallations) {
+            roomInstallations.add(handler.getCopyInstance(originalRi));
+        }
+        cgmlRoom = originalAr.cgmlRoom;
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnel.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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+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 java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractTunnel extends CityObject {
+
+    @Serial
+    private static final long serialVersionUID = -2196414503088741206L;
+
+    private static final Logger logger = LogManager.getLogger(AbstractTunnel.class);
+
+    private final List<Installation> tunnelInstallations = new ArrayList<>(2);
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+    private final List<TunnelHollow> tunnelHollows = new ArrayList<>();
+    private final List<TunnelPart> tunnelParts = new ArrayList<>();
+    private final List<TunnelFurniture> tunnelFurnitureList = new ArrayList<>();
+    private final List<TunnelConstructiveElement> tunnelConstructiveElements = new ArrayList<>();
+    private org.citygml4j.core.model.tunnel.AbstractTunnel at;
+
+    /**
+     * Getter for all boundary surfaces contained in this building.
+     *
+     * @return the boundary surfaces
+     */
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+
+    @Override
+    public org.citygml4j.core.model.tunnel.AbstractTunnel getGmlObject() {
+        return at;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.TUNNEL;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        at.setLod1Solid(null);
+        at.setLod2Solid(null);
+        at.setLod3Solid(null);
+        at.setLod2MultiSurface(null);
+        at.setLod3MultiSurface(null);
+        at.getDeprecatedProperties().setLod1MultiSurface(null);
+        at.getDeprecatedProperties().setLod4MultiSurface(null);
+        at.getDeprecatedProperties().setLod4Solid(null);
+
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.unsetGmlGeometries();
+        }
+        for (Installation bi : tunnelInstallations) {
+            bi.unsetGmlGeometries();
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.unsetGmlGeometries();
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.unsetGmlGeometries();
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.unsetGmlGeometries();
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.unsetGmlGeometries();
+        }
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            reCreateBoundarySurface(factory, config, bs);
+        }
+        for (Installation bi : tunnelInstallations) {
+            bi.reCreateGeometries(factory, config);
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.reCreateGeometries(factory, config);
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.reCreateGeometries(factory, config);
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.reCreateGeometries(factory, config);
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.reCreateGeometries(factory, config);
+        }
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : at.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
+                    at.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                at.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD1:
+                at.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                at.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                at.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD4:
+                at.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                at.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                at.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                at.setLod3Solid(new SolidProperty(solid));
+                break;
+            case LOD4:
+                at.getDeprecatedProperties().setLod4Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (Installation bi : tunnelInstallations) {
+            bi.accept(c);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.accept(c);
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.accept(c);
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.accept(c);
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.accept(c);
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (Installation bi : tunnelInstallations) {
+            bi.collectContainedErrors(errors);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.collectContainedErrors(errors);
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.collectContainedErrors(errors);
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.collectContainedErrors(errors);
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.collectContainedErrors(errors);
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (Installation bi : tunnelInstallations) {
+            bi.clearAllContainedCheckResults();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearAllContainedCheckResults();
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.clearAllContainedCheckResults();
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.clearAllContainedCheckResults();
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.clearAllContainedCheckResults();
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (Installation bi : tunnelInstallations) {
+            if (bi.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            if (th.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            if (tfr.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            if (te.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (TunnelPart tp : tunnelParts) {
+            if (tp.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (Installation bi : tunnelInstallations) {
+            if (bi.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsAnyError()) {
+                return true;
+            }
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            if (th.containsAnyError()) {
+                return true;
+            }
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            if (tfr.containsAnyError()) {
+                return true;
+            }
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            if (te.containsAnyError()) {
+                return true;
+            }
+        }
+        for (TunnelPart tp : tunnelParts) {
+            if (tp.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void setCityGmlBuilding(org.citygml4j.core.model.tunnel.AbstractTunnel at) {
+        this.at = at;
+    }
+
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
+
+    public void addTunnelInstallation(Installation coBi) {
+        tunnelInstallations.add(coBi);
+        coBi.setParent(this);
+    }
+
+    public void addTunnelHollow(TunnelHollow hollow) {
+        tunnelHollows.add(hollow);
+        hollow.setParent(this);
+    }
+
+    public void addTunnelFurniture(TunnelFurniture furniture) {
+        tunnelFurnitureList.add(furniture);
+        furniture.setParent(this);
+    }
+
+    public void addTunnelConstructiveElement(TunnelConstructiveElement te) {
+        tunnelConstructiveElements.add(te);
+    }
+
+    public void addTunnelPart(TunnelPart tunnelPart) {
+        tunnelParts.add(tunnelPart);
+    }
+
+    public void setGmlObject(org.citygml4j.core.model.tunnel.AbstractTunnel at) {
+        this.at = at;
+    }
+
+    public List<Installation> getTunnelInstallations() {
+        return tunnelInstallations;
+    }
+
+    public List<TunnelHollow> getTunnelHollows() {
+        return tunnelHollows;
+    }
+
+    public List<TunnelFurniture> getTunnelFurnitureList() {
+        return tunnelFurnitureList;
+    }
+
+    public List<TunnelPart> getTunnelParts() {
+        return tunnelParts;
+    }
+
+    public List<TunnelConstructiveElement> getTunnelConstructiveElements() {
+        return tunnelConstructiveElements;
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (Installation bi : tunnelInstallations) {
+            bi.prepareForChecking();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.prepareForChecking();
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.prepareForChecking();
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.prepareForChecking();
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.prepareForChecking();
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (Installation bi : tunnelInstallations) {
+            bi.clearMetaInformation();
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearMetaInformation();
+        }
+        for (TunnelHollow th : tunnelHollows) {
+            th.clearMetaInformation();
+        }
+        for (TunnelFurniture tfr : tunnelFurnitureList) {
+            tfr.clearMetaInformation();
+        }
+        for (TunnelConstructiveElement te : tunnelConstructiveElements) {
+            te.clearMetaInformation();
+        }
+        for (TunnelPart tp : tunnelParts) {
+            tp.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(boundarySurfaceList);
+        handler.addInstance(tunnelInstallations);
+        handler.addInstance(tunnelHollows);
+        handler.addInstance(tunnelFurnitureList);
+        handler.addInstance(tunnelConstructiveElements);
+        handler.addInstance(tunnelParts);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        AbstractTunnel originalAt = (AbstractTunnel) original;
+        for (BoundarySurface originalBs : originalAt.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+        for (Installation originalTi : originalAt.tunnelInstallations) {
+            tunnelInstallations.add(handler.getCopyInstance(originalTi));
+        }
+        for (TunnelHollow originalTh : originalAt.tunnelHollows) {
+            tunnelHollows.add(handler.getCopyInstance(originalTh));
+        }
+        for (TunnelFurniture originalTFR : originalAt.tunnelFurnitureList) {
+            tunnelFurnitureList.add(handler.getCopyInstance(originalTFR));
+        }
+        for (TunnelConstructiveElement originalTE : originalAt.tunnelConstructiveElements) {
+            tunnelConstructiveElements.add(handler.getCopyInstance(originalTE));
+        }
+        for (TunnelPart originalTp : originalAt.tunnelParts) {
+            tunnelParts.add(handler.getCopyInstance(originalTp));
+        }
+        at = originalAt.at;
+    }
+}

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

@@ -18,15 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.citygml4j.core.model.core.AbstractThematicSurface;
-import org.citygml4j.core.util.geometry.GeometryFactory;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
@@ -34,12 +25,19 @@ 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 org.citygml4j.core.model.core.AbstractThematicSurface;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Representing a boundary surface in CityGML
  *
  * @author Matthias Betz
- *
  */
 public class BoundarySurface extends CityObject {
 
@@ -94,6 +92,9 @@ public class BoundarySurface extends CityObject {
             gmlObject.setId(getGmlId().getGmlString());
         }
         for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
                 if (ms != null) {

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

@@ -22,7 +22,6 @@ package de.hft.stuttgart.citydoctor2.datastructure;
  * Types of boundary surfaces used in city doctor
  *
  * @author Matthias Betz
- *
  */
 public enum BoundarySurfaceType {
 

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

@@ -18,17 +18,16 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.util.Collection;
-import java.util.List;
-
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.utils.BoundingBoxCalculator;
 
+import java.util.Collection;
+import java.util.List;
+
 /**
  * An axis aligned bounding box represented by its two corners
  *
  * @author Matthias Betz
- *
  */
 public class BoundingBox {
 

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

@@ -18,10 +18,13 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
+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.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
@@ -34,13 +37,9 @@ import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
 import org.xmlobjects.gml.model.geometry.primitives.Solid;
 import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
 
-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.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
 
 public class BridgeConstructiveElement extends CityObject {
 
@@ -70,6 +69,9 @@ public class BridgeConstructiveElement extends CityObject {
         // 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);

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

@@ -52,8 +52,10 @@ public class BridgeObject extends CityObject {
     private final List<BridgeConstructiveElement> elements = new ArrayList<>(2);
     private final List<BoundarySurface> boundarySurfaces = new ArrayList<>(2);
     private final List<Installation> bridgeInstallations = new ArrayList<>(2);
+    private final List<BridgeRoom> bridgeRooms = new ArrayList<>(2);
     private AbstractBridge ab;
     private BridgeType type;
+
     public BridgeObject(BridgeType type, AbstractBridge ab) {
         this.ab = ab;
         this.type = type;
@@ -72,9 +74,16 @@ public class BridgeObject extends CityObject {
         return bridgeInstallations;
     }
 
+    public List<BridgeRoom> getBridgeRooms() {
+        return bridgeRooms;
+    }
+
     @Override
     public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
                 setMultiSurfaceAccordingToLod(geom, ms);
@@ -95,6 +104,9 @@ public class BridgeObject extends CityObject {
         for (BridgeConstructiveElement ele : elements) {
             ele.reCreateGeometries(factory, config);
         }
+        for (BridgeRoom br : bridgeRooms) {
+            br.reCreateGeometries(factory, config);
+        }
 
     }
 
@@ -135,11 +147,16 @@ public class BridgeObject extends CityObject {
                 throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to bridges");
         }
     }
+
     public void addBridgeInstallation(Installation coBi) {
         bridgeInstallations.add(coBi);
         coBi.setParent(this);
     }
 
+    public void addBridgeRoom(BridgeRoom room) {
+        bridgeRooms.add(room);
+    }
+
     @Override
     public void clearAllContainedCheckResults() {
         super.clearAllContainedCheckResults();
@@ -155,6 +172,9 @@ public class BridgeObject extends CityObject {
         for (BridgeConstructiveElement ele : elements) {
             ele.clearAllContainedCheckResults();
         }
+        for (BridgeRoom br : bridgeRooms) {
+            br.clearAllContainedCheckResults();
+        }
     }
 
     @Override
@@ -172,6 +192,9 @@ public class BridgeObject extends CityObject {
         for (BridgeConstructiveElement ele : elements) {
             ele.collectContainedErrors(errors);
         }
+        for (BridgeRoom br : bridgeRooms) {
+            br.collectContainedErrors(errors);
+        }
 
     }
 
@@ -199,6 +222,11 @@ public class BridgeObject extends CityObject {
                 return true;
             }
         }
+        for (BridgeRoom br : bridgeRooms) {
+            if (br.containsAnyError()) {
+                return true;
+            }
+        }
         return false;
     }
 
@@ -236,6 +264,11 @@ public class BridgeObject extends CityObject {
                 return true;
             }
         }
+        for (BridgeRoom br : bridgeRooms) {
+            if (br.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
         return false;
     }
 
@@ -267,6 +300,9 @@ public class BridgeObject extends CityObject {
         for (BridgeConstructiveElement ele : elements) {
             ele.accept(c);
         }
+        for (BridgeRoom br : bridgeRooms) {
+            br.accept(c);
+        }
 
     }
 
@@ -324,6 +360,9 @@ public class BridgeObject extends CityObject {
         for (BridgeConstructiveElement ele : elements) {
             ele.unsetGmlGeometries();
         }
+        for (BridgeRoom br : bridgeRooms) {
+            br.unsetGmlGeometries();
+        }
 
     }
 
@@ -348,6 +387,9 @@ public class BridgeObject extends CityObject {
         for (Installation bi : bridgeInstallations) {
             bi.prepareForChecking();
         }
+        for (BridgeObject part : parts) {
+            part.prepareForChecking();
+        }
     }
 
     @Override
@@ -369,6 +411,10 @@ public class BridgeObject extends CityObject {
             ele.clearMetaInformation();
         }
 
+        for (BridgeRoom br : bridgeRooms) {
+            br.clearMetaInformation();
+        }
+
     }
 
     @Override
@@ -390,6 +436,10 @@ public class BridgeObject extends CityObject {
             handler.addInstance(ele);
         }
 
+        for (BridgeRoom br : bridgeRooms) {
+            handler.addInstance(br);
+        }
+
     }
 
     public void anonymize() {
@@ -429,6 +479,10 @@ public class BridgeObject extends CityObject {
             getConstructiveElements().add(handler.getCopyInstance(ele));
         }
 
+        for (BridgeRoom br : originalBo.bridgeRooms) {
+            getBridgeRooms().add(handler.getCopyInstance(br));
+        }
+
     }
 
     public List<BoundarySurface> getBoundarySurfaces() {

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

+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 BridgeRoom extends AbstractRoom {
+
+    @Serial
+    private static final long serialVersionUID = -276088332165299253L;
+
+    private BridgeObject parent;
+
+    private BridgeRoom() {
+    }
+
+    public BridgeRoom(BridgeObject parent) {
+        this.parent = parent;
+        parent.addBridgeRoom(this);
+    }
+
+
+    public void setGmlObject(org.citygml4j.core.model.bridge.BridgeRoom cgmlRoom) {
+        super.cgmlRoom = cgmlRoom;
+    }
+
+
+    public BridgeObject getParent() {
+        return parent;
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        BridgeRoom oRoom = (BridgeRoom) original;
+        parent = handler.getCopyInstance(oRoom.getParent());
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(parent);
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new BridgeRoom();
+    }
+}

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.bridge.BridgeFurniture;
+
+import java.io.Serial;
+
+public class BridgeRoomFurniture extends AbstractFurniture {
+
+    @Serial
+    private static final long serialVersionUID = 2450802405053172352L;
+
+    public void setGmlObject(BridgeFurniture gmlObject) {
+        super.setGmlObject(gmlObject);
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new BridgeRoomFurniture();
+    }
+}

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

@@ -18,21 +18,20 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.citygml4j.core.model.building.BuildingInstallation;
-import org.citygml4j.core.model.building.BuildingInstallationProperty;
-import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
-import org.citygml4j.core.util.geometry.GeometryFactory;
-
 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.model.building.BuildingInstallation;
+import org.citygml4j.core.model.building.BuildingInstallationProperty;
+import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
 
 public class Building extends AbstractBuilding {
 

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 org.citygml4j.core.model.building.BuildingFurnitureProperty;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BuildingRoom extends AbstractRoom {
+
+    @Serial
+    private static final long serialVersionUID = -276088332165299253L;
+    private final List<BuildingFurnitureProperty> furnitureRefs = new ArrayList<>(2);
+    private CityObject parent;
+
+    public void setGmlObject(org.citygml4j.core.model.building.BuildingRoom cgmlRoom) {
+        super.cgmlRoom = cgmlRoom;
+    }
+
+
+    public void setParent(CityObject parent) {
+        this.parent = parent;
+    }
+
+    public void addFurnitureRef(BuildingFurnitureProperty furnitureRef) {
+        furnitureRefs.add(furnitureRef);
+    }
+
+    /**
+     * Returns the list of citygml3 furniture objects registered to this room.
+     * The reference objects only hold a HRef to the actual furniture object.
+     *
+     * @return
+     */
+    public List<BuildingFurnitureProperty> getFurnitureRefs() {
+        return furnitureRefs;
+    }
+
+    public CityObject getParent() {
+        return parent;
+    }
+
+    @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);
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new BuildingRoom();
+    }
+}

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;
+
+public class BuildingRoomFurniture extends AbstractFurniture {
+
+    @Serial
+    private static final long serialVersionUID = -1046265159354525567L;
+
+    public void setGmlObject(BuildingFurniture gmlObject) {
+        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 java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BuildingUnit extends AbstractBuildingSubdivision {
+
+    @Serial
+    private static final long serialVersionUID = -2931788311665810322L;
+
+    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) {
+        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;
+    }
+}

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

@@ -18,24 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Stream;
-
-import org.citygml4j.core.model.CityGMLVersion;
-import org.citygml4j.core.model.core.CityModel;
-
 import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
@@ -43,13 +25,23 @@ import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.writer.CityGMLWriterUtils;
 import de.hft.stuttgart.quality.model.types.ValidationPlan;
+import org.citygml4j.core.model.CityGMLVersion;
+import org.citygml4j.core.model.core.CityModel;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
 
 /**
  * The complete CityGML model containing all features that are used in
  * CityDoctor
  *
  * @author Matthias Betz
- *
  */
 public class CityDoctorModel {
 
@@ -57,8 +49,11 @@ public class CityDoctorModel {
     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 CityModel cModel;
     private final ParserConfiguration config;
@@ -81,7 +76,10 @@ public class CityDoctorModel {
         bridges = new ArrayList<>();
         land = new ArrayList<>();
         roads = new ArrayList<>();
+        tunnels = new ArrayList<>();
         water = new ArrayList<>();
+        cityfurniture = new ArrayList<>();
+        genericObjects = new ArrayList<>();
         globalErrors = new ArrayList<>();
     }
 
@@ -121,7 +119,7 @@ public class CityDoctorModel {
 
     public Stream<CityObject> createFeatureStream() {
         return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
-				water.stream()).flatMap(co -> co);
+                tunnels.stream(), water.stream(), cityfurniture.stream(), genericObjects.stream()).flatMap(co -> co);
     }
 
     public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
@@ -223,7 +221,10 @@ public class CityDoctorModel {
         collectErrorsFromList(errors, bridges);
         collectErrorsFromList(errors, land);
         collectErrorsFromList(errors, roads);
+        collectErrorsFromList(errors, tunnels);
         collectErrorsFromList(errors, water);
+        collectErrorsFromList(errors, cityfurniture);
+        collectErrorsFromList(errors, genericObjects);
         return new HashSet<>(errors);
     }
 
@@ -253,6 +254,22 @@ public class CityDoctorModel {
         return bridges;
     }
 
+    public List<CityFurniture> getCityFurniture() {
+        return cityfurniture;
+    }
+
+    public void addCityFurniture(CityFurniture coFurniture) {
+        cityfurniture.add(coFurniture);
+    }
+
+    public List<GenericCityObject> getGenericCityObjects() {
+        return genericObjects;
+    }
+
+    public void addGenericCityObject(GenericCityObject coGenericCityObject) {
+        genericObjects.add(coGenericCityObject);
+    }
+
     public void setCityModel(CityModel cModel) {
         this.cModel = cModel;
     }
@@ -265,6 +282,10 @@ public class CityDoctorModel {
         return roads;
     }
 
+    public List<Tunnel> getTunnels() {
+        return tunnels;
+    }
+
     public List<WaterObject> getWater() {
         return water;
     }
@@ -293,8 +314,13 @@ public class CityDoctorModel {
         roads.add(to);
     }
 
+    public void addTunnel(Tunnel tunnel) {
+        tunnels.add(tunnel);
+    }
+
     public int getNumberOfFeatures() {
-		return buildings.size() + vegetation.size() + bridges.size() + land.size() + roads.size() + water.size();
+        return buildings.size() + vegetation.size() + bridges.size() + land.size() + tunnels.size()
+                + roads.size() + water.size() + cityfurniture.size() + genericObjects.size();
     }
 
     public ParserConfiguration getParserConfig() {
@@ -308,12 +334,18 @@ public class CityDoctorModel {
             replaceBridge(currentFeature, nextFeature);
         } else if (nextFeature instanceof TransportationObject) {
             replaceTransportationObject(currentFeature, nextFeature);
+        } else if (nextFeature instanceof Tunnel) {
+            replaceTunnel(currentFeature, nextFeature);
         } else if (nextFeature instanceof Vegetation) {
             replaceVegetation(currentFeature, nextFeature);
         } else if (nextFeature instanceof LandObject) {
             replaceLandObject(currentFeature, nextFeature);
         } else if (nextFeature instanceof WaterObject) {
             replaceWaterObject(currentFeature, nextFeature);
+        } else if (nextFeature instanceof CityFurniture) {
+            replaceCityFurniture(currentFeature, nextFeature);
+        } else if (nextFeature instanceof GenericCityObject) {
+            replaceGenericCityObject(currentFeature, nextFeature);
         }
     }
 
@@ -341,6 +373,22 @@ public class CityDoctorModel {
         vegetation.set(index, (Vegetation) nextFeature);
     }
 
+    private void replaceCityFurniture(CityObject currentFeature, CityObject nextFeature) {
+        int index = cityfurniture.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
+        }
+        cityfurniture.set(index, (CityFurniture) nextFeature);
+    }
+
+    private void replaceGenericCityObject(CityObject currentFeature, CityObject nextFeature) {
+        int index = genericObjects.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in generic city objects");
+        }
+        genericObjects.set(index, (GenericCityObject) nextFeature);
+    }
+
     private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
         int index = roads.indexOf(currentFeature);
         if (index == -1) {
@@ -349,6 +397,14 @@ public class CityDoctorModel {
         roads.set(index, (TransportationObject) nextFeature);
     }
 
+    private void replaceTunnel(CityObject currentFeature, CityObject nextFeature) {
+        int index = tunnels.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in tunnels");
+        }
+        tunnels.set(index, (Tunnel) nextFeature);
+    }
+
     private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
         int index = bridges.indexOf(currentFeature);
         if (index == -1) {
@@ -372,6 +428,8 @@ public class CityDoctorModel {
             bridges.add(bo);
         } else if (co instanceof TransportationObject to) {
             roads.add(to);
+        } else if (co instanceof Tunnel tu) {
+            tunnels.add(tu);
         } else if (co instanceof Vegetation veg) {
             vegetation.add(veg);
         } else if (co instanceof LandObject lo) {
@@ -382,6 +440,10 @@ public class CityDoctorModel {
             land.add(co);
         } else if (co instanceof TinObject) {
             land.add(co);
+        } else if (co instanceof CityFurniture cf) {
+            cityfurniture.add(cf);
+        } else if (co instanceof GenericCityObject gco) {
+            genericObjects.add(gco);
         }
     }