Skip to content
GitLab
Commit 0f3d9a85 authored by Riegel's avatar Riegel
Browse files

Merge branch 'dev' into 'master' 

CityDoctor Release Version 3.16.0

See merge request !11
parents b7b8f5fe b2d40f78
master 107-opengl-view dev dev_cpp_code_conversion dev_gui_features dev_gui_features_zip_loading 3.16.0 archive/dev_gui_features_zip_loading
2 merge requests!12Synchronize Dev branch with Master,!11CityDoctor Release Version 3.16.0
Pipeline #10323 passed with stage
in 1 minute and 25 seconds
Hide whitespace changes
Inline Side-by-side
Showing
with 3380 additions and 1480 deletions
+3380 -1480
CHANGELOG.md
+ 37
- 0
View file @ 0f3d9a85
......@@ -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
+ 9
- 17
View file @ 0f3d9a85
......@@ -26,23 +26,7 @@ import java.util.Map;
import java.util.Set;
import de.hft.stuttgart.citydoctor2.check.error.DependenciesNotMetError;
import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding;
import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface;
import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject;
import de.hft.stuttgart.citydoctor2.datastructure.Building;
import de.hft.stuttgart.citydoctor2.datastructure.Installation;
import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart;
import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
import de.hft.stuttgart.citydoctor2.datastructure.LandObject;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
import de.hft.stuttgart.citydoctor2.datastructure.Opening;
import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
import de.hft.stuttgart.citydoctor2.datastructure.ReliefObject;
import de.hft.stuttgart.citydoctor2.datastructure.TinObject;
import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject;
import de.hft.stuttgart.citydoctor2.datastructure.Vegetation;
import de.hft.stuttgart.citydoctor2.datastructure.WaterObject;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
/**
......@@ -313,6 +297,14 @@ public abstract class Check {
}
public void check(CityFurniture cf){
}
public void check(GenericCityObject gco) {
}
/**
* The initialization method of this check. It will be called before any check
* method will be executed. Override this if you want to have configurable
......
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuilding.java
+ 452
- 274
View file @ 0f3d9a85
/*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
*
*
* This file is part of CityDoctor2.
*
* CityDoctor2 is free software: you can redistribute it and/or modify
......@@ -18,10 +18,13 @@
*/
package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import de.hft.stuttgart.citydoctor2.check.Check;
import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.CheckId;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
......@@ -31,281 +34,456 @@ import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.primitives.Solid;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import de.hft.stuttgart.citydoctor2.check.Check;
import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.CheckId;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
/**
* Container for attributes of an abstract building. It can be a Building or
* BuildingPart.
*
* @author Matthias Betz
*
* @author Matthias Betz
*/
public abstract class AbstractBuilding extends CityObject {
@Serial
private static final long serialVersionUID = -2196414503088741206L;
private static final Logger logger = LogManager.getLogger(AbstractBuilding.class);
private final List<Installation> buildingInstallations = new ArrayList<>(2);
private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
private org.citygml4j.core.model.building.AbstractBuilding ab;
/**
* Getter for all boundary surfaces contained in this building.
*
* @return the boundary surfaces
*/
public List<BoundarySurface> getBoundarySurfaces() {
return boundarySurfaceList;
}
@Override
public org.citygml4j.core.model.building.AbstractBuilding getGmlObject() {
return ab;
}
@Override
public FeatureType getFeatureType() {
return FeatureType.BUILDING;
}
@Override
public void unsetGmlGeometries() {
ab.setLod1Solid(null);
ab.setLod2Solid(null);
ab.setLod3Solid(null);
ab.setLod2MultiSurface(null);
ab.setLod3MultiSurface(null);
ab.getDeprecatedProperties().setLod1MultiSurface(null);
ab.getDeprecatedProperties().setLod4MultiSurface(null);
ab.getDeprecatedProperties().setLod4Solid(null);
for (BoundarySurface bs : boundarySurfaceList) {
bs.unsetGmlGeometries();
}
for (Installation bi : buildingInstallations) {
bi.unsetGmlGeometries();
}
}
@Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
for (Geometry geom : getGeometries()) {
if (geom.getType() == GeometryType.MULTI_SURFACE) {
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
setMultiSurfaceAccordingToLod(geom, ms);
} else {
Solid solid = CityGmlUtils.createSolid(geom, factory, config);
setSolidAccordingToLod(geom, solid);
}
}
for (BoundarySurface bs : boundarySurfaceList) {
reCreateBoundarySurface(factory, config, bs);
}
for (Installation bi : buildingInstallations) {
bi.reCreateGeometries(factory, config);
}
}
private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
if (bs.getGeometries().isEmpty()) {
for (AbstractSpaceBoundaryProperty bsp : ab.getBoundaries()) {
if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
ab.getBoundaries().remove(bsp);
break;
}
}
return;
}
bs.reCreateGeometries(factory, config);
}
private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
switch (geom.getLod()) {
case LOD0:
ab.setLod0MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD1:
ab.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD2:
ab.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD3:
ab.setLod3MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD4:
ab.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
}
}
private void setSolidAccordingToLod(Geometry geom, Solid solid) {
switch (geom.getLod()) {
case LOD1:
ab.setLod1Solid(new SolidProperty(solid));
break;
case LOD2:
ab.setLod2Solid(new SolidProperty(solid));
break;
case LOD3:
ab.setLod3Solid(new SolidProperty(solid));
break;
case LOD4:
ab.getDeprecatedProperties().setLod4Solid(new SolidProperty(solid));
break;
default:
throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
}
}
@Override
public void accept(Check c) {
super.accept(c);
if (c.canExecute(this)) {
c.check(this);
}
for (Installation bi : buildingInstallations) {
bi.accept(c);
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.accept(c);
}
}
@Override
public void collectContainedErrors(List<CheckError> errors) {
super.collectContainedErrors(errors);
for (Installation bi : buildingInstallations) {
bi.collectContainedErrors(errors);
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.collectContainedErrors(errors);
}
}
@Override
public void clearAllContainedCheckResults() {
super.clearAllContainedCheckResults();
for (Installation bi : buildingInstallations) {
bi.clearAllContainedCheckResults();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.clearAllContainedCheckResults();
}
}
@Override
public boolean containsError(CheckId checkIdentifier) {
boolean hasError = super.containsError(checkIdentifier);
if (hasError) {
return true;
}
for (Installation bi : buildingInstallations) {
if (bi.containsError(checkIdentifier)) {
return true;
}
}
for (BoundarySurface bs : boundarySurfaceList) {
if (bs.containsError(checkIdentifier)) {
return true;
}
}
return false;
}
@Override
public boolean containsAnyError() {
boolean hasError = super.containsAnyError();
if (hasError) {
return true;
}
for (Installation bi : buildingInstallations) {
if (bi.containsAnyError()) {
return true;
}
}
for (BoundarySurface bs : boundarySurfaceList) {
if (bs.containsAnyError()) {
return true;
}
}
return false;
}
void setCityGmlBuilding(org.citygml4j.core.model.building.AbstractBuilding ab) {
this.ab = ab;
}
public void addBoundarySurface(BoundarySurface bs) {
boundarySurfaceList.add(bs);
bs.setParent(this);
}
public void addBuildingInstallation(Installation coBi) {
buildingInstallations.add(coBi);
coBi.setParent(this);
}
public void setGmlObject(org.citygml4j.core.model.building.AbstractBuilding ab) {
this.ab = ab;
}
public List<Installation> getBuildingInstallations() {
return buildingInstallations;
}
@Override
public void prepareForChecking() {
super.prepareForChecking();
for (Installation bi : buildingInstallations) {
bi.prepareForChecking();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.prepareForChecking();
}
}
@Override
public void clearMetaInformation() {
super.clearMetaInformation();
for (Installation bi : buildingInstallations) {
bi.clearMetaInformation();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.clearMetaInformation();
}
}
@Override
public void collectInstances(CopyHandler handler) {
super.collectInstances(handler);
handler.addInstance(boundarySurfaceList);
handler.addInstance(buildingInstallations);
}
@Override
public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler);
AbstractBuilding originalAb = (AbstractBuilding) original;
for (BoundarySurface originalBs : originalAb.boundarySurfaceList) {
boundarySurfaceList.add(handler.getCopyInstance(originalBs));
}
for (Installation originalBi : originalAb.buildingInstallations) {
buildingInstallations.add(handler.getCopyInstance(originalBi));
}
ab = originalAb.ab;
}
@Serial
private static final long serialVersionUID = -2196414503088741206L;
private static final Logger logger = LogManager.getLogger(AbstractBuilding.class);
private final List<Installation> buildingInstallations = new ArrayList<>(2);
private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
private final List<BuildingRoom> buildingRooms = new ArrayList<>();
private final List<Storey> buildingStoreys = new ArrayList<>();
private final List<BuildingUnit> buildingUnits = new ArrayList<>();
private final List<BuildingRoomFurniture> buildingRoomFurnitureList = new ArrayList<>();
private org.citygml4j.core.model.building.AbstractBuilding ab;
/**
* Getter for all boundary surfaces contained in this building.
*
* @return the boundary surfaces
*/
public List<BoundarySurface> getBoundarySurfaces() {
return boundarySurfaceList;
}
@Override
public org.citygml4j.core.model.building.AbstractBuilding getGmlObject() {
return ab;
}
@Override
public FeatureType getFeatureType() {
return FeatureType.BUILDING;
}
@Override
public void unsetGmlGeometries() {
ab.setLod1Solid(null);
ab.setLod2Solid(null);
ab.setLod3Solid(null);
ab.setLod2MultiSurface(null);
ab.setLod3MultiSurface(null);
ab.getDeprecatedProperties().setLod1MultiSurface(null);
ab.getDeprecatedProperties().setLod4MultiSurface(null);
ab.getDeprecatedProperties().setLod4Solid(null);
for (BoundarySurface bs : boundarySurfaceList) {
bs.unsetGmlGeometries();
}
for (Installation bi : buildingInstallations) {
bi.unsetGmlGeometries();
}
for (BuildingRoom br : buildingRooms) {
br.unsetGmlGeometries();
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.unsetGmlGeometries();
}
for (Storey storey : buildingStoreys) {
storey.unsetGmlGeometries();
}
for (BuildingUnit bu : buildingUnits) {
bu.unsetGmlGeometries();
}
}
@Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
for (Geometry geom : getGeometries()) {
if (geom instanceof ImplicitGeometryHolder) {
continue;
}
if (geom.getType() == GeometryType.MULTI_SURFACE) {
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
setMultiSurfaceAccordingToLod(geom, ms);
} else {
Solid solid = CityGmlUtils.createSolid(geom, factory, config);
setSolidAccordingToLod(geom, solid);
}
}
for (BoundarySurface bs : boundarySurfaceList) {
reCreateBoundarySurface(factory, config, bs);
}
for (Installation bi : buildingInstallations) {
bi.reCreateGeometries(factory, config);
}
for (BuildingRoom br : buildingRooms) {
br.reCreateGeometries(factory, config);
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.reCreateGeometries(factory, config);
}
for (Storey storey : buildingStoreys) {
storey.reCreateGeometries(factory, config);
}
for (BuildingUnit bu : buildingUnits) {
bu.reCreateGeometries(factory, config);
}
}
private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
if (bs.getGeometries().isEmpty()) {
for (AbstractSpaceBoundaryProperty bsp : ab.getBoundaries()) {
if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
logger.warn("Found empty boundary surface: {}, removing from building", bs.getGmlId());
ab.getBoundaries().remove(bsp);
break;
}
}
return;
}
bs.reCreateGeometries(factory, config);
}
private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
switch (geom.getLod()) {
case LOD0:
ab.setLod0MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD1:
ab.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD2:
ab.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD3:
ab.setLod3MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD4:
ab.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
}
}
private void setSolidAccordingToLod(Geometry geom, Solid solid) {
switch (geom.getLod()) {
case LOD1:
ab.setLod1Solid(new SolidProperty(solid));
break;
case LOD2:
ab.setLod2Solid(new SolidProperty(solid));
break;
case LOD3:
ab.setLod3Solid(new SolidProperty(solid));
break;
case LOD4:
ab.getDeprecatedProperties().setLod4Solid(new SolidProperty(solid));
break;
default:
throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
}
}
@Override
public void accept(Check c) {
super.accept(c);
if (c.canExecute(this)) {
c.check(this);
}
for (Installation bi : buildingInstallations) {
bi.accept(c);
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.accept(c);
}
for (BuildingRoom br : buildingRooms) {
br.accept(c);
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.accept(c);
}
for (Storey storey : buildingStoreys) {
storey.accept(c);
}
for (BuildingUnit bu : buildingUnits) {
bu.accept(c);
}
}
@Override
public void collectContainedErrors(List<CheckError> errors) {
super.collectContainedErrors(errors);
for (Installation bi : buildingInstallations) {
bi.collectContainedErrors(errors);
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.collectContainedErrors(errors);
}
for (BuildingRoom br : buildingRooms) {
br.collectContainedErrors(errors);
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.collectContainedErrors(errors);
}
for (Storey storey : buildingStoreys) {
storey.collectContainedErrors(errors);
}
for (BuildingUnit bu : buildingUnits) {
bu.collectContainedErrors(errors);
}
}
@Override
public void clearAllContainedCheckResults() {
super.clearAllContainedCheckResults();
for (Installation bi : buildingInstallations) {
bi.clearAllContainedCheckResults();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.clearAllContainedCheckResults();
}
for (BuildingRoom br : buildingRooms) {
br.clearAllContainedCheckResults();
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.clearAllContainedCheckResults();
}
for (Storey storey : buildingStoreys) {
storey.clearAllContainedCheckResults();
}
for (BuildingUnit bu : buildingUnits) {
bu.clearAllContainedCheckResults();
}
}
@Override
public boolean containsError(CheckId checkIdentifier) {
boolean hasError = super.containsError(checkIdentifier);
if (hasError) {
return true;
}
for (Installation bi : buildingInstallations) {
if (bi.containsError(checkIdentifier)) {
return true;
}
}
for (BoundarySurface bs : boundarySurfaceList) {
if (bs.containsError(checkIdentifier)) {
return true;
}
}
for (BuildingRoom br : buildingRooms) {
if (br.containsError(checkIdentifier)) {
return true;
}
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
if (bfr.containsError(checkIdentifier)) {
return true;
}
}
for (Storey storey : buildingStoreys) {
if (storey.containsError(checkIdentifier)) {
return true;
}
}
for (BuildingUnit bu : buildingUnits) {
if (bu.containsError(checkIdentifier)) {
return true;
}
}
return false;
}
@Override
public boolean containsAnyError() {
boolean hasError = super.containsAnyError();
if (hasError) {
return true;
}
for (Installation bi : buildingInstallations) {
if (bi.containsAnyError()) {
return true;
}
}
for (BoundarySurface bs : boundarySurfaceList) {
if (bs.containsAnyError()) {
return true;
}
}
for (BuildingRoom br : buildingRooms) {
if (br.containsAnyError()) {
return true;
}
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
if (bfr.containsAnyError()) {
return true;
}
}
for (Storey storey : buildingStoreys) {
if (storey.containsAnyError()) {
return true;
}
}
for (BuildingUnit bu : buildingUnits) {
if (bu.containsAnyError()) {
return true;
}
}
return false;
}
void setCityGmlBuilding(org.citygml4j.core.model.building.AbstractBuilding ab) {
this.ab = ab;
}
public void addBoundarySurface(BoundarySurface bs) {
boundarySurfaceList.add(bs);
bs.setParent(this);
}
public void addBuildingInstallation(Installation coBi) {
buildingInstallations.add(coBi);
coBi.setParent(this);
}
public void addBuildingRoom(BuildingRoom room) {
buildingRooms.add(room);
room.setParent(this);
}
public void addBuildingRoomFurniture(BuildingRoomFurniture roomFurniture) {
buildingRoomFurnitureList.add(roomFurniture);
roomFurniture.setParent(this);
}
public void addStorey(Storey storey) {
buildingStoreys.add(storey);
}
public void addBuildingUnit(BuildingUnit buildingUnit) {
buildingUnits.add(buildingUnit);
}
public void setGmlObject(org.citygml4j.core.model.building.AbstractBuilding ab) {
this.ab = ab;
}
public List<Installation> getBuildingInstallations() {
return buildingInstallations;
}
public List<BuildingRoom> getBuildingRooms() {
return buildingRooms;
}
public List<BuildingRoomFurniture> getBuildingRoomFurnitureList() {
return buildingRoomFurnitureList;
}
public List<Storey> getBuildingStoreys() {
return buildingStoreys;
}
public List<BuildingUnit> getBuildingUnits() {
return buildingUnits;
}
@Override
public void prepareForChecking() {
super.prepareForChecking();
for (Installation bi : buildingInstallations) {
bi.prepareForChecking();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.prepareForChecking();
}
for (BuildingRoom br : buildingRooms) {
br.prepareForChecking();
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.prepareForChecking();
}
for (Storey storey : buildingStoreys) {
storey.prepareForChecking();
}
for (BuildingUnit bu : buildingUnits) {
bu.prepareForChecking();
}
}
@Override
public void clearMetaInformation() {
super.clearMetaInformation();
for (Installation bi : buildingInstallations) {
bi.clearMetaInformation();
}
for (BoundarySurface bs : boundarySurfaceList) {
bs.clearMetaInformation();
}
for (BuildingRoom br : buildingRooms) {
br.clearMetaInformation();
}
for (BuildingRoomFurniture bfr : buildingRoomFurnitureList) {
bfr.clearMetaInformation();
}
for (Storey storey : buildingStoreys) {
storey.clearMetaInformation();
}
for (BuildingUnit bu : buildingUnits) {
bu.clearMetaInformation();
}
}
@Override
public void collectInstances(CopyHandler handler) {
super.collectInstances(handler);
handler.addInstance(boundarySurfaceList);
handler.addInstance(buildingInstallations);
handler.addInstance(buildingRooms);
handler.addInstance(buildingRoomFurnitureList);
handler.addInstance(buildingStoreys);
handler.addInstance(buildingUnits);
}
@Override
public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler);
AbstractBuilding originalAb = (AbstractBuilding) original;
for (BoundarySurface originalBs : originalAb.boundarySurfaceList) {
boundarySurfaceList.add(handler.getCopyInstance(originalBs));
}
for (Installation originalBi : originalAb.buildingInstallations) {
buildingInstallations.add(handler.getCopyInstance(originalBi));
}
for (BuildingRoom originalBr : originalAb.buildingRooms) {
buildingRooms.add(handler.getCopyInstance(originalBr));
}
for (BuildingRoomFurniture originalBFR : originalAb.buildingRoomFurnitureList) {
buildingRoomFurnitureList.add(handler.getCopyInstance(originalBFR));
}
for (Storey originalBStoreys : originalAb.buildingStoreys) {
buildingStoreys.add(handler.getCopyInstance(originalBStoreys));
}
for (BuildingUnit originalBun : originalAb.buildingUnits) {
buildingUnits.add(handler.getCopyInstance(originalBun));
}
ab = originalAb.ab;
}
}
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.java 0 → 100644
+ 368
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 200
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 258
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 464
- 0
View file @ 0f3d9a85
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
+ 252
- 251
View file @ 0f3d9a85
/*-
* 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
+ 3
- 4
View file @ 0f3d9a85
/*-
* 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
+ 134
- 135
View file @ 0f3d9a85
/*-
* 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
+ 244
- 242
View file @ 0f3d9a85
/*-
* 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
+ 54
- 0
View file @ 0f3d9a85
......@@ -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 0 → 100644
+ 50
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 21
- 0
View file @ 0f3d9a85
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
+ 144
- 145
View file @ 0f3d9a85
/*-
* 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
+ 44
- 44
View file @ 0f3d9a85
/*-
* 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 0 → 100644
+ 63
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 24
- 0
View file @ 0f3d9a85
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 0 → 100644
+ 129
- 0
View file @ 0f3d9a85
package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.check.Check;
import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.CheckId;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import org.citygml4j.core.util.geometry.GeometryFactory;
import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
public class BuildingUnit extends AbstractBuildingSubdivision {
@Serial
private static final long serialVersionUID = -2931788311665810322L;
private final List<Storey> storeys = new ArrayList<>();
@Override
public Copyable createCopyInstance() {
return new BuildingUnit();
}
@Override
public void unsetGmlGeometries() {
super.unsetGmlGeometries();
for (Storey storey : storeys) {
storey.unsetGmlGeometries();
}
}
@Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
super.reCreateGeometries(factory, config);
for (Storey storey : storeys) {
storey.reCreateGeometries(factory, config);
}
}
@Override
public void accept(Check c) {
super.accept(c);
for (Storey storey : storeys) {
storey.accept(c);
}
}
@Override
public void collectContainedErrors(List<CheckError> errors) {
super.collectContainedErrors(errors);
for (Storey storey : storeys) {
storey.collectContainedErrors(errors);
}
}
@Override
public void clearAllContainedCheckResults() {
super.clearAllContainedCheckResults();
for (Storey storey : storeys) {
storey.clearAllContainedCheckResults();
}
}
@Override
public boolean containsError(CheckId checkIdentifier) {
boolean hasError = super.containsError(checkIdentifier);
if (hasError) {
return true;
}
for (Storey storey : storeys) {
if (storey.containsError(checkIdentifier)) {
return true;
}
}
return false;
}
@Override
public boolean containsAnyError() {
boolean hasError = super.containsAnyError();
if (hasError) {
return true;
}
for (Storey storey : storeys) {
if (storey.containsAnyError()) {
return true;
}
}
return false;
}
@Override
public void prepareForChecking() {
super.prepareForChecking();
for (Storey storey : storeys) {
storey.prepareForChecking();
}
}
@Override
public void clearMetaInformation() {
super.clearMetaInformation();
for (Storey storey : storeys) {
storey.clearMetaInformation();
}
}
@Override
public void collectInstances(CopyHandler handler) {
super.collectInstances(handler);
for (Storey storey : storeys) {
storey.collectInstances(handler);
}
}
@Override
public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler);
BuildingUnit originalBu = (BuildingUnit) original;
for (Storey storey : originalBu.storeys) {
storeys.add(handler.getCopyInstance(storey));
}
this.abs = originalBu.abs;
}
}
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java
+ 430
- 368
View file @ 0f3d9a85
/*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
*
*
* This file is part of CityDoctor2.
*
* CityDoctor2 is free software: you can redistribute it and/or modify
......@@ -18,24 +18,6 @@
*/
package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;
import org.citygml4j.core.model.CityGMLVersion;
import org.citygml4j.core.model.core.CityModel;
import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
import de.hft.stuttgart.citydoctor2.check.Check;
import de.hft.stuttgart.citydoctor2.check.CheckError;
......@@ -43,361 +25,441 @@ import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.writer.CityGMLWriterUtils;
import de.hft.stuttgart.quality.model.types.ValidationPlan;
import org.citygml4j.core.model.CityGMLVersion;
import org.citygml4j.core.model.core.CityModel;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;
/**
* The complete CityGML model containing all features that are used in
* CityDoctor
*
* @author Matthias Betz
*
* @author Matthias Betz
*/
public class CityDoctorModel {
private static final String COULD_NOT_FIND_FEATURE = "Could not find feature: ";
private final List<Building> buildings;
private final List<Vegetation> vegetation;
private final List<BridgeObject> bridges;
private final List<CityObject> land;
private final List<TransportationObject> roads;
private final List<WaterObject> water;
private CityModel cModel;
private final ParserConfiguration config;
private final String fileName;
private final File file;
private final List<CheckError> globalErrors;
private boolean isValidated = false;
private ValidationPlan plan;
private CityGMLVersion cityGMLVersion;
public CityDoctorModel(ParserConfiguration config, File file) {
if (config == null) {
throw new IllegalArgumentException("Parser configuration may not be null");
}
this.fileName = file.getName();
this.config = config;
this.file = file;
buildings = new ArrayList<>();
vegetation = new ArrayList<>();
bridges = new ArrayList<>();
land = new ArrayList<>();
roads = new ArrayList<>();
water = new ArrayList<>();
globalErrors = new ArrayList<>();
}
public boolean isValidated() {
return isValidated;
}
public void setValidated(ValidationPlan plan) {
if (plan == null) {
this.plan = null;
this.isValidated = false;
return;
}
this.plan = plan;
this.isValidated = true;
}
public ValidationPlan getValidationPlan() {
return plan;
}
public void addGlobalError(CheckError err) {
globalErrors.add(err);
}
public void addGlobalErrors(List<? extends CheckError> generalErrors) {
globalErrors.addAll(generalErrors);
}
public List<CheckError> getGlobalErrors() {
return globalErrors;
}
public File getFile() {
return file;
}
public Stream<CityObject> createFeatureStream() {
return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
water.stream()).flatMap(co -> co);
}
public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
if (file.endsWith(".off")) {
exportAsOff(file);
} else {
ValidationPlan tempPlan = plan;
if (!saveQualityAde) {
setValidated(null);
}
exportAsGML(file);
if (!saveQualityAde) {
setValidated(tempPlan);
}
}
}
private void exportAsGML(String file) throws CityDoctorWriteException {
CityGMLWriterUtils.writeCityModel(file, this);
}
private void exportAsOff(String file) {
file = file.substring(0, file.lastIndexOf('.'));
File folder = new File(file);
folder.mkdirs();
createFeatureStream().forEach(co -> {
Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
Check c = new AbstractCheck() {
@Override
public void check(Geometry geom) {
polygonMap.compute(geom.getLod(), (lod, polys) -> {
if (polys == null) {
polys = new HashSet<>();
}
for (Polygon poly : geom.getPolygons()) {
polys.add(poly.getOriginal());
}
return polys;
});
}
};
co.accept(c);
Set<Polygon> highestLod = polygonMap.get(Lod.LOD2);
if (highestLod == null) {
highestLod = polygonMap.get(Lod.LOD1);
}
if (highestLod == null) {
return;
}
Map<Vertex, Integer> idMap = new LinkedHashMap<>();
AtomicInteger counter = new AtomicInteger(0);
for (Polygon poly : highestLod) {
addRing(poly.getExteriorRing(), idMap, counter);
}
try (BufferedWriter writer = Files.newBufferedWriter(folder.toPath().resolve(co.getGmlId() + ".off"))) {
writer.write("OFF\n");
writer.write(Integer.toString(idMap.size()));
writer.write(' ');
writer.write(Integer.toString(highestLod.size()));
writer.write(" 0\n");
for (Vertex v : idMap.keySet()) {
writer.write(Double.toString(v.getX()));
writer.write(' ');
writer.write(Double.toString(v.getY()));
writer.write(' ');
writer.write(Double.toString(v.getZ()));
writer.write('\n');
}
for (Polygon poly : highestLod) {
writer.write(Integer.toString(poly.getExteriorRing().getVertices().size() - 1));
writer.write(' ');
for (int i = 0; i < poly.getExteriorRing().getVertices().size() - 1; i++) {
Vertex v = poly.getExteriorRing().getVertices().get(i);
writer.write(Integer.toString(idMap.get(v)));
writer.write(' ');
}
writer.write('\n');
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
});
}
private void addRing(LinearRing ring, Map<Vertex, Integer> idMap, AtomicInteger counter) {
for (Vertex v : ring.getVertices()) {
idMap.computeIfAbsent(v, k -> counter.getAndIncrement());
}
}
public Set<CheckError> collectErrors() {
List<CheckError> errors = new ArrayList<>();
collectErrorsFromList(errors, buildings);
collectErrorsFromList(errors, vegetation);
collectErrorsFromList(errors, bridges);
collectErrorsFromList(errors, land);
collectErrorsFromList(errors, roads);
collectErrorsFromList(errors, water);
return new HashSet<>(errors);
}
private void collectErrorsFromList(List<CheckError> errors, List<? extends CityObject> cos) {
for (CityObject co : cos) {
co.collectContainedErrors(errors);
}
}
public String getFileName() {
return fileName;
}
public void addBridge(BridgeObject coBridge) {
bridges.add(coBridge);
}
public void addBuilding(Building coBuilding) {
buildings.add(coBuilding);
}
public List<Building> getBuildings() {
return buildings;
}
public List<BridgeObject> getBridges() {
return bridges;
}
public void setCityModel(CityModel cModel) {
this.cModel = cModel;
}
public CityModel getCityModel() {
return cModel;
}
public List<TransportationObject> getTransportation() {
return roads;
}
public List<WaterObject> getWater() {
return water;
}
public List<CityObject> getLand() {
return land;
}
public List<Vegetation> getVegetation() {
return vegetation;
}
public void addWater(WaterObject wo) {
water.add(wo);
}
public void addLand(LandObject lo) {
land.add(lo);
}
public void addVegetation(Vegetation veg) {
vegetation.add(veg);
}
public void addTransportation(TransportationObject to) {
roads.add(to);
}
public int getNumberOfFeatures() {
return buildings.size() + vegetation.size() + bridges.size() + land.size() + roads.size() + water.size();
}
public ParserConfiguration getParserConfig() {
return config;
}
public void replaceFeature(CityObject currentFeature, CityObject nextFeature) {
if (nextFeature instanceof Building) {
replaceBuilding(currentFeature, nextFeature);
} else if (nextFeature instanceof BridgeObject) {
replaceBridge(currentFeature, nextFeature);
} else if (nextFeature instanceof TransportationObject) {
replaceTransportationObject(currentFeature, nextFeature);
} else if (nextFeature instanceof Vegetation) {
replaceVegetation(currentFeature, nextFeature);
} else if (nextFeature instanceof LandObject) {
replaceLandObject(currentFeature, nextFeature);
} else if (nextFeature instanceof WaterObject) {
replaceWaterObject(currentFeature, nextFeature);
}
}
private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
int index = water.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
}
water.set(index, (WaterObject) nextFeature);
}
private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
int index = land.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
}
land.set(index, nextFeature);
}
private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
int index = vegetation.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
}
vegetation.set(index, (Vegetation) nextFeature);
}
private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
int index = roads.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
}
roads.set(index, (TransportationObject) nextFeature);
}
private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
int index = bridges.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
}
bridges.set(index, (BridgeObject) nextFeature);
}
private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
int index = buildings.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
}
buildings.set(index, (Building) nextFeature);
}
public void addCityObject(CityObject co) {
if (co instanceof Building b) {
buildings.add(b);
} else if (co instanceof BridgeObject bo) {
bridges.add(bo);
} else if (co instanceof TransportationObject to) {
roads.add(to);
} else if (co instanceof Vegetation veg) {
vegetation.add(veg);
} else if (co instanceof LandObject lo) {
land.add(lo);
} else if (co instanceof WaterObject wo) {
water.add(wo);
} else if (co instanceof ReliefObject) {
land.add(co);
} else if (co instanceof TinObject) {
land.add(co);
}
}
public void setParsedCityGMLVersion(CityGMLVersion cityGMLVersion) {
this.cityGMLVersion = cityGMLVersion;
}
public CityGMLVersion getCityGMLVersion() {
return cityGMLVersion;
}
public void addRelief(ReliefObject relief) {
addCityObject(relief);
}
public void addTin(TinObject tin) {
addCityObject(tin);
}
private static final String COULD_NOT_FIND_FEATURE = "Could not find feature: ";
private final List<Building> buildings;
private final List<Vegetation> vegetation;
private final List<BridgeObject> bridges;
private final List<CityFurniture> cityfurniture;
private final List<GenericCityObject> genericObjects;
private final List<CityObject> land;
private final List<TransportationObject> roads;
private final List<Tunnel> tunnels;
private final List<WaterObject> water;
private CityModel cModel;
private final ParserConfiguration config;
private final String fileName;
private final File file;
private final List<CheckError> globalErrors;
private boolean isValidated = false;
private ValidationPlan plan;
private CityGMLVersion cityGMLVersion;
public CityDoctorModel(ParserConfiguration config, File file) {
if (config == null) {
throw new IllegalArgumentException("Parser configuration may not be null");
}
this.fileName = file.getName();
this.config = config;
this.file = file;
buildings = new ArrayList<>();
vegetation = new ArrayList<>();
bridges = new ArrayList<>();
land = new ArrayList<>();
roads = new ArrayList<>();
tunnels = new ArrayList<>();
water = new ArrayList<>();
cityfurniture = new ArrayList<>();
genericObjects = new ArrayList<>();
globalErrors = new ArrayList<>();
}
public boolean isValidated() {
return isValidated;
}
public void setValidated(ValidationPlan plan) {
if (plan == null) {
this.plan = null;
this.isValidated = false;
return;
}
this.plan = plan;
this.isValidated = true;
}
public ValidationPlan getValidationPlan() {
return plan;
}
public void addGlobalError(CheckError err) {
globalErrors.add(err);
}
public void addGlobalErrors(List<? extends CheckError> generalErrors) {
globalErrors.addAll(generalErrors);
}
public List<CheckError> getGlobalErrors() {
return globalErrors;
}
public File getFile() {
return file;
}
public Stream<CityObject> createFeatureStream() {
return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
tunnels.stream(), water.stream(), cityfurniture.stream(), genericObjects.stream()).flatMap(co -> co);
}
public void saveAs(String file, boolean saveQualityAde) throws CityDoctorWriteException {
if (file.endsWith(".off")) {
exportAsOff(file);
} else {
ValidationPlan tempPlan = plan;
if (!saveQualityAde) {
setValidated(null);
}
exportAsGML(file);
if (!saveQualityAde) {
setValidated(tempPlan);
}
}
}
private void exportAsGML(String file) throws CityDoctorWriteException {
CityGMLWriterUtils.writeCityModel(file, this);
}
private void exportAsOff(String file) {
file = file.substring(0, file.lastIndexOf('.'));
File folder = new File(file);
folder.mkdirs();
createFeatureStream().forEach(co -> {
Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
Check c = new AbstractCheck() {
@Override
public void check(Geometry geom) {
polygonMap.compute(geom.getLod(), (lod, polys) -> {
if (polys == null) {
polys = new HashSet<>();
}
for (Polygon poly : geom.getPolygons()) {
polys.add(poly.getOriginal());
}
return polys;
});
}
};
co.accept(c);
Set<Polygon> highestLod = polygonMap.get(Lod.LOD2);
if (highestLod == null) {
highestLod = polygonMap.get(Lod.LOD1);
}
if (highestLod == null) {
return;
}
Map<Vertex, Integer> idMap = new LinkedHashMap<>();
AtomicInteger counter = new AtomicInteger(0);
for (Polygon poly : highestLod) {
addRing(poly.getExteriorRing(), idMap, counter);
}
try (BufferedWriter writer = Files.newBufferedWriter(folder.toPath().resolve(co.getGmlId() + ".off"))) {
writer.write("OFF\n");
writer.write(Integer.toString(idMap.size()));
writer.write(' ');
writer.write(Integer.toString(highestLod.size()));
writer.write(" 0\n");
for (Vertex v : idMap.keySet()) {
writer.write(Double.toString(v.getX()));
writer.write(' ');
writer.write(Double.toString(v.getY()));
writer.write(' ');
writer.write(Double.toString(v.getZ()));
writer.write('\n');
}
for (Polygon poly : highestLod) {
writer.write(Integer.toString(poly.getExteriorRing().getVertices().size() - 1));
writer.write(' ');
for (int i = 0; i < poly.getExteriorRing().getVertices().size() - 1; i++) {
Vertex v = poly.getExteriorRing().getVertices().get(i);
writer.write(Integer.toString(idMap.get(v)));
writer.write(' ');
}
writer.write('\n');
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
});
}
private void addRing(LinearRing ring, Map<Vertex, Integer> idMap, AtomicInteger counter) {
for (Vertex v : ring.getVertices()) {
idMap.computeIfAbsent(v, k -> counter.getAndIncrement());
}
}
public Set<CheckError> collectErrors() {
List<CheckError> errors = new ArrayList<>();
collectErrorsFromList(errors, buildings);
collectErrorsFromList(errors, vegetation);
collectErrorsFromList(errors, bridges);
collectErrorsFromList(errors, land);
collectErrorsFromList(errors, roads);
collectErrorsFromList(errors, tunnels);
collectErrorsFromList(errors, water);
collectErrorsFromList(errors, cityfurniture);
collectErrorsFromList(errors, genericObjects);
return new HashSet<>(errors);
}
private void collectErrorsFromList(List<CheckError> errors, List<? extends CityObject> cos) {
for (CityObject co : cos) {
co.collectContainedErrors(errors);
}
}
public String getFileName() {
return fileName;
}
public void addBridge(BridgeObject coBridge) {
bridges.add(coBridge);
}
public void addBuilding(Building coBuilding) {
buildings.add(coBuilding);
}
public List<Building> getBuildings() {
return buildings;
}
public List<BridgeObject> getBridges() {
return bridges;
}
public List<CityFurniture> getCityFurniture() {
return cityfurniture;
}
public void addCityFurniture(CityFurniture coFurniture) {
cityfurniture.add(coFurniture);
}
public List<GenericCityObject> getGenericCityObjects() {
return genericObjects;
}
public void addGenericCityObject(GenericCityObject coGenericCityObject) {
genericObjects.add(coGenericCityObject);
}
public void setCityModel(CityModel cModel) {
this.cModel = cModel;
}
public CityModel getCityModel() {
return cModel;
}
public List<TransportationObject> getTransportation() {
return roads;
}
public List<Tunnel> getTunnels() {
return tunnels;
}
public List<WaterObject> getWater() {
return water;
}
public List<CityObject> getLand() {
return land;
}
public List<Vegetation> getVegetation() {
return vegetation;
}
public void addWater(WaterObject wo) {
water.add(wo);
}
public void addLand(LandObject lo) {
land.add(lo);
}
public void addVegetation(Vegetation veg) {
vegetation.add(veg);
}
public void addTransportation(TransportationObject to) {
roads.add(to);
}
public void addTunnel(Tunnel tunnel) {
tunnels.add(tunnel);
}
public int getNumberOfFeatures() {
return buildings.size() + vegetation.size() + bridges.size() + land.size() + tunnels.size()
+ roads.size() + water.size() + cityfurniture.size() + genericObjects.size();
}
public ParserConfiguration getParserConfig() {
return config;
}
public void replaceFeature(CityObject currentFeature, CityObject nextFeature) {
if (nextFeature instanceof Building) {
replaceBuilding(currentFeature, nextFeature);
} else if (nextFeature instanceof BridgeObject) {
replaceBridge(currentFeature, nextFeature);
} else if (nextFeature instanceof TransportationObject) {
replaceTransportationObject(currentFeature, nextFeature);
} else if (nextFeature instanceof Tunnel) {
replaceTunnel(currentFeature, nextFeature);
} else if (nextFeature instanceof Vegetation) {
replaceVegetation(currentFeature, nextFeature);
} else if (nextFeature instanceof LandObject) {
replaceLandObject(currentFeature, nextFeature);
} else if (nextFeature instanceof WaterObject) {
replaceWaterObject(currentFeature, nextFeature);
} else if (nextFeature instanceof CityFurniture) {
replaceCityFurniture(currentFeature, nextFeature);
} else if (nextFeature instanceof GenericCityObject) {
replaceGenericCityObject(currentFeature, nextFeature);
}
}
private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
int index = water.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
}
water.set(index, (WaterObject) nextFeature);
}
private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
int index = land.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
}
land.set(index, nextFeature);
}
private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
int index = vegetation.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
}
vegetation.set(index, (Vegetation) nextFeature);
}
private void replaceCityFurniture(CityObject currentFeature, CityObject nextFeature) {
int index = cityfurniture.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
}
cityfurniture.set(index, (CityFurniture) nextFeature);
}
private void replaceGenericCityObject(CityObject currentFeature, CityObject nextFeature) {
int index = genericObjects.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in generic city objects");
}
genericObjects.set(index, (GenericCityObject) nextFeature);
}
private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
int index = roads.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
}
roads.set(index, (TransportationObject) nextFeature);
}
private void replaceTunnel(CityObject currentFeature, CityObject nextFeature) {
int index = tunnels.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in tunnels");
}
tunnels.set(index, (Tunnel) nextFeature);
}
private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
int index = bridges.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
}
bridges.set(index, (BridgeObject) nextFeature);
}
private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
int index = buildings.indexOf(currentFeature);
if (index == -1) {
throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
}
buildings.set(index, (Building) nextFeature);
}
public void addCityObject(CityObject co) {
if (co instanceof Building b) {
buildings.add(b);
} else if (co instanceof BridgeObject bo) {
bridges.add(bo);
} else if (co instanceof TransportationObject to) {
roads.add(to);
} else if (co instanceof Tunnel tu) {
tunnels.add(tu);
} else if (co instanceof Vegetation veg) {
vegetation.add(veg);
} else if (co instanceof LandObject lo) {
land.add(lo);
} else if (co instanceof WaterObject wo) {
water.add(wo);
} else if (co instanceof ReliefObject) {
land.add(co);
} else if (co instanceof TinObject) {
land.add(co);
} else if (co instanceof CityFurniture cf) {
cityfurniture.add(cf);
} else if (co instanceof GenericCityObject gco) {
genericObjects.add(gco);
}
}
public void setParsedCityGMLVersion(CityGMLVersion cityGMLVersion) {
this.cityGMLVersion = cityGMLVersion;
}
public CityGMLVersion getCityGMLVersion() {
return cityGMLVersion;
}
public void addRelief(ReliefObject relief) {
addCityObject(relief);
}
public void addTin(TinObject tin) {
addCityObject(tin);
}
}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

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