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/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;
+    }
+}