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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -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,281 +34,456 @@ 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
  *
+ * @author Matthias Betz
  */
 public abstract class AbstractBuilding extends CityObject {
 
-	@Serial
-	private static final long serialVersionUID = -2196414503088741206L;
-
-	private static final Logger logger = LogManager.getLogger(AbstractBuilding.class);
-
-	private final List<Installation> buildingInstallations = new ArrayList<>(2);
-	private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
-
-	private org.citygml4j.core.model.building.AbstractBuilding ab;
-
-	/**
-	 * 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.AbstractBuilding getGmlObject() {
-		return ab;
-	}
-
-	@Override
-	public FeatureType getFeatureType() {
-		return FeatureType.BUILDING;
-	}
-
-	@Override
-	public void unsetGmlGeometries() {
-		ab.setLod1Solid(null);
-		ab.setLod2Solid(null);
-		ab.setLod3Solid(null);
-		ab.setLod2MultiSurface(null);
-		ab.setLod3MultiSurface(null);
-		ab.getDeprecatedProperties().setLod1MultiSurface(null);
-		ab.getDeprecatedProperties().setLod4MultiSurface(null);
-		ab.getDeprecatedProperties().setLod4Solid(null);
-		
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.unsetGmlGeometries();
-		}
-		for (Installation bi : buildingInstallations) {
-			bi.unsetGmlGeometries();
-		}
-	}
-
-	@Override
-	public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-		for (Geometry geom : getGeometries()) {
-			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);
-		}
-	}
-
-	private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
-		if (bs.getGeometries().isEmpty()) {
-			for (AbstractSpaceBoundaryProperty bsp : ab.getBoundaries()) {
-				if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
-					logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
-					ab.getBoundaries().remove(bsp);
-					break;
-				}
-			}
-			return;
-		}
-		bs.reCreateGeometries(factory, config);
-	}
-
-	private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
-		switch (geom.getLod()) {
-		case LOD0:
-			ab.setLod0MultiSurface(new MultiSurfaceProperty(ms));
-			break;
-		case LOD1:
-			ab.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
-			break;
-		case LOD2:
-			ab.setLod2MultiSurface(new MultiSurfaceProperty(ms));
-			break;
-		case LOD3:
-			ab.setLod3MultiSurface(new MultiSurfaceProperty(ms));
-			break;
-		case LOD4:
-			ab.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:
-			ab.setLod1Solid(new SolidProperty(solid));
-			break;
-		case LOD2:
-			ab.setLod2Solid(new SolidProperty(solid));
-			break;
-		case LOD3:
-			ab.setLod3Solid(new SolidProperty(solid));
-			break;
-		case LOD4:
-			ab.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 : buildingInstallations) {
-			bi.accept(c);
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.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);
-		}
-	}
-
-	@Override
-	public void clearAllContainedCheckResults() {
-		super.clearAllContainedCheckResults();
-		for (Installation bi : buildingInstallations) {
-			bi.clearAllContainedCheckResults();
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.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;
-			}
-		}
-		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;
-			}
-		}
-		return false;
-	}
-
-	void setCityGmlBuilding(org.citygml4j.core.model.building.AbstractBuilding ab) {
-		this.ab = ab;
-	}
-
-	public void addBoundarySurface(BoundarySurface bs) {
-		boundarySurfaceList.add(bs);
-		bs.setParent(this);
-	}
-
-	public void addBuildingInstallation(Installation coBi) {
-		buildingInstallations.add(coBi);
-		coBi.setParent(this);
-	}
-
-	public void setGmlObject(org.citygml4j.core.model.building.AbstractBuilding ab) {
-		this.ab = ab;
-	}
-
-	public List<Installation> getBuildingInstallations() {
-		return buildingInstallations;
-	}
-	
-	@Override
-	public void prepareForChecking() {
-		super.prepareForChecking();
-		for (Installation bi : buildingInstallations) {
-			bi.prepareForChecking();
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.prepareForChecking();
-		}
-	}
-	
-	@Override
-	public void clearMetaInformation() {
-		super.clearMetaInformation();
-		for (Installation bi : buildingInstallations) {
-			bi.clearMetaInformation();
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.clearMetaInformation();
-		}
-	}
-	
-	@Override
-	public void collectInstances(CopyHandler handler) {
-		super.collectInstances(handler);
-		handler.addInstance(boundarySurfaceList);
-		handler.addInstance(buildingInstallations);
-	}
-	
-	@Override
-	public void fillValues(Copyable original, CopyHandler handler) {
-		super.fillValues(original, handler);
-		AbstractBuilding originalAb = (AbstractBuilding) original;
-		for (BoundarySurface originalBs : originalAb.boundarySurfaceList) {
-			boundarySurfaceList.add(handler.getCopyInstance(originalBs));
-		}
-		for (Installation originalBi : originalAb.buildingInstallations) {
-			buildingInstallations.add(handler.getCopyInstance(originalBi));
-		}
-		ab = originalAb.ab;
-	}
-	
+    @Serial
+    private static final long serialVersionUID = -2196414503088741206L;
+
+    private static final Logger logger = LogManager.getLogger(AbstractBuilding.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<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;
+
+    /**
+     * 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.AbstractBuilding getGmlObject() {
+        return ab;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BUILDING;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        ab.setLod1Solid(null);
+        ab.setLod2Solid(null);
+        ab.setLod3Solid(null);
+        ab.setLod2MultiSurface(null);
+        ab.setLod3MultiSurface(null);
+        ab.getDeprecatedProperties().setLod1MultiSurface(null);
+        ab.getDeprecatedProperties().setLod4MultiSurface(null);
+        ab.getDeprecatedProperties().setLod4Solid(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();
+        }
+        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);
+            } 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);
+        }
+        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) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : ab.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
+                    ab.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                ab.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD1:
+                ab.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                ab.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                ab.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD4:
+                ab.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:
+                ab.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                ab.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                ab.setLod3Solid(new SolidProperty(solid));
+                break;
+            case LOD4:
+                ab.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 : 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);
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.accept(c);
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.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);
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.collectContainedErrors(errors);
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.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();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.clearAllContainedCheckResults();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.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;
+            }
+        }
+        for (Storey storey : buildingStoreys) {
+            if (storey.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            if (bu.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;
+            }
+        }
+        for (Storey storey : buildingStoreys) {
+            if (storey.containsAnyError()) {
+                return true;
+            }
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            if (bu.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void setCityGmlBuilding(org.citygml4j.core.model.building.AbstractBuilding ab) {
+        this.ab = ab;
+    }
+
+    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 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;
+    }
+
+    public List<Installation> getBuildingInstallations() {
+        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();
+        for (Installation bi : buildingInstallations) {
+            bi.prepareForChecking();
+        }
+        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
+    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();
+        }
+        for (Storey storey : buildingStoreys) {
+            storey.clearMetaInformation();
+        }
+        for (BuildingUnit bu : buildingUnits) {
+            bu.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(boundarySurfaceList);
+        handler.addInstance(buildingInstallations);
+        handler.addInstance(buildingRooms);
+        handler.addInstance(buildingRoomFurnitureList);
+        handler.addInstance(buildingStoreys);
+        handler.addInstance(buildingUnits);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        AbstractBuilding originalAb = (AbstractBuilding) original;
+        for (BoundarySurface originalBs : originalAb.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+        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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -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,252 +25,262 @@ 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
  *
+ * @author Matthias Betz
  */
 public class BoundarySurface extends CityObject {
 
-	@Serial
-	private static final long serialVersionUID = 8793865135393496408L;
-
-	private SurfaceFeatureType featureType;
-	private BoundarySurfaceType type;
-
-	private final List<Opening> openings = new ArrayList<>(2);
-	private CityObject parent;
-
-	private AbstractThematicSurface gmlObject;
-
-	public BoundarySurface(AbstractThematicSurface aco) {
-		this(SurfaceFeatureType.BUILDING, BoundarySurfaceType.UNDEFINED, aco);
-	}
-
-	public BoundarySurface(SurfaceFeatureType featureType, BoundarySurfaceType type, AbstractThematicSurface aco) {
-		this.featureType = featureType;
-		this.type = type;
-		gmlObject = aco;
-	}
-
-	public void setFeatureType(SurfaceFeatureType featureType) {
-		this.featureType = featureType;
-	}
-
-	public void setType(BoundarySurfaceType type) {
-		this.type = type;
-	}
-
-	public void setGmlObject(AbstractThematicSurface gmlObject) {
-		this.gmlObject = gmlObject;
-	}
-
-	public SurfaceFeatureType getSurfaceFeatureType() {
-		return featureType;
-	}
-
-	public BoundarySurfaceType getType() {
-		return type;
-	}
-
-	public List<Opening> getOpenings() {
-		return openings;
-	}
-
-	@Override
-	public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-		if (gmlObject.getId() == null) {
-			gmlObject.setId(getGmlId().getGmlString());
-		}
-		for (Geometry geom : getGeometries()) {
-			if (geom.getType() == GeometryType.MULTI_SURFACE) {
-				MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
-				if (ms != null) {
-					setGeometryAccordingToLod(geom.getLod(), new MultiSurfaceProperty(ms));
-				}
-			} else {
-				throw new IllegalStateException("BoundarySurfaces can only have MultiSurface geometries");
-			}
-		}
-		for (Opening o : openings) {
-			o.reCreateGeometries(factory, config);
-		}
-	}
-
-	private void setGeometryAccordingToLod(Lod lod, MultiSurfaceProperty ms) {
-		switch (lod) {
-		case LOD0:
-			gmlObject.setLod0MultiSurface(ms);
-			break;
-		case LOD1:
-			gmlObject.setLod1MultiSurface(ms);
-			break;
-		case LOD2:
-			gmlObject.setLod2MultiSurface(ms);
-			break;
-		case LOD3:
-			gmlObject.setLod3MultiSurface(ms);
-			break;
-		case LOD4:
-			gmlObject.getDeprecatedProperties().setLod4MultiSurface(ms);
-			break;
-		default:
-			throw new IllegalStateException("Found geometry with LOD other than LOD1-4, which is illegal for BoundarySurfaces: " + lod);
-		}
-	}
-	
-	@Override
-	public void clearAllContainedCheckResults() {
-		super.clearAllContainedCheckResults();
-		for (Opening o : openings) {
-			o.clearAllContainedCheckResults();
-		}
-	}
-
-	@Override
-	public void collectContainedErrors(List<CheckError> errors) {
-		super.collectContainedErrors(errors);
-		for (Opening o : openings) {
-			o.collectContainedErrors(errors);
-		}
-	}
-
-	@Override
-	public boolean containsAnyError() {
-		boolean hasError = super.containsAnyError();
-		if (hasError) {
-			return true;
-		}
-		for (Opening o : openings) {
-			if (o.containsAnyError()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean containsError(CheckId checkIdentifier) {
-		boolean hasError = super.containsError(checkIdentifier);
-		if (hasError) {
-			return true;
-		}
-		for (Opening o : openings) {
-			if (o.containsError(checkIdentifier)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public void accept(Check c) {
-		super.accept(c);
-		if (c.canExecute(this)) {
-			c.check(this);
-		}
-		for (Opening o : openings) {
-			o.accept(c);
-		}
-	}
-
-	public void setParent(CityObject parent) {
-		this.parent = parent;
-	}
-
-	public CityObject getParent() {
-		return parent;
-	}
-
-	@Override
-	public void unsetGmlGeometries() {
-		gmlObject.setLod0MultiSurface(null);
-		gmlObject.setLod1MultiSurface(null);
-		gmlObject.setLod2MultiSurface(null);
-		gmlObject.setLod3MultiSurface(null);
-		gmlObject.getDeprecatedProperties().setLod4MultiSurface(null);
-		
-		for (Opening o : openings) {
-			o.unsetGmlGeometries();
-		}
-	}
-
-	@Override
-	public String toString() {
-		return "BoundarySurface [type=" + type + ", id=" + getGmlId() + "]";
-	}
-
-	void anonymize() {
-		gmlObject.setAppearances(null);
-		gmlObject.setBoundedBy(null);
-		gmlObject.setCreationDate(null);
-		gmlObject.setDescription(null);
-		gmlObject.setExternalReferences(null);
-		gmlObject.setGeneralizesTo(null);
-		gmlObject.setADEProperties(null);
-		gmlObject.setGenericAttributes(null);
-		setGmlId(GmlId.generateId());
-		gmlObject.setId(getGmlId().getGmlString());
-	}
-
-	@Override
-	public AbstractThematicSurface getGmlObject() {
-		return gmlObject;
-	}
-
-	@Override
-	public FeatureType getFeatureType() {
-		return FeatureType.BOUNDARY_SURFACE;
-	}
-
-	public void addOpening(Opening opening) {
-		openings.add(opening);
-		opening.setPartOfSurface(this);
-	}
-
-	@Override
-	public void prepareForChecking() {
-		super.prepareForChecking();
-		for (Opening o : openings) {
-			o.prepareForChecking();
-		}
-	}
-
-	@Override
-	public void clearMetaInformation() {
-		super.clearMetaInformation();
-		for (Opening o : openings) {
-			o.clearMetaInformation();
-		}
-	}
-
-	@Override
-	public Copyable createCopyInstance() {
-		return new BoundarySurface(gmlObject);
-	}
-	
-	@Override
-	public void collectInstances(CopyHandler handler) {
-		super.collectInstances(handler);
-		for (Opening o : openings) {
-			handler.addInstance(o);
-		}
-		handler.addInstance(parent);
-	}
-	
-	@Override
-	public void fillValues(Copyable original, CopyHandler handler) {
-		super.fillValues(original, handler);
-		BoundarySurface originalBs = (BoundarySurface) original;
-		featureType = originalBs.featureType;
-		type = originalBs.type;
-		for (Opening originalOpening : originalBs.openings) {
-			openings.add(handler.getCopyInstance(originalOpening));
-		}
-		parent = handler.getCopyInstance(originalBs.parent);
-		gmlObject = originalBs.gmlObject;
-	}
-	
+    @Serial
+    private static final long serialVersionUID = 8793865135393496408L;
+
+    private SurfaceFeatureType featureType;
+    private BoundarySurfaceType type;
+
+    private final List<Opening> openings = new ArrayList<>(2);
+    private CityObject parent;
+
+    private AbstractThematicSurface gmlObject;
+
+    public BoundarySurface(AbstractThematicSurface aco) {
+        this(SurfaceFeatureType.BUILDING, BoundarySurfaceType.UNDEFINED, aco);
+    }
+
+    public BoundarySurface(SurfaceFeatureType featureType, BoundarySurfaceType type, AbstractThematicSurface aco) {
+        this.featureType = featureType;
+        this.type = type;
+        gmlObject = aco;
+    }
+
+    public void setFeatureType(SurfaceFeatureType featureType) {
+        this.featureType = featureType;
+    }
+
+    public void setType(BoundarySurfaceType type) {
+        this.type = type;
+    }
+
+    public void setGmlObject(AbstractThematicSurface gmlObject) {
+        this.gmlObject = gmlObject;
+    }
+
+    public SurfaceFeatureType getSurfaceFeatureType() {
+        return featureType;
+    }
+
+    public BoundarySurfaceType getType() {
+        return type;
+    }
+
+    public List<Opening> getOpenings() {
+        return openings;
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        if (gmlObject.getId() == null) {
+            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) {
+                    setGeometryAccordingToLod(geom.getLod(), new MultiSurfaceProperty(ms));
+                }
+            } else {
+                throw new IllegalStateException("BoundarySurfaces can only have MultiSurface geometries");
+            }
+        }
+        for (Opening o : openings) {
+            o.reCreateGeometries(factory, config);
+        }
+    }
+
+    private void setGeometryAccordingToLod(Lod lod, MultiSurfaceProperty ms) {
+        switch (lod) {
+            case LOD0:
+                gmlObject.setLod0MultiSurface(ms);
+                break;
+            case LOD1:
+                gmlObject.setLod1MultiSurface(ms);
+                break;
+            case LOD2:
+                gmlObject.setLod2MultiSurface(ms);
+                break;
+            case LOD3:
+                gmlObject.setLod3MultiSurface(ms);
+                break;
+            case LOD4:
+                gmlObject.getDeprecatedProperties().setLod4MultiSurface(ms);
+                break;
+            default:
+                throw new IllegalStateException("Found geometry with LOD other than LOD1-4, which is illegal for BoundarySurfaces: " + lod);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (Opening o : openings) {
+            o.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (Opening o : openings) {
+            o.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (Opening o : openings) {
+            if (o.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (Opening o : openings) {
+            if (o.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (Opening o : openings) {
+            o.accept(c);
+        }
+    }
+
+    public void setParent(CityObject parent) {
+        this.parent = parent;
+    }
+
+    public CityObject getParent() {
+        return parent;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        gmlObject.setLod0MultiSurface(null);
+        gmlObject.setLod1MultiSurface(null);
+        gmlObject.setLod2MultiSurface(null);
+        gmlObject.setLod3MultiSurface(null);
+        gmlObject.getDeprecatedProperties().setLod4MultiSurface(null);
+
+        for (Opening o : openings) {
+            o.unsetGmlGeometries();
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "BoundarySurface [type=" + type + ", id=" + getGmlId() + "]";
+    }
+
+    void anonymize() {
+        gmlObject.setAppearances(null);
+        gmlObject.setBoundedBy(null);
+        gmlObject.setCreationDate(null);
+        gmlObject.setDescription(null);
+        gmlObject.setExternalReferences(null);
+        gmlObject.setGeneralizesTo(null);
+        gmlObject.setADEProperties(null);
+        gmlObject.setGenericAttributes(null);
+        setGmlId(GmlId.generateId());
+        gmlObject.setId(getGmlId().getGmlString());
+    }
+
+    @Override
+    public AbstractThematicSurface getGmlObject() {
+        return gmlObject;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BOUNDARY_SURFACE;
+    }
+
+    public void addOpening(Opening opening) {
+        openings.add(opening);
+        opening.setPartOfSurface(this);
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (Opening o : openings) {
+            o.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (Opening o : openings) {
+            o.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new BoundarySurface(gmlObject);
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        for (Opening o : openings) {
+            handler.addInstance(o);
+        }
+        handler.addInstance(parent);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        BoundarySurface originalBs = (BoundarySurface) original;
+        featureType = originalBs.featureType;
+        type = originalBs.type;
+        for (Opening originalOpening : originalBs.openings) {
+            openings.add(handler.getCopyInstance(originalOpening));
+        }
+        parent = handler.getCopyInstance(originalBs.parent);
+        gmlObject = originalBs.gmlObject;
+    }
+
 }

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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -20,12 +20,11 @@ package de.hft.stuttgart.citydoctor2.datastructure;
 
 /**
  * Types of boundary surfaces used in city doctor
- * 
- * @author Matthias Betz
  *
+ * @author Matthias Betz
  */
 public enum BoundarySurfaceType {
 
-	UNDEFINED, ROOF, WALL, GROUND, CLOSURE, OUTER_FLOOR, OUTER_CEILING, CEILING, INTERIOR_WALL, FLOOR
+    UNDEFINED, ROOF, WALL, GROUND, CLOSURE, OUTER_FLOOR, OUTER_CEILING, CEILING, INTERIOR_WALL, FLOOR
 
 }

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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -18,148 +18,147 @@
  */
 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
  *
+ * @author Matthias Betz
  */
 public class BoundingBox {
 
-	private final Vector3d[] bbox;
-
-	/**
-	 * Creates an axis aligned bounding box containing all points of all polygons
-	 * 
-	 * @param polygons containing the points from which the box will be created
-	 * @return the bounding box around all points
-	 */
-	public static BoundingBox of(Collection<? extends Polygon> polygons) {
-		return BoundingBoxCalculator.calculateBoundingBox(polygons);
-	}
-	
-	public static BoundingBox ofPoints(List<? extends Vector3d> points) {
-		return BoundingBoxCalculator.calculateBoundingBoxFromPoints(points);
-	}
-
-	/**
-	 * Creates an axis aligned bounding box of the whole model.
-	 * 
-	 * @param model the model containing the features with geometries used for the
-	 *              bounding box
-	 * @return the bounding box around all features
-	 */
-	public static BoundingBox of(CityDoctorModel model) {
-		return BoundingBoxCalculator.calculateBoundingBox(model);
-	}
-
-	/**
-	 * Creates a new bounding box with two vectors as corner points.
-	 * 
-	 * @param box the array of length 2 containing both corners
-	 * @return the new bounding box
-	 */
-	public static BoundingBox of(Vector3d[] box) {
-		return new BoundingBox(box);
-	}
-
-	private BoundingBox(Vector3d[] bbox) {
-		if (bbox == null || bbox.length != 2) {
-			throw new IllegalArgumentException("BoundingBox must be an array of the length 2");
-		}
-		this.bbox = bbox;
-	}
-
-	/**
-	 * Calculates the volume of the box
-	 * 
-	 * @return the volume of the box
-	 */
-	public double getVolume() {
-		double length = getDepth();
-		double width = getWidth();
-		double height = getHeight();
-		return height * width * length;
-	}
-
-	/**
-	 * Calculates the center of the bounding box
-	 * 
-	 * @return the center of the bounding box
-	 */
-	public Vector3d getCenter() {
-		return bbox[0].plus(bbox[1].minus(bbox[0]).mult(0.5));
-	}
-
-	/**
-	 * Getter for the corner array
-	 * 
-	 * @return the array containing the corner points
-	 */
-	public Vector3d[] getBox() {
-		return bbox;
-	}
-
-	/**
-	 * Calculates the width of the bounding box
-	 * 
-	 * @return the width of the bounding box
-	 */
-	public double getWidth() {
-		return bbox[1].getY() - bbox[0].getY();
-	}
-
-	/**
-	 * Calculates the height of the bounding box
-	 * 
-	 * @return the height of the bounding box
-	 */
-	public double getHeight() {
-		return bbox[1].getZ() - bbox[0].getZ();
-	}
-
-	/**
-	 * Calculates the depth of the bounding box
-	 * 
-	 * @return the depth of the bounding box
-	 */
-	public double getDepth() {
-		return bbox[1].getX() - bbox[0].getX();
-	}
-
-	/**
-	 * Returns the length of the longest side of the bounding box, ignoring the
-	 * height. Only X and Y axis are considered
-	 * 
-	 * @return the length of the longest side in X or Y direction
-	 */
-	public double getLongestSide() {
-		double width = getWidth();
-		double depth = getDepth();
+    private final Vector3d[] bbox;
+
+    /**
+     * Creates an axis aligned bounding box containing all points of all polygons
+     *
+     * @param polygons containing the points from which the box will be created
+     * @return the bounding box around all points
+     */
+    public static BoundingBox of(Collection<? extends Polygon> polygons) {
+        return BoundingBoxCalculator.calculateBoundingBox(polygons);
+    }
+
+    public static BoundingBox ofPoints(List<? extends Vector3d> points) {
+        return BoundingBoxCalculator.calculateBoundingBoxFromPoints(points);
+    }
+
+    /**
+     * Creates an axis aligned bounding box of the whole model.
+     *
+     * @param model the model containing the features with geometries used for the
+     *              bounding box
+     * @return the bounding box around all features
+     */
+    public static BoundingBox of(CityDoctorModel model) {
+        return BoundingBoxCalculator.calculateBoundingBox(model);
+    }
+
+    /**
+     * Creates a new bounding box with two vectors as corner points.
+     *
+     * @param box the array of length 2 containing both corners
+     * @return the new bounding box
+     */
+    public static BoundingBox of(Vector3d[] box) {
+        return new BoundingBox(box);
+    }
+
+    private BoundingBox(Vector3d[] bbox) {
+        if (bbox == null || bbox.length != 2) {
+            throw new IllegalArgumentException("BoundingBox must be an array of the length 2");
+        }
+        this.bbox = bbox;
+    }
+
+    /**
+     * Calculates the volume of the box
+     *
+     * @return the volume of the box
+     */
+    public double getVolume() {
+        double length = getDepth();
+        double width = getWidth();
+        double height = getHeight();
+        return height * width * length;
+    }
+
+    /**
+     * Calculates the center of the bounding box
+     *
+     * @return the center of the bounding box
+     */
+    public Vector3d getCenter() {
+        return bbox[0].plus(bbox[1].minus(bbox[0]).mult(0.5));
+    }
+
+    /**
+     * Getter for the corner array
+     *
+     * @return the array containing the corner points
+     */
+    public Vector3d[] getBox() {
+        return bbox;
+    }
+
+    /**
+     * Calculates the width of the bounding box
+     *
+     * @return the width of the bounding box
+     */
+    public double getWidth() {
+        return bbox[1].getY() - bbox[0].getY();
+    }
+
+    /**
+     * Calculates the height of the bounding box
+     *
+     * @return the height of the bounding box
+     */
+    public double getHeight() {
+        return bbox[1].getZ() - bbox[0].getZ();
+    }
+
+    /**
+     * Calculates the depth of the bounding box
+     *
+     * @return the depth of the bounding box
+     */
+    public double getDepth() {
+        return bbox[1].getX() - bbox[0].getX();
+    }
+
+    /**
+     * Returns the length of the longest side of the bounding box, ignoring the
+     * height. Only X and Y axis are considered
+     *
+     * @return the length of the longest side in X or Y direction
+     */
+    public double getLongestSide() {
+        double width = getWidth();
+        double depth = getDepth();
         return Math.max(width, depth);
-	}
-
-	/**
-	 * Calculates the direction vector from the lower corner to the upper corner
-	 * 
-	 * @return the direction vector from the lower corner to the upper corner
-	 */
-	public Vector3d getDiagonal() {
-		return bbox[1].minus(bbox[0]);
-	}
-
-	/**
-	 * Calculates the distance between the corner points
-	 * 
-	 * @return the distance between the corner points
-	 */
-	public double getDiagonalLength() {
-		return bbox[1].getDistance(bbox[0]);
-	}
+    }
+
+    /**
+     * Calculates the direction vector from the lower corner to the upper corner
+     *
+     * @return the direction vector from the lower corner to the upper corner
+     */
+    public Vector3d getDiagonal() {
+        return bbox[1].minus(bbox[0]);
+    }
+
+    /**
+     * Calculates the distance between the corner points
+     *
+     * @return the distance between the corner points
+     */
+    public double getDiagonalLength() {
+        return bbox[1].getDistance(bbox[0]);
+    }
 }

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

 /*-
  *  Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -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,257 +37,256 @@ 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 {
-	
-	private static final Logger logger = LogManager.getLogger(BridgeConstructiveElement.class);
 
-	private static final String CANNOT_ADD = "Cannot add ";
+    private static final Logger logger = LogManager.getLogger(BridgeConstructiveElement.class);
+
+    private static final String CANNOT_ADD = "Cannot add ";
+
+    @Serial
+    private static final long serialVersionUID = 7353233899458901155L;
+
+    private final org.citygml4j.core.model.bridge.BridgeConstructiveElement gmlBridgeElement;
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+
+
+    public BridgeConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement gmlObject) {
+        this.gmlBridgeElement = gmlObject;
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new BridgeConstructiveElement(gmlBridgeElement);
+    }
+
+    @Override
+    public void reCreateGeometries(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;
+                case COMPOSITE_SURFACE:
+                    CompositeSurface cs = CityGmlUtils.createCompositeSurface(geom, factory, config);
+                    setCompositeSurfaceAccordingToLod(geom, cs);
+                    break;
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            reCreateBoundarySurface(factory, config, bs);
+        }
+    }
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+    }
+
+    @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;
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : gmlBridgeElement.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from BridgeConstructiveElement", bs.getGmlId());
+                    gmlBridgeElement.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
 
-	@Serial
-	private static final long serialVersionUID = 7353233899458901155L;
+    private void setCompositeSurfaceAccordingToLod(Geometry geom, CompositeSurface cs) {
+        switch (geom.getLod()) {
+            case LOD1:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new GeometryProperty<>(cs));
+                break;
+            case LOD2:
+                gmlBridgeElement.getDeprecatedProperties().setLod2Geometry(new GeometryProperty<>(cs));
+                break;
+            case LOD3:
+                gmlBridgeElement.getDeprecatedProperties().setLod3Geometry(new GeometryProperty<>(cs));
+                break;
+            case LOD4:
+                gmlBridgeElement.getDeprecatedProperties().setLod4Geometry(new GeometryProperty<>(cs));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " composite surface to buildings");
+        }
+    }
 
-	private final org.citygml4j.core.model.bridge.BridgeConstructiveElement gmlBridgeElement;
-	private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new SolidProperty(solid));
+                break;
+            case LOD2:
+                gmlBridgeElement.getDeprecatedProperties().setLod2Geometry(new SolidProperty(solid));
+                break;
+            case LOD3:
+                gmlBridgeElement.getDeprecatedProperties().setLod3Geometry(new SolidProperty(solid));
+                break;
+            case LOD4:
+                gmlBridgeElement.getDeprecatedProperties().setLod4Geometry(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:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
+            case LOD1:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
+            case LOD4:
+                gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " multi surface to buildings");
+        }
+    }
 
-	public BridgeConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement gmlObject) {
-		this.gmlBridgeElement = gmlObject;
-	}
+    @Override
+    public org.citygml4j.core.model.bridge.BridgeConstructiveElement getGmlObject() {
+        return gmlBridgeElement;
+    }
 
-	@Override
-	public Copyable createCopyInstance() {
-		return new BridgeConstructiveElement(gmlBridgeElement);
-	}
+    @Override
+    public void unsetGmlGeometries() {
+        gmlBridgeElement.setLod0MultiSurface(null);
+        gmlBridgeElement.setLod2MultiSurface(null);
+        gmlBridgeElement.setLod3MultiSurface(null);
+        DeprecatedPropertiesOfBridgeConstructiveElement depProps = gmlBridgeElement.getDeprecatedProperties();
+        depProps.setLod1Geometry(null);
+        depProps.setLod2Geometry(null);
+        depProps.setLod3Geometry(null);
+        depProps.setLod4Geometry(null);
+        gmlBridgeElement.setLod1Solid(null);
+        gmlBridgeElement.setLod2Solid(null);
+        gmlBridgeElement.setLod3Solid(null);
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.unsetGmlGeometries();
+        }
+    }
 
-	@Override
-	public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-		// only handles CityGML2 for now
-		// unknown which CityGML is handled here
-		// need context information to decide
-		for (Geometry geom : getGeometries()) {
-			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;
-			case COMPOSITE_SURFACE:
-				CompositeSurface cs = CityGmlUtils.createCompositeSurface(geom, factory, config);
-				setCompositeSurfaceAccordingToLod(geom, cs);
-				break;
-			}
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			reCreateBoundarySurface(factory, config, bs);
-		}
-	}
-	
-	@Override
-	public void accept(Check c) {
-		super.accept(c);
-		if (c.canExecute(this)) {
-			c.check(this);
-		}
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.accept(c);
-		}
-	}
-	
-	@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;
-	}
-	
-	private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
-		if (bs.getGeometries().isEmpty()) {
-			for (AbstractSpaceBoundaryProperty bsp : gmlBridgeElement.getBoundaries()) {
-				if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
-					logger.warn("Found empty boundary surface: {}, removing from BridgeConstructiveElement", bs.getGmlId());
-					gmlBridgeElement.getBoundaries().remove(bsp);
-					break;
-				}
-			}
-			return;
-		}
-		bs.reCreateGeometries(factory, config);
-	}
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BRIDGE_CONSTRUCTION_ELEMENT;
+    }
 
-	private void setCompositeSurfaceAccordingToLod(Geometry geom, CompositeSurface cs) {
-		switch (geom.getLod()) {
-		case LOD1:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new GeometryProperty<>(cs));
-			break;
-		case LOD2:
-			gmlBridgeElement.getDeprecatedProperties().setLod2Geometry(new GeometryProperty<>(cs));
-			break;
-		case LOD3:
-			gmlBridgeElement.getDeprecatedProperties().setLod3Geometry(new GeometryProperty<>(cs));
-			break;
-		case LOD4:
-			gmlBridgeElement.getDeprecatedProperties().setLod4Geometry(new GeometryProperty<>(cs));
-			break;
-		default:
-			throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " composite surface to buildings");
-		}		
-	}
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
 
-	private void setSolidAccordingToLod(Geometry geom, Solid solid) {
-		switch (geom.getLod()) {
-		case LOD1:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new SolidProperty(solid));
-			break;
-		case LOD2:
-			gmlBridgeElement.getDeprecatedProperties().setLod2Geometry(new SolidProperty(solid));
-			break;
-		case LOD3:
-			gmlBridgeElement.getDeprecatedProperties().setLod3Geometry(new SolidProperty(solid));
-			break;
-		case LOD4:
-			gmlBridgeElement.getDeprecatedProperties().setLod4Geometry(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:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
-			break;
-		case LOD1:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
-			break;
-		case LOD2:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
-			break;
-		case LOD3:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
-			break;
-		case LOD4:
-			gmlBridgeElement.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
-			break;
-		default:
-			throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " multi surface to buildings");
-		}
-	}
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
 
-	@Override
-	public org.citygml4j.core.model.bridge.BridgeConstructiveElement getGmlObject() {
-		return gmlBridgeElement;
-	}
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.prepareForChecking();
+        }
+    }
 
-	@Override
-	public void unsetGmlGeometries() {
-		gmlBridgeElement.setLod0MultiSurface(null);
-		gmlBridgeElement.setLod2MultiSurface(null);
-		gmlBridgeElement.setLod3MultiSurface(null);
-		DeprecatedPropertiesOfBridgeConstructiveElement depProps = gmlBridgeElement.getDeprecatedProperties();
-		depProps.setLod1Geometry(null);
-		depProps.setLod2Geometry(null);
-		depProps.setLod3Geometry(null);
-		depProps.setLod4Geometry(null);
-		gmlBridgeElement.setLod1Solid(null);
-		gmlBridgeElement.setLod2Solid(null);
-		gmlBridgeElement.setLod3Solid(null);
-		for (BoundarySurface bs : boundarySurfaceList) {
-			bs.unsetGmlGeometries();
-		}
-	}
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearMetaInformation();
+        }
+    }
 
-	@Override
-	public FeatureType getFeatureType() {
-		return FeatureType.BRIDGE_CONSTRUCTION_ELEMENT;
-	}
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(boundarySurfaceList);
+    }
 
-	public void addBoundarySurface(BoundarySurface bs) {
-		boundarySurfaceList.add(bs);
-		bs.setParent(this);
-	}
-	
-	public List<BoundarySurface> getBoundarySurfaces() {
-		return boundarySurfaceList;
-	}
-	
-	@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);
-		BridgeConstructiveElement originalBce = (BridgeConstructiveElement) original;
-		for (BoundarySurface originalBs : originalBce.boundarySurfaceList) {
-			boundarySurfaceList.add(handler.getCopyInstance(originalBs));
-		}
-	}
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        BridgeConstructiveElement originalBce = (BridgeConstructiveElement) original;
+        for (BoundarySurface originalBs : originalBce.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+    }
 
 }

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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -18,158 +18,157 @@
  */
 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 {
 
-	@Serial
-	private static final long serialVersionUID = 588480113268630052L;
-
-	private final List<BuildingPart> buildingParts = new ArrayList<>(2);
-
-	public List<BuildingPart> getBuildingParts() {
-		return buildingParts;
-	}
-
-	@Override
-	public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-		super.reCreateGeometries(factory, config);
-		for (BuildingPart bp : buildingParts) {
-			bp.reCreateGeometries(factory, config);
-		}
-	}
-
-	@Override
-	public void accept(Check c) {
-		super.accept(c);
-		if (c.canExecute(this)) {
-			c.check(this);
-		}
-		for (BuildingPart bp : buildingParts) {
-			bp.accept(c);
-		}
-	}
-
-	@Override
-	public void clearAllContainedCheckResults() {
-		super.clearAllContainedCheckResults();
-		for (BuildingPart bp : buildingParts) {
-			bp.clearAllContainedCheckResults();
-		}
-	}
-
-	@Override
-	public void collectContainedErrors(List<CheckError> errors) {
-		super.collectContainedErrors(errors);
-		for (BuildingPart bp : buildingParts) {
-			bp.collectContainedErrors(errors);
-		}
-	}
-
-	@Override
-	public boolean containsAnyError() {
-		boolean hasError = super.containsAnyError();
-		if (hasError) {
-			return true;
-		}
-		for (BuildingPart bp : buildingParts) {
-			if (bp.containsAnyError()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean containsError(CheckId checkIdentifier) {
-		boolean hasError = super.containsError(checkIdentifier);
-		if (hasError) {
-			return true;
-		}
-		for (BuildingPart bp : buildingParts) {
-			if (bp.containsError(checkIdentifier)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	public void addBuildingPart(BuildingPart buildingPart) {
-		buildingParts.add(buildingPart);
-	}
-
-	@Override
-	public String toString() {
-		return "Building [id=" + getGmlId() + "]";
-	}
-
-	public void anonymize() {
-		for (Geometry geom : getGeometries()) {
-			geom.anonymize();
-		}
-		org.citygml4j.core.model.building.Building gmlB = new org.citygml4j.core.model.building.Building();
-		gmlB.setId(GmlId.generateId().getGmlString());
-		for (Installation bi : getBuildingInstallations()) {
-			bi.anonymize();
-			gmlB.getBuildingInstallations().add(new BuildingInstallationProperty((BuildingInstallation) bi.getGmlObject()));
-		}
-		for (BoundarySurface bs : getBoundarySurfaces()) {
-			bs.anonymize();
-			gmlB.addBoundary(new AbstractSpaceBoundaryProperty(bs.getGmlObject()));
-		}
-		setCityGmlBuilding(gmlB);
-	}
-	
-	@Override
-	public void clearMetaInformation() {
-		super.clearMetaInformation();
-		for (BuildingPart part : buildingParts) {
-			part.clearMetaInformation();
-		}
-	}
-	
-	@Override
-	public void prepareForChecking() {
-		super.prepareForChecking();
-		for (BuildingPart part : buildingParts) {
-			part.prepareForChecking();
-		}
-	}
-	
-	@Override
-	public void fillValues(Copyable original, CopyHandler handler) {
-		super.fillValues(original, handler);
-		Building originalBuilding = (Building) original;
-		for (BuildingPart originalBp : originalBuilding.buildingParts) {
-			buildingParts.add(handler.getCopyInstance(originalBp));
-		}
-	}
-	
-	@Override
-	public void collectInstances(CopyHandler handler) {
-		super.collectInstances(handler);
-		for (BuildingPart bp : buildingParts) {
-			handler.addInstance(bp);
-		}
-	}
-
-	@Override
-	public Copyable createCopyInstance() {
-		return new Building();
-	}
+    @Serial
+    private static final long serialVersionUID = 588480113268630052L;
+
+    private final List<BuildingPart> buildingParts = new ArrayList<>(2);
+
+    public List<BuildingPart> getBuildingParts() {
+        return buildingParts;
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        super.reCreateGeometries(factory, config);
+        for (BuildingPart bp : buildingParts) {
+            bp.reCreateGeometries(factory, config);
+        }
+    }
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BuildingPart bp : buildingParts) {
+            bp.accept(c);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (BuildingPart bp : buildingParts) {
+            bp.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (BuildingPart bp : buildingParts) {
+            bp.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (BuildingPart bp : buildingParts) {
+            if (bp.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (BuildingPart bp : buildingParts) {
+            if (bp.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void addBuildingPart(BuildingPart buildingPart) {
+        buildingParts.add(buildingPart);
+    }
+
+    @Override
+    public String toString() {
+        return "Building [id=" + getGmlId() + "]";
+    }
+
+    public void anonymize() {
+        for (Geometry geom : getGeometries()) {
+            geom.anonymize();
+        }
+        org.citygml4j.core.model.building.Building gmlB = new org.citygml4j.core.model.building.Building();
+        gmlB.setId(GmlId.generateId().getGmlString());
+        for (Installation bi : getBuildingInstallations()) {
+            bi.anonymize();
+            gmlB.getBuildingInstallations().add(new BuildingInstallationProperty((BuildingInstallation) bi.getGmlObject()));
+        }
+        for (BoundarySurface bs : getBoundarySurfaces()) {
+            bs.anonymize();
+            gmlB.addBoundary(new AbstractSpaceBoundaryProperty(bs.getGmlObject()));
+        }
+        setCityGmlBuilding(gmlB);
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (BuildingPart part : buildingParts) {
+            part.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (BuildingPart part : buildingParts) {
+            part.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        Building originalBuilding = (Building) original;
+        for (BuildingPart originalBp : originalBuilding.buildingParts) {
+            buildingParts.add(handler.getCopyInstance(originalBp));
+        }
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        for (BuildingPart bp : buildingParts) {
+            handler.addInstance(bp);
+        }
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new Building();
+    }
 
 }

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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -24,50 +24,50 @@ import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import java.io.Serial;
 
 public class BuildingPart extends AbstractBuilding {
-	
-	@Serial
-	private static final long serialVersionUID = 8200322261958679163L;
-	
-	private Building parent;
-	
-	private BuildingPart() {
-	}
-	
-	public BuildingPart(Building parent) {
-		this.parent = parent;
-		parent.addBuildingPart(this);
-	}
-	
-	public Building getParent() {
-		return parent;
-	}
-	
-	@Override
-	public FeatureType getFeatureType() {
-		return FeatureType.BUILDING_PART;
-	}
 
-	@Override
-	public String toString() {
-		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);
-	}
+    @Serial
+    private static final long serialVersionUID = 8200322261958679163L;
+
+    private Building parent;
+
+    private BuildingPart() {
+    }
+
+    public BuildingPart(Building parent) {
+        this.parent = parent;
+        parent.addBuildingPart(this);
+    }
+
+    public Building getParent() {
+        return parent;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BUILDING_PART;
+    }
+
+    @Override
+    public String toString() {
+        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();
-	}
+    @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 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

 /*-
  *  Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
- * 
+ *
  *  This file is part of CityDoctor2.
  *
  *  CityDoctor2 is free software: you can redistribute it and/or modify
@@ -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,361 +25,441 @@ 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
  *
+ * @author Matthias Betz
  */
 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<CityObject> land;
-	private final List<TransportationObject> roads;
-	private final List<WaterObject> water;
-	private CityModel cModel;
-	private final ParserConfiguration config;
-	private final String fileName;
-	private final File file;
-	private final List<CheckError> globalErrors;
-	private boolean isValidated = false;
-	private ValidationPlan plan;
-	private CityGMLVersion cityGMLVersion;
-
-	public CityDoctorModel(ParserConfiguration config, File file) {
-		if (config == null) {
-			throw new IllegalArgumentException("Parser configuration may not be null");
-		}
-		this.fileName = file.getName();
-		this.config = config;
-		this.file = file;
-		buildings = new ArrayList<>();
-		vegetation = new ArrayList<>();
-		bridges = new ArrayList<>();
-		land = new ArrayList<>();
-		roads = new ArrayList<>();
-		water = new ArrayList<>();
-		globalErrors = new ArrayList<>();
-	}
-
-	public boolean isValidated() {
-		return isValidated;
-	}
-
-	public void setValidated(ValidationPlan plan) {
-		if (plan == null) {
-			this.plan = null;
-			this.isValidated = false;
-			return;
-		}
-		this.plan = plan;
-		this.isValidated = true;
-	}
-	
-	public ValidationPlan getValidationPlan() {
-		return plan;
-	}
-
-	public void addGlobalError(CheckError err) {
-		globalErrors.add(err);
-	}
-
-	public void addGlobalErrors(List<? extends CheckError> generalErrors) {
-		globalErrors.addAll(generalErrors);
-	}
-
-	public List<CheckError> getGlobalErrors() {
-		return globalErrors;
-	}
-
-	public File getFile() {
-		return file;
-	}
-
-	public Stream<CityObject> createFeatureStream() {
-		return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
-				water.stream()).flatMap(co -> co);
-	}
-
-	public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
-		if (file.endsWith(".off")) {
-			exportAsOff(file);
-		} else {
-			ValidationPlan tempPlan = plan;
-			if (!saveQualityAde) {
-				setValidated(null);
-			}
-			exportAsGML(file);
-			if (!saveQualityAde) {
-				setValidated(tempPlan);
-			}
-		}
-	}
-
-	private void exportAsGML(String file) throws CityDoctorWriteException {
-		CityGMLWriterUtils.writeCityModel(file, this);
-	}
-
-	private void exportAsOff(String file) {
-		file = file.substring(0, file.lastIndexOf('.'));
-		File folder = new File(file);
-		folder.mkdirs();
-		createFeatureStream().forEach(co -> {
-			Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
-			Check c = new AbstractCheck() {
-				
-				@Override
-				public void check(Geometry geom) {
-					polygonMap.compute(geom.getLod(), (lod, polys) -> {
-						if (polys == null) {
-							polys = new HashSet<>();
-						}
-						for (Polygon poly : geom.getPolygons()) {
-							polys.add(poly.getOriginal());
-						}
-						return polys;
-					});
-				}
-			};
-			co.accept(c);
-			
-			Set<Polygon> highestLod = polygonMap.get(Lod.LOD2);
-			if (highestLod == null) {
-				highestLod = polygonMap.get(Lod.LOD1);
-			}
-			if (highestLod == null) {
-				return;
-			}
-			Map<Vertex, Integer> idMap = new LinkedHashMap<>();
-			AtomicInteger counter = new AtomicInteger(0);
-			for (Polygon poly : highestLod) {
-				addRing(poly.getExteriorRing(), idMap, counter);
-			}
-			
-			try (BufferedWriter writer = Files.newBufferedWriter(folder.toPath().resolve(co.getGmlId() + ".off"))) {
-				writer.write("OFF\n");
-				writer.write(Integer.toString(idMap.size()));
-				writer.write(' ');
-				writer.write(Integer.toString(highestLod.size()));
-				writer.write(" 0\n");
-				for (Vertex v : idMap.keySet()) {
-					writer.write(Double.toString(v.getX()));
-					writer.write(' ');
-					writer.write(Double.toString(v.getY()));
-					writer.write(' ');
-					writer.write(Double.toString(v.getZ()));
-					writer.write('\n');
-				}
-				for (Polygon poly : highestLod) {
-					writer.write(Integer.toString(poly.getExteriorRing().getVertices().size() - 1));
-					writer.write(' ');
-					for (int i = 0; i < poly.getExteriorRing().getVertices().size() - 1; i++) {
-						Vertex v = poly.getExteriorRing().getVertices().get(i);
-						writer.write(Integer.toString(idMap.get(v)));
-						writer.write(' ');
-					}
-					writer.write('\n');
-				}
-			} catch (IOException e) {
-				throw new UncheckedIOException(e);
-			} 
-			
-		});
-	}
-
-	private void addRing(LinearRing ring, Map<Vertex, Integer> idMap, AtomicInteger counter) {
-		for (Vertex v : ring.getVertices()) {
-			idMap.computeIfAbsent(v, k -> counter.getAndIncrement());
-		}
-	}
-
-	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, water);
-		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);
-	}
-
-	public List<Building> getBuildings() {
-		return buildings;
-	}
-
-	public List<BridgeObject> getBridges() {
-		return bridges;
-	}
-
-	public void setCityModel(CityModel cModel) {
-		this.cModel = cModel;
-	}
-
-	public CityModel getCityModel() {
-		return cModel;
-	}
-
-	public List<TransportationObject> getTransportation() {
-		return roads;
-	}
-
-	public List<WaterObject> getWater() {
-		return water;
-	}
-
-	public List<CityObject> getLand() {
-		return land;
-	}
-
-	public List<Vegetation> getVegetation() {
-		return vegetation;
-	}
-
-	public void addWater(WaterObject wo) {
-		water.add(wo);
-	}
-
-	public void addLand(LandObject lo) {
-		land.add(lo);
-	}
-
-	public void addVegetation(Vegetation veg) {
-		vegetation.add(veg);
-	}
-
-	public void addTransportation(TransportationObject to) {
-		roads.add(to);
-	}
-
-	public int getNumberOfFeatures() {
-		return buildings.size() + vegetation.size() + bridges.size() + land.size() + roads.size() + water.size();
-	}
-
-	public ParserConfiguration getParserConfig() {
-		return config;
-	}
-
-	public void replaceFeature(CityObject currentFeature, CityObject nextFeature) {
-		if (nextFeature instanceof Building) {
-			replaceBuilding(currentFeature, nextFeature);
-		} else if (nextFeature instanceof BridgeObject) {
-			replaceBridge(currentFeature, nextFeature);
-		} else if (nextFeature instanceof TransportationObject) {
-			replaceTransportationObject(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);
-		}
-	}
-
-	private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
-		int index = water.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
-		}
-		water.set(index, (WaterObject) nextFeature);
-	}
-
-	private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
-		int index = land.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
-		}
-		land.set(index, nextFeature);
-	}
-
-	private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
-		int index = vegetation.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
-		}
-		vegetation.set(index, (Vegetation) nextFeature);
-	}
-
-	private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
-		int index = roads.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
-		}
-		roads.set(index, (TransportationObject) nextFeature);
-	}
-
-	private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
-		int index = bridges.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
-		}
-		bridges.set(index, (BridgeObject) nextFeature);
-	}
-
-	private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
-		int index = buildings.indexOf(currentFeature);
-		if (index == -1) {
-			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
-		}
-		buildings.set(index, (Building) nextFeature);
-	}
-
-	public void addCityObject(CityObject co) {
-		if (co instanceof Building b) {
-			buildings.add(b);
-		} else if (co instanceof BridgeObject bo) {
-			bridges.add(bo);
-		} else if (co instanceof TransportationObject to) {
-			roads.add(to);
-		} else if (co instanceof Vegetation veg) {
-			vegetation.add(veg);
-		} else if (co instanceof LandObject lo) {
-			land.add(lo);
-		} else if (co instanceof WaterObject wo) {
-			water.add(wo);
-		} else if (co instanceof ReliefObject) {
-			land.add(co);
-		} else if (co instanceof TinObject) {
-			land.add(co);
-		}
-	}
-
-	public void setParsedCityGMLVersion(CityGMLVersion cityGMLVersion) {
-		this.cityGMLVersion = cityGMLVersion;
-	}
-	
-	public CityGMLVersion getCityGMLVersion() {
-		return cityGMLVersion;
-	}
-
-	public void addRelief(ReliefObject relief) {
-		addCityObject(relief);
-	}
-
-	public void addTin(TinObject tin) {
-		addCityObject(tin);
-	}
+    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 CityModel cModel;
+    private final ParserConfiguration config;
+    private final String fileName;
+    private final File file;
+    private final List<CheckError> globalErrors;
+    private boolean isValidated = false;
+    private ValidationPlan plan;
+    private CityGMLVersion cityGMLVersion;
+
+    public CityDoctorModel(ParserConfiguration config, File file) {
+        if (config == null) {
+            throw new IllegalArgumentException("Parser configuration may not be null");
+        }
+        this.fileName = file.getName();
+        this.config = config;
+        this.file = file;
+        buildings = new ArrayList<>();
+        vegetation = new ArrayList<>();
+        bridges = new ArrayList<>();
+        land = new ArrayList<>();
+        roads = new ArrayList<>();
+        tunnels = new ArrayList<>();
+        water = new ArrayList<>();
+        cityfurniture = new ArrayList<>();
+        genericObjects = new ArrayList<>();
+        globalErrors = new ArrayList<>();
+    }
+
+    public boolean isValidated() {
+        return isValidated;
+    }
+
+    public void setValidated(ValidationPlan plan) {
+        if (plan == null) {
+            this.plan = null;
+            this.isValidated = false;
+            return;
+        }
+        this.plan = plan;
+        this.isValidated = true;
+    }
+
+    public ValidationPlan getValidationPlan() {
+        return plan;
+    }
+
+    public void addGlobalError(CheckError err) {
+        globalErrors.add(err);
+    }
+
+    public void addGlobalErrors(List<? extends CheckError> generalErrors) {
+        globalErrors.addAll(generalErrors);
+    }
+
+    public List<CheckError> getGlobalErrors() {
+        return globalErrors;
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    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);
+    }
+
+    public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
+        if (file.endsWith(".off")) {
+            exportAsOff(file);
+        } else {
+            ValidationPlan tempPlan = plan;
+            if (!saveQualityAde) {
+                setValidated(null);
+            }
+            exportAsGML(file);
+            if (!saveQualityAde) {
+                setValidated(tempPlan);
+            }
+        }
+    }
+
+    private void exportAsGML(String file) throws CityDoctorWriteException {
+        CityGMLWriterUtils.writeCityModel(file, this);
+    }
+
+    private void exportAsOff(String file) {
+        file = file.substring(0, file.lastIndexOf('.'));
+        File folder = new File(file);
+        folder.mkdirs();
+        createFeatureStream().forEach(co -> {
+            Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
+            Check c = new AbstractCheck() {
+
+                @Override
+                public void check(Geometry geom) {
+                    polygonMap.compute(geom.getLod(), (lod, polys) -> {
+                        if (polys == null) {
+                            polys = new HashSet<>();
+                        }
+                        for (Polygon poly : geom.getPolygons()) {
+                            polys.add(poly.getOriginal());
+                        }
+                        return polys;
+                    });
+                }
+            };
+            co.accept(c);
+
+            Set<Polygon> highestLod = polygonMap.get(Lod.LOD2);
+            if (highestLod == null) {
+                highestLod = polygonMap.get(Lod.LOD1);
+            }
+            if (highestLod == null) {
+                return;
+            }
+            Map<Vertex, Integer> idMap = new LinkedHashMap<>();
+            AtomicInteger counter = new AtomicInteger(0);
+            for (Polygon poly : highestLod) {
+                addRing(poly.getExteriorRing(), idMap, counter);
+            }
+
+            try (BufferedWriter writer = Files.newBufferedWriter(folder.toPath().resolve(co.getGmlId() + ".off"))) {
+                writer.write("OFF\n");
+                writer.write(Integer.toString(idMap.size()));
+                writer.write(' ');
+                writer.write(Integer.toString(highestLod.size()));
+                writer.write(" 0\n");
+                for (Vertex v : idMap.keySet()) {
+                    writer.write(Double.toString(v.getX()));
+                    writer.write(' ');
+                    writer.write(Double.toString(v.getY()));
+                    writer.write(' ');
+                    writer.write(Double.toString(v.getZ()));
+                    writer.write('\n');
+                }
+                for (Polygon poly : highestLod) {
+                    writer.write(Integer.toString(poly.getExteriorRing().getVertices().size() - 1));
+                    writer.write(' ');
+                    for (int i = 0; i < poly.getExteriorRing().getVertices().size() - 1; i++) {
+                        Vertex v = poly.getExteriorRing().getVertices().get(i);
+                        writer.write(Integer.toString(idMap.get(v)));
+                        writer.write(' ');
+                    }
+                    writer.write('\n');
+                }
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+
+        });
+    }
+
+    private void addRing(LinearRing ring, Map<Vertex, Integer> idMap, AtomicInteger counter) {
+        for (Vertex v : ring.getVertices()) {
+            idMap.computeIfAbsent(v, k -> counter.getAndIncrement());
+        }
+    }
+
+    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);
+        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);
+    }
+
+    public List<Building> getBuildings() {
+        return buildings;
+    }
+
+    public List<BridgeObject> getBridges() {
+        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;
+    }
+
+    public CityModel getCityModel() {
+        return cModel;
+    }
+
+    public List<TransportationObject> getTransportation() {
+        return roads;
+    }
+
+    public List<Tunnel> getTunnels() {
+        return tunnels;
+    }
+
+    public List<WaterObject> getWater() {
+        return water;
+    }
+
+    public List<CityObject> getLand() {
+        return land;
+    }
+
+    public List<Vegetation> getVegetation() {
+        return vegetation;
+    }
+
+    public void addWater(WaterObject wo) {
+        water.add(wo);
+    }
+
+    public void addLand(LandObject lo) {
+        land.add(lo);
+    }
+
+    public void addVegetation(Vegetation veg) {
+        vegetation.add(veg);
+    }
+
+    public void addTransportation(TransportationObject to) {
+        roads.add(to);
+    }
+
+    public void addTunnel(Tunnel tunnel) {
+        tunnels.add(tunnel);
+    }
+
+    public int getNumberOfFeatures() {
+        return buildings.size() + vegetation.size() + bridges.size() + land.size() + tunnels.size()
+                + roads.size() + water.size() + cityfurniture.size() + genericObjects.size();
+    }
+
+    public ParserConfiguration getParserConfig() {
+        return config;
+    }
+
+    public void replaceFeature(CityObject currentFeature, CityObject nextFeature) {
+        if (nextFeature instanceof Building) {
+            replaceBuilding(currentFeature, nextFeature);
+        } else if (nextFeature instanceof BridgeObject) {
+            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);
+        }
+    }
+
+    private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
+        int index = water.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
+        }
+        water.set(index, (WaterObject) nextFeature);
+    }
+
+    private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
+        int index = land.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
+        }
+        land.set(index, nextFeature);
+    }
+
+    private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
+        int index = vegetation.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
+        }
+        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) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
+        }
+        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) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
+        }
+        bridges.set(index, (BridgeObject) nextFeature);
+    }
+
+    private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
+        int index = buildings.indexOf(currentFeature);
+        if (index == -1) {
+            throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
+        }
+        buildings.set(index, (Building) nextFeature);
+    }
+
+    public void addCityObject(CityObject co) {
+        if (co instanceof Building b) {
+            buildings.add(b);
+        } else if (co instanceof BridgeObject bo) {
+            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) {
+            land.add(lo);
+        } else if (co instanceof WaterObject wo) {
+            water.add(wo);
+        } else if (co instanceof ReliefObject) {
+            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);
+        }
+    }
+
+    public void setParsedCityGMLVersion(CityGMLVersion cityGMLVersion) {
+        this.cityGMLVersion = cityGMLVersion;
+    }
+
+    public CityGMLVersion getCityGMLVersion() {
+        return cityGMLVersion;
+    }
+
+    public void addRelief(ReliefObject relief) {
+        addCityObject(relief);
+    }
+
+    public void addTin(TinObject tin) {
+        addCityObject(tin);
+    }
 }