Skip to content
GitLab
Commit 02de0a22 authored by Riegel's avatar Riegel
Browse files

Reformat code

parent ad3589e8
Pipeline #10297 passed with stage
in 1 minute and 5 seconds
Hide whitespace changes
Inline Side-by-side
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObject.java
View file @ 02de0a22
/*- /*-
* Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,142 +18,141 @@ ...@@ -18,142 +18,141 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import org.citygml4j.core.model.relief.ReliefFeature;
import org.citygml4j.core.util.geometry.GeometryFactory;
import de.hft.stuttgart.citydoctor2.check.Check; import de.hft.stuttgart.citydoctor2.check.Check;
import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckId;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler; import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable; import de.hft.stuttgart.citydoctor2.utils.Copyable;
import org.citygml4j.core.model.relief.ReliefFeature;
import org.citygml4j.core.util.geometry.GeometryFactory;
import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
public class ReliefObject extends CityObject { public class ReliefObject extends CityObject {
@Serial @Serial
private static final long serialVersionUID = -9162169874426519903L; private static final long serialVersionUID = -9162169874426519903L;
private final ReliefFeature feature; private final ReliefFeature feature;
private final List<TinObject> components = new ArrayList<>(); private final List<TinObject> components = new ArrayList<>();
public ReliefObject(ReliefFeature feature) { public ReliefObject(ReliefFeature feature) {
this.feature = feature; this.feature = feature;
} }
@Override @Override
public void accept(Check c) { public void accept(Check c) {
super.accept(c); super.accept(c);
if (c.canExecute(this)) { if (c.canExecute(this)) {
c.check(this); c.check(this);
} }
for (TinObject tin : components) { for (TinObject tin : components) {
tin.accept(c); tin.accept(c);
} }
} }
@Override @Override
public void collectInstances(CopyHandler handler) { public void collectInstances(CopyHandler handler) {
handler.addInstance(components); handler.addInstance(components);
} }
@Override @Override
public void fillValues(Copyable original, CopyHandler handler) { public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler); super.fillValues(original, handler);
ReliefObject originalRelief = (ReliefObject) original; ReliefObject originalRelief = (ReliefObject) original;
for (TinObject tin : originalRelief.components) { for (TinObject tin : originalRelief.components) {
components.add(handler.getCopyInstance(tin)); components.add(handler.getCopyInstance(tin));
} }
} }
@Override @Override
public Copyable createCopyInstance() { public Copyable createCopyInstance() {
return new ReliefObject(feature); return new ReliefObject(feature);
} }
@Override @Override
public void prepareForChecking() { public void prepareForChecking() {
for (TinObject component : components) { for (TinObject component : components) {
component.prepareForChecking(); component.prepareForChecking();
} }
} }
@Override @Override
public void clearMetaInformation() { public void clearMetaInformation() {
for (TinObject component : components) { for (TinObject component : components) {
component.clearMetaInformation(); component.clearMetaInformation();
} }
} }
@Override @Override
public void clearAllContainedCheckResults() { public void clearAllContainedCheckResults() {
for (TinObject component : components) { for (TinObject component : components) {
component.clearAllContainedCheckResults(); component.clearAllContainedCheckResults();
} }
} }
@Override @Override
public void collectContainedErrors(List<CheckError> errors) { public void collectContainedErrors(List<CheckError> errors) {
super.collectContainedErrors(errors); super.collectContainedErrors(errors);
for (TinObject tin : components) { for (TinObject tin : components) {
tin.collectContainedErrors(errors); tin.collectContainedErrors(errors);
} }
} }
@Override @Override
public boolean containsAnyError() { public boolean containsAnyError() {
boolean containsError = super.containsAnyError(); boolean containsError = super.containsAnyError();
if (containsError) { if (containsError) {
return true; return true;
} }
for (TinObject tin : components) { for (TinObject tin : components) {
if (tin.containsAnyError()) { if (tin.containsAnyError()) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public boolean containsError(CheckId checkIdentifier) { public boolean containsError(CheckId checkIdentifier) {
boolean hasError = super.containsError(checkIdentifier); boolean hasError = super.containsError(checkIdentifier);
if (hasError) { if (hasError) {
return true; return true;
} }
for (TinObject tin : components) { for (TinObject tin : components) {
if (tin.containsError(checkIdentifier)) { if (tin.containsError(checkIdentifier)) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) { public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
// no geometries // no geometries
} }
@Override @Override
public ReliefFeature getGmlObject() { public ReliefFeature getGmlObject() {
return feature; return feature;
} }
@Override @Override
public void unsetGmlGeometries() { public void unsetGmlGeometries() {
// no geometries // no geometries
} }
@Override @Override
public FeatureType getFeatureType() { public FeatureType getFeatureType() {
return FeatureType.LAND; return FeatureType.LAND;
} }
public List<TinObject> getComponents() { public List<TinObject> getComponents() {
return components; return components;
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Storey.java
View file @ 02de0a22
...@@ -12,7 +12,7 @@ import java.io.Serial; ...@@ -12,7 +12,7 @@ import java.io.Serial;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class Storey extends AbstractBuildingSubdivision{ public class Storey extends AbstractBuildingSubdivision {
@Serial @Serial
private static final long serialVersionUID = 5162814691642668089L; private static final long serialVersionUID = 5162814691642668089L;
......
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/SurfaceFeatureType.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -20,12 +20,11 @@ package de.hft.stuttgart.citydoctor2.datastructure; ...@@ -20,12 +20,11 @@ package de.hft.stuttgart.citydoctor2.datastructure;
/** /**
* Availabel bridge types in CityGML * Availabel bridge types in CityGML
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public enum SurfaceFeatureType { public enum SurfaceFeatureType {
BUILDING, BRIDGE, TUNNEL BUILDING, BRIDGE, TUNNEL
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TinObject.java
View file @ 02de0a22
/*- /*-
* Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,10 +18,9 @@ ...@@ -18,10 +18,9 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial; import de.hft.stuttgart.citydoctor2.check.Check;
import java.util.ArrayList; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import java.util.List; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.citygml4j.core.model.relief.TINRelief; import org.citygml4j.core.model.relief.TINRelief;
...@@ -31,70 +30,70 @@ import org.xmlobjects.gml.model.geometry.primitives.Triangle; ...@@ -31,70 +30,70 @@ import org.xmlobjects.gml.model.geometry.primitives.Triangle;
import org.xmlobjects.gml.model.geometry.primitives.TriangleArrayProperty; import org.xmlobjects.gml.model.geometry.primitives.TriangleArrayProperty;
import org.xmlobjects.gml.model.geometry.primitives.TriangulatedSurface; import org.xmlobjects.gml.model.geometry.primitives.TriangulatedSurface;
import de.hft.stuttgart.citydoctor2.check.Check; import java.io.Serial;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.ArrayList;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import java.util.List;
public class TinObject extends CityObject { public class TinObject extends CityObject {
private static final Logger logger = LogManager.getLogger(TinObject.class); private static final Logger logger = LogManager.getLogger(TinObject.class);
@Serial @Serial
private static final long serialVersionUID = 1910744427384724422L; private static final long serialVersionUID = 1910744427384724422L;
private final TINRelief gmlRelief; private final TINRelief gmlRelief;
public TinObject(TINRelief gmlRelief) { public TinObject(TINRelief gmlRelief) {
this.gmlRelief = gmlRelief; this.gmlRelief = gmlRelief;
} }
@Override @Override
public void accept(Check c) { public void accept(Check c) {
super.accept(c); super.accept(c);
if (c.canExecute(this)) { if (c.canExecute(this)) {
c.check(this); c.check(this);
} }
} }
@Override @Override
public TinObject createCopyInstance() { public TinObject createCopyInstance() {
return new TinObject(gmlRelief); return new TinObject(gmlRelief);
} }
@Override @Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) { public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
if (getGeometries().isEmpty()) { if (getGeometries().isEmpty()) {
return; return;
} }
if (getGeometries().size() > 1) { if (getGeometries().size() > 1) {
logger.warn("A TINRelief can only have one geometry but found {}. Using the first geometry found", logger.warn("A TINRelief can only have one geometry but found {}. Using the first geometry found",
getGeometries().size()); getGeometries().size());
} }
Geometry geom = getGeometries().get(0); Geometry geom = getGeometries().get(0);
List<Triangle> triangles = new ArrayList<>(); List<Triangle> triangles = new ArrayList<>();
TriangulatedSurface surface = new TriangulatedSurface(); TriangulatedSurface surface = new TriangulatedSurface();
surface.setPatches(new TriangleArrayProperty(triangles)); surface.setPatches(new TriangleArrayProperty(triangles));
for (Polygon poly : geom.getPolygons()) { for (Polygon poly : geom.getPolygons()) {
LinearRing ring = poly.getExteriorRing(); LinearRing ring = poly.getExteriorRing();
Triangle t = new Triangle(); Triangle t = new Triangle();
t.setExterior(new AbstractRingProperty(CityGmlUtils.createGmlRing(factory, config, ring))); t.setExterior(new AbstractRingProperty(CityGmlUtils.createGmlRing(factory, config, ring)));
triangles.add(t); triangles.add(t);
} }
} }
@Override @Override
public TINRelief getGmlObject() { public TINRelief getGmlObject() {
return gmlRelief; return gmlRelief;
} }
@Override @Override
public void unsetGmlGeometries() { public void unsetGmlGeometries() {
gmlRelief.setTin(null); gmlRelief.setTin(null);
} }
@Override @Override
public FeatureType getFeatureType() { public FeatureType getFeatureType() {
return FeatureType.LAND; return FeatureType.LAND;
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationObject.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,10 +18,13 @@ ...@@ -18,10 +18,13 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial; import de.hft.stuttgart.citydoctor2.check.Check;
import java.util.ArrayList; import de.hft.stuttgart.citydoctor2.check.CheckError;
import java.util.List; 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.model.core.AbstractCityObject;
import org.citygml4j.core.model.core.AbstractSpace; import org.citygml4j.core.model.core.AbstractSpace;
import org.citygml4j.core.model.transportation.AbstractTransportationSpace; import org.citygml4j.core.model.transportation.AbstractTransportationSpace;
...@@ -31,302 +34,297 @@ import org.citygml4j.core.util.geometry.GeometryFactory; ...@@ -31,302 +34,297 @@ import org.citygml4j.core.util.geometry.GeometryFactory;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import de.hft.stuttgart.citydoctor2.check.Check; import java.io.Serial;
import de.hft.stuttgart.citydoctor2.check.CheckError; import java.util.ArrayList;
import de.hft.stuttgart.citydoctor2.check.CheckId; import java.util.List;
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;
/** /**
* Representation of a transportation object. * Representation of a transportation object.
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public class TransportationObject extends CityObject { public class TransportationObject extends CityObject {
@Serial @Serial
private static final long serialVersionUID = -2698907271726700390L; private static final long serialVersionUID = -2698907271726700390L;
public enum TransportationType {
ROAD, TRACK, RAILWAY, TRAFFIC_AREA, AUXILLIARY_TRAFFIC_AREA, TRANSPORTATION_COMPLEX, SQUARE, AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE
}
private AbstractCityObject ato;
private final List<TransportationObject> composesOf = new ArrayList<>(1);
private final TransportationType type;
public enum TransportationType { public TransportationObject(TransportationType type) {
ROAD, TRACK, RAILWAY, TRAFFIC_AREA, AUXILLIARY_TRAFFIC_AREA, TRANSPORTATION_COMPLEX, SQUARE, AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE this.type = type;
} }
private AbstractCityObject ato; @Override
private final List<TransportationObject> composesOf = new ArrayList<>(1); public FeatureType getFeatureType() {
private final TransportationType type; return FeatureType.TRANSPORTATION;
}
public TransportationObject(TransportationType type) { @Override
this.type = type; 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);
switch (type) {
case ROAD, TRACK, RAILWAY, SQUARE, TRANSPORTATION_COMPLEX:
AbstractTransportationSpace tc = (AbstractTransportationSpace) ato;
setMultiSurfaceAccordingToLod(tc, ms, geom.getLod());
break;
case TRAFFIC_AREA:
TrafficArea ta = (TrafficArea) ato;
setMultiSurfaceAccordingToLod(ta, ms, geom.getLod());
break;
case AUXILLIARY_TRAFFIC_AREA:
AuxiliaryTrafficArea ata = (AuxiliaryTrafficArea) ato;
setMultiSurfaceAccordingToLod(ata, ms, geom.getLod());
break;
case AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE:
AbstractSpace ats = (AbstractSpace) ato;
setMultiSurfaceAccordingToLod(ats, ms, geom.getLod());
break;
}
} else {
throw new IllegalStateException("Geometry in TransportationObject cannot be of type " + geom.getType()
+ ". Only MultiSurface allowed");
}
}
for (TransportationObject children : composesOf) {
children.reCreateGeometries(factory, config);
}
}
@Override private void setMultiSurfaceAccordingToLod(AbstractSpace ats, MultiSurface ms, Lod lod) {
public FeatureType getFeatureType() { switch (lod) {
return FeatureType.TRANSPORTATION; case LOD0:
} ats.setLod0MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD2:
ats.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break;
case LOD3:
ats.setLod3MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("cannot set geometry with LOD for AuxiliaryTrafficSpace: " + lod);
}
}
@Override private void setMultiSurfaceAccordingToLod(AbstractTransportationSpace tc, MultiSurface ms, Lod lod) {
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) { switch (lod) {
for (Geometry geom : getGeometries()) { case LOD1:
if (geom instanceof ImplicitGeometryHolder){ tc.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
continue; break;
} case LOD2:
if (geom.getType() == GeometryType.MULTI_SURFACE) { tc.setLod2MultiSurface(new MultiSurfaceProperty(ms));
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config); break;
switch (type) { case LOD3:
case ROAD, TRACK, RAILWAY, SQUARE, TRANSPORTATION_COMPLEX: tc.setLod3MultiSurface(new MultiSurfaceProperty(ms));
AbstractTransportationSpace tc = (AbstractTransportationSpace) ato; break;
setMultiSurfaceAccordingToLod(tc, ms, geom.getLod()); case LOD4:
break; tc.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
case TRAFFIC_AREA: break;
TrafficArea ta = (TrafficArea) ato; default:
setMultiSurfaceAccordingToLod(ta, ms, geom.getLod()); throw new IllegalStateException("cannot set geometry with LOD for TransportationComplex: " + lod);
break; }
case AUXILLIARY_TRAFFIC_AREA: }
AuxiliaryTrafficArea ata = (AuxiliaryTrafficArea) ato;
setMultiSurfaceAccordingToLod(ata, ms, geom.getLod());
break;
case AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE:
AbstractSpace ats = (AbstractSpace) ato;
setMultiSurfaceAccordingToLod(ats, ms, geom.getLod());
break;
}
} else {
throw new IllegalStateException("Geometry in TransportationObject cannot be of type " + geom.getType()
+ ". Only MultiSurface allowed");
}
}
for (TransportationObject children : composesOf) {
children.reCreateGeometries(factory, config);
}
}
private void setMultiSurfaceAccordingToLod(AbstractSpace ats, MultiSurface ms, Lod lod) { private void setMultiSurfaceAccordingToLod(AuxiliaryTrafficArea ata, MultiSurface ms, Lod lod) {
switch (lod) { switch (lod) {
case LOD0: case LOD0:
ats.setLod0MultiSurface(new MultiSurfaceProperty(ms)); ata.setLod0MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD2: case LOD1:
ats.setLod2MultiSurface(new MultiSurfaceProperty(ms)); ata.setLod1MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD3: case LOD2:
ats.setLod3MultiSurface(new MultiSurfaceProperty(ms)); ata.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break; break;
default: case LOD3:
throw new IllegalStateException("cannot set geometry with LOD for AuxiliaryTrafficSpace: " + lod); ata.setLod3MultiSurface(new MultiSurfaceProperty(ms));
} break;
} case LOD4:
ata.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("cannot set geometry with LOD for AuxiliaryTrafficArea: " + lod);
}
}
private void setMultiSurfaceAccordingToLod(AbstractTransportationSpace tc, MultiSurface ms, Lod lod) { private void setMultiSurfaceAccordingToLod(TrafficArea ta, MultiSurface ms, Lod lod) {
switch (lod) { switch (lod) {
case LOD1: case LOD2:
tc.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms)); ta.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD2: case LOD3:
tc.setLod2MultiSurface(new MultiSurfaceProperty(ms)); ta.setLod3MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD3: case LOD4:
tc.setLod3MultiSurface(new MultiSurfaceProperty(ms)); ta.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD4: default:
tc.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms)); throw new IllegalStateException("cannot set geometry with LOD for TrafficArea: " + lod);
break; }
default: }
throw new IllegalStateException("cannot set geometry with LOD for TransportationComplex: " + lod);
}
}
private void setMultiSurfaceAccordingToLod(AuxiliaryTrafficArea ata, MultiSurface ms, Lod lod) { @Override
switch (lod) { public boolean containsError(CheckId checkIdentifier) {
case LOD0: boolean hasError = super.containsError(checkIdentifier);
ata.setLod0MultiSurface(new MultiSurfaceProperty(ms)); if (hasError) {
break; return true;
case LOD1: }
ata.setLod1MultiSurface(new MultiSurfaceProperty(ms)); for (TransportationObject to : composesOf) {
break; if (to.containsError(checkIdentifier)) {
case LOD2: return true;
ata.setLod2MultiSurface(new MultiSurfaceProperty(ms)); }
break; }
case LOD3: return false;
ata.setLod3MultiSurface(new MultiSurfaceProperty(ms)); }
break;
case LOD4:
ata.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("cannot set geometry with LOD for AuxiliaryTrafficArea: " + lod);
}
}
private void setMultiSurfaceAccordingToLod(TrafficArea ta, MultiSurface ms, Lod lod) { @Override
switch (lod) { public void clearAllContainedCheckResults() {
case LOD2: super.clearAllContainedCheckResults();
ta.setLod2MultiSurface(new MultiSurfaceProperty(ms)); for (TransportationObject to : composesOf) {
break; to.clearAllContainedCheckResults();
case LOD3: }
ta.setLod3MultiSurface(new MultiSurfaceProperty(ms)); }
break;
case LOD4:
ta.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break;
default:
throw new IllegalStateException("cannot set geometry with LOD for TrafficArea: " + lod);
}
}
@Override @Override
public boolean containsError(CheckId checkIdentifier) { public void collectContainedErrors(List<CheckError> errors) {
boolean hasError = super.containsError(checkIdentifier); super.collectContainedErrors(errors);
if (hasError) { for (TransportationObject to : composesOf) {
return true; to.collectContainedErrors(errors);
} }
for (TransportationObject to : composesOf) { }
if (to.containsError(checkIdentifier)) {
return true;
}
}
return false;
}
@Override @Override
public void clearAllContainedCheckResults() { public boolean containsAnyError() {
super.clearAllContainedCheckResults(); boolean hasError = super.containsAnyError();
for (TransportationObject to : composesOf) { if (hasError) {
to.clearAllContainedCheckResults(); return true;
} }
} for (TransportationObject to : composesOf) {
if (to.containsAnyError()) {
return true;
}
}
return false;
}
@Override @Override
public void collectContainedErrors(List<CheckError> errors) { public void accept(Check c) {
super.collectContainedErrors(errors); super.accept(c);
for (TransportationObject to : composesOf) { if (c.canExecute(this)) {
to.collectContainedErrors(errors); c.check(this);
} }
} for (TransportationObject to : composesOf) {
to.accept(c);
}
}
@Override @Override
public boolean containsAnyError() { public AbstractCityObject getGmlObject() {
boolean hasError = super.containsAnyError(); return ato;
if (hasError) { }
return true;
}
for (TransportationObject to : composesOf) {
if (to.containsAnyError()) {
return true;
}
}
return false;
}
@Override @Override
public void accept(Check c) { public void unsetGmlGeometries() {
super.accept(c); switch (type) {
if (c.canExecute(this)) { case ROAD, TRACK, RAILWAY, SQUARE, TRANSPORTATION_COMPLEX:
c.check(this); AbstractTransportationSpace tc = (AbstractTransportationSpace) ato;
} tc.getDeprecatedProperties().setLod1MultiSurface(null);
for (TransportationObject to : composesOf) { tc.setLod2MultiSurface(null);
to.accept(c); tc.setLod3MultiSurface(null);
} tc.getDeprecatedProperties().setLod4MultiSurface(null);
} break;
case TRAFFIC_AREA:
TrafficArea ta = (TrafficArea) ato;
ta.setLod2MultiSurface(null);
ta.setLod3MultiSurface(null);
ta.getDeprecatedProperties().setLod4MultiSurface(null);
break;
case AUXILLIARY_TRAFFIC_AREA:
AuxiliaryTrafficArea ata = (AuxiliaryTrafficArea) ato;
ata.setLod0MultiSurface(null);
ata.setLod1MultiSurface(null);
ata.setLod2MultiSurface(null);
ata.setLod3MultiSurface(null);
ata.getDeprecatedProperties().setLod4MultiSurface(null);
break;
case AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE:
AbstractSpace ats = (AbstractSpace) ato;
ats.setLod0MultiSurface(null);
ats.setLod2MultiSurface(null);
ats.setLod3MultiSurface(null);
break;
}
}
@Override public void setGmlObject(AbstractCityObject tc) {
public AbstractCityObject getGmlObject() { ato = tc;
return ato; }
}
@Override public void addChild(TransportationObject subTrans) {
public void unsetGmlGeometries() { composesOf.add(subTrans);
switch (type) { }
case ROAD, TRACK, RAILWAY, SQUARE,TRANSPORTATION_COMPLEX:
AbstractTransportationSpace tc = (AbstractTransportationSpace) ato;
tc.getDeprecatedProperties().setLod1MultiSurface(null);
tc.setLod2MultiSurface(null);
tc.setLod3MultiSurface(null);
tc.getDeprecatedProperties().setLod4MultiSurface(null);
break;
case TRAFFIC_AREA:
TrafficArea ta = (TrafficArea) ato;
ta.setLod2MultiSurface(null);
ta.setLod3MultiSurface(null);
ta.getDeprecatedProperties().setLod4MultiSurface(null);
break;
case AUXILLIARY_TRAFFIC_AREA:
AuxiliaryTrafficArea ata = (AuxiliaryTrafficArea) ato;
ata.setLod0MultiSurface(null);
ata.setLod1MultiSurface(null);
ata.setLod2MultiSurface(null);
ata.setLod3MultiSurface(null);
ata.getDeprecatedProperties().setLod4MultiSurface(null);
break;
case AUXILLIARY_TRAFFIC_SPACE, TRAFFIC_SPACE:
AbstractSpace ats = (AbstractSpace) ato;
ats.setLod0MultiSurface(null);
ats.setLod2MultiSurface(null);
ats.setLod3MultiSurface(null);
break;
}
}
public void setGmlObject(AbstractCityObject tc) { public List<TransportationObject> getChildren() {
ato = tc; return composesOf;
} }
public void addChild(TransportationObject subTrans) { public TransportationType getTransportationType() {
composesOf.add(subTrans); return type;
} }
public List<TransportationObject> getChildren() { @Override
return composesOf; public String toString() {
} return "TransportationObject [id=" + getGmlId() + "]";
}
public TransportationType getTransportationType() { @Override
return type; public void prepareForChecking() {
} super.prepareForChecking();
for (TransportationObject child : composesOf) {
child.prepareForChecking();
}
}
@Override @Override
public String toString() { public void clearMetaInformation() {
return "TransportationObject [id=" + getGmlId() + "]"; super.clearMetaInformation();
} for (TransportationObject child : composesOf) {
child.clearMetaInformation();
}
}
@Override @Override
public void prepareForChecking() { public void collectInstances(CopyHandler handler) {
super.prepareForChecking(); super.collectInstances(handler);
for (TransportationObject child : composesOf) { for (TransportationObject to : composesOf) {
child.prepareForChecking(); handler.addInstance(to);
} }
} }
@Override @Override
public void clearMetaInformation() { public void fillValues(Copyable original, CopyHandler handler) {
super.clearMetaInformation(); super.fillValues(original, handler);
for (TransportationObject child : composesOf) { TransportationObject originalTo = (TransportationObject) original;
child.clearMetaInformation(); for (TransportationObject to : originalTo.composesOf) {
} composesOf.add(handler.getCopyInstance(to));
} }
ato = originalTo.ato;
@Override }
public void collectInstances(CopyHandler handler) {
super.collectInstances(handler);
for (TransportationObject to : composesOf) {
handler.addInstance(to);
}
}
@Override
public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler);
TransportationObject originalTo = (TransportationObject) original;
for (TransportationObject to : originalTo.composesOf) {
composesOf.add(handler.getCopyInstance(to));
}
ato = originalTo.ato;
}
@Override @Override
public Copyable createCopyInstance() { public Copyable createCopyInstance() {
return new TransportationObject(type); return new TransportationObject(type);
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java
View file @ 02de0a22
...@@ -15,7 +15,7 @@ import java.io.Serial; ...@@ -15,7 +15,7 @@ import java.io.Serial;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class Tunnel extends AbstractTunnel{ public class Tunnel extends AbstractTunnel {
@Serial @Serial
private static final long serialVersionUID = 5316281216192555555L; private static final long serialVersionUID = 5316281216192555555L;
......
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelFurniture.java
View file @ 02de0a22
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.utils.Copyable; import de.hft.stuttgart.citydoctor2.utils.Copyable;
import org.citygml4j.core.model.building.BuildingFurniture;
import java.io.Serial; import java.io.Serial;
...@@ -15,7 +14,7 @@ public class TunnelFurniture extends AbstractFurniture { ...@@ -15,7 +14,7 @@ public class TunnelFurniture extends AbstractFurniture {
} }
@Override @Override
public Copyable createCopyInstance(){ public Copyable createCopyInstance() {
return new BuildingRoomFurniture(); return new BuildingRoomFurniture();
} }
......
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelHollow.java
View file @ 02de0a22
...@@ -8,18 +8,18 @@ import java.io.Serial; ...@@ -8,18 +8,18 @@ import java.io.Serial;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class TunnelHollow extends AbstractRoom{ public class TunnelHollow extends AbstractRoom {
@Serial @Serial
private static final long serialVersionUID = -276088332165299253L; private static final long serialVersionUID = -276088332165299253L;
private final List<TunnelFurnitureProperty> furnitureRefs = new ArrayList<>(2); private final List<TunnelFurnitureProperty> furnitureRefs = new ArrayList<>(2);
private CityObject parent; private CityObject parent;
public void setGmlObject(org.citygml4j.core.model.tunnel.HollowSpace gmlHollowSpace){ public void setGmlObject(org.citygml4j.core.model.tunnel.HollowSpace gmlHollowSpace) {
super.cgmlRoom = gmlHollowSpace; super.cgmlRoom = gmlHollowSpace;
} }
public void setParent(CityObject parent){ public void setParent(CityObject parent) {
this.parent = parent; this.parent = parent;
} }
...@@ -36,7 +36,7 @@ public class TunnelHollow extends AbstractRoom{ ...@@ -36,7 +36,7 @@ public class TunnelHollow extends AbstractRoom{
} }
@Override @Override
public void fillValues(Copyable original, CopyHandler handler){ public void fillValues(Copyable original, CopyHandler handler) {
super.fillValues(original, handler); super.fillValues(original, handler);
TunnelHollow oHollow = (TunnelHollow) original; TunnelHollow oHollow = (TunnelHollow) original;
...@@ -44,7 +44,7 @@ public class TunnelHollow extends AbstractRoom{ ...@@ -44,7 +44,7 @@ public class TunnelHollow extends AbstractRoom{
} }
@Override @Override
public void collectInstances(CopyHandler handler){ public void collectInstances(CopyHandler handler) {
super.collectInstances(handler); super.collectInstances(handler);
handler.addInstance(parent); handler.addInstance(parent);
} }
......
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelPart.java
View file @ 02de0a22
...@@ -50,5 +50,6 @@ public class TunnelPart extends AbstractTunnel { ...@@ -50,5 +50,6 @@ public class TunnelPart extends AbstractTunnel {
return new TunnelPart(); return new TunnelPart();
} }
private TunnelPart(){} private TunnelPart() {
}
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,9 +18,10 @@ ...@@ -18,9 +18,10 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial; import de.hft.stuttgart.citydoctor2.check.Check;
import java.util.Collections; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import org.citygml4j.core.model.core.AbstractCityObject; import org.citygml4j.core.model.core.AbstractCityObject;
import org.citygml4j.core.model.vegetation.AbstractVegetationObject; import org.citygml4j.core.model.vegetation.AbstractVegetationObject;
import org.citygml4j.core.model.vegetation.PlantCover; import org.citygml4j.core.model.vegetation.PlantCover;
...@@ -33,188 +34,185 @@ import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; ...@@ -33,188 +34,185 @@ import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.primitives.Solid; import org.xmlobjects.gml.model.geometry.primitives.Solid;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty; import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import de.hft.stuttgart.citydoctor2.check.Check; import java.io.Serial;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.Collections;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
/** /**
* Representation of CityGML vegetation objects * Representation of CityGML vegetation objects
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public class Vegetation extends CityObject { public class Vegetation extends CityObject {
@Serial @Serial
private static final long serialVersionUID = -5136358065541704146L; private static final long serialVersionUID = -5136358065541704146L;
public enum VegetationType { public enum VegetationType {
SOLITARY_VEGETATION_OBJECT, PLANT_COVER SOLITARY_VEGETATION_OBJECT, PLANT_COVER
} }
private AbstractVegetationObject citygmlVegetation; private AbstractVegetationObject citygmlVegetation;
private final VegetationType type; private final VegetationType type;
public Vegetation(VegetationType type) { public Vegetation(VegetationType type) {
this.type = type; this.type = type;
} }
@Override @Override
public FeatureType getFeatureType() { public FeatureType getFeatureType() {
return FeatureType.VEGETATION; return FeatureType.VEGETATION;
} }
@Override @Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) { public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
for (Geometry geom : getGeometries()) { for (Geometry geom : getGeometries()) {
if (geom instanceof ImplicitGeometryHolder){ if (geom instanceof ImplicitGeometryHolder) {
continue; continue;
} }
if (geom.getType() == GeometryType.MULTI_SURFACE) { if (geom.getType() == GeometryType.MULTI_SURFACE) {
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config); MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) { if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) {
SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation; SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation;
setMultiSurfaceAccordingToLod(svo, ms, geom.getLod()); setMultiSurfaceAccordingToLod(svo, ms, geom.getLod());
} else { } else {
PlantCover pc = (PlantCover) citygmlVegetation; PlantCover pc = (PlantCover) citygmlVegetation;
setMultiSurfaceAccordingToLod(pc, ms, geom.getLod()); setMultiSurfaceAccordingToLod(pc, ms, geom.getLod());
} }
} else { } else {
Solid solid = CityGmlUtils.createSolid(geom, factory, config); Solid solid = CityGmlUtils.createSolid(geom, factory, config);
if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) { if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) {
SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation; SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation;
setSolidAccordingToLod(svo, solid, geom.getLod()); setSolidAccordingToLod(svo, solid, geom.getLod());
} else { } else {
PlantCover pc = (PlantCover) citygmlVegetation; PlantCover pc = (PlantCover) citygmlVegetation;
setSolidAccordingToLod(pc, solid, geom.getLod()); setSolidAccordingToLod(pc, solid, geom.getLod());
} }
} }
} }
} }
private void setSolidAccordingToLod(PlantCover pc, Solid solid, Lod lod) { private void setSolidAccordingToLod(PlantCover pc, Solid solid, Lod lod) {
switch (lod) { switch (lod) {
case LOD1: case LOD1:
pc.getDeprecatedProperties().setLod1MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid))))); pc.getDeprecatedProperties().setLod1MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid)))));
break; break;
case LOD2: case LOD2:
pc.getDeprecatedProperties().setLod2MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid))))); pc.getDeprecatedProperties().setLod2MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid)))));
break; break;
case LOD3: case LOD3:
pc.getDeprecatedProperties().setLod3MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid))))); pc.getDeprecatedProperties().setLod3MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid)))));
break; break;
case LOD4: case LOD4:
pc.getDeprecatedProperties().setLod4MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid))))); pc.getDeprecatedProperties().setLod4MultiSolid(new MultiSolidProperty(new MultiSolid(Collections.singletonList(new SolidProperty(solid)))));
break; break;
default: default:
throw new IllegalStateException("Cannot set Solid with lod to PlantCover:" + lod); throw new IllegalStateException("Cannot set Solid with lod to PlantCover:" + lod);
} }
} }
private void setSolidAccordingToLod(SolitaryVegetationObject svo, Solid solid, Lod lod) { private void setSolidAccordingToLod(SolitaryVegetationObject svo, Solid solid, Lod lod) {
switch (lod) { switch (lod) {
case LOD1: case LOD1:
svo.getDeprecatedProperties().setLod1Geometry(new SolidProperty(solid)); svo.getDeprecatedProperties().setLod1Geometry(new SolidProperty(solid));
break; break;
case LOD2: case LOD2:
svo.getDeprecatedProperties().setLod2Geometry(new SolidProperty(solid)); svo.getDeprecatedProperties().setLod2Geometry(new SolidProperty(solid));
break; break;
case LOD3: case LOD3:
svo.getDeprecatedProperties().setLod3Geometry(new SolidProperty(solid)); svo.getDeprecatedProperties().setLod3Geometry(new SolidProperty(solid));
break; break;
case LOD4: case LOD4:
svo.getDeprecatedProperties().setLod4Geometry(new SolidProperty(solid)); svo.getDeprecatedProperties().setLod4Geometry(new SolidProperty(solid));
break; break;
default: default:
throw new IllegalStateException("Cannot set Solid with lod to SolitaryVegetationObject:" + lod); throw new IllegalStateException("Cannot set Solid with lod to SolitaryVegetationObject:" + lod);
} }
} }
private void setMultiSurfaceAccordingToLod(PlantCover pc, MultiSurface ms, Lod lod) { private void setMultiSurfaceAccordingToLod(PlantCover pc, MultiSurface ms, Lod lod) {
switch (lod) { switch (lod) {
case LOD1: case LOD1:
pc.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms)); pc.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD2: case LOD2:
pc.setLod2MultiSurface(new MultiSurfaceProperty(ms)); pc.setLod2MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD3: case LOD3:
pc.setLod3MultiSurface(new MultiSurfaceProperty(ms)); pc.setLod3MultiSurface(new MultiSurfaceProperty(ms));
break; break;
case LOD4: case LOD4:
pc.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms)); pc.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty(ms));
break; break;
default: default:
throw new IllegalStateException("Cannot set MultiSurface with lod to PlantCover:" + lod); throw new IllegalStateException("Cannot set MultiSurface with lod to PlantCover:" + lod);
} }
} }
private void setMultiSurfaceAccordingToLod(SolitaryVegetationObject svo, MultiSurface ms, Lod lod) { private void setMultiSurfaceAccordingToLod(SolitaryVegetationObject svo, MultiSurface ms, Lod lod) {
switch (lod) { switch (lod) {
case LOD1: case LOD1:
svo.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms)); svo.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty(ms));
break; break;
case LOD2: case LOD2:
svo.getDeprecatedProperties().setLod2Geometry(new MultiSurfaceProperty(ms)); svo.getDeprecatedProperties().setLod2Geometry(new MultiSurfaceProperty(ms));
break; break;
case LOD3: case LOD3:
svo.getDeprecatedProperties().setLod3Geometry(new MultiSurfaceProperty(ms)); svo.getDeprecatedProperties().setLod3Geometry(new MultiSurfaceProperty(ms));
break; break;
case LOD4: case LOD4:
svo.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty(ms)); svo.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty(ms));
break; break;
default: default:
throw new IllegalStateException("Cannot set MultiSurface with lod to SolitaryVegetationObject:" + lod); throw new IllegalStateException("Cannot set MultiSurface with lod to SolitaryVegetationObject:" + lod);
} }
} }
@Override @Override
public void accept(Check c) { public void accept(Check c) {
super.accept(c); super.accept(c);
if (c.canExecute(this)) { if (c.canExecute(this)) {
c.check(this); c.check(this);
} }
} }
@Override @Override
public AbstractCityObject getGmlObject() { public AbstractCityObject getGmlObject() {
return citygmlVegetation; return citygmlVegetation;
} }
@Override @Override
public void unsetGmlGeometries() { public void unsetGmlGeometries() {
if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) { if (type == VegetationType.SOLITARY_VEGETATION_OBJECT) {
SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation; SolitaryVegetationObject svo = (SolitaryVegetationObject) citygmlVegetation;
svo.getDeprecatedProperties().setLod1Geometry(null); svo.getDeprecatedProperties().setLod1Geometry(null);
svo.getDeprecatedProperties().setLod2Geometry(null); svo.getDeprecatedProperties().setLod2Geometry(null);
svo.getDeprecatedProperties().setLod3Geometry(null); svo.getDeprecatedProperties().setLod3Geometry(null);
svo.getDeprecatedProperties().setLod4Geometry(null); svo.getDeprecatedProperties().setLod4Geometry(null);
} else { } else {
PlantCover pc = (PlantCover) citygmlVegetation; PlantCover pc = (PlantCover) citygmlVegetation;
pc.getDeprecatedProperties().setLod1MultiSurface(null); pc.getDeprecatedProperties().setLod1MultiSurface(null);
pc.setLod2MultiSurface(null); pc.setLod2MultiSurface(null);
pc.setLod3MultiSurface(null); pc.setLod3MultiSurface(null);
pc.getDeprecatedProperties().setLod4MultiSurface(null); pc.getDeprecatedProperties().setLod4MultiSurface(null);
} }
} }
public void setGmlObject(AbstractVegetationObject avo) { public void setGmlObject(AbstractVegetationObject avo) {
citygmlVegetation = avo; citygmlVegetation = avo;
} }
public VegetationType getVegetationType() { public VegetationType getVegetationType() {
return type; return type;
} }
@Override @Override
public String toString() { public String toString() {
return "Vegetation [id=" + getGmlId() + "]"; return "Vegetation [id=" + getGmlId() + "]";
} }
@Override @Override
public Copyable createCopyInstance() { public Copyable createCopyInstance() {
return new Vegetation(type); return new Vegetation(type);
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vertex.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,155 +18,154 @@ ...@@ -18,155 +18,154 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.math.Vector3d;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
import java.io.Serial; import java.io.Serial;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import de.hft.stuttgart.citydoctor2.math.Vector3d;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
/** /**
* Contains the vertex information of a point in a linear ring * Contains the vertex information of a point in a linear ring
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public class Vertex extends Vector3d implements Copyable { public class Vertex extends Vector3d implements Copyable {
@Serial @Serial
private static final long serialVersionUID = -5525361920397934892L; private static final long serialVersionUID = -5525361920397934892L;
private List<SerializablePair<Geometry, HashSet<LinearRing>>> adjacentRings = new ArrayList<>(2); private List<SerializablePair<Geometry, HashSet<LinearRing>>> adjacentRings = new ArrayList<>(2);
public Vertex(double x, double y, double z) { public Vertex(double x, double y, double z) {
super(x, y, z); super(x, y, z);
} }
public Vertex(Vector3d vec) { public Vertex(Vector3d vec) {
super(vec); super(vec);
} }
private Set<LinearRing> getAdjacentRingsWithoutNeighbor(Geometry geom) { private Set<LinearRing> getAdjacentRingsWithoutNeighbor(Geometry geom) {
for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) { for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) {
if (adjacency.getValue0() == geom) { if (adjacency.getValue0() == geom) {
return adjacency.getValue1(); return adjacency.getValue1();
} }
} }
throw new IllegalStateException("Requested adjacent rings with Geometry not containing this vertex"); throw new IllegalStateException("Requested adjacent rings with Geometry not containing this vertex");
} }
public Set<LinearRing> getAdjacentRings(Geometry geom) { public Set<LinearRing> getAdjacentRings(Geometry geom) {
return getAdjacentRingsWithoutNeighbor(geom); return getAdjacentRingsWithoutNeighbor(geom);
} }
void addAdjacentRing(LinearRing ring, Geometry geom) { void addAdjacentRing(LinearRing ring, Geometry geom) {
findAdjacentRingsForGeometry(geom).add(ring); findAdjacentRingsForGeometry(geom).add(ring);
} }
private Set<LinearRing> findAdjacentRingsForGeometry(Geometry geom) { private Set<LinearRing> findAdjacentRingsForGeometry(Geometry geom) {
HashSet<LinearRing> adjacendRingsSet = null; HashSet<LinearRing> adjacendRingsSet = null;
for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) { for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) {
if (adjacency.getValue0() == geom) { if (adjacency.getValue0() == geom) {
adjacendRingsSet = adjacency.getValue1(); adjacendRingsSet = adjacency.getValue1();
} }
} }
if (adjacendRingsSet == null) { if (adjacendRingsSet == null) {
adjacendRingsSet = new HashSet<>(4); adjacendRingsSet = new HashSet<>(4);
adjacentRings.add(new SerializablePair<>(geom, adjacendRingsSet)); adjacentRings.add(new SerializablePair<>(geom, adjacendRingsSet));
} }
return adjacendRingsSet; return adjacendRingsSet;
} }
private Set<Polygon> getAdjacentPolygonsWithoutNeighbor(Geometry geom) { private Set<Polygon> getAdjacentPolygonsWithoutNeighbor(Geometry geom) {
for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) { for (SerializablePair<Geometry, HashSet<LinearRing>> adjacency : adjacentRings) {
if (adjacency.getValue0() == geom) { if (adjacency.getValue0() == geom) {
Set<Polygon> polygons = new HashSet<>(); Set<Polygon> polygons = new HashSet<>();
for (LinearRing lr : adjacency.getValue1()) { for (LinearRing lr : adjacency.getValue1()) {
polygons.add(lr.getParent()); polygons.add(lr.getParent());
} }
return polygons; return polygons;
} }
} }
throw new IllegalStateException("Requested adjacent polygons with Geometry not containing this vertex"); throw new IllegalStateException("Requested adjacent polygons with Geometry not containing this vertex");
} }
public Set<Polygon> getAdjacentPolygons(Geometry geom) { public Set<Polygon> getAdjacentPolygons(Geometry geom) {
return getAdjacentPolygonsWithoutNeighbor(geom); return getAdjacentPolygonsWithoutNeighbor(geom);
} }
@Override @Override
public int hashCode() { public int hashCode() {
final int prime = 31; final int prime = 31;
int result = super.hashCode(); int result = super.hashCode();
return prime * result; return prime * result;
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (this == obj) { if (this == obj) {
return true; return true;
} }
if (!super.equals(obj)) { if (!super.equals(obj)) {
return false; return false;
} }
return getClass() == obj.getClass(); return getClass() == obj.getClass();
} }
@Override @Override
public String toString() { public String toString() {
return "Vertex [x=" + getX() + ", y=" + getY() + ", z=" + getZ() + "]"; return "Vertex [x=" + getX() + ", y=" + getY() + ", z=" + getZ() + "]";
} }
public void clearAdjacentRings(Geometry geometry) { public void clearAdjacentRings(Geometry geometry) {
if (adjacentRings == null) { if (adjacentRings == null) {
return; return;
} }
findAdjacentRingsForGeometry(geometry).clear(); findAdjacentRingsForGeometry(geometry).clear();
} }
void removeAdjacency(LinearRing lr, Geometry geom) { void removeAdjacency(LinearRing lr, Geometry geom) {
findAdjacentRingsForGeometry(geom).remove(lr); findAdjacentRingsForGeometry(geom).remove(lr);
} }
/** /**
* Remove all adjacent rings from this vertex, ignoring geometry association * Remove all adjacent rings from this vertex, ignoring geometry association
*/ */
void clearAdjacentRings() { void clearAdjacentRings() {
adjacentRings = new ArrayList<>(2); adjacentRings = new ArrayList<>(2);
} }
@Override @Override
public void collectInstances(CopyHandler handler) { public void collectInstances(CopyHandler handler) {
for (SerializablePair<Geometry, HashSet<LinearRing>> pair : adjacentRings) { for (SerializablePair<Geometry, HashSet<LinearRing>> pair : adjacentRings) {
handler.addInstance(pair.getValue0()); handler.addInstance(pair.getValue0());
for (LinearRing lr : pair.getValue1()) { for (LinearRing lr : pair.getValue1()) {
handler.addInstance(lr); handler.addInstance(lr);
} }
} }
} }
@Override @Override
public Copyable createCopyInstance() { public Copyable createCopyInstance() {
return new Vertex(this); return new Vertex(this);
} }
@Override @Override
public void fillValues(Copyable original, CopyHandler handler) { public void fillValues(Copyable original, CopyHandler handler) {
Vertex originalVertex = (Vertex) original; Vertex originalVertex = (Vertex) original;
// vertex point data already filled // vertex point data already filled
for (SerializablePair<Geometry, HashSet<LinearRing>> pair : originalVertex.adjacentRings) { for (SerializablePair<Geometry, HashSet<LinearRing>> pair : originalVertex.adjacentRings) {
Geometry geomCopy = handler.getCopyInstance(pair.getValue0()); Geometry geomCopy = handler.getCopyInstance(pair.getValue0());
HashSet<LinearRing> set = new HashSet<>(); HashSet<LinearRing> set = new HashSet<>();
for (LinearRing originalRing : pair.getValue1()) { for (LinearRing originalRing : pair.getValue1()) {
set.add(handler.getCopyInstance(originalRing)); set.add(handler.getCopyInstance(originalRing));
} }
SerializablePair<Geometry, HashSet<LinearRing>> copyPair = new SerializablePair<>(geomCopy, set); SerializablePair<Geometry, HashSet<LinearRing>> copyPair = new SerializablePair<>(geomCopy, set);
adjacentRings.add(copyPair); adjacentRings.add(copyPair);
} }
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,155 +18,153 @@ ...@@ -18,155 +18,153 @@
*/ */
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import java.io.Serial; import de.hft.stuttgart.citydoctor2.check.Check;
import java.util.ArrayList; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import java.util.List; 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.model.core.AbstractCityObject;
import org.citygml4j.core.model.waterbody.WaterBody; import org.citygml4j.core.model.waterbody.WaterBody;
import org.citygml4j.core.util.geometry.GeometryFactory; import org.citygml4j.core.util.geometry.GeometryFactory;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import de.hft.stuttgart.citydoctor2.check.Check; import java.io.Serial;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.ArrayList;
import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import java.util.List;
import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
import de.hft.stuttgart.citydoctor2.utils.Copyable;
/** /**
* Represents cityGML water body objects. * Represents cityGML water body objects.
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public class WaterObject extends CityObject { public class WaterObject extends CityObject {
@Serial @Serial
private static final long serialVersionUID = -3821060595086337424L; private static final long serialVersionUID = -3821060595086337424L;
private WaterBody gmlWater; private WaterBody gmlWater;
private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>(); private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
@Override @Override
public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) { public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
for (Geometry geom : getGeometries()) { for (Geometry geom : getGeometries()) {
if (geom.getType() == GeometryType.MULTI_SURFACE) { if (geom.getType() == GeometryType.MULTI_SURFACE) {
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config); MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
if (geom.getLod() == Lod.LOD0) { if (geom.getLod() == Lod.LOD0) {
gmlWater.setLod0MultiSurface(new MultiSurfaceProperty(ms)); gmlWater.setLod0MultiSurface(new MultiSurfaceProperty(ms));
} else if (geom.getLod() == Lod.LOD1) { } else if (geom.getLod() == Lod.LOD1) {
gmlWater.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms)); gmlWater.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty(ms));
} else { } else {
throw new IllegalStateException( throw new IllegalStateException(
"Cannot add MultiSurface geometry with lod to WaterBody:" + geom.getLod()); "Cannot add MultiSurface geometry with lod to WaterBody:" + geom.getLod());
} }
} else { } else {
throw new IllegalStateException("Cannot add Solid geometry to WaterBody"); throw new IllegalStateException("Cannot add Solid geometry to WaterBody");
} }
} }
} }
/** /**
* Getter for all boundary surfaces contained in this building. * Getter for all boundary surfaces contained in this building.
* *
* @return the boundary surfaces * @return the boundary surfaces
*/ */
public List<BoundarySurface> getBoundarySurfaces() { public List<BoundarySurface> getBoundarySurfaces() {
return boundarySurfaceList; return boundarySurfaceList;
} }
public void addBoundarySurface(BoundarySurface bs) { public void addBoundarySurface(BoundarySurface bs) {
boundarySurfaceList.add(bs); boundarySurfaceList.add(bs);
bs.setParent(this); bs.setParent(this);
} }
@Override @Override
public FeatureType getFeatureType() { public FeatureType getFeatureType() {
return FeatureType.WATER; return FeatureType.WATER;
} }
@Override @Override
public void accept(Check c) { public void accept(Check c) {
super.accept(c); super.accept(c);
if (c.canExecute(this)) { if (c.canExecute(this)) {
c.check(this); c.check(this);
} }
for (BoundarySurface bs : boundarySurfaceList) { for (BoundarySurface bs : boundarySurfaceList) {
bs.accept(c); bs.accept(c);
} }
} }
@Override @Override
public AbstractCityObject getGmlObject() { public AbstractCityObject getGmlObject() {
return gmlWater; return gmlWater;
} }
@Override @Override
public void unsetGmlGeometries() { public void unsetGmlGeometries() {
gmlWater.setLod0MultiSurface(null); gmlWater.setLod0MultiSurface(null);
gmlWater.getDeprecatedProperties().setLod1MultiSurface(null); gmlWater.getDeprecatedProperties().setLod1MultiSurface(null);
} }
public void setGmlObject(WaterBody waterBody) { public void setGmlObject(WaterBody waterBody) {
gmlWater = waterBody; gmlWater = waterBody;
} }
@Override @Override
public String toString() { public String toString() {
return "WaterObject [id=" + getGmlId() + "]"; return "WaterObject [id=" + getGmlId() + "]";
} }
@Override @Override
public WaterObject createCopyInstance() { public WaterObject createCopyInstance() {
return new WaterObject(); return new WaterObject();
} }
@Override @Override
public void fillValues(Copyable original, CopyHandler handler) { public void fillValues(Copyable original, CopyHandler handler) {
WaterObject wo = (WaterObject) original; WaterObject wo = (WaterObject) original;
WaterObject originalWaterObject = (WaterObject) original; WaterObject originalWaterObject = (WaterObject) original;
for (BoundarySurface originalBs : originalWaterObject.boundarySurfaceList) { for (BoundarySurface originalBs : originalWaterObject.boundarySurfaceList) {
boundarySurfaceList.add(handler.getCopyInstance(originalBs)); boundarySurfaceList.add(handler.getCopyInstance(originalBs));
} }
gmlWater = wo.gmlWater; gmlWater = wo.gmlWater;
} }
@Override @Override
public boolean containsAnyError() { public boolean containsAnyError() {
boolean hasError = super.containsAnyError(); boolean hasError = super.containsAnyError();
if (hasError) { if (hasError) {
return true; return true;
} }
for (BoundarySurface bs : boundarySurfaceList) { for (BoundarySurface bs : boundarySurfaceList) {
if (bs.containsAnyError()) { if (bs.containsAnyError()) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public void collectInstances(CopyHandler handler) { public void collectInstances(CopyHandler handler) {
super.collectInstances(handler); super.collectInstances(handler);
handler.addInstance(boundarySurfaceList); handler.addInstance(boundarySurfaceList);
} }
@Override @Override
public void clearMetaInformation() { public void clearMetaInformation() {
super.clearMetaInformation(); super.clearMetaInformation();
for (BoundarySurface bs : boundarySurfaceList) { for (BoundarySurface bs : boundarySurfaceList) {
bs.clearMetaInformation(); bs.clearMetaInformation();
} }
} }
@Override @Override
public void prepareForChecking() { public void prepareForChecking() {
super.prepareForChecking(); super.prepareForChecking();
for (BoundarySurface bs : boundarySurfaceList) { for (BoundarySurface bs : boundarySurfaceList) {
bs.prepareForChecking(); bs.prepareForChecking();
} }
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3FeatureMapper.java
View file @ 02de0a22
...@@ -18,51 +18,37 @@ ...@@ -18,51 +18,37 @@
*/ */
package de.hft.stuttgart.citydoctor2.mapper.citygml3; package de.hft.stuttgart.citydoctor2.mapper.citygml3;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding; import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding;
import de.hft.stuttgart.citydoctor2.datastructure.AbstractTunnel; import de.hft.stuttgart.citydoctor2.datastructure.AbstractTunnel;
import de.hft.stuttgart.citydoctor2.datastructure.BridgeConstructiveElement;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.datastructure.Building; import de.hft.stuttgart.citydoctor2.datastructure.Building;
import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart; import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart;
import de.hft.stuttgart.citydoctor2.datastructure.BuildingRoom; import de.hft.stuttgart.citydoctor2.datastructure.BuildingRoom;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject.BridgeType;
import de.hft.stuttgart.citydoctor2.datastructure.TunnelFurniture; import de.hft.stuttgart.citydoctor2.datastructure.TunnelFurniture;
import de.hft.stuttgart.citydoctor2.datastructure.TunnelPart; import de.hft.stuttgart.citydoctor2.datastructure.TunnelPart;
import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject.TransportationType;
import de.hft.stuttgart.citydoctor2.datastructure.Vegetation.VegetationType;
import de.hft.stuttgart.citydoctor2.math.graph.KDTree;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.Localization;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.citygml4j.core.model.CityGMLVersion; import org.citygml4j.core.model.CityGMLVersion;
import org.citygml4j.core.model.bridge.AbstractBridge; import org.citygml4j.core.model.bridge.*;
import org.citygml4j.core.model.bridge.Bridge;
import org.citygml4j.core.model.bridge.BridgeConstructiveElementProperty;
import org.citygml4j.core.model.bridge.BridgeInstallation;
import org.citygml4j.core.model.bridge.BridgeInstallationProperty;
import org.citygml4j.core.model.bridge.BridgePart;
import org.citygml4j.core.model.bridge.BridgePartProperty;
import org.citygml4j.core.model.building.*;
import org.citygml4j.core.model.building.BuildingFurniture;
import org.citygml4j.core.model.building.BuildingUnit; import org.citygml4j.core.model.building.BuildingUnit;
import org.citygml4j.core.model.building.Storey; import org.citygml4j.core.model.building.Storey;
import org.citygml4j.core.model.building.*;
import org.citygml4j.core.model.construction.AbstractConstruction; import org.citygml4j.core.model.construction.AbstractConstruction;
import org.citygml4j.core.model.core.*; import org.citygml4j.core.model.core.*;
import org.citygml4j.core.model.deprecated.transportation.TransportationComplex; import org.citygml4j.core.model.deprecated.transportation.TransportationComplex;
import org.citygml4j.core.model.landuse.LandUse; import org.citygml4j.core.model.landuse.LandUse;
import org.citygml4j.core.model.transportation.AbstractTransportationSpace; import org.citygml4j.core.model.transportation.*;
import org.citygml4j.core.model.transportation.AuxiliaryTrafficArea;
import org.citygml4j.core.model.transportation.AuxiliaryTrafficSpace;
import org.citygml4j.core.model.transportation.AuxiliaryTrafficSpaceProperty;
import org.citygml4j.core.model.transportation.Railway;
import org.citygml4j.core.model.transportation.Road;
import org.citygml4j.core.model.transportation.Square;
import org.citygml4j.core.model.transportation.Track;
import org.citygml4j.core.model.transportation.TrafficArea;
import org.citygml4j.core.model.transportation.TrafficSpace;
import org.citygml4j.core.model.transportation.TrafficSpaceProperty;
import org.citygml4j.core.model.tunnel.*;
import org.citygml4j.core.model.tunnel.Tunnel; import org.citygml4j.core.model.tunnel.Tunnel;
import org.citygml4j.core.model.tunnel.*;
import org.citygml4j.core.model.vegetation.AbstractVegetationObject; import org.citygml4j.core.model.vegetation.AbstractVegetationObject;
import org.citygml4j.core.model.vegetation.PlantCover; import org.citygml4j.core.model.vegetation.PlantCover;
import org.citygml4j.core.model.vegetation.SolitaryVegetationObject; import org.citygml4j.core.model.vegetation.SolitaryVegetationObject;
...@@ -75,1165 +61,1154 @@ import org.xmlobjects.gml.model.geometry.GeometryProperty; ...@@ -75,1165 +61,1154 @@ import org.xmlobjects.gml.model.geometry.GeometryProperty;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface; import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
import org.xmlobjects.gml.model.geometry.primitives.AbstractSolid; import org.xmlobjects.gml.model.geometry.primitives.*;
import org.xmlobjects.gml.model.geometry.primitives.AbstractSurface;
import org.xmlobjects.gml.model.geometry.primitives.Shell;
import org.xmlobjects.gml.model.geometry.primitives.ShellProperty;
import org.xmlobjects.gml.model.geometry.primitives.Solid;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject.BridgeType; import java.nio.file.Path;
import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject.TransportationType; import java.util.ArrayList;
import de.hft.stuttgart.citydoctor2.datastructure.Vegetation.VegetationType; import java.util.HashMap;
import de.hft.stuttgart.citydoctor2.math.graph.KDTree; import java.util.List;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.Map;
import de.hft.stuttgart.citydoctor2.utils.Localization;
public class Citygml3FeatureMapper extends ObjectWalker { public class Citygml3FeatureMapper extends ObjectWalker {
private static final Logger logger = LogManager.getLogger(Citygml3FeatureMapper.class); private static final Logger logger = LogManager.getLogger(Citygml3FeatureMapper.class);
private final CityDoctorModel model; private final CityDoctorModel model;
private final ParserConfiguration config;
private Map<String, ConcretePolygon> polygonMap = new HashMap<>(); private final Path directory;
private List<ResolvableReference> references = new ArrayList<>(); private final double neighborDistance;
private Map<Vertex, Vertex> vertexMap = new HashMap<>(); private Map<String, ConcretePolygon> polygonMap = new HashMap<>();
private final ParserConfiguration config; private List<ResolvableReference> references = new ArrayList<>();
private final Path directory; private Map<Vertex, Vertex> vertexMap = new HashMap<>();
private final double neighborDistance;
public Citygml3FeatureMapper(ParserConfiguration config, Path path) {
public Citygml3FeatureMapper(ParserConfiguration config, Path path) { this.config = config;
this.config = config; this.directory = path.getParent();
this.directory = path.getParent(); model = new CityDoctorModel(config, path.toFile());
model = new CityDoctorModel(config, path.toFile()); neighborDistance = 1.8d / Math.pow(10, config.getNumberOfRoundingPlaces());
neighborDistance = 1.8d / Math.pow(10, config.getNumberOfRoundingPlaces()); }
}
public static void parseId(AbstractGML gml, GmlElement gmlElement) {
@Override String id = gml.getId();
public void visit(AbstractSpace space) { if (id != null) {
// if we are here, an AbstractSpace thing was read that is not handled in the gmlElement.setGmlId(new GmlId(id));
// other methods }
}
}
@Override
@Override public void visit(AbstractSpace space) {
public void visit(org.citygml4j.core.model.cityfurniture.CityFurniture gmlCityFurniture) { // if we are here, an AbstractSpace thing was read that is not handled in the
CityFurniture cf = new CityFurniture(); // other methods
cf.setGmlObject(gmlCityFurniture);
mapAbstractOccupiedSpace(gmlCityFurniture, cf); }
resolveAndClearReferences();
cf.unsetGmlGeometries(); @Override
updateEdgesAndVertices(cf); public void visit(org.citygml4j.core.model.cityfurniture.CityFurniture gmlCityFurniture) {
model.addCityFurniture(cf); CityFurniture cf = new CityFurniture();
} cf.setGmlObject(gmlCityFurniture);
mapAbstractOccupiedSpace(gmlCityFurniture, cf);
@Override resolveAndClearReferences();
public void visit(org.citygml4j.core.model.generics.GenericOccupiedSpace gos){ cf.unsetGmlGeometries();
GenericCityObject gco = new GenericCityObject(); updateEdgesAndVertices(cf);
gco.setGmlObject(gos); model.addCityFurniture(cf);
mapAbstractOccupiedSpace(gos, gco); }
resolveAndClearReferences();
gco.unsetGmlGeometries(); @Override
updateEdgesAndVertices(gco); public void visit(org.citygml4j.core.model.generics.GenericOccupiedSpace gos) {
model.addGenericCityObject(gco); GenericCityObject gco = new GenericCityObject();
} gco.setGmlObject(gos);
mapAbstractOccupiedSpace(gos, gco);
resolveAndClearReferences();
@Override gco.unsetGmlGeometries();
public void visit(org.citygml4j.core.model.building.Building gmlBuilding) { updateEdgesAndVertices(gco);
Building cdBuilding = new Building(); model.addGenericCityObject(gco);
readAbstractBuilding(gmlBuilding, cdBuilding); }
for (BuildingPartProperty bpProp : gmlBuilding.getBuildingParts()) {
if (!bpProp.isSetObject()) { @Override
continue; public void visit(org.citygml4j.core.model.building.Building gmlBuilding) {
} Building cdBuilding = new Building();
BuildingPart part = new BuildingPart(cdBuilding); readAbstractBuilding(gmlBuilding, cdBuilding);
readAbstractBuilding(bpProp.getObject(), part); for (BuildingPartProperty bpProp : gmlBuilding.getBuildingParts()) {
} if (!bpProp.isSetObject()) {
model.addBuilding(cdBuilding); continue;
} }
BuildingPart part = new BuildingPart(cdBuilding);
@Override readAbstractBuilding(bpProp.getObject(), part);
public void visit(WaterBody waterBody) { }
WaterObject wo = new WaterObject(); model.addBuilding(cdBuilding);
wo.setGmlObject(waterBody); }
mapAbstractOccupiedSpace(waterBody, wo);
parseAndAddMultiSurface(waterBody.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, wo); @Override
parseAndAddSolid(waterBody.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, wo); public void visit(WaterBody waterBody) {
WaterObject wo = new WaterObject();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); wo.setGmlObject(waterBody);
for (AbstractSpaceBoundaryProperty surfaceProp : waterBody.getBoundaries()) { mapAbstractOccupiedSpace(waterBody, wo);
if (!surfaceProp.isSetObject()) { parseAndAddMultiSurface(waterBody.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, wo);
continue; parseAndAddSolid(waterBody.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, wo);
}
AbstractSpaceBoundary surface = surfaceProp.getObject(); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
surface.accept(surfaceMapper); for (AbstractSpaceBoundaryProperty surfaceProp : waterBody.getBoundaries()) {
} if (!surfaceProp.isSetObject()) {
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { continue;
wo.addBoundarySurface(bs); }
} AbstractSpaceBoundary surface = surfaceProp.getObject();
surface.accept(surfaceMapper);
resolveAndClearReferences(); }
wo.unsetGmlGeometries(); for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
updateEdgesAndVertices(wo); wo.addBoundarySurface(bs);
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { }
updateEdgesAndVertices(bs);
} resolveAndClearReferences();
model.addWater(wo); wo.unsetGmlGeometries();
} updateEdgesAndVertices(wo);
for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
@Override updateEdgesAndVertices(bs);
public void visit(LandUse landUse) { }
LandObject lo = new LandObject(landUse); model.addWater(wo);
}
mapAbstractThematicSurface(landUse, lo);
@Override
finishCityObjectConstruction(lo); public void visit(LandUse landUse) {
model.addLand(lo); LandObject lo = new LandObject(landUse);
}
mapAbstractThematicSurface(landUse, lo);
@Override
public void visit(PlantCover plantCover) { finishCityObjectConstruction(lo);
Vegetation veg = new Vegetation(VegetationType.PLANT_COVER); model.addLand(lo);
veg.setGmlObject(plantCover); }
mapAbstractVegetationObject(plantCover, veg);
@Override
parseAndAddMultiSurface(plantCover.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, veg); public void visit(PlantCover plantCover) {
parseAndAddMultiSurface(plantCover.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, veg); Vegetation veg = new Vegetation(VegetationType.PLANT_COVER);
veg.setGmlObject(plantCover);
finishCityObjectConstruction(veg); mapAbstractVegetationObject(plantCover, veg);
model.addVegetation(veg);
} parseAndAddMultiSurface(plantCover.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, veg);
parseAndAddMultiSurface(plantCover.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, veg);
@Override
public void visit(SolitaryVegetationObject solitaryVegetationObject) { finishCityObjectConstruction(veg);
Vegetation veg = new Vegetation(VegetationType.SOLITARY_VEGETATION_OBJECT); model.addVegetation(veg);
veg.setGmlObject(solitaryVegetationObject); }
mapAbstractVegetationObject(solitaryVegetationObject, veg);
@Override
parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod1Geometry(), Lod.LOD1, veg); public void visit(SolitaryVegetationObject solitaryVegetationObject) {
parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod2Geometry(), Lod.LOD2, veg); Vegetation veg = new Vegetation(VegetationType.SOLITARY_VEGETATION_OBJECT);
parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod3Geometry(), Lod.LOD3, veg); veg.setGmlObject(solitaryVegetationObject);
parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod4Geometry(), Lod.LOD4, veg); mapAbstractVegetationObject(solitaryVegetationObject, veg);
finishCityObjectConstruction(veg); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod1Geometry(), Lod.LOD1, veg);
model.addVegetation(veg); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod2Geometry(), Lod.LOD2, veg);
} parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod3Geometry(), Lod.LOD3, veg);
parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod4Geometry(), Lod.LOD4, veg);
private void mapAbstractVegetationObject(AbstractVegetationObject avo, Vegetation veg) {
mapAbstractOccupiedSpace(avo, veg); finishCityObjectConstruction(veg);
} model.addVegetation(veg);
}
private void mapAbstractOccupiedSpace(AbstractOccupiedSpace aos, CityObject co) {
mapAbstractPhysicalSpace(aos, co); private void mapAbstractVegetationObject(AbstractVegetationObject avo, Vegetation veg) {
parseImplicitGeometry(aos, co); mapAbstractOccupiedSpace(avo, veg);
} }
private void mapAbstractPhysicalSpace(AbstractPhysicalSpace aps, CityObject co) { private void mapAbstractOccupiedSpace(AbstractOccupiedSpace aos, CityObject co) {
mapAbstractSpace(aps, co); mapAbstractPhysicalSpace(aos, co);
} parseImplicitGeometry(aos, co);
}
private void mapAbstractSpace(AbstractSpace as, CityObject co) {
mapAbstractFeature(as, co); private void mapAbstractPhysicalSpace(AbstractPhysicalSpace aps, CityObject co) {
parseAndAddMultiSurface(as.getLod0MultiSurface(), Lod.LOD0, co); mapAbstractSpace(aps, co);
parseAndAddMultiSurface(as.getLod2MultiSurface(), Lod.LOD2, co); }
parseAndAddMultiSurface(as.getLod3MultiSurface(), Lod.LOD3, co);
parseAndAddSolid(as.getLod1Solid(), Lod.LOD1, co); private void mapAbstractSpace(AbstractSpace as, CityObject co) {
parseAndAddSolid(as.getLod2Solid(), Lod.LOD2, co); mapAbstractFeature(as, co);
parseAndAddSolid(as.getLod3Solid(), Lod.LOD3, co); parseAndAddMultiSurface(as.getLod0MultiSurface(), Lod.LOD0, co);
parseAndAddMultiSurface(as.getLod2MultiSurface(), Lod.LOD2, co);
} parseAndAddMultiSurface(as.getLod3MultiSurface(), Lod.LOD3, co);
parseAndAddSolid(as.getLod1Solid(), Lod.LOD1, co);
parseAndAddSolid(as.getLod2Solid(), Lod.LOD2, co);
parseAndAddSolid(as.getLod3Solid(), Lod.LOD3, co);
@Override
public void visit(Bridge bridge) { }
BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, bridge);
for (BridgePartProperty bPartProperty : bridge.getBridgeParts()) { @Override
if (!bPartProperty.isSetObject()) { public void visit(Bridge bridge) {
continue; BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, bridge);
} for (BridgePartProperty bPartProperty : bridge.getBridgeParts()) {
BridgePart gmlBridgePart = bPartProperty.getObject(); if (!bPartProperty.isSetObject()) {
BridgeObject bPart = new BridgeObject(BridgeType.BRIDGE_PART, gmlBridgePart); continue;
mapAbstractBridge(gmlBridgePart, bPart); }
bo.addBridgePart(bPart); BridgePart gmlBridgePart = bPartProperty.getObject();
} BridgeObject bPart = new BridgeObject(BridgeType.BRIDGE_PART, gmlBridgePart);
mapAbstractBridge(bridge, bo); mapAbstractBridge(gmlBridgePart, bPart);
resolveAndClearReferences(); bo.addBridgePart(bPart);
updateEdgesAndVertices(bo); }
for (BridgeObject part : bo.getParts()) { mapAbstractBridge(bridge, bo);
updateEdgesAndVertices(part); resolveAndClearReferences();
} updateEdgesAndVertices(bo);
for (BridgeConstructiveElement ele : bo.getConstructiveElements()) { for (BridgeObject part : bo.getParts()) {
updateEdgesAndVertices(ele); updateEdgesAndVertices(part);
for (BoundarySurface bs : ele.getBoundarySurfaces()) { }
updateEdgesAndVertices(bs); for (BridgeConstructiveElement ele : bo.getConstructiveElements()) {
} updateEdgesAndVertices(ele);
} for (BoundarySurface bs : ele.getBoundarySurfaces()) {
for (Installation bi : bo.getBridgeInstallations()) { updateEdgesAndVertices(bs);
updateEdgesAndVertices(bi); }
for (BoundarySurface bs : bi.getBoundarySurfaces()) { }
updateEdgesAndVertices(bs); for (Installation bi : bo.getBridgeInstallations()) {
} updateEdgesAndVertices(bi);
} for (BoundarySurface bs : bi.getBoundarySurfaces()) {
model.addBridge(bo); updateEdgesAndVertices(bs);
} }
}
private void mapAbstractBridge(AbstractBridge ab, BridgeObject bo) { model.addBridge(bo);
mapAbstractConstruction(ab, bo); }
for (BridgeConstructiveElementProperty eleProp : ab.getBridgeConstructiveElements()) {
if (!eleProp.isSetObject()) { private void mapAbstractBridge(AbstractBridge ab, BridgeObject bo) {
continue; mapAbstractConstruction(ab, bo);
} for (BridgeConstructiveElementProperty eleProp : ab.getBridgeConstructiveElements()) {
org.citygml4j.core.model.bridge.BridgeConstructiveElement constructiveElement = eleProp.getObject(); if (!eleProp.isSetObject()) {
BridgeConstructiveElement cdEle = new BridgeConstructiveElement(constructiveElement); continue;
mapConstructiveElement(constructiveElement, cdEle); }
bo.addConstructiveElement(cdEle); org.citygml4j.core.model.bridge.BridgeConstructiveElement constructiveElement = eleProp.getObject();
} BridgeConstructiveElement cdEle = new BridgeConstructiveElement(constructiveElement);
mapConstructiveElement(constructiveElement, cdEle);
List<BridgeInstallationProperty> bridgeInstallations = ab.getBridgeInstallations(); bo.addConstructiveElement(cdEle);
for (BridgeInstallationProperty installationProp : bridgeInstallations) { }
var gmlBi = installationProp.getObject();
if (gmlBi == null) { List<BridgeInstallationProperty> bridgeInstallations = ab.getBridgeInstallations();
// ignore empty properties for (BridgeInstallationProperty installationProp : bridgeInstallations) {
continue; var gmlBi = installationProp.getObject();
} if (gmlBi == null) {
Installation bi = mapBridgeInstallation(gmlBi); // ignore empty properties
bo.addBridgeInstallation(bi); continue;
} }
Installation bi = mapBridgeInstallation(gmlBi);
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); bo.addBridgeInstallation(bi);
for (AbstractSpaceBoundaryProperty surfaceProp : ab.getBoundaries()) { }
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : ab.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
updatePartOfSurface(bo, surfaceMapper); AbstractSpaceBoundary surface = surfaceProp.getObject();
surface.accept(surfaceMapper);
for (BoundarySurface bs : bo.getBoundarySurfaces()) { }
updateEdgesAndVertices(bs); updatePartOfSurface(bo, surfaceMapper);
}
for (BoundarySurface bs : bo.getBoundarySurfaces()) {
bo.unsetGmlGeometries(); updateEdgesAndVertices(bs);
} }
private Installation mapBridgeInstallation(BridgeInstallation gmlBi) { bo.unsetGmlGeometries();
Installation bi = new Installation(); }
bi.setGmlObject(gmlBi);
mapAbstractOccupiedSpace(gmlBi, bi); private Installation mapBridgeInstallation(BridgeInstallation gmlBi) {
GeometryProperty<?> lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry(); Installation bi = new Installation();
parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi); bi.setGmlObject(gmlBi);
GeometryProperty<?> lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry(); mapAbstractOccupiedSpace(gmlBi, bi);
parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi); GeometryProperty<?> lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry();
GeometryProperty<?> lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry(); parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi);
parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi); GeometryProperty<?> lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry();
bi.unsetGmlGeometries(); parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi);
GeometryProperty<?> lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) { bi.unsetGmlGeometries();
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
bi.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); bi.addBoundarySurface(bs);
p.setPartOfInstallation(bi); for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
} p.setPartOfInstallation(bi);
for (Geometry geom : bi.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { }
p.setPartOfInstallation(bi); }
} for (Geometry geom : bi.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
p.setPartOfInstallation(bi);
return bi; }
} }
@Override return bi;
public void visit(Tunnel tunnel){ }
de.hft.stuttgart.citydoctor2.datastructure.Tunnel tu = new de.hft.stuttgart.citydoctor2.datastructure.Tunnel();
for (TunnelPartProperty tPartProperty : tunnel.getTunnelParts()) { @Override
if (!tPartProperty.isSetObject()) { public void visit(Tunnel tunnel) {
continue; de.hft.stuttgart.citydoctor2.datastructure.Tunnel tu = new de.hft.stuttgart.citydoctor2.datastructure.Tunnel();
} for (TunnelPartProperty tPartProperty : tunnel.getTunnelParts()) {
org.citygml4j.core.model.tunnel.TunnelPart gmlTunnelPart = tPartProperty.getObject(); if (!tPartProperty.isSetObject()) {
TunnelPart tPart = new TunnelPart(tu); continue;
readAbstractTunnel(gmlTunnelPart, tPart); }
tu.addTunnelPart(tPart); org.citygml4j.core.model.tunnel.TunnelPart gmlTunnelPart = tPartProperty.getObject();
} TunnelPart tPart = new TunnelPart(tu);
readAbstractTunnel(tunnel, tu); readAbstractTunnel(gmlTunnelPart, tPart);
resolveAndClearReferences(); tu.addTunnelPart(tPart);
updateEdgesAndVertices(tu); }
for (TunnelPart part : tu.getTunnelParts()) { readAbstractTunnel(tunnel, tu);
updateEdgesAndVertices(part); resolveAndClearReferences();
} updateEdgesAndVertices(tu);
model.addTunnel(tu); for (TunnelPart part : tu.getTunnelParts()) {
updateEdgesAndVertices(part);
} }
model.addTunnel(tu);
private void readAbstractTunnel(org.citygml4j.core.model.tunnel.AbstractTunnel gmlTunnel, AbstractTunnel cdTunnel) {
mapAbstractOccupiedSpace(gmlTunnel, cdTunnel); }
cdTunnel.setGmlObject(gmlTunnel);
private void readAbstractTunnel(org.citygml4j.core.model.tunnel.AbstractTunnel gmlTunnel, AbstractTunnel cdTunnel) {
// parse deprecated geometries mapAbstractOccupiedSpace(gmlTunnel, cdTunnel);
parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdTunnel); cdTunnel.setGmlObject(gmlTunnel);
parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdTunnel);
parseAndAddSolid(gmlTunnel.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdTunnel); // parse deprecated geometries
parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdTunnel);
for (TunnelInstallationProperty tiProp : gmlTunnel.getTunnelInstallations()) { parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdTunnel);
var gmlTi = tiProp.getObject(); parseAndAddSolid(gmlTunnel.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdTunnel);
if (gmlTi == null) {
// ignore empty properties for (TunnelInstallationProperty tiProp : gmlTunnel.getTunnelInstallations()) {
continue; var gmlTi = tiProp.getObject();
} if (gmlTi == null) {
Installation ti = mapTunnelInstallation(gmlTi); // ignore empty properties
cdTunnel.addTunnelInstallation(ti); continue;
} }
Installation ti = mapTunnelInstallation(gmlTi);
for (HollowSpaceProperty thProp : gmlTunnel.getHollowSpaces()) { cdTunnel.addTunnelInstallation(ti);
var gmlTh = thProp.getObject(); }
if (gmlTh == null) {
continue; for (HollowSpaceProperty thProp : gmlTunnel.getHollowSpaces()) {
} var gmlTh = thProp.getObject();
TunnelHollow br = mapTunnelHollow(gmlTh); if (gmlTh == null) {
cdTunnel.addTunnelHollow(br); continue;
} }
TunnelHollow br = mapTunnelHollow(gmlTh);
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); cdTunnel.addTunnelHollow(br);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlTunnel.getBoundaries()) { }
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlTunnel.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
AbstractSpaceBoundary surface = surfaceProp.getObject();
cdTunnel.unsetGmlGeometries(); surface.accept(surfaceMapper);
resolveAndClearReferences(); }
updateEdgesAndVertices(cdTunnel);
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { cdTunnel.unsetGmlGeometries();
updateEdgesAndVertices(bs); resolveAndClearReferences();
for (Opening o : bs.getOpenings()) { updateEdgesAndVertices(cdTunnel);
updateEdgesAndVertices(o); for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
} updateEdgesAndVertices(bs);
} for (Opening o : bs.getOpenings()) {
for (Installation ti : cdTunnel.getTunnelInstallations()) { updateEdgesAndVertices(o);
updateEdgesAndVertices(ti); }
for (BoundarySurface bs : ti.getBoundarySurfaces()) { }
updateEdgesAndVertices(bs); for (Installation ti : cdTunnel.getTunnelInstallations()) {
for (Opening o : bs.getOpenings()) { updateEdgesAndVertices(ti);
updateEdgesAndVertices(o); for (BoundarySurface bs : ti.getBoundarySurfaces()) {
} updateEdgesAndVertices(bs);
} for (Opening o : bs.getOpenings()) {
} updateEdgesAndVertices(o);
for (TunnelFurnitureProperty tfProp : gmlTunnel.getTunnelFurniture()){ }
var gmlTf = tfProp.getObject(); }
if (gmlTf == null) { }
continue; for (TunnelFurnitureProperty tfProp : gmlTunnel.getTunnelFurniture()) {
} var gmlTf = tfProp.getObject();
TunnelFurniture tf = mapTunnelFurniture(gmlTf); if (gmlTf == null) {
cdTunnel.addTunnelFurniture(tf); continue;
} }
} TunnelFurniture tf = mapTunnelFurniture(gmlTf);
cdTunnel.addTunnelFurniture(tf);
private Installation mapTunnelInstallation(TunnelInstallation gmlTi){ }
Installation ti = new Installation(); }
ti.setGmlObject(gmlTi);
mapAbstractOccupiedSpace(gmlTi, ti); private Installation mapTunnelInstallation(TunnelInstallation gmlTi) {
GeometryProperty<?> lod2Prop = gmlTi.getDeprecatedProperties().getLod2Geometry(); Installation ti = new Installation();
parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, ti); ti.setGmlObject(gmlTi);
GeometryProperty<?> lod3Prop = gmlTi.getDeprecatedProperties().getLod3Geometry(); mapAbstractOccupiedSpace(gmlTi, ti);
parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, ti); GeometryProperty<?> lod2Prop = gmlTi.getDeprecatedProperties().getLod2Geometry();
GeometryProperty<?> lod4Prop = gmlTi.getDeprecatedProperties().getLod4Geometry(); parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, ti);
parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, ti); GeometryProperty<?> lod3Prop = gmlTi.getDeprecatedProperties().getLod3Geometry();
ti.unsetGmlGeometries(); parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, ti);
GeometryProperty<?> lod4Prop = gmlTi.getDeprecatedProperties().getLod4Geometry();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, ti);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlTi.getBoundaries()) { ti.unsetGmlGeometries();
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlTi.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
ti.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); ti.addBoundarySurface(bs);
p.setPartOfInstallation(ti); for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
} p.setPartOfInstallation(ti);
for (Geometry geom : ti.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { }
p.setPartOfInstallation(ti); }
} for (Geometry geom : ti.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
p.setPartOfInstallation(ti);
return ti; }
} }
private TunnelHollow mapTunnelHollow(HollowSpace gmlHo){ return ti;
TunnelHollow tHollow = new TunnelHollow(); }
tHollow.setGmlObject(gmlHo);
mapAbstractUnoccupiedSpace(gmlHo,tHollow); private TunnelHollow mapTunnelHollow(HollowSpace gmlHo) {
TunnelHollow tHollow = new TunnelHollow();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); tHollow.setGmlObject(gmlHo);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlHo.getBoundaries()) { mapAbstractUnoccupiedSpace(gmlHo, tHollow);
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlHo.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
tHollow.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); tHollow.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
for (TunnelInstallationProperty tiProp : gmlHo.getTunnelInstallations()) { }
var gmlTi = tiProp.getObject(); }
if (gmlTi == null) { }
// ignore empty properties for (TunnelInstallationProperty tiProp : gmlHo.getTunnelInstallations()) {
continue; var gmlTi = tiProp.getObject();
} if (gmlTi == null) {
Installation bi = mapTunnelInstallation(gmlTi); // ignore empty properties
tHollow.addRoomInstallation(bi); continue;
} }
for (TunnelFurnitureProperty tfProp : gmlHo.getTunnelFurniture()){ Installation bi = mapTunnelInstallation(gmlTi);
var gmlHref = tfProp.getHref(); tHollow.addRoomInstallation(bi);
if (gmlHref == null) { }
continue; for (TunnelFurnitureProperty tfProp : gmlHo.getTunnelFurniture()) {
} var gmlHref = tfProp.getHref();
tHollow.addFurnitureRef(tfProp); if (gmlHref == null) {
} continue;
return tHollow; }
} tHollow.addFurnitureRef(tfProp);
}
private TunnelFurniture mapTunnelFurniture(org.citygml4j.core.model.tunnel.TunnelFurniture gmlTf){ return tHollow;
TunnelFurniture tf = new TunnelFurniture(); }
tf.setGmlObject(gmlTf);
mapAbstractOccupiedSpace(gmlTf, tf); private TunnelFurniture mapTunnelFurniture(org.citygml4j.core.model.tunnel.TunnelFurniture gmlTf) {
tf.unsetGmlGeometries(); TunnelFurniture tf = new TunnelFurniture();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); tf.setGmlObject(gmlTf);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlTf.getBoundaries()) { mapAbstractOccupiedSpace(gmlTf, tf);
if (!surfaceProp.isSetObject()) { tf.unsetGmlGeometries();
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlTf.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
tf.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); tf.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
return tf; }
} }
}
private void updatePartOfSurface(BridgeObject bo, SurfaceMapper surfaceMapper) { return tf;
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { }
bo.addBoundarySurface(bs);
for (Geometry geom : bs.getGeometries()) { private void updatePartOfSurface(BridgeObject bo, SurfaceMapper surfaceMapper) {
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); bo.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
} }
}
private void mapConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement ele, BridgeConstructiveElement bce) { }
mapAbstractConstructiveElement(ele, bce); }
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); private void mapConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement ele, BridgeConstructiveElement bce) {
for (AbstractSpaceBoundaryProperty surfaceProp : ele.getBoundaries()) { mapAbstractConstructiveElement(ele, bce);
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : ele.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
bce.addBoundarySurface(bs); surface.accept(surfaceMapper);
} }
} for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
bce.addBoundarySurface(bs);
private void mapAbstractConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement ele, BridgeConstructiveElement bce) { }
mapAbstractOccupiedSpace(ele, bce); }
}
private void mapAbstractConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement ele, BridgeConstructiveElement bce) {
private void mapAbstractConstruction(AbstractConstruction ac, BridgeObject bo) { mapAbstractOccupiedSpace(ele, bce);
mapAbstractOccupiedSpace(ac, bo); }
}
private void mapAbstractConstruction(AbstractConstruction ac, BridgeObject bo) {
@Override mapAbstractOccupiedSpace(ac, bo);
public void visit(AuxiliaryTrafficArea ata) { }
TransportationObject to = new TransportationObject(TransportationType.AUXILLIARY_TRAFFIC_AREA);
mapAbstractThematicSurface(ata, to); @Override
finishTransportationMapping(to); public void visit(AuxiliaryTrafficArea ata) {
} TransportationObject to = new TransportationObject(TransportationType.AUXILLIARY_TRAFFIC_AREA);
mapAbstractThematicSurface(ata, to);
@Override finishTransportationMapping(to);
public void visit(TrafficArea ta) { }
TransportationObject to = new TransportationObject(TransportationType.TRAFFIC_AREA);
mapAbstractThematicSurface(ta, to); @Override
finishTransportationMapping(to); public void visit(TrafficArea ta) {
} TransportationObject to = new TransportationObject(TransportationType.TRAFFIC_AREA);
mapAbstractThematicSurface(ta, to);
@Override finishTransportationMapping(to);
public void visit(Road road) { }
TransportationObject to = new TransportationObject(TransportationType.ROAD);
mapAbstractTransportationSpace(road, to); @Override
finishTransportationMapping(to); public void visit(Road road) {
} TransportationObject to = new TransportationObject(TransportationType.ROAD);
mapAbstractTransportationSpace(road, to);
private void mapAbstractThematicSurface(AbstractThematicSurface ats, CityObject co) { finishTransportationMapping(to);
mapAbstractSpaceBoundary(ats, co); }
parseAndAddMultiSurface(ats.getLod0MultiSurface(), Lod.LOD0, co);
parseAndAddMultiSurface(ats.getLod1MultiSurface(), Lod.LOD1, co); private void mapAbstractThematicSurface(AbstractThematicSurface ats, CityObject co) {
parseAndAddMultiSurface(ats.getLod2MultiSurface(), Lod.LOD2, co); mapAbstractSpaceBoundary(ats, co);
parseAndAddMultiSurface(ats.getLod3MultiSurface(), Lod.LOD3, co); parseAndAddMultiSurface(ats.getLod0MultiSurface(), Lod.LOD0, co);
parseAndAddMultiSurface(ats.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, co); parseAndAddMultiSurface(ats.getLod1MultiSurface(), Lod.LOD1, co);
} parseAndAddMultiSurface(ats.getLod2MultiSurface(), Lod.LOD2, co);
parseAndAddMultiSurface(ats.getLod3MultiSurface(), Lod.LOD3, co);
private void mapAbstractSpaceBoundary(AbstractSpaceBoundary asb, CityObject co) { parseAndAddMultiSurface(ats.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, co);
mapAbstractCityObject(asb, co); }
}
private void mapAbstractSpaceBoundary(AbstractSpaceBoundary asb, CityObject co) {
private void mapAbstractCityObject(AbstractCityObject aco, CityObject to) { mapAbstractCityObject(asb, co);
mapAbstractFeatureWithLifespan(aco, to); }
}
private void mapAbstractCityObject(AbstractCityObject aco, CityObject to) {
private void mapAbstractFeatureWithLifespan(AbstractFeatureWithLifespan afwl, CityObject to) { mapAbstractFeatureWithLifespan(aco, to);
mapAbstractFeature(afwl, to); }
}
private void mapAbstractFeatureWithLifespan(AbstractFeatureWithLifespan afwl, CityObject to) {
private void mapAbstractFeature(AbstractFeature af, CityObject to) { mapAbstractFeature(afwl, to);
mapAbstractGML(af, to); }
}
private void mapAbstractFeature(AbstractFeature af, CityObject to) {
private void mapAbstractGML(AbstractGML ag, CityObject to) { mapAbstractGML(af, to);
parseId(ag, to); }
}
private void mapAbstractGML(AbstractGML ag, CityObject to) {
@Override parseId(ag, to);
public void visit(Railway railway) { }
TransportationObject to = new TransportationObject(TransportationType.RAILWAY);
mapAbstractTransportationSpace(railway, to); @Override
finishTransportationMapping(to); public void visit(Railway railway) {
} TransportationObject to = new TransportationObject(TransportationType.RAILWAY);
mapAbstractTransportationSpace(railway, to);
@Override finishTransportationMapping(to);
public void visit(Square square) { }
TransportationObject to = new TransportationObject(TransportationType.SQUARE);
mapAbstractTransportationSpace(square, to); @Override
finishTransportationMapping(to); public void visit(Square square) {
} TransportationObject to = new TransportationObject(TransportationType.SQUARE);
mapAbstractTransportationSpace(square, to);
@Override finishTransportationMapping(to);
public void visit(Track track) { }
TransportationObject to = new TransportationObject(TransportationType.TRACK);
mapAbstractTransportationSpace(track, to); @Override
finishTransportationMapping(to); public void visit(Track track) {
} TransportationObject to = new TransportationObject(TransportationType.TRACK);
mapAbstractTransportationSpace(track, to);
@Override finishTransportationMapping(to);
public void visit(TransportationComplex transportationComplex) { }
TransportationObject to = new TransportationObject(TransportationType.TRANSPORTATION_COMPLEX);
mapAbstractTransportationSpace(transportationComplex, to); @Override
finishTransportationMapping(to); public void visit(TransportationComplex transportationComplex) {
} TransportationObject to = new TransportationObject(TransportationType.TRANSPORTATION_COMPLEX);
mapAbstractTransportationSpace(transportationComplex, to);
private void finishTransportationMapping(TransportationObject to) { finishTransportationMapping(to);
finishCityObjectConstruction(to); }
model.addTransportation(to);
} private void finishTransportationMapping(TransportationObject to) {
finishCityObjectConstruction(to);
private void finishCityObjectConstruction(CityObject co) { model.addTransportation(to);
co.unsetGmlGeometries(); }
resolveAndClearReferences();
updateEdgesAndVertices(co); private void finishCityObjectConstruction(CityObject co) {
} co.unsetGmlGeometries();
resolveAndClearReferences();
private void mapAbstractTransportationSpace(AbstractTransportationSpace ats, TransportationObject to) { updateEdgesAndVertices(co);
to.setGmlObject(ats); }
parseAbstractTransportationSpaceGeometries(ats, to);
for (TrafficSpaceProperty tsp : ats.getTrafficSpaces()) { private void mapAbstractTransportationSpace(AbstractTransportationSpace ats, TransportationObject to) {
if (tsp.isSetObject()) { to.setGmlObject(ats);
TransportationObject trafficSpace = new TransportationObject(TransportationType.TRAFFIC_SPACE); parseAbstractTransportationSpaceGeometries(ats, to);
mapTrafficSpace(tsp.getObject(), trafficSpace); for (TrafficSpaceProperty tsp : ats.getTrafficSpaces()) {
finishTransportationMapping(trafficSpace); if (tsp.isSetObject()) {
to.getChildren().add(trafficSpace); TransportationObject trafficSpace = new TransportationObject(TransportationType.TRAFFIC_SPACE);
} mapTrafficSpace(tsp.getObject(), trafficSpace);
} finishTransportationMapping(trafficSpace);
for (AuxiliaryTrafficSpaceProperty auxTrafficProp : ats.getAuxiliaryTrafficSpaces()) { to.getChildren().add(trafficSpace);
if (auxTrafficProp.isSetObject()) { }
TransportationObject trafficSpace = parseAuxiliaryTrafficSpace(auxTrafficProp.getObject()); }
finishTransportationMapping(trafficSpace); for (AuxiliaryTrafficSpaceProperty auxTrafficProp : ats.getAuxiliaryTrafficSpaces()) {
to.addChild(trafficSpace); if (auxTrafficProp.isSetObject()) {
} TransportationObject trafficSpace = parseAuxiliaryTrafficSpace(auxTrafficProp.getObject());
} finishTransportationMapping(trafficSpace);
} to.addChild(trafficSpace);
}
private void mapTrafficSpace(TrafficSpace ts, TransportationObject to) { }
mapAbstractUnoccupiedSpace(ts, to); }
}
private void mapTrafficSpace(TrafficSpace ts, TransportationObject to) {
private void mapAbstractUnoccupiedSpace(AbstractUnoccupiedSpace aus, CityObject co) { mapAbstractUnoccupiedSpace(ts, to);
mapAbstractPhysicalSpace(aus, co); }
}
private void mapAbstractUnoccupiedSpace(AbstractUnoccupiedSpace aus, CityObject co) {
private TransportationObject parseAuxiliaryTrafficSpace(AuxiliaryTrafficSpace ats) { mapAbstractPhysicalSpace(aus, co);
TransportationObject to = new TransportationObject(TransportationType.AUXILLIARY_TRAFFIC_SPACE); }
parseAbstractSpaceGeometries(ats, to);
finishCityObjectConstruction(to); private TransportationObject parseAuxiliaryTrafficSpace(AuxiliaryTrafficSpace ats) {
return to; TransportationObject to = new TransportationObject(TransportationType.AUXILLIARY_TRAFFIC_SPACE);
} parseAbstractSpaceGeometries(ats, to);
finishCityObjectConstruction(to);
private void parseAbstractTransportationSpaceGeometries(AbstractTransportationSpace space, CityObject co) { return to;
parseAndAddMultiSurface(space.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, co); }
parseAndAddMultiSurface(space.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, co);
} private void parseAbstractTransportationSpaceGeometries(AbstractTransportationSpace space, CityObject co) {
parseAndAddMultiSurface(space.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, co);
private void parseAbstractSpaceGeometries(AbstractSpace as, CityObject co) { parseAndAddMultiSurface(space.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, co);
parseAndAddMultiSurface(as.getLod0MultiSurface(), Lod.LOD0, co); }
parseAndAddMultiSurface(as.getLod2MultiSurface(), Lod.LOD2, co);
parseAndAddMultiSurface(as.getLod3MultiSurface(), Lod.LOD3, co); private void parseAbstractSpaceGeometries(AbstractSpace as, CityObject co) {
parseAndAddSolid(as.getLod1Solid(), Lod.LOD1, co); parseAndAddMultiSurface(as.getLod0MultiSurface(), Lod.LOD0, co);
parseAndAddSolid(as.getLod2Solid(), Lod.LOD2, co); parseAndAddMultiSurface(as.getLod2MultiSurface(), Lod.LOD2, co);
parseAndAddSolid(as.getLod3Solid(), Lod.LOD3, co); parseAndAddMultiSurface(as.getLod3MultiSurface(), Lod.LOD3, co);
parseAndAddSolid(as.getLod1Solid(), Lod.LOD1, co);
} parseAndAddSolid(as.getLod2Solid(), Lod.LOD2, co);
parseAndAddSolid(as.getLod3Solid(), Lod.LOD3, co);
private void parseAndAddMultiSurface(MultiSurfaceProperty msp, Lod lod, CityObject co) {
if (msp == null || msp.getObject() == null) { }
return;
} private void parseAndAddMultiSurface(MultiSurfaceProperty msp, Lod lod, CityObject co) {
Geometry geom = parseMultiSurface(msp.getObject(), lod); if (msp == null || msp.getObject() == null) {
co.addGeometry(geom); return;
} }
Geometry geom = parseMultiSurface(msp.getObject(), lod);
private void parseAndAddSolid(SolidProperty sp, Lod lod, CityObject co) { co.addGeometry(geom);
if (sp == null || sp.getObject() == null) { }
return;
} private void parseAndAddSolid(SolidProperty sp, Lod lod, CityObject co) {
Geometry geom = parseSolid(sp.getObject(), lod); if (sp == null || sp.getObject() == null) {
if (geom != null) { return;
co.addGeometry(geom); }
} Geometry geom = parseSolid(sp.getObject(), lod);
} if (geom != null) {
co.addGeometry(geom);
private void parseAndAddCompositeSurface(MultiSurfaceProperty ms, Lod lod, CityObject co){ }
if (ms == null || ms.getObject() == null) { }
return;
} private void parseAndAddCompositeSurface(MultiSurfaceProperty ms, Lod lod, CityObject co) {
List<SurfaceProperty> surfaces = ms.getObject().getSurfaceMember(); if (ms == null || ms.getObject() == null) {
for (SurfaceProperty surface : surfaces) { return;
if (surface.getObject() instanceof CompositeSurface cs) { }
Geometry geom = parseCompositeSurface(cs, lod); List<SurfaceProperty> surfaces = ms.getObject().getSurfaceMember();
if (geom != null) { for (SurfaceProperty surface : surfaces) {
co.addGeometry(geom); if (surface.getObject() instanceof CompositeSurface cs) {
} Geometry geom = parseCompositeSurface(cs, lod);
} if (geom != null) {
} co.addGeometry(geom);
}
} }
}
private void parseImplicitGeometry(AbstractOccupiedSpace aos, CityObject co){
for (int i = 1; i <= 3; i++){ }
if (aos.getImplicitRepresentation(i) == null){
continue; private void parseImplicitGeometry(AbstractOccupiedSpace aos, CityObject co) {
} for (int i = 1; i <= 3; i++) {
if (aos.getImplicitRepresentation(i).getObject() != null){ if (aos.getImplicitRepresentation(i) == null) {
ImplicitGeometry impGeom = aos.getImplicitRepresentation(i).getObject(); continue;
ImplicitGeometryHolder igh = resolveImplicitGeometry(impGeom, i); }
if (igh != null){ if (aos.getImplicitRepresentation(i).getObject() != null) {
co.addGeometry(igh); ImplicitGeometry impGeom = aos.getImplicitRepresentation(i).getObject();
} ImplicitGeometryHolder igh = resolveImplicitGeometry(impGeom, i);
} else if (aos.getImplicitRepresentation(i).getHref() != null){ if (igh != null) {
// TODO: HREF handling of implicit geometries co.addGeometry(igh);
} }
} else if (aos.getImplicitRepresentation(i).getHref() != null) {
// Hrefs of ImplicitGeometries point to its RelativeGeometry.
} // Can be ignored for CD since the Href is only used for repeating the RelativeGeometry at different LODs
}
}
private ImplicitGeometryHolder resolveImplicitGeometry(ImplicitGeometry ig, int lodInt) { }
ImplicitGeometryHolder igh = null;
if (ig.getLibraryObject() != null){ }
Path libraryObjectPath = directory.resolve(ig.getLibraryObject());
LibraryObject libObj = LibraryObject.of(libraryObjectPath, config); private ImplicitGeometryHolder resolveImplicitGeometry(ImplicitGeometry ig, int lodInt) {
if (libObj != null){ ImplicitGeometryHolder igh = null;
igh = new ImplicitGeometryHolder(ig, libObj); if (ig.getLibraryObject() != null) {
} Path libraryObjectPath = directory.resolve(ig.getLibraryObject());
} else if (ig.getRelativeGeometry() != null){ LibraryObject libObj = LibraryObject.of(libraryObjectPath, config);
AbstractGeometry aGeom = ig.getRelativeGeometry().getObject(); if (libObj != null) {
Geometry geom = null; igh = new ImplicitGeometryHolder(ig, libObj);
Lod lod = Lod.values()[lodInt]; }
RelativeGeometry relGeo = null; } else if (ig.getRelativeGeometry() != null) {
if (aGeom instanceof MultiSurface ms){ AbstractGeometry aGeom = ig.getRelativeGeometry().getObject();
geom = parseMultiSurface(ms, lod); Geometry geom = null;
} else if (aGeom instanceof Solid s){ Lod lod = Lod.values()[lodInt];
geom = parseSolid(s, lod); RelativeGeometry relGeo = null;
} else if (aGeom instanceof CompositeSurface cs){ if (aGeom instanceof MultiSurface ms) {
geom = parseCompositeSurface(cs, lod); geom = parseMultiSurface(ms, lod);
} } else if (aGeom instanceof Solid s) {
if (geom != null){ geom = parseSolid(s, lod);
relGeo = RelativeGeometry.of(geom); } else if (aGeom instanceof CompositeSurface cs) {
igh = new ImplicitGeometryHolder(ig, relGeo); geom = parseCompositeSurface(cs, lod);
} }
if (geom != null) {
} else{ relGeo = RelativeGeometry.of(geom);
logger.error(String.format("Implicit geometry of GML-ID %s has no referenced geometry.", ig.getId())); igh = new ImplicitGeometryHolder(ig, relGeo);
} }
return igh;
} } else {
logger.error(String.format("Implicit geometry of GML-ID %s has no referenced geometry.", ig.getId()));
private void resolveAndClearReferences() { }
for (ResolvableReference ref : references) { return igh;
String href = ref.href(); }
if (href.startsWith("#")) {
href = href.substring(1); private void resolveAndClearReferences() {
} for (ResolvableReference ref : references) {
Geometry geom = ref.geometry(); String href = ref.href();
ConcretePolygon concPoly = polygonMap.get(href); if (href.startsWith("#")) {
if (concPoly == null) { href = href.substring(1);
if (logger.isWarnEnabled()) { }
logger.warn(Localization.getText("FeatureMapper.polygonUnreferenced"), href); Geometry geom = ref.geometry();
} ConcretePolygon concPoly = polygonMap.get(href);
continue; if (concPoly == null) {
} if (logger.isWarnEnabled()) {
if (concPoly instanceof CompositePolygon comp) { logger.warn(Localization.getText("FeatureMapper.polygonUnreferenced"), href);
resolveCompositePolygon(comp).forEach(geom::addPolygon); }
} else { continue;
// }
if (concPoly instanceof CompositePolygon comp) {
LinkedPolygon lPoly = new LinkedPolygon(concPoly, geom); resolveCompositePolygon(comp).forEach(geom::addPolygon);
if (geom.getParent() instanceof BoundarySurface bs) { } else {
lPoly.setPartOfSurface(bs); //
if (bs.getParent() instanceof Installation bi) {
lPoly.setPartOfInstallation(bi); LinkedPolygon lPoly = new LinkedPolygon(concPoly, geom);
} if (geom.getParent() instanceof BoundarySurface bs) {
} lPoly.setPartOfSurface(bs);
geom.addPolygon(lPoly); if (bs.getParent() instanceof Installation bi) {
} lPoly.setPartOfInstallation(bi);
} }
}
// clear storage for polygons and vertices geom.addPolygon(lPoly);
// probably faster than .clear() ? }
references = new ArrayList<>(); }
vertexMap = new HashMap<>();
polygonMap = new HashMap<>(); // clear storage for polygons and vertices
} // probably faster than .clear() ?
references = new ArrayList<>();
private List<ConcretePolygon> resolveCompositePolygon(CompositePolygon comp) { vertexMap = new HashMap<>();
List<ConcretePolygon> polygons = new ArrayList<>(); polygonMap = new HashMap<>();
for (ConcretePolygon conc: comp.getCompositeMembers()){ }
if (conc instanceof CompositePolygon recComp){
polygons.addAll(resolveCompositePolygon(recComp)); private List<ConcretePolygon> resolveCompositePolygon(CompositePolygon comp) {
} else { List<ConcretePolygon> polygons = new ArrayList<>();
polygons.add(conc); for (ConcretePolygon conc : comp.getCompositeMembers()) {
} if (conc instanceof CompositePolygon recComp) {
} polygons.addAll(resolveCompositePolygon(recComp));
return polygons; } else {
} polygons.add(conc);
}
private void readAbstractBuilding(org.citygml4j.core.model.building.AbstractBuilding gmlAb, }
AbstractBuilding cdBuilding) { return polygons;
mapAbstractOccupiedSpace(gmlAb, cdBuilding); }
cdBuilding.setGmlObject(gmlAb);
private void readAbstractBuilding(org.citygml4j.core.model.building.AbstractBuilding gmlAb,
// parse deprecated geometries AbstractBuilding cdBuilding) {
parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdBuilding); mapAbstractOccupiedSpace(gmlAb, cdBuilding);
parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdBuilding); cdBuilding.setGmlObject(gmlAb);
parseAndAddSolid(gmlAb.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdBuilding);
// parse deprecated geometries
for (BuildingInstallationProperty biProp : gmlAb.getBuildingInstallations()) { parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdBuilding);
var gmlBi = biProp.getObject(); parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdBuilding);
if (gmlBi == null) { parseAndAddSolid(gmlAb.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdBuilding);
// ignore empty properties
continue; for (BuildingInstallationProperty biProp : gmlAb.getBuildingInstallations()) {
} var gmlBi = biProp.getObject();
Installation bi = mapBuildingInstallation(gmlBi); if (gmlBi == null) {
cdBuilding.addBuildingInstallation(bi); // ignore empty properties
} continue;
}
for (BuildingRoomProperty brProp : gmlAb.getBuildingRooms()) { Installation bi = mapBuildingInstallation(gmlBi);
var gmlBr = brProp.getObject(); cdBuilding.addBuildingInstallation(bi);
if (gmlBr == null) { }
continue;
} for (BuildingRoomProperty brProp : gmlAb.getBuildingRooms()) {
BuildingRoom br = mapBuildingRoom(gmlBr); var gmlBr = brProp.getObject();
cdBuilding.addBuildingRoom(br); if (gmlBr == null) {
} continue;
}
for(AbstractBuildingSubdivisionProperty abs : gmlAb.getBuildingSubdivisions()) { BuildingRoom br = mapBuildingRoom(gmlBr);
var gmlABS = abs.getObject(); cdBuilding.addBuildingRoom(br);
if (gmlABS == null) { }
continue;
} for (AbstractBuildingSubdivisionProperty abs : gmlAb.getBuildingSubdivisions()) {
if (gmlABS instanceof Storey gmlStorey) { var gmlABS = abs.getObject();
de.hft.stuttgart.citydoctor2.datastructure.Storey storey = mapBuildingStorey(gmlStorey); if (gmlABS == null) {
cdBuilding.addStorey(storey); continue;
} }
else if (gmlABS instanceof BuildingUnit gmlBU){ if (gmlABS instanceof Storey gmlStorey) {
de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit bu = mapBuildingUnit(gmlBU); de.hft.stuttgart.citydoctor2.datastructure.Storey storey = mapBuildingStorey(gmlStorey);
cdBuilding.addBuildingUnit(bu); cdBuilding.addStorey(storey);
} } else if (gmlABS instanceof BuildingUnit gmlBU) {
} de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit bu = mapBuildingUnit(gmlBU);
cdBuilding.addBuildingUnit(bu);
}
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); }
for (AbstractSpaceBoundaryProperty surfaceProp : gmlAb.getBoundaries()) {
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlAb.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
updatePartOfSurface(cdBuilding, surfaceMapper); AbstractSpaceBoundary surface = surfaceProp.getObject();
surface.accept(surfaceMapper);
cdBuilding.unsetGmlGeometries(); }
resolveAndClearReferences(); updatePartOfSurface(cdBuilding, surfaceMapper);
updateEdgesAndVertices(cdBuilding);
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { cdBuilding.unsetGmlGeometries();
updateEdgesAndVertices(bs); resolveAndClearReferences();
for (Opening o : bs.getOpenings()) { updateEdgesAndVertices(cdBuilding);
updateEdgesAndVertices(o); for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
} updateEdgesAndVertices(bs);
} for (Opening o : bs.getOpenings()) {
for (Installation bi : cdBuilding.getBuildingInstallations()) { updateEdgesAndVertices(o);
updateEdgesAndVertices(bi); }
for (BoundarySurface bs : bi.getBoundarySurfaces()) { }
updateEdgesAndVertices(bs); for (Installation bi : cdBuilding.getBuildingInstallations()) {
for (Opening o : bs.getOpenings()) { updateEdgesAndVertices(bi);
updateEdgesAndVertices(o); for (BoundarySurface bs : bi.getBoundarySurfaces()) {
} updateEdgesAndVertices(bs);
} for (Opening o : bs.getOpenings()) {
} updateEdgesAndVertices(o);
for (BuildingFurnitureProperty bfProp : gmlAb.getBuildingFurniture()){ }
var gmlBf = bfProp.getObject(); }
if (gmlBf == null) { }
continue; for (BuildingFurnitureProperty bfProp : gmlAb.getBuildingFurniture()) {
} var gmlBf = bfProp.getObject();
BuildingRoomFurniture bf = mapBuildingFurniture(gmlBf); if (gmlBf == null) {
cdBuilding.addBuildingRoomFurniture(bf); continue;
} }
} BuildingRoomFurniture bf = mapBuildingFurniture(gmlBf);
cdBuilding.addBuildingRoomFurniture(bf);
private BuildingRoom mapBuildingRoom(org.citygml4j.core.model.building.BuildingRoom gmlBr) { }
}
BuildingRoom br = new BuildingRoom();
br.setGmlObject(gmlBr); private BuildingRoom mapBuildingRoom(org.citygml4j.core.model.building.BuildingRoom gmlBr) {
mapAbstractUnoccupiedSpace(gmlBr,br);
BuildingRoom br = new BuildingRoom();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); br.setGmlObject(gmlBr);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlBr.getBoundaries()) { mapAbstractUnoccupiedSpace(gmlBr, br);
if (!surfaceProp.isSetObject()) {
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlBr.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
br.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); br.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
for (BuildingInstallationProperty biProp : gmlBr.getBuildingInstallations()) { }
var gmlBi = biProp.getObject(); }
if (gmlBi == null) { }
// ignore empty properties for (BuildingInstallationProperty biProp : gmlBr.getBuildingInstallations()) {
continue; var gmlBi = biProp.getObject();
} if (gmlBi == null) {
Installation bi = mapBuildingInstallation(gmlBi); // ignore empty properties
br.addRoomInstallation(bi); continue;
} }
for (BuildingFurnitureProperty bfProp : gmlBr.getBuildingFurniture()){ Installation bi = mapBuildingInstallation(gmlBi);
var gmlHref = bfProp.getHref(); br.addRoomInstallation(bi);
if (gmlHref == null) { }
continue; for (BuildingFurnitureProperty bfProp : gmlBr.getBuildingFurniture()) {
} var gmlHref = bfProp.getHref();
br.addFurnitureRef(bfProp); if (gmlHref == null) {
} continue;
}
br.addFurnitureRef(bfProp);
return br; }
}
private BuildingRoomFurniture mapBuildingFurniture(BuildingFurniture gmlAF){ return br;
BuildingRoomFurniture bf = new BuildingRoomFurniture(); }
bf.setGmlObject(gmlAF);
mapAbstractOccupiedSpace(gmlAF, bf); private BuildingRoomFurniture mapBuildingFurniture(BuildingFurniture gmlAF) {
bf.unsetGmlGeometries(); BuildingRoomFurniture bf = new BuildingRoomFurniture();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); bf.setGmlObject(gmlAF);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlAF.getBoundaries()) { mapAbstractOccupiedSpace(gmlAF, bf);
if (!surfaceProp.isSetObject()) { bf.unsetGmlGeometries();
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlAF.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
bf.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); bf.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
return bf; }
}
} }
return bf;
private de.hft.stuttgart.citydoctor2.datastructure.Storey mapBuildingStorey(Storey gmlStorey){
de.hft.stuttgart.citydoctor2.datastructure.Storey storey = new de.hft.stuttgart.citydoctor2.datastructure.Storey(); }
storey.setGmlObject(gmlStorey);
mapAbstractSpace(gmlStorey, storey); private de.hft.stuttgart.citydoctor2.datastructure.Storey mapBuildingStorey(Storey gmlStorey) {
storey.unsetGmlGeometries(); de.hft.stuttgart.citydoctor2.datastructure.Storey storey = new de.hft.stuttgart.citydoctor2.datastructure.Storey();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); storey.setGmlObject(gmlStorey);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlStorey.getBoundaries()) { mapAbstractSpace(gmlStorey, storey);
if (!surfaceProp.isSetObject()) { storey.unsetGmlGeometries();
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlStorey.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
storey.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); storey.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
return storey; }
} }
}
private de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit mapBuildingUnit(BuildingUnit gmlBU){ return storey;
de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit bu = new de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit(); }
bu.setGmlObject(gmlBU);
mapAbstractSpace(gmlBU, bu); private de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit mapBuildingUnit(BuildingUnit gmlBU) {
bu.unsetGmlGeometries(); de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit bu = new de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit();
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); bu.setGmlObject(gmlBU);
for (AbstractSpaceBoundaryProperty surfaceProp : gmlBU.getBoundaries()) { mapAbstractSpace(gmlBU, bu);
if (!surfaceProp.isSetObject()) { bu.unsetGmlGeometries();
continue; SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
} for (AbstractSpaceBoundaryProperty surfaceProp : gmlBU.getBoundaries()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); if (!surfaceProp.isSetObject()) {
surface.accept(surfaceMapper); continue;
} }
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
bu.addBoundarySurface(bs); surface.accept(surfaceMapper);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); bu.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
return bu; }
} }
}
private void updatePartOfSurface(AbstractBuilding cdBuilding, SurfaceMapper surfaceMapper) { return bu;
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { }
cdBuilding.addBoundarySurface(bs);
for (Geometry geom : bs.getGeometries()) { private void updatePartOfSurface(AbstractBuilding cdBuilding, SurfaceMapper surfaceMapper) {
for (Polygon p : geom.getPolygons()) { for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
p.setPartOfSurface(bs); cdBuilding.addBoundarySurface(bs);
} for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfSurface(bs);
} }
}
public static void parseId(AbstractGML gml, GmlElement gmlElement) { }
String id = gml.getId(); }
if (id != null) {
gmlElement.setGmlId(new GmlId(id)); private Installation mapBuildingInstallation(org.citygml4j.core.model.building.BuildingInstallation gmlBi) {
} Installation bi = new Installation();
} bi.setGmlObject(gmlBi);
mapAbstractOccupiedSpace(gmlBi, bi);
private Installation mapBuildingInstallation(org.citygml4j.core.model.building.BuildingInstallation gmlBi) { GeometryProperty<?> lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry();
Installation bi = new Installation(); parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi);
bi.setGmlObject(gmlBi); GeometryProperty<?> lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry();
mapAbstractOccupiedSpace(gmlBi, bi); parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi);
GeometryProperty<?> lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry(); GeometryProperty<?> lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry();
parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi); parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi);
GeometryProperty<?> lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry(); bi.unsetGmlGeometries();
parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi);
GeometryProperty<?> lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry(); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config);
parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi); for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) {
bi.unsetGmlGeometries(); if (!surfaceProp.isSetObject()) {
continue;
SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, vertexMap, config); }
for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) { AbstractSpaceBoundary surface = surfaceProp.getObject();
if (!surfaceProp.isSetObject()) { surface.accept(surfaceMapper);
continue; }
} for (BoundarySurface bs : surfaceMapper.getSurfaces()) {
AbstractSpaceBoundary surface = surfaceProp.getObject(); bi.addBoundarySurface(bs);
surface.accept(surfaceMapper); for (Geometry geom : bs.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
for (BoundarySurface bs : surfaceMapper.getSurfaces()) { p.setPartOfSurface(bs);
bi.addBoundarySurface(bs); p.setPartOfInstallation(bi);
for (Geometry geom : bs.getGeometries()) { }
for (Polygon p : geom.getPolygons()) { }
p.setPartOfSurface(bs); }
p.setPartOfInstallation(bi); for (Geometry geom : bi.getGeometries()) {
} for (Polygon p : geom.getPolygons()) {
} p.setPartOfInstallation(bi);
} }
for (Geometry geom : bi.getGeometries()) { }
for (Polygon p : geom.getPolygons()) {
p.setPartOfInstallation(bi); return bi;
} }
}
private void parseAndAddAbstractGeometry(GeometryProperty<?> geomProp, Lod lod, CityObject co) {
return bi; if (geomProp == null || geomProp.getObject() == null) {
} return;
}
private void parseAndAddAbstractGeometry(GeometryProperty<?> geomProp, Lod lod, CityObject co) { AbstractGeometry abstractGeometry = geomProp.getObject();
if (geomProp == null || geomProp.getObject() == null) { if (abstractGeometry instanceof MultiSurface ms) {
return; Geometry geom = parseMultiSurface(ms, lod);
} co.addGeometry(geom);
AbstractGeometry abstractGeometry = geomProp.getObject(); } else if (abstractGeometry instanceof Solid solid) {
if (abstractGeometry instanceof MultiSurface ms) { Geometry geom = parseSolid(solid, lod);
Geometry geom = parseMultiSurface(ms, lod); if (geom != null) {
co.addGeometry(geom); co.addGeometry(geom);
} else if (abstractGeometry instanceof Solid solid) { }
Geometry geom = parseSolid(solid, lod); } else {
if (geom != null) { logger.warn("Cannot handle geometry type {}, ignoring", abstractGeometry.getClass().getSimpleName());
co.addGeometry(geom); }
} }
} else {
logger.warn("Cannot handle geometry type {}, ignoring", abstractGeometry.getClass().getSimpleName()); private Geometry parseSolid(AbstractSolid abstractSolid, Lod lod) {
} if (abstractSolid instanceof Solid s) {
} return handleSolidGeometry(s, lod);
} else {
private Geometry parseSolid(AbstractSolid abstractSolid, Lod lod) { logger.warn("Cannot handle solid class {}, can only process pure solids",
if (abstractSolid instanceof Solid s) { abstractSolid.getClass().getSimpleName());
return handleSolidGeometry(s, lod); return null;
} else { }
logger.warn("Cannot handle solid class {}, can only process pure solids", }
abstractSolid.getClass().getSimpleName());
return null; private Geometry handleSolidGeometry(Solid solid, Lod lod) {
} ShellProperty exteriorProperty = solid.getExterior();
} if (exteriorProperty == null || exteriorProperty.getObject() == null) {
logger.warn("Found solid {} without exterior hull, ignoring", solid.getId());
private Geometry handleSolidGeometry(Solid solid, Lod lod) { return null;
ShellProperty exteriorProperty = solid.getExterior(); }
if (exteriorProperty == null || exteriorProperty.getObject() == null) { Geometry geom = new Geometry(GeometryType.SOLID, lod);
logger.warn("Found solid {} without exterior hull, ignoring", solid.getId()); Shell exterior = solid.getExterior().getObject();
return null; Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
} readSurfaceMember(geom, geometryMapper, exterior.getSurfaceMembers());
Geometry geom = new Geometry(GeometryType.SOLID, lod); return geom;
Shell exterior = solid.getExterior().getObject(); }
Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, exterior.getSurfaceMembers()); private Geometry parseMultiSurface(MultiSurface ms, Lod lod) {
return geom; Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod);
} Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember());
private Geometry parseMultiSurface(MultiSurface ms, Lod lod) { return geom;
Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod); }
Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember()); private void readSurfaceMember(Geometry geom, Citygml3GeometryMapper geometryMapper,
return geom; List<SurfaceProperty> surfaceMember) {
} for (SurfaceProperty prop : surfaceMember) {
if (prop.getHref() != null) {
private void readSurfaceMember(Geometry geom, Citygml3GeometryMapper geometryMapper, references.add(new ResolvableReference(prop.getHref(), geom));
List<SurfaceProperty> surfaceMember) { continue;
for (SurfaceProperty prop : surfaceMember) { }
if (prop.getHref() != null) { if (prop.getObject() != null) {
references.add(new ResolvableReference(prop.getHref(), geom)); AbstractSurface as = prop.getObject();
continue; as.accept(geometryMapper);
} }
if (prop.getObject() != null) { }
AbstractSurface as = prop.getObject();
as.accept(geometryMapper); List<ConcretePolygon> polygons = geometryMapper.getPolygons();
}
} for (ConcretePolygon concretePoly : polygons) {
geom.addPolygon(concretePoly);
List<ConcretePolygon> polygons = geometryMapper.getPolygons(); if (concretePoly.hasExistingGmlId()) {
polygonMap.put(concretePoly.getGmlId().getGmlString(), concretePoly);
for (ConcretePolygon concretePoly : polygons) { }
geom.addPolygon(concretePoly); }
if (concretePoly.hasExistingGmlId()) { }
polygonMap.put(concretePoly.getGmlId().getGmlString(), concretePoly);
} private Geometry parseCompositeSurface(CompositeSurface cs, Lod lod) {
} Geometry geom = new Geometry(GeometryType.COMPOSITE_SURFACE, lod);
} Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, cs.getSurfaceMembers());
private Geometry parseCompositeSurface(CompositeSurface cs, Lod lod) { return geom;
Geometry geom = new Geometry(GeometryType.COMPOSITE_SURFACE, lod); }
Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, cs.getSurfaceMembers()); private void updateEdgesAndVertices(CityObject co) {
return geom; // searching for neighboring vertices, replacing them with one single vertex to
} // avoid later problems with edges and manifold problems
for (Geometry geom : co.getGeometries()) {
private void updateEdgesAndVertices(CityObject co) { KDTree tree = new KDTree();
// searching for neighboring vertices, replacing them with one single vertex to for (Polygon poly : geom.getPolygons()) {
// avoid later problems with edges and manifold problems if (poly instanceof CompositePolygon) {
for (Geometry geom : co.getGeometries()) { continue;
KDTree tree = new KDTree(); }
for (Polygon poly : geom.getPolygons()) { LinearRing lr = poly.getExteriorRing();
if (poly instanceof CompositePolygon){ updateRing(tree, lr);
continue; for (LinearRing innerRing : poly.getInnerRings()) {
} updateRing(tree, innerRing);
LinearRing lr = poly.getExteriorRing(); }
updateRing(tree, lr); }
for (LinearRing innerRing : poly.getInnerRings()) { if (!config.useLowMemoryConsumption()) {
updateRing(tree, innerRing); // no low memory consumption mode meaning create all meta information in
} // geometry
} geom.updateEdgesAndVertices();
if (!config.useLowMemoryConsumption()) { }
// no low memory consumption mode meaning create all meta information in }
// geometry }
geom.updateEdgesAndVertices();
} private void updateRing(KDTree tree, LinearRing lr) {
} for (int i = 0; i < lr.getVertices().size(); i++) {
} Vertex v = lr.getVertices().get(i);
List<Vertex> nodesInRange = tree.getNodesInRange(v, neighborDistance);
private void updateRing(KDTree tree, LinearRing lr) { if (nodesInRange.isEmpty()) {
for (int i = 0; i < lr.getVertices().size(); i++) { tree.add(v);
Vertex v = lr.getVertices().get(i); } else {
List<Vertex> nodesInRange = tree.getNodesInRange(v, neighborDistance); // replace other vertex with any neighboring one
if (nodesInRange.isEmpty()) { Vertex original = nodesInRange.get(0);
tree.add(v); lr.setVertex(i, original);
} else { }
// replace other vertex with any neighboring one }
Vertex original = nodesInRange.get(0); }
lr.setVertex(i, original);
} public void setCityModel(CityModel cModel) {
} model.setCityModel(cModel);
} }
public void setCityModel(CityModel cModel) { public CityDoctorModel getModel() {
model.setCityModel(cModel); return model;
} }
public CityDoctorModel getModel() { public void setCityGMLVersion(CityGMLVersion cityGMLVersion) {
return model; model.setParsedCityGMLVersion(cityGMLVersion);
} }
public void setCityGMLVersion(CityGMLVersion cityGMLVersion) {
model.setParsedCityGMLVersion(cityGMLVersion);
}
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3GeometryMapper.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,188 +18,187 @@ ...@@ -18,188 +18,187 @@
*/ */
package de.hft.stuttgart.citydoctor2.mapper.citygml3; package de.hft.stuttgart.citydoctor2.mapper.citygml3;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.Localization;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.locationtech.proj4j.BasicCoordinateTransform; import org.locationtech.proj4j.BasicCoordinateTransform;
import org.locationtech.proj4j.ProjCoordinate; import org.locationtech.proj4j.ProjCoordinate;
import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface; import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
import org.xmlobjects.gml.model.geometry.primitives.*;
import org.xmlobjects.gml.model.geometry.primitives.Polygon; import org.xmlobjects.gml.model.geometry.primitives.Polygon;
import org.xmlobjects.gml.model.geometry.primitives.*;
import org.xmlobjects.gml.visitor.GeometryWalker; import org.xmlobjects.gml.visitor.GeometryWalker;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import java.math.BigDecimal;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.math.RoundingMode;
import de.hft.stuttgart.citydoctor2.utils.Localization; import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class Citygml3GeometryMapper extends GeometryWalker { public class Citygml3GeometryMapper extends GeometryWalker {
private static final Logger logger = LogManager.getLogger(Citygml3GeometryMapper.class); private static final Logger logger = LogManager.getLogger(Citygml3GeometryMapper.class);
private final List<ConcretePolygon> polygons = new ArrayList<>(); private final List<ConcretePolygon> polygons = new ArrayList<>();
private LinearRing currentRing = null; private LinearRing currentRing = null;
private final ParserConfiguration config; private final ParserConfiguration config;
private final ProjCoordinate p1 = new ProjCoordinate(); private final ProjCoordinate p1 = new ProjCoordinate();
private final ProjCoordinate p2 = new ProjCoordinate(); private final ProjCoordinate p2 = new ProjCoordinate();
private final Map<Vertex, Vertex> vertexMap; private final Map<Vertex, Vertex> vertexMap;
public Citygml3GeometryMapper(ParserConfiguration config, Map<Vertex, Vertex> vertices) { public Citygml3GeometryMapper(ParserConfiguration config, Map<Vertex, Vertex> vertices) {
this.config = config; this.config = config;
this.vertexMap = vertices; this.vertexMap = vertices;
} }
@Override @Override
public void visit(Polygon polygon) { public void visit(Polygon polygon) {
parsePolygon(polygon.getId(), polygon.getExterior(), polygon.getInterior()); parsePolygon(polygon.getId(), polygon.getExterior(), polygon.getInterior());
if (polygon.getExterior() == null) { if (polygon.getExterior() == null) {
logger.warn(String.format("No exterior: %s" ,polygon.getId())); logger.warn(String.format("No exterior: %s", polygon.getId()));
} }
} }
private void parsePolygon(String id, AbstractRingProperty exterior, List<AbstractRingProperty> interior) { private void parsePolygon(String id, AbstractRingProperty exterior, List<AbstractRingProperty> interior) {
if (exterior == null || exterior.getObject() == null) { if (exterior == null || exterior.getObject() == null) {
if (logger.isWarnEnabled()) { if (logger.isWarnEnabled()) {
logger.warn(Localization.getText("GeometryMapper.emptyPolygon")); logger.warn(Localization.getText("GeometryMapper.emptyPolygon"));
} }
return; return;
} }
ConcretePolygon cdPoly = new ConcretePolygon(); ConcretePolygon cdPoly = new ConcretePolygon();
polygons.add(cdPoly); polygons.add(cdPoly);
if (id != null) { if (id != null) {
cdPoly.setGmlId(new GmlId(id)); cdPoly.setGmlId(new GmlId(id));
} }
currentRing = new LinearRing(LinearRingType.EXTERIOR); currentRing = new LinearRing(LinearRingType.EXTERIOR);
exterior.getObject().accept(this); exterior.getObject().accept(this);
cdPoly.setExteriorRing(currentRing); cdPoly.setExteriorRing(currentRing);
for (AbstractRingProperty interiorGmlRing : interior) { for (AbstractRingProperty interiorGmlRing : interior) {
AbstractRing gmlRing = interiorGmlRing.getObject(); AbstractRing gmlRing = interiorGmlRing.getObject();
if (gmlRing == null) { if (gmlRing == null) {
continue; continue;
} }
currentRing = new LinearRing(LinearRingType.INTERIOR); currentRing = new LinearRing(LinearRingType.INTERIOR);
gmlRing.accept(this); gmlRing.accept(this);
cdPoly.addInteriorRing(currentRing); cdPoly.addInteriorRing(currentRing);
} }
} }
@Override @Override
public void visit(CompositeSurface cs){ public void visit(CompositeSurface cs) {
if (cs.getSurfaceMembers() != null && cs.getSurfaceMembers().isEmpty()) { if (cs.getSurfaceMembers() != null && cs.getSurfaceMembers().isEmpty()) {
logger.warn("CompositeSurface %s is empty", cs.getId()); logger.warn("CompositeSurface %s is empty", cs.getId());
return; return;
} }
List<SurfaceProperty> surfaceMember = cs.getSurfaceMembers(); List<SurfaceProperty> surfaceMember = cs.getSurfaceMembers();
Citygml3GeometryMapper recursiveMapper = new Citygml3GeometryMapper(config, vertexMap); Citygml3GeometryMapper recursiveMapper = new Citygml3GeometryMapper(config, vertexMap);
CompositePolygon comp = new CompositePolygon(); CompositePolygon comp = new CompositePolygon();
if (cs.getId() == null){ if (cs.getId() == null) {
comp.setGmlId(GmlId.generateId()); comp.setGmlId(GmlId.generateId());
} else { } else {
comp.setGmlId(new GmlId(cs.getId())); comp.setGmlId(new GmlId(cs.getId()));
} }
for (SurfaceProperty prop : surfaceMember) { for (SurfaceProperty prop : surfaceMember) {
if (prop.getObject() != null) { if (prop.getObject() != null) {
AbstractSurface as = prop.getObject(); AbstractSurface as = prop.getObject();
as.accept(recursiveMapper); as.accept(recursiveMapper);
} }
} }
List<ConcretePolygon> compPolys = recursiveMapper.getPolygons(); List<ConcretePolygon> compPolys = recursiveMapper.getPolygons();
compPolys.forEach(comp::addCompositeMember); compPolys.forEach(comp::addCompositeMember);
polygons.add(comp); polygons.add(comp);
polygons.addAll(compPolys); polygons.addAll(compPolys);
} }
@Override @Override
public void visit(org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlRing) { public void visit(org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlRing) {
if (gmlRing.getSrsDimension() != null && gmlRing.getSrsDimension() != 3) { if (gmlRing.getSrsDimension() != null && gmlRing.getSrsDimension() != 3) {
logger.warn("Cannot handle geometry with srsDimension not 3"); logger.warn("Cannot handle geometry with srsDimension not 3");
return; return;
} }
if (gmlRing.getId() != null) { if (gmlRing.getId() != null) {
currentRing.setGmlId(new GmlId(gmlRing.getId())); currentRing.setGmlId(new GmlId(gmlRing.getId()));
} }
List<Double> coordinates = gmlRing.toCoordinateList3D(); List<Double> coordinates = gmlRing.toCoordinateList3D();
handleCoordinateList(coordinates); handleCoordinateList(coordinates);
} }
@Override @Override
public void visit(Ring ring) { public void visit(Ring ring) {
if (ring.getSrsDimension() != null && ring.getSrsDimension() != 3) { if (ring.getSrsDimension() != null && ring.getSrsDimension() != 3) {
logger.warn("Cannot handle geometry with srsDimension not 3"); logger.warn("Cannot handle geometry with srsDimension not 3");
return; return;
} }
if (ring.getId() != null) { if (ring.getId() != null) {
currentRing.setGmlId(new GmlId(ring.getId())); currentRing.setGmlId(new GmlId(ring.getId()));
} }
List<Double> coordinates = ring.toCoordinateList3D(); List<Double> coordinates = ring.toCoordinateList3D();
handleCoordinateList(coordinates); handleCoordinateList(coordinates);
} }
private void handleCoordinateList(List<Double> coordinates) { private void handleCoordinateList(List<Double> coordinates) {
if (coordinates.size() % 3 != 0) { if (coordinates.size() % 3 != 0) {
String id; String id;
if (currentRing.hasExistingGmlId()) { if (currentRing.hasExistingGmlId()) {
id = currentRing.getGmlId().getGmlString(); id = currentRing.getGmlId().getGmlString();
} else { } else {
id = ""; id = "";
} }
logger.warn("The number of coordinates for linear ring {} do not result in fully 3D points", id); logger.warn("The number of coordinates for linear ring {} do not result in fully 3D points", id);
} }
for (int i = 0; i < coordinates.size(); i = i + 3) { for (int i = 0; i < coordinates.size(); i = i + 3) {
double x = coordinates.get(i); double x = coordinates.get(i);
double y = coordinates.get(i + 1); double y = coordinates.get(i + 1);
double z = coordinates.get(i + 2); double z = coordinates.get(i + 2);
createVertex(x, y, z); createVertex(x, y, z);
} }
} }
private void createVertex(double x, double y, double z) { private void createVertex(double x, double y, double z) {
// transform into utm, if available // transform into utm, if available
BasicCoordinateTransform trans = config.getTargetTransform(); BasicCoordinateTransform trans = config.getTargetTransform();
if (trans != null) { if (trans != null) {
p1.setValue(x, y); p1.setValue(x, y);
trans.transform(p1, p2); trans.transform(p1, p2);
x = p2.x; x = p2.x;
y = p2.y; y = p2.y;
z = z / config.getFromMeters(); z = z / config.getFromMeters();
} }
x = round(x, config.getNumberOfRoundingPlaces()); x = round(x, config.getNumberOfRoundingPlaces());
y = round(y, config.getNumberOfRoundingPlaces()); y = round(y, config.getNumberOfRoundingPlaces());
z = round(z, config.getNumberOfRoundingPlaces()); z = round(z, config.getNumberOfRoundingPlaces());
Vertex v = new Vertex(x, y, z); Vertex v = new Vertex(x, y, z);
Vertex duplicate = vertexMap.get(v); Vertex duplicate = vertexMap.get(v);
if (duplicate == null) { if (duplicate == null) {
vertexMap.put(v, v); vertexMap.put(v, v);
} else { } else {
v = duplicate; v = duplicate;
} }
currentRing.addVertex(v); currentRing.addVertex(v);
} }
private double round(double value, int places) { private double round(double value, int places) {
if (places < 0) { if (places < 0) {
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
BigDecimal bd = BigDecimal.valueOf(value); BigDecimal bd = BigDecimal.valueOf(value);
bd = bd.setScale(places, RoundingMode.HALF_UP); bd = bd.setScale(places, RoundingMode.HALF_UP);
return bd.doubleValue(); return bd.doubleValue();
} }
public List<ConcretePolygon> getPolygons() { public List<ConcretePolygon> getPolygons() {
return polygons; return polygons;
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/SurfaceMapper.java
View file @ 02de0a22
/*- /*-
* Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2022 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,206 +18,192 @@ ...@@ -18,206 +18,192 @@
*/ */
package de.hft.stuttgart.citydoctor2.mapper.citygml3; package de.hft.stuttgart.citydoctor2.mapper.citygml3;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import de.hft.stuttgart.citydoctor2.datastructure.*; import de.hft.stuttgart.citydoctor2.datastructure.*;
import org.citygml4j.core.model.construction.AbstractConstructionSurface; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.construction.AbstractFillingSurface; import org.citygml4j.core.model.construction.*;
import org.citygml4j.core.model.construction.AbstractFillingSurfaceProperty;
import org.citygml4j.core.model.construction.CeilingSurface;
import org.citygml4j.core.model.construction.DoorSurface;
import org.citygml4j.core.model.construction.FloorSurface;
import org.citygml4j.core.model.construction.GroundSurface;
import org.citygml4j.core.model.construction.InteriorWallSurface;
import org.citygml4j.core.model.construction.OuterCeilingSurface;
import org.citygml4j.core.model.construction.OuterFloorSurface;
import org.citygml4j.core.model.construction.RoofSurface;
import org.citygml4j.core.model.construction.WallSurface;
import org.citygml4j.core.model.construction.WindowSurface;
import org.citygml4j.core.model.core.AbstractThematicSurface; import org.citygml4j.core.model.core.AbstractThematicSurface;
import org.citygml4j.core.model.core.ClosureSurface; import org.citygml4j.core.model.core.ClosureSurface;
import org.citygml4j.core.visitor.ObjectWalker; import org.citygml4j.core.visitor.ObjectWalker;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
import org.xmlobjects.gml.model.geometry.primitives.AbstractSurface; import org.xmlobjects.gml.model.geometry.primitives.AbstractSurface;
import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty; import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class SurfaceMapper extends ObjectWalker { public class SurfaceMapper extends ObjectWalker {
private final List<BoundarySurface> surfaces = new ArrayList<>(); private final List<BoundarySurface> surfaces = new ArrayList<>();
private final Map<String, ConcretePolygon> polygonMap; private final Map<String, ConcretePolygon> polygonMap;
private final List<ResolvableReference> references; private final List<ResolvableReference> references;
private final Map<Vertex, Vertex> vertexMap; private final Map<Vertex, Vertex> vertexMap;
private final ParserConfiguration config; private final ParserConfiguration config;
public SurfaceMapper(Map<String, ConcretePolygon> polygonMap, List<ResolvableReference> references, public SurfaceMapper(Map<String, ConcretePolygon> polygonMap, List<ResolvableReference> references,
Map<Vertex, Vertex> vertexMap, ParserConfiguration config) { Map<Vertex, Vertex> vertexMap, ParserConfiguration config) {
this.polygonMap = polygonMap; this.polygonMap = polygonMap;
this.references = references; this.references = references;
this.vertexMap = vertexMap; this.vertexMap = vertexMap;
this.config = config; this.config = config;
} }
@Override @Override
public void visit(WallSurface wallSurface) { public void visit(WallSurface wallSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL,
wallSurface); wallSurface);
handleConstructionSurface(wallSurface, surface); handleConstructionSurface(wallSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
private void handleConstructionSurface(AbstractConstructionSurface gmlSurface, BoundarySurface cdSurface) { private void handleConstructionSurface(AbstractConstructionSurface gmlSurface, BoundarySurface cdSurface) {
for (AbstractFillingSurfaceProperty fillingProp : gmlSurface.getFillingSurfaces()) { for (AbstractFillingSurfaceProperty fillingProp : gmlSurface.getFillingSurfaces()) {
if (fillingProp.isSetObject()) { if (fillingProp.isSetObject()) {
readAbstractFillingSurface(fillingProp.getObject(), cdSurface); readAbstractFillingSurface(fillingProp.getObject(), cdSurface);
} }
} }
handleThematicSurface(gmlSurface, cdSurface); handleThematicSurface(gmlSurface, cdSurface);
cdSurface.unsetGmlGeometries(); cdSurface.unsetGmlGeometries();
} }
private void readAbstractFillingSurface(AbstractFillingSurface afs, BoundarySurface cdSurface) { private void readAbstractFillingSurface(AbstractFillingSurface afs, BoundarySurface cdSurface) {
Opening o; Opening o;
if (afs instanceof DoorSurface ds) { if (afs instanceof DoorSurface ds) {
o = new Opening(OpeningType.DOOR, SurfaceFeatureType.BUILDING, cdSurface, ds); o = new Opening(OpeningType.DOOR, SurfaceFeatureType.BUILDING, cdSurface, ds);
} else if (afs instanceof WindowSurface ws){ } else if (afs instanceof WindowSurface ws) {
o = new Opening(OpeningType.WINDOW, SurfaceFeatureType.BUILDING, cdSurface, ws); o = new Opening(OpeningType.WINDOW, SurfaceFeatureType.BUILDING, cdSurface, ws);
} else { } else {
o = new Opening(OpeningType.UNKNOWN, SurfaceFeatureType.BUILDING, cdSurface, afs); o = new Opening(OpeningType.UNKNOWN, SurfaceFeatureType.BUILDING, cdSurface, afs);
} }
cdSurface.addOpening(o); cdSurface.addOpening(o);
parseAndAddMultiSurface(afs.getLod0MultiSurface(), Lod.LOD0, o); parseAndAddMultiSurface(afs.getLod0MultiSurface(), Lod.LOD0, o);
parseAndAddMultiSurface(afs.getLod1MultiSurface(), Lod.LOD1, o); parseAndAddMultiSurface(afs.getLod1MultiSurface(), Lod.LOD1, o);
parseAndAddMultiSurface(afs.getLod2MultiSurface(), Lod.LOD2, o); parseAndAddMultiSurface(afs.getLod2MultiSurface(), Lod.LOD2, o);
parseAndAddMultiSurface(afs.getLod3MultiSurface(), Lod.LOD3, o); parseAndAddMultiSurface(afs.getLod3MultiSurface(), Lod.LOD3, o);
parseAndAddMultiSurface(afs.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, o); parseAndAddMultiSurface(afs.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, o);
o.unsetGmlGeometries(); o.unsetGmlGeometries();
} }
private void handleThematicSurface(AbstractThematicSurface gmlSurface, CityObject cdSurface) { private void handleThematicSurface(AbstractThematicSurface gmlSurface, CityObject cdSurface) {
Citygml3FeatureMapper.parseId(gmlSurface, cdSurface); Citygml3FeatureMapper.parseId(gmlSurface, cdSurface);
parseAndAddMultiSurface(gmlSurface.getLod0MultiSurface(), Lod.LOD0, cdSurface); parseAndAddMultiSurface(gmlSurface.getLod0MultiSurface(), Lod.LOD0, cdSurface);
parseAndAddMultiSurface(gmlSurface.getLod1MultiSurface(), Lod.LOD1, cdSurface); parseAndAddMultiSurface(gmlSurface.getLod1MultiSurface(), Lod.LOD1, cdSurface);
parseAndAddMultiSurface(gmlSurface.getLod2MultiSurface(), Lod.LOD2, cdSurface); parseAndAddMultiSurface(gmlSurface.getLod2MultiSurface(), Lod.LOD2, cdSurface);
parseAndAddMultiSurface(gmlSurface.getLod3MultiSurface(), Lod.LOD3, cdSurface); parseAndAddMultiSurface(gmlSurface.getLod3MultiSurface(), Lod.LOD3, cdSurface);
parseAndAddMultiSurface(gmlSurface.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdSurface); parseAndAddMultiSurface(gmlSurface.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdSurface);
} }
private void parseAndAddMultiSurface(MultiSurfaceProperty msp, Lod lod, CityObject cdSurface) { private void parseAndAddMultiSurface(MultiSurfaceProperty msp, Lod lod, CityObject cdSurface) {
if (msp == null || msp.getObject() == null) { if (msp == null || msp.getObject() == null) {
return; return;
} }
Geometry geom = parseMultiSurface(msp.getObject(), lod); Geometry geom = parseMultiSurface(msp.getObject(), lod);
cdSurface.addGeometry(geom); cdSurface.addGeometry(geom);
} }
private Geometry parseMultiSurface(MultiSurface ms, Lod lod) { private Geometry parseMultiSurface(MultiSurface ms, Lod lod) {
Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod); Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod);
Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap); Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap);
readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember()); readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember());
return geom; return geom;
} }
private void readSurfaceMember(Geometry geom, Citygml3GeometryMapper geometryMapper, private void readSurfaceMember(Geometry geom, Citygml3GeometryMapper geometryMapper,
List<SurfaceProperty> surfaceMember) { List<SurfaceProperty> surfaceMember) {
for (SurfaceProperty prop : surfaceMember) { for (SurfaceProperty prop : surfaceMember) {
if (prop.getHref() != null) { if (prop.getHref() != null) {
references.add(new ResolvableReference(prop.getHref(), geom)); references.add(new ResolvableReference(prop.getHref(), geom));
continue; continue;
} }
if (prop.getObject() != null) { if (prop.getObject() != null) {
AbstractSurface as = prop.getObject(); AbstractSurface as = prop.getObject();
as.accept(geometryMapper); as.accept(geometryMapper);
} }
} }
List<ConcretePolygon> polygons = geometryMapper.getPolygons(); List<ConcretePolygon> polygons = geometryMapper.getPolygons();
for (ConcretePolygon concretePoly : polygons) { for (ConcretePolygon concretePoly : polygons) {
if (concretePoly instanceof CompositePolygon comp) { if (concretePoly instanceof CompositePolygon comp) {
references.add(new ResolvableReference(comp.getGmlId().toString(), geom)); references.add(new ResolvableReference(comp.getGmlId().toString(), geom));
polygonMap.put(comp.getGmlId().toString(), comp); polygonMap.put(comp.getGmlId().toString(), comp);
} else { } else {
geom.addPolygon(concretePoly); geom.addPolygon(concretePoly);
if (concretePoly.hasExistingGmlId()) { if (concretePoly.hasExistingGmlId()) {
polygonMap.put(concretePoly.getGmlId().getGmlString(), concretePoly); polygonMap.put(concretePoly.getGmlId().getGmlString(), concretePoly);
} }
} }
} }
} }
@Override @Override
public void visit(FloorSurface floorSurface) { public void visit(FloorSurface floorSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.FLOOR, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.FLOOR,
floorSurface); floorSurface);
handleConstructionSurface(floorSurface, surface); handleConstructionSurface(floorSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(CeilingSurface ceilingSurface) { public void visit(CeilingSurface ceilingSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.CEILING, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.CEILING,
ceilingSurface); ceilingSurface);
handleConstructionSurface(ceilingSurface, surface); handleConstructionSurface(ceilingSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(GroundSurface groundSurface) { public void visit(GroundSurface groundSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.GROUND, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.GROUND,
groundSurface); groundSurface);
handleConstructionSurface(groundSurface, surface); handleConstructionSurface(groundSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(InteriorWallSurface interiorWallSurface) { public void visit(InteriorWallSurface interiorWallSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.INTERIOR_WALL, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.INTERIOR_WALL,
interiorWallSurface); interiorWallSurface);
handleConstructionSurface(interiorWallSurface, surface); handleConstructionSurface(interiorWallSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(OuterCeilingSurface outerCeilingSurface) { public void visit(OuterCeilingSurface outerCeilingSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.OUTER_CEILING, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.OUTER_CEILING,
outerCeilingSurface); outerCeilingSurface);
handleConstructionSurface(outerCeilingSurface, surface); handleConstructionSurface(outerCeilingSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(OuterFloorSurface outerFloorSurface) { public void visit(OuterFloorSurface outerFloorSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.OUTER_FLOOR, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.OUTER_FLOOR,
outerFloorSurface); outerFloorSurface);
handleConstructionSurface(outerFloorSurface, surface); handleConstructionSurface(outerFloorSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(RoofSurface roofSurface) { public void visit(RoofSurface roofSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.ROOF, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.ROOF,
roofSurface); roofSurface);
handleConstructionSurface(roofSurface, surface); handleConstructionSurface(roofSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
@Override @Override
public void visit(ClosureSurface closureSurface) { public void visit(ClosureSurface closureSurface) {
BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.CLOSURE, BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.CLOSURE,
closureSurface); closureSurface);
handleThematicSurface(closureSurface, surface); handleThematicSurface(closureSurface, surface);
surfaces.add(surface); surfaces.add(surface);
} }
public List<BoundarySurface> getSurfaces() { public List<BoundarySurface> getSurfaces() {
return surfaces; return surfaces;
} }
} }
CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CityGmlUtils.java
View file @ 02de0a22
/*- /*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
* *
* This file is part of CityDoctor2. * This file is part of CityDoctor2.
* *
* CityDoctor2 is free software: you can redistribute it and/or modify * CityDoctor2 is free software: you can redistribute it and/or modify
...@@ -18,209 +18,205 @@ ...@@ -18,209 +18,205 @@
*/ */
package de.hft.stuttgart.citydoctor2.utils; package de.hft.stuttgart.citydoctor2.utils;
import java.util.ArrayList; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
import java.util.HashSet; import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
import java.util.List;
import java.util.Set;
import de.hft.stuttgart.citydoctor2.datastructure.*; import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.util.geometry.GeometryFactory; import org.citygml4j.core.util.geometry.GeometryFactory;
import org.locationtech.proj4j.BasicCoordinateTransform; import org.locationtech.proj4j.BasicCoordinateTransform;
import org.locationtech.proj4j.ProjCoordinate; import org.locationtech.proj4j.ProjCoordinate;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface; import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
import org.xmlobjects.gml.model.geometry.primitives.AbstractRingProperty; import org.xmlobjects.gml.model.geometry.primitives.*;
import org.xmlobjects.gml.model.geometry.primitives.Shell;
import org.xmlobjects.gml.model.geometry.primitives.ShellProperty;
import org.xmlobjects.gml.model.geometry.primitives.Solid;
import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/** /**
* Utility class dedicated to create CityGML4j datastructures. * Utility class dedicated to create CityGML4j datastructures.
*
* @author Matthias Betz
* *
* @author Matthias Betz
*/ */
public final class CityGmlUtils { public final class CityGmlUtils {
private CityGmlUtils() { private CityGmlUtils() {
// util class // util class
} }
public static org.xmlobjects.gml.model.geometry.primitives.Polygon createGmlPolygon(GeometryFactory factory, public static org.xmlobjects.gml.model.geometry.primitives.Polygon createGmlPolygon(GeometryFactory factory,
Polygon cdPoly, ParserConfiguration config) { Polygon cdPoly, ParserConfiguration config) {
if (cdPoly.getExteriorRing() == null) { if (cdPoly.getExteriorRing() == null) {
return null; return null;
} }
org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = new org.xmlobjects.gml.model.geometry.primitives.Polygon(); org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = new org.xmlobjects.gml.model.geometry.primitives.Polygon();
// exterior ring // exterior ring
LinearRing extLr = cdPoly.getExteriorRing(); LinearRing extLr = cdPoly.getExteriorRing();
if (extLr.getVertices().size() < 3) { if (extLr.getVertices().size() < 3) {
// this ring does not have enough points in it // this ring does not have enough points in it
// this leads to errors when exporting therefore ignore it // this leads to errors when exporting therefore ignore it
return null; return null;
} }
org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlLr = createGmlRing(factory, config, extLr); org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlLr = createGmlRing(factory, config, extLr);
gmlPoly.setExterior(new AbstractRingProperty(gmlLr)); gmlPoly.setExterior(new AbstractRingProperty(gmlLr));
// interior rings // interior rings
for (LinearRing lr : cdPoly.getInnerRings()) { for (LinearRing lr : cdPoly.getInnerRings()) {
gmlLr = createGmlRing(factory, config, lr); gmlLr = createGmlRing(factory, config, lr);
if (lr.getVertices().size() < 3) { if (lr.getVertices().size() < 3) {
// this ring does not have enough points in it // this ring does not have enough points in it
// this leads to errors when exporting therefore ignore it // this leads to errors when exporting therefore ignore it
return null; return null;
} }
gmlPoly.getInterior().add(new AbstractRingProperty(gmlLr)); gmlPoly.getInterior().add(new AbstractRingProperty(gmlLr));
} }
gmlPoly.setId(cdPoly.getGmlId().getGmlString()); gmlPoly.setId(cdPoly.getGmlId().getGmlString());
return gmlPoly; return gmlPoly;
} }
public static CompositeSurface createGmlComposite(GeometryFactory factory, CompositePolygon cdPoly, public static CompositeSurface createGmlComposite(GeometryFactory factory, CompositePolygon cdPoly,
ParserConfiguration config) { ParserConfiguration config) {
List<ConcretePolygon> cdMembers = cdPoly.getCompositeMembers(); List<ConcretePolygon> cdMembers = cdPoly.getCompositeMembers();
List<SurfaceProperty> surfaces = new ArrayList<>(); List<SurfaceProperty> surfaces = new ArrayList<>();
for (ConcretePolygon cd : cdMembers) { for (ConcretePolygon cd : cdMembers) {
surfaces.add(resolveCompositeMember(factory, cd, config)); surfaces.add(resolveCompositeMember(factory, cd, config));
} }
if (surfaces.isEmpty()){ if (surfaces.isEmpty()) {
return null; return null;
} }
return new CompositeSurface(surfaces); return new CompositeSurface(surfaces);
} }
private static SurfaceProperty resolveCompositeMember(GeometryFactory factory, ConcretePolygon cdPoly, private static SurfaceProperty resolveCompositeMember(GeometryFactory factory, ConcretePolygon cdPoly,
ParserConfiguration config){ ParserConfiguration config) {
if (cdPoly instanceof CompositePolygon comp) { if (cdPoly instanceof CompositePolygon comp) {
return new SurfaceProperty(createGmlComposite(factory, comp, config)); return new SurfaceProperty(createGmlComposite(factory, comp, config));
} else { } else {
return new SurfaceProperty(createGmlPolygon(factory, cdPoly, config)); return new SurfaceProperty(createGmlPolygon(factory, cdPoly, config));
} }
} }
public static org.xmlobjects.gml.model.geometry.primitives.LinearRing createGmlRing(GeometryFactory factory, public static org.xmlobjects.gml.model.geometry.primitives.LinearRing createGmlRing(GeometryFactory factory,
ParserConfiguration config, LinearRing lr) { ParserConfiguration config, LinearRing lr) {
ProjCoordinate p1 = new ProjCoordinate(); ProjCoordinate p1 = new ProjCoordinate();
ProjCoordinate p2 = new ProjCoordinate(); ProjCoordinate p2 = new ProjCoordinate();
List<Double> ringValues = new ArrayList<>(); List<Double> ringValues = new ArrayList<>();
BasicCoordinateTransform trans = config.getOriginalTransform(); BasicCoordinateTransform trans = config.getOriginalTransform();
for (Vertex v : lr.getVertices()) { for (Vertex v : lr.getVertices()) {
double x = v.getX(); double x = v.getX();
double y = v.getY(); double y = v.getY();
double z = v.getZ(); double z = v.getZ();
if (trans != null) { if (trans != null) {
p1.x = x; p1.x = x;
p1.y = y; p1.y = y;
trans.transform(p1, p2); trans.transform(p1, p2);
x = p2.x; x = p2.x;
y = p2.y; y = p2.y;
z = z * config.getFromMeters(); z = z * config.getFromMeters();
} }
ringValues.add(x); ringValues.add(x);
ringValues.add(y); ringValues.add(y);
ringValues.add(z); ringValues.add(z);
} }
org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlLr = factory.createLinearRing(ringValues, 3); org.xmlobjects.gml.model.geometry.primitives.LinearRing gmlLr = factory.createLinearRing(ringValues, 3);
gmlLr.setId(lr.getGmlId().getGmlString()); gmlLr.setId(lr.getGmlId().getGmlString());
return gmlLr; return gmlLr;
} }
public static Solid createSolid(Geometry geom, GeometryFactory factory, ParserConfiguration config) { public static Solid createSolid(Geometry geom, GeometryFactory factory, ParserConfiguration config) {
if (geom.getType() != GeometryType.SOLID) { if (geom.getType() != GeometryType.SOLID) {
throw new IllegalArgumentException("Only solids are allowed"); throw new IllegalArgumentException("Only solids are allowed");
} }
CompositeSurface comp = new CompositeSurface(); CompositeSurface comp = new CompositeSurface();
List<SurfaceProperty> surfaceMember = comp.getSurfaceMembers(); List<SurfaceProperty> surfaceMember = comp.getSurfaceMembers();
for (Polygon cdPoly : geom.getPolygons()) { for (Polygon cdPoly : geom.getPolygons()) {
if (!cdPoly.isLink()) { if (!cdPoly.isLink()) {
org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config); org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config);
if (gmlPoly != null) { if (gmlPoly != null) {
surfaceMember.add(new SurfaceProperty(gmlPoly)); surfaceMember.add(new SurfaceProperty(gmlPoly));
} }
} else { } else {
// add reference to polygon // add reference to polygon
surfaceMember.add(new SurfaceProperty("#" + cdPoly.getGmlId().getGmlString())); surfaceMember.add(new SurfaceProperty("#" + cdPoly.getGmlId().getGmlString()));
} }
} }
if (surfaceMember.isEmpty()) { if (surfaceMember.isEmpty()) {
return null; return null;
} }
Solid solid = new Solid(); Solid solid = new Solid();
Shell shell = new Shell(surfaceMember); Shell shell = new Shell(surfaceMember);
solid.setExterior(new ShellProperty(shell)); solid.setExterior(new ShellProperty(shell));
solid.setId(geom.getGmlId().getGmlString()); solid.setId(geom.getGmlId().getGmlString());
return solid; return solid;
} }
public static MultiSurface createMultiSurface(Geometry geom, GeometryFactory factory, public static MultiSurface createMultiSurface(Geometry geom, GeometryFactory factory,
ParserConfiguration config) { ParserConfiguration config) {
if (geom.getType() != GeometryType.MULTI_SURFACE && geom.getType() != GeometryType.COMPOSITE_SURFACE) { if (geom.getType() != GeometryType.MULTI_SURFACE && geom.getType() != GeometryType.COMPOSITE_SURFACE) {
throw new IllegalArgumentException("This can only handle MultiSurfaces"); throw new IllegalArgumentException("This can only handle MultiSurfaces");
} }
List<SurfaceProperty> surfaces = new ArrayList<>(); List<SurfaceProperty> surfaces = new ArrayList<>();
Set<CompositePolygon> compositePolygons = new HashSet<>(); Set<CompositePolygon> compositePolygons = new HashSet<>();
for (Polygon cdPoly : geom.getPolygons()) { for (Polygon cdPoly : geom.getPolygons()) {
if (cdPoly instanceof ConcretePolygon conc && conc.isCompositeMember()) { if (cdPoly instanceof ConcretePolygon conc && conc.isCompositeMember()) {
compositePolygons.add(conc.getPartOfComposite()); compositePolygons.add(conc.getPartOfComposite());
}else if (cdPoly instanceof CompositePolygon composite) { } else if (cdPoly instanceof CompositePolygon composite) {
compositePolygons.add(composite); compositePolygons.add(composite);
} else if (!cdPoly.isLink()) { } else if (!cdPoly.isLink()) {
// is not part of a boundary surface // is not part of a boundary surface
org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config); org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config);
if (gmlPoly != null) { if (gmlPoly != null) {
surfaces.add(new SurfaceProperty(gmlPoly)); surfaces.add(new SurfaceProperty(gmlPoly));
} }
} else { } else {
// add reference to polygon // add reference to polygon
surfaces.add(new SurfaceProperty("#" + cdPoly.getGmlId().getGmlString())); surfaces.add(new SurfaceProperty("#" + cdPoly.getGmlId().getGmlString()));
} }
} }
for (CompositePolygon cdPoly : compositePolygons) { for (CompositePolygon cdPoly : compositePolygons) {
surfaces.add(new SurfaceProperty(createGmlComposite(factory, cdPoly, config))); surfaces.add(new SurfaceProperty(createGmlComposite(factory, cdPoly, config)));
} }
if (surfaces.isEmpty()) { if (surfaces.isEmpty()) {
return null; return null;
} }
MultiSurface ms = new MultiSurface(surfaces); MultiSurface ms = new MultiSurface(surfaces);
ms.setId(geom.getGmlId().getGmlString()); ms.setId(geom.getGmlId().getGmlString());
return ms; return ms;
} }
public static MultiSurface createMultiSurface(List<Polygon> polygons, GeometryFactory factory, public static MultiSurface createMultiSurface(List<Polygon> polygons, GeometryFactory factory,
ParserConfiguration config) { ParserConfiguration config) {
List<SurfaceProperty> surfaces = new ArrayList<>(); List<SurfaceProperty> surfaces = new ArrayList<>();
for (Polygon cdPoly : polygons) { for (Polygon cdPoly : polygons) {
org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config); org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config);
if (gmlPoly != null) { if (gmlPoly != null) {
surfaces.add(new SurfaceProperty(gmlPoly)); surfaces.add(new SurfaceProperty(gmlPoly));
} }
} }
if (surfaces.isEmpty()) { if (surfaces.isEmpty()) {
return null; return null;
} }
return new MultiSurface(surfaces); return new MultiSurface(surfaces);
} }
public static CompositeSurface createCompositeSurface(Geometry geom, GeometryFactory factory, public static CompositeSurface createCompositeSurface(Geometry geom, GeometryFactory factory,
ParserConfiguration config) { ParserConfiguration config) {
List<SurfaceProperty> surfaces = new ArrayList<>(); List<SurfaceProperty> surfaces = new ArrayList<>();
for (Polygon cdPoly : geom.getPolygons()) { for (Polygon cdPoly : geom.getPolygons()) {
org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config); org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly = createGmlPolygon(factory, cdPoly, config);
if (gmlPoly != null) { if (gmlPoly != null) {
surfaces.add(new SurfaceProperty(gmlPoly)); surfaces.add(new SurfaceProperty(gmlPoly));
} }
} }
if (surfaces.isEmpty()) { if (surfaces.isEmpty()) {
return null; return null;
} }
return new CompositeSurface(surfaces); return new CompositeSurface(surfaces);
} }
} }
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java
View file @ 02de0a22
package de.hft.stuttgart.citydoctor2.gui; package de.hft.stuttgart.citydoctor2.gui;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.StringJoiner;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.gui.tree.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.citygml4j.core.model.core.CityModel;
import org.xml.sax.SAXParseException;
import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.Checker; import de.hft.stuttgart.citydoctor2.check.Checker;
import de.hft.stuttgart.citydoctor2.check.ErrorId; import de.hft.stuttgart.citydoctor2.check.ErrorId;
import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration; import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration;
import de.hft.stuttgart.citydoctor2.check.error.SchematronError; import de.hft.stuttgart.citydoctor2.check.error.SchematronError;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException; import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
import de.hft.stuttgart.citydoctor2.gui.table.ErrorStat; import de.hft.stuttgart.citydoctor2.gui.table.ErrorStat;
import de.hft.stuttgart.citydoctor2.gui.tree.*;
import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler; import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler;
import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; import de.hft.stuttgart.citydoctor2.parser.*;
import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.parser.ProgressListener;
import de.hft.stuttgart.citydoctor2.utils.Localization; import de.hft.stuttgart.citydoctor2.utils.Localization;
import javafx.application.Platform; import javafx.application.Platform;
import javafx.scene.chart.XYChart.Data; import javafx.scene.chart.XYChart.Data;
...@@ -42,6 +21,15 @@ import javafx.scene.control.TreeItem; ...@@ -42,6 +21,15 @@ import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeView; import javafx.scene.control.TreeView;
import javafx.stage.FileChooser; import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter; import javafx.stage.FileChooser.ExtensionFilter;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.citygml4j.core.model.core.CityModel;
import org.xml.sax.SAXParseException;
import java.io.File;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
public class CityDoctorController { public class CityDoctorController {
...@@ -150,7 +138,7 @@ public class CityDoctorController { ...@@ -150,7 +138,7 @@ public class CityDoctorController {
} }
} }
private void setupFeatureTabs(){ private void setupFeatureTabs() {
mainWindow.setDisableOfFeatureTab(FeatureType.BUILDING, model.getBuildings().isEmpty()); mainWindow.setDisableOfFeatureTab(FeatureType.BUILDING, model.getBuildings().isEmpty());
mainWindow.setDisableOfFeatureTab(FeatureType.VEGETATION, model.getVegetation().isEmpty()); mainWindow.setDisableOfFeatureTab(FeatureType.VEGETATION, model.getVegetation().isEmpty());
mainWindow.setDisableOfFeatureTab(FeatureType.TRANSPORTATION, model.getTransportation().isEmpty()); mainWindow.setDisableOfFeatureTab(FeatureType.TRANSPORTATION, model.getTransportation().isEmpty());
...@@ -298,7 +286,7 @@ public class CityDoctorController { ...@@ -298,7 +286,7 @@ public class CityDoctorController {
addMoreButtonIfNecessary(trans, transView, transRoot, transportationChunkNr); addMoreButtonIfNecessary(trans, transView, transRoot, transportationChunkNr);
} }
private void buildTunnel(List<Tunnel> tunnels){ private void buildTunnel(List<Tunnel> tunnels) {
if (tunnels.isEmpty()) { if (tunnels.isEmpty()) {
return; return;
} }
...@@ -575,7 +563,7 @@ public class CityDoctorController { ...@@ -575,7 +563,7 @@ public class CityDoctorController {
} }
private void createBuildingStoreyNodes(Building ab, TreeItem<Renderable> root){ private void createBuildingStoreyNodes(Building ab, TreeItem<Renderable> root) {
List<Storey> storeys = ab.getBuildingStoreys(); List<Storey> storeys = ab.getBuildingStoreys();
if (storeys.isEmpty()) { if (storeys.isEmpty()) {
return; return;
...@@ -1087,7 +1075,7 @@ public class CityDoctorController { ...@@ -1087,7 +1075,7 @@ public class CityDoctorController {
transportationChunkNr); transportationChunkNr);
} }
public void fillTreeViewWithErrorTunnel(){ public void fillTreeViewWithErrorTunnel() {
if (model == null) { if (model == null) {
return; return;
} }
...@@ -1264,7 +1252,7 @@ public class CityDoctorController { ...@@ -1264,7 +1252,7 @@ public class CityDoctorController {
return currentConfig; return currentConfig;
} }
public void setOriginBB(BoundingBox origin){ public void setOriginBB(BoundingBox origin) {
this.originBB = origin; this.originBB = origin;
} }
......
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/MainToolBar.java
View file @ 02de0a22
package de.hft.stuttgart.citydoctor2.gui; package de.hft.stuttgart.citydoctor2.gui;
import java.io.IOException;
import java.io.InputStream;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import de.hft.stuttgart.citydoctor2.gui.tree.Renderable; import de.hft.stuttgart.citydoctor2.gui.tree.Renderable;
import de.hft.stuttgart.citydoctor2.utils.Localization; import de.hft.stuttgart.citydoctor2.utils.Localization;
import javafx.fxml.FXML; import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader; import javafx.fxml.FXMLLoader;
import javafx.scene.control.Button; import javafx.scene.control.*;
import javafx.scene.control.Tab;
import javafx.scene.control.TabPane;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.Tooltip;
import javafx.scene.control.TreeView;
import javafx.scene.image.Image; import javafx.scene.image.Image;
import javafx.scene.image.ImageView; import javafx.scene.image.ImageView;
import javafx.scene.layout.HBox; import javafx.scene.layout.HBox;
import javafx.stage.Stage; import javafx.stage.Stage;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.io.InputStream;
public class MainToolBar { public class MainToolBar {
private static final Logger logger = LogManager.getLogger(MainToolBar.class); private static final Logger logger = LogManager.getLogger(MainToolBar.class);
@FXML @FXML
private Button saveBtn; private Button saveBtn;
@FXML @FXML
private ImageView saveView; private ImageView saveView;
@FXML @FXML
private Button openBtn; private Button openBtn;
@FXML @FXML
private ImageView openImageView; private ImageView openImageView;
@FXML @FXML
private Button checkBtn; private Button checkBtn;
@FXML @FXML
private ImageView checkImageView; private ImageView checkImageView;
@FXML @FXML
private Button showWorldBtn; private Button showWorldBtn;
@FXML @FXML
private ImageView showWorldImageView; private ImageView showWorldImageView;
@FXML @FXML
private ToggleButton hideRoofBtn; private ToggleButton hideRoofBtn;
@FXML @FXML
private ImageView hideRoofView; private ImageView hideRoofView;
@FXML @FXML
private Button resetCameraBtn; private Button resetCameraBtn;
@FXML @FXML
private ImageView resetCameraView; private ImageView resetCameraView;
@FXML @FXML
private Button schematronBtn; private Button schematronBtn;
@FXML @FXML
private ImageView schematronImgView; private ImageView schematronImgView;
@FXML @FXML
private ToggleButton lod1Btn; private ToggleButton lod1Btn;
@FXML @FXML
private ImageView lod1View; private ImageView lod1View;
@FXML @FXML
private ToggleButton lod2Btn; private ToggleButton lod2Btn;
@FXML @FXML
private ImageView lod2View; private ImageView lod2View;
@FXML @FXML
private ToggleButton lod3Btn; private ToggleButton lod3Btn;
@FXML @FXML
private ImageView lod3View; private ImageView lod3View;
@FXML @FXML
private ToggleButton lod4Btn; private ToggleButton lod4Btn;
@FXML @FXML
private ImageView lod4View; private ImageView lod4View;
@FXML @FXML
private Button aboutBtn; private Button aboutBtn;
@FXML @FXML
private ImageView aboutImgView; private ImageView aboutImgView;
@FXML @FXML
private ToggleButton gridButton; private ToggleButton gridButton;
@FXML @FXML
private ToggleButton cullingButton; private ToggleButton cullingButton;
@FXML @FXML
private ImageView cullingImageView; private ImageView cullingImageView;
@FXML @FXML
private ImageView gridImageView; private ImageView gridImageView;
@FXML @FXML
private Button reportBtn; private Button reportBtn;
@FXML @FXML
private ImageView reportImageView; private ImageView reportImageView;
private OpenFileDialog fileDialog; private OpenFileDialog fileDialog;
private CheckDialog checkDialog; private CheckDialog checkDialog;
private WriteReportDialog writeDialog; private WriteReportDialog writeDialog;
private AboutDialog aboutDialog; private AboutDialog aboutDialog;
private CityDoctorController controller; private CityDoctorController controller;
private TabPane featurePane; private TabPane featurePane;
private Stage stage; private Stage stage;
private Renderer renderer; private Renderer renderer;
private MainWindow mainWindow; private MainWindow mainWindow;
private HBox toolBar; private HBox toolBar;
public MainToolBar(Stage stage, CityDoctorController controller, TabPane featurePane, Renderer renderer, public MainToolBar(Stage stage, CityDoctorController controller, TabPane featurePane, Renderer renderer,
MainWindow mainWindow) throws IOException { MainWindow mainWindow) throws IOException {
this.controller = controller; this.controller = controller;
this.featurePane = featurePane; this.featurePane = featurePane;
this.renderer = renderer; this.renderer = renderer;
this.stage = stage; this.stage = stage;
this.mainWindow = mainWindow; this.mainWindow = mainWindow;
FXMLLoader loader = new FXMLLoader(MainToolBar.class.getResource("MainToolBar.fxml")); FXMLLoader loader = new FXMLLoader(MainToolBar.class.getResource("MainToolBar.fxml"));
loader.setController(this); loader.setController(this);
toolBar = loader.load(); toolBar = loader.load();
fileDialog = new OpenFileDialog(stage, controller); fileDialog = new OpenFileDialog(stage, controller);
} }
public void initialize() { public void initialize() {
openBtn.setOnAction(ae -> fileDialog.show()); openBtn.setOnAction(ae -> fileDialog.show());
setupSaveBtn(); setupSaveBtn();
setupCheckButton(); setupCheckButton();
setupLodButtons(); setupLodButtons();
setupAboutButton(); setupAboutButton();
setupReportButton(); setupReportButton();
setupResetCameraButton(); setupResetCameraButton();
setupHideRoofButton(); setupHideRoofButton();
loadImages(); loadImages();
gridButton.setOnAction(ae -> renderer.showWireFrame(gridButton.isSelected())); gridButton.setOnAction(ae -> renderer.showWireFrame(gridButton.isSelected()));
gridButton.setTooltip(new Tooltip(Localization.getText("MainToolBar.wireframe"))); gridButton.setTooltip(new Tooltip(Localization.getText("MainToolBar.wireframe")));
cullingButton.setOnAction(ae -> renderer.enableCulling(cullingButton.isSelected())); cullingButton.setOnAction(ae -> renderer.enableCulling(cullingButton.isSelected()));
cullingButton.setTooltip(new Tooltip(Localization.getText("MainToolBar.culling"))); cullingButton.setTooltip(new Tooltip(Localization.getText("MainToolBar.culling")));
showWorldBtn.setOnAction(ar -> { showWorldBtn.setOnAction(ar -> {
Tab selectedItem = featurePane.getSelectionModel().getSelectedItem(); Tab selectedItem = featurePane.getSelectionModel().getSelectedItem();
if (selectedItem.getContent() instanceof TreeView) { if (selectedItem.getContent() instanceof TreeView) {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
TreeView<Renderable> content = (TreeView<Renderable>) selectedItem.getContent(); TreeView<Renderable> content = (TreeView<Renderable>) selectedItem.getContent();
content.getSelectionModel().clearSelection(); content.getSelectionModel().clearSelection();
} }
controller.showWorld(); controller.showWorld();
}); });
showWorldBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.showWorld"))); showWorldBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.showWorld")));
} }
private void loadImages() { private void loadImages() {
try { try {
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/openFolderIcon.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/openFolderIcon.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
openImageView.setImage(img); openImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/check32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/check32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
checkImageView.setImage(img); checkImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/wireframe32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/wireframe32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
gridImageView.setImage(img); gridImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/Culling.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/Culling.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
cullingImageView.setImage(img); cullingImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/error_stat32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/error_stat32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
reportImageView.setImage(img); reportImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/scene.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/scene.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
showWorldImageView.setImage(img); showWorldImageView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod1_32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod1_32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
lod1View.setImage(img); lod1View.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod2_32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod2_32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
lod2View.setImage(img); lod2View.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod3_32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod3_32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
lod3View.setImage(img); lod3View.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod4_32x32.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/lod4_32x32.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
lod4View.setImage(img); lod4View.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/about.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/about.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
aboutImgView.setImage(img); aboutImgView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/save.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/save.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
saveView.setImage(img); saveView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/reset_camera.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/reset_camera.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
resetCameraView.setImage(img); resetCameraView.setImage(img);
} }
try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/hide_roof.png")) { try (InputStream inStream = MainWindow.class.getResourceAsStream("icons/hide_roof.png")) {
Image img = new Image(inStream); Image img = new Image(inStream);
hideRoofView.setImage(img); hideRoofView.setImage(img);
} }
} catch (IOException e) { } catch (IOException e) {
// ignore close exception // ignore close exception
} }
} }
private void setupReportButton() { private void setupReportButton() {
reportBtn.setDisable(true); reportBtn.setDisable(true);
reportBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.writeReports"))); reportBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.writeReports")));
reportBtn.setOnAction(ae -> { reportBtn.setOnAction(ae -> {
if (writeDialog == null) { if (writeDialog == null) {
try { try {
writeDialog = new WriteReportDialog(stage, controller, mainWindow); writeDialog = new WriteReportDialog(stage, controller, mainWindow);
} catch (IOException e) { } catch (IOException e) {
logger.catching(e); logger.catching(e);
mainWindow.showExceptionDialog(e); mainWindow.showExceptionDialog(e);
} }
} }
if (writeDialog != null) { if (writeDialog != null) {
// writeDialog can be null if creation of said dialog fails // writeDialog can be null if creation of said dialog fails
writeDialog.show(); writeDialog.show();
} }
}); });
} }
private void setupAboutButton() { private void setupAboutButton() {
aboutBtn.setOnAction(ae -> { aboutBtn.setOnAction(ae -> {
if (aboutDialog == null) { if (aboutDialog == null) {
try { try {
aboutDialog = new AboutDialog(stage); aboutDialog = new AboutDialog(stage);
aboutDialog.show(); aboutDialog.show();
} catch (IOException e) { } catch (IOException e) {
logger.error("Could not load about dialog.", e); logger.error("Could not load about dialog.", e);
} }
} else { } else {
aboutDialog.show(); aboutDialog.show();
} }
}); });
} }
private void setupLodButtons() { private void setupLodButtons() {
lod1Btn.setOnAction(ae -> { lod1Btn.setOnAction(ae -> {
if (lod1Btn.isSelected()) { if (lod1Btn.isSelected()) {
renderer.enableLod1(); renderer.enableLod1();
} else { } else {
renderer.disableLod1(); renderer.disableLod1();
} }
}); });
lod2Btn.setOnAction(ae -> { lod2Btn.setOnAction(ae -> {
if (lod2Btn.isSelected()) { if (lod2Btn.isSelected()) {
renderer.enableLod2(); renderer.enableLod2();
} else { } else {
renderer.disableLod2(); renderer.disableLod2();
} }
}); });
lod3Btn.setOnAction(ae -> { lod3Btn.setOnAction(ae -> {
if (lod3Btn.isSelected()) { if (lod3Btn.isSelected()) {
renderer.enableLod3(); renderer.enableLod3();
} else { } else {
renderer.disableLod3(); renderer.disableLod3();
} }
}); });
lod4Btn.setOnAction(ae -> { lod4Btn.setOnAction(ae -> {
if (lod4Btn.isSelected()) { if (lod4Btn.isSelected()) {
renderer.enableLod4(); renderer.enableLod4();
} else { } else {
renderer.disableLod4(); renderer.disableLod4();
} }
}); });
} }
private void setupSaveBtn() { private void setupSaveBtn() {
saveBtn.setOnAction(ae -> controller.askAndSave()); saveBtn.setOnAction(ae -> controller.askAndSave());
} }
private void setupCheckButton() { private void setupCheckButton() {
checkBtn.setDisable(true); checkBtn.setDisable(true);
checkBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.executeChecks"))); checkBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.executeChecks")));
checkBtn.setOnAction(ae -> { checkBtn.setOnAction(ae -> {
if (checkDialog == null) { if (checkDialog == null) {
try { try {
checkDialog = new CheckDialog(mainWindow, stage, controller); checkDialog = new CheckDialog(mainWindow, stage, controller);
} catch (IOException e) { } catch (IOException e) {
mainWindow.showExceptionDialog(e); mainWindow.showExceptionDialog(e);
logger.catching(e); logger.catching(e);
} }
} }
checkDialog.show(); checkDialog.show();
}); });
} }
private void setupResetCameraButton(){ private void setupResetCameraButton() {
resetCameraBtn.setDisable(true); resetCameraBtn.setDisable(true);
resetCameraBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.resetCamera"))); resetCameraBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.resetCamera")));
resetCameraBtn.setOnAction(ae -> mainWindow.resetCamera()); resetCameraBtn.setOnAction(ae -> mainWindow.resetCamera());
} }
private void setupHideRoofButton() { private void setupHideRoofButton() {
hideRoofBtn.setDisable(true); hideRoofBtn.setDisable(true);
hideRoofBtn.setSelected(false); hideRoofBtn.setSelected(false);
hideRoofBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.hideRoof"))); hideRoofBtn.setTooltip(new Tooltip(Localization.getText("MainToolBar.hideRoof")));
hideRoofBtn.setOnAction(ae -> { hideRoofBtn.setOnAction(ae -> {
if (hideRoofBtn.isSelected()) { if (hideRoofBtn.isSelected()) {
renderer.hideRoofs(); renderer.hideRoofs();
} else { } else {
renderer.showRoofs(); renderer.showRoofs();
}}); }
});
}
}
public Button getCheckButton() {
return checkBtn; public Button getCheckButton() {
} return checkBtn;
}
public ToggleButton getGridButton() {
return gridButton; public ToggleButton getGridButton() {
} return gridButton;
}
public ToggleButton getCullingButton() {
return cullingButton; public ToggleButton getCullingButton() {
} return cullingButton;
}
public Button getSaveButton() {
return saveBtn; public Button getSaveButton() {
} return saveBtn;
}
public Button getWriteReportButton() {
return reportBtn; public Button getWriteReportButton() {
} return reportBtn;
}
public ToggleButton getLod1Btn() {
return lod1Btn; public ToggleButton getLod1Btn() {
} return lod1Btn;
}
public ToggleButton getLod2Btn() {
return lod2Btn; public ToggleButton getLod2Btn() {
} return lod2Btn;
}
public ToggleButton getLod3Btn() {
return lod3Btn; public ToggleButton getLod3Btn() {
} return lod3Btn;
}
public ToggleButton getLod4Btn() {
return lod4Btn; public ToggleButton getLod4Btn() {
} return lod4Btn;
}
public ToggleButton getHideRoofBtn(){
return hideRoofBtn; public ToggleButton getHideRoofBtn() {
} return hideRoofBtn;
}
public Button getWorldBtn() {
return showWorldBtn; public Button getWorldBtn() {
} return showWorldBtn;
}
public Button getSaveBtn() {
return saveBtn; public Button getSaveBtn() {
} return saveBtn;
}
public Button getResetCameraBtn(){
return resetCameraBtn; public Button getResetCameraBtn() {
} return resetCameraBtn;
}
public HBox getToolBar() {
return toolBar; public HBox getToolBar() {
} return toolBar;
}
public Button getOpenBtn() {
return openBtn; public Button getOpenBtn() {
} return openBtn;
}
} }
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/MainWindow.java
View file @ 02de0a22
package de.hft.stuttgart.citydoctor2.gui; package de.hft.stuttgart.citydoctor2.gui;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;
import java.util.Locale;
import java.util.Optional;
import java.util.Timer;
import java.util.TimerTask;
import javax.imageio.ImageIO;
import javafx.scene.chart.NumberAxis;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import de.hft.stuttgart.citydoctor2.CityDoctorValidation; import de.hft.stuttgart.citydoctor2.CityDoctorValidation;
import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration; import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration;
import de.hft.stuttgart.citydoctor2.datastructure.BoundingBox; import de.hft.stuttgart.citydoctor2.datastructure.BoundingBox;
...@@ -35,35 +19,9 @@ import javafx.beans.value.ChangeListener; ...@@ -35,35 +19,9 @@ import javafx.beans.value.ChangeListener;
import javafx.embed.swing.SwingFXUtils; import javafx.embed.swing.SwingFXUtils;
import javafx.fxml.FXML; import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader; import javafx.fxml.FXMLLoader;
import javafx.scene.AmbientLight; import javafx.scene.*;
import javafx.scene.Group; import javafx.scene.control.*;
import javafx.scene.Node;
import javafx.scene.PerspectiveCamera;
import javafx.scene.Scene;
import javafx.scene.SceneAntialiasing;
import javafx.scene.SubScene;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType; import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.ComboBox;
import javafx.scene.control.ContextMenu;
import javafx.scene.control.Label;
import javafx.scene.control.ListCell;
import javafx.scene.control.ListView;
import javafx.scene.control.MenuItem;
import javafx.scene.control.ProgressBar;
import javafx.scene.control.RadioButton;
import javafx.scene.control.SplitPane;
import javafx.scene.control.Tab;
import javafx.scene.control.TabPane;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.control.ToolBar;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeView;
import javafx.scene.image.Image; import javafx.scene.image.Image;
import javafx.scene.image.ImageView; import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage; import javafx.scene.image.WritableImage;
...@@ -78,6 +36,15 @@ import javafx.scene.layout.Priority; ...@@ -78,6 +36,15 @@ import javafx.scene.layout.Priority;
import javafx.scene.paint.Color; import javafx.scene.paint.Color;
import javafx.scene.transform.Rotate; import javafx.scene.transform.Rotate;
import javafx.stage.Stage; import javafx.stage.Stage;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.*;
public class MainWindow extends Application { public class MainWindow extends Application {
...@@ -673,7 +640,7 @@ public class MainWindow extends Application { ...@@ -673,7 +640,7 @@ public class MainWindow extends Application {
}); });
} }
public void setDisableOfFeatureTab(FeatureType featureType, boolean value){ public void setDisableOfFeatureTab(FeatureType featureType, boolean value) {
switch (featureType) { switch (featureType) {
case BUILDING: case BUILDING:
buildingsTab.setDisable(value); buildingsTab.setDisable(value);
...@@ -708,7 +675,7 @@ public class MainWindow extends Application { ...@@ -708,7 +675,7 @@ public class MainWindow extends Application {
} }
} }
public void activateAllTabs(){ public void activateAllTabs() {
buildingsTab.setDisable(false); buildingsTab.setDisable(false);
vegetationTab.setDisable(false); vegetationTab.setDisable(false);
transportationTab.setDisable(false); transportationTab.setDisable(false);
...@@ -921,7 +888,7 @@ public class MainWindow extends Application { ...@@ -921,7 +888,7 @@ public class MainWindow extends Application {
alignNorthArrow(); alignNorthArrow();
} }
if (me.getButton() == MouseButton.SECONDARY) { if (me.getButton() == MouseButton.SECONDARY) {
double translationSpeed = Math.abs(camera.getTranslateZ())/1000; double translationSpeed = Math.abs(camera.getTranslateZ()) / 1000;
double deltaX = me.getScreenX() - dragX; double deltaX = me.getScreenX() - dragX;
double deltaY = me.getScreenY() - dragY; double deltaY = me.getScreenY() - dragY;
dragX = me.getScreenX(); dragX = me.getScreenX();
...@@ -942,27 +909,27 @@ public class MainWindow extends Application { ...@@ -942,27 +909,27 @@ public class MainWindow extends Application {
cameraXRotation.setAngle(cameraYRot); cameraXRotation.setAngle(cameraYRot);
} }
public void alignNorthArrow(){ public void alignNorthArrow() {
double absRotZ = cameraZRotation.getAngle() - 360 * Math.floor(cameraZRotation.getAngle() / 360); double absRotZ = cameraZRotation.getAngle() - 360 * Math.floor(cameraZRotation.getAngle() / 360);
double absRotX = cameraXRotation.getAngle() - 360 * Math.floor(cameraXRotation.getAngle() / 360); double absRotX = cameraXRotation.getAngle() - 360 * Math.floor(cameraXRotation.getAngle() / 360);
double northRot; double northRot;
if (80 <= absRotX && absRotX <= 260){ if (80 <= absRotX && absRotX <= 260) {
northRot = 360-absRotZ; northRot = 360 - absRotZ;
if (northArrow.getImage() != north){ if (northArrow.getImage() != north) {
northArrow.setImage(north); northArrow.setImage(north);
} }
} else { } else {
//Camera is below horizon line -> flip north arrow horizontally //Camera is below horizon line -> flip north arrow horizontally
northRot = (absRotZ+180)%360; northRot = (absRotZ + 180) % 360;
if (northArrow.getImage() != northFlip){ if (northArrow.getImage() != northFlip) {
northArrow.setImage(northFlip); northArrow.setImage(northFlip);
} }
} }
northArrow.setRotate(northRot); northArrow.setRotate(northRot);
} }
public void resetCamera(){ public void resetCamera() {
cameraXRot = CAMERA_INITIAL_X_ANGLE; cameraXRot = CAMERA_INITIAL_X_ANGLE;
cameraYRot = CAMERA_INITIAL_Y_ANGLE; cameraYRot = CAMERA_INITIAL_Y_ANGLE;
cameraZRotation.setAngle(cameraXRot); cameraZRotation.setAngle(cameraXRot);
...@@ -1092,15 +1059,15 @@ public class MainWindow extends Application { ...@@ -1092,15 +1059,15 @@ public class MainWindow extends Application {
return mainToolBar.getWorldBtn(); return mainToolBar.getWorldBtn();
} }
public Button getResetCameraBtn(){ public Button getResetCameraBtn() {
return mainToolBar.getResetCameraBtn(); return mainToolBar.getResetCameraBtn();
} }
public ToggleButton getHideRoofBtn(){ public ToggleButton getHideRoofBtn() {
return mainToolBar.getHideRoofBtn(); return mainToolBar.getHideRoofBtn();
} }
public ImageView getNorthArrow(){ public ImageView getNorthArrow() {
return northArrow; return northArrow;
} }
......
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/Renderer.java
View file @ 02de0a22
package de.hft.stuttgart.citydoctor2.gui; package de.hft.stuttgart.citydoctor2.gui;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckError;
import de.hft.stuttgart.citydoctor2.check.Checkable; import de.hft.stuttgart.citydoctor2.check.Checkable;
import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter; import de.hft.stuttgart.citydoctor2.gui.filter.ViewFilter;
import de.hft.stuttgart.citydoctor2.gui.tree.EdgeNode; import de.hft.stuttgart.citydoctor2.gui.tree.*;
import de.hft.stuttgart.citydoctor2.gui.tree.ErrorItemVisitor;
import de.hft.stuttgart.citydoctor2.gui.tree.ErrorNode;
import de.hft.stuttgart.citydoctor2.gui.tree.LinearRingNode;
import de.hft.stuttgart.citydoctor2.gui.tree.PolygonNode;
import de.hft.stuttgart.citydoctor2.gui.tree.Renderable;
import de.hft.stuttgart.citydoctor2.gui.tree.VertexNode;
import de.hft.stuttgart.citydoctor2.math.Triangle3d; import de.hft.stuttgart.citydoctor2.math.Triangle3d;
import javafx.application.Platform; import javafx.application.Platform;
import javafx.scene.control.TreeItem; import javafx.scene.control.TreeItem;
import javafx.scene.paint.Color; import javafx.scene.paint.Color;
import javafx.scene.shape.CullFace; import javafx.scene.shape.CullFace;
import javafx.scene.shape.DrawMode; import javafx.scene.shape.DrawMode;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.util.*;
public class Renderer { public class Renderer {
private static final Logger logger = LogManager.getLogger(Renderer.class); private static final Logger logger = LogManager.getLogger(Renderer.class);
private TriangulatedGeometry currentTriGeom; private TriangulatedGeometry currentTriGeom;
private Geometry currentGeometry; private Geometry currentGeometry;
private CullFace currentCulling = CullFace.BACK; private CullFace currentCulling = CullFace.BACK;
private DrawMode currentDrawMode = DrawMode.FILL; private DrawMode currentDrawMode = DrawMode.FILL;
private MainWindow mainWindow; private MainWindow mainWindow;
private HighlightController highlightController; private HighlightController highlightController;
private ListErrorVisitor errVisitor; private ListErrorVisitor errVisitor;
private LoadingInfoDialog loadingDialog; private LoadingInfoDialog loadingDialog;
private List<ViewFilter> lodFilters = new ArrayList<>(); private List<ViewFilter> lodFilters = new ArrayList<>();
private ViewFilter roofFilter; private ViewFilter roofFilter;
private Runnable refresher; private Runnable refresher;
private Runnable errorUpdater; private Runnable errorUpdater;
public Renderer(MainWindow mainWindow, HighlightController highlightController) throws IOException { public Renderer(MainWindow mainWindow, HighlightController highlightController) throws IOException {
this.mainWindow = mainWindow; this.mainWindow = mainWindow;
this.highlightController = highlightController; this.highlightController = highlightController;
loadingDialog = new LoadingInfoDialog(mainWindow.getMainStage()); loadingDialog = new LoadingInfoDialog(mainWindow.getMainStage());
errVisitor = new ListErrorVisitor(highlightController); errVisitor = new ListErrorVisitor(highlightController);
setupLodFilters(); setupLodFilters();
} }
private void setupLodFilters() { private void setupLodFilters() {
lodFilters.add(new ViewFilter() { lodFilters.add(new ViewFilter() {
@Override @Override
public boolean useGeometry(CityObject co, Geometry geom) { public boolean useGeometry(CityObject co, Geometry geom) {
return geom.getLod() == Lod.LOD1; return geom.getLod() == Lod.LOD1;
} }
}); });
lodFilters.add(new ViewFilter() { lodFilters.add(new ViewFilter() {
@Override @Override
public boolean useGeometry(CityObject co, Geometry geom) { public boolean useGeometry(CityObject co, Geometry geom) {
return geom.getLod() == Lod.LOD2; return geom.getLod() == Lod.LOD2;
} }
}); });
lodFilters.add(new ViewFilter() { lodFilters.add(new ViewFilter() {
@Override @Override
public boolean useGeometry(CityObject co, Geometry geom) { public boolean useGeometry(CityObject co, Geometry geom) {
return geom.getLod() == Lod.LOD3; return geom.getLod() == Lod.LOD3;
} }
}); });
lodFilters.add(new ViewFilter() { lodFilters.add(new ViewFilter() {
@Override @Override
protected boolean useGeometry(CityObject co, Geometry geom) { protected boolean useGeometry(CityObject co, Geometry geom) {
return geom.getLod() == Lod.LOD0; return geom.getLod() == Lod.LOD0;
} }
}); });
lodFilters.add(new ViewFilter() { lodFilters.add(new ViewFilter() {
@Override @Override
public boolean useGeometry(CityObject co, Geometry geom) { public boolean useGeometry(CityObject co, Geometry geom) {
return geom.getLod() == Lod.LOD4; return geom.getLod() == Lod.LOD4;
} }
}); });
roofFilter = new ViewFilter() { roofFilter = new ViewFilter() {
@Override @Override
public boolean allowedToUse(CityObject co, Geometry geom){ public boolean allowedToUse(CityObject co, Geometry geom) {
if (!this.isEnabled()){ if (!this.isEnabled()) {
return true; return true;
} }
return this.useGeometry(co, geom); return this.useGeometry(co, geom);
} }
@Override @Override
public boolean useGeometry(CityObject co, Geometry geom) { public boolean useGeometry(CityObject co, Geometry geom) {
if (co instanceof BoundarySurface bs){ if (co instanceof BoundarySurface bs) {
return bs.getType() != BoundarySurfaceType.ROOF; return bs.getType() != BoundarySurfaceType.ROOF;
} }
return true; return true;
} }
}; };
roofFilter.setEnable(false); roofFilter.setEnable(false);
} }
public void enableLod1() { public void enableLod1() {
lodFilters.get(0).enable(); lodFilters.get(0).enable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void disableLod1() { public void disableLod1() {
lodFilters.get(0).disable(); lodFilters.get(0).disable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void enableLod2() { public void enableLod2() {
lodFilters.get(1).enable(); lodFilters.get(1).enable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void disableLod2() { public void disableLod2() {
lodFilters.get(1).disable(); lodFilters.get(1).disable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void enableLod3() { public void enableLod3() {
lodFilters.get(2).enable(); lodFilters.get(2).enable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void disableLod3() { public void disableLod3() {
lodFilters.get(2).disable(); lodFilters.get(2).disable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void enableLod4() { public void enableLod4() {
lodFilters.get(3).enable(); lodFilters.get(3).enable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void disableLod4() { public void disableLod4() {
lodFilters.get(3).disable(); lodFilters.get(3).disable();
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void hideRoofs(){ public void hideRoofs() {
roofFilter.setEnable(true); roofFilter.setEnable(true);
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void showRoofs(){ public void showRoofs() {
roofFilter.setEnable(false); roofFilter.setEnable(false);
if (refresher != null) { if (refresher != null) {
refresher.run(); refresher.run();
} }
} }
public void render(Building building) { public void render(Building building) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupBuildingPolygons = setupBuildingPolygons(building); Set<ConcretePolygon> setupBuildingPolygons = setupBuildingPolygons(building);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPolygons));
render(setupBuildingPolygons); render(setupBuildingPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(building); errorUpdater = () -> displayErrors(building);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBuildingPolygons(Building b) { private Set<ConcretePolygon> setupBuildingPolygons(Building b) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(b, polygons); addPolygons(b, polygons);
for (BoundarySurface bs : b.getBoundarySurfaces()) { for (BoundarySurface bs : b.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
for (Installation bi : b.getBuildingInstallations()) { for (Installation bi : b.getBuildingInstallations()) {
addPolygons(bi, polygons); addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) { for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
} }
for (BuildingRoom br : b.getBuildingRooms()) { for (BuildingRoom br : b.getBuildingRooms()) {
addPolygons(br, polygons); addPolygons(br, polygons);
for (BoundarySurface bs : br.getBoundarySurfaceList()){ for (BoundarySurface bs : br.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (BuildingRoomFurniture brf : b.getBuildingRoomFurnitureList()){ for (BuildingRoomFurniture brf : b.getBuildingRoomFurnitureList()) {
addPolygons(brf, polygons); addPolygons(brf, polygons);
for (BoundarySurface bs : brf.getBoundarySurfaceList()){ for (BoundarySurface bs : brf.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (BuildingPart bp : b.getBuildingParts()) { for (BuildingPart bp : b.getBuildingParts()) {
polygons.addAll(setupBuildingPartPolygons(bp)); polygons.addAll(setupBuildingPartPolygons(bp));
} }
return polygons; return polygons;
} }
public void render(BuildingPart bp) { public void render(BuildingPart bp) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupBuildingPartPolygons = setupBuildingPartPolygons(bp); Set<ConcretePolygon> setupBuildingPartPolygons = setupBuildingPartPolygons(bp);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPartPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingPartPolygons));
render(setupBuildingPartPolygons); render(setupBuildingPartPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bp); errorUpdater = () -> displayErrors(bp);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBuildingPartPolygons(BuildingPart bp) { private Set<ConcretePolygon> setupBuildingPartPolygons(BuildingPart bp) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bp, polygons); addPolygons(bp, polygons);
for (BoundarySurface bs : bp.getBoundarySurfaces()) { for (BoundarySurface bs : bp.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
for (Installation bi : bp.getBuildingInstallations()) { for (Installation bi : bp.getBuildingInstallations()) {
addPolygons(bi, polygons); addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) { for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
} }
return polygons; return polygons;
} }
public void render(AbstractRoom room){ public void render(AbstractRoom room) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupRoomPolygons = setupRoomPolygons(room); Set<ConcretePolygon> setupRoomPolygons = setupRoomPolygons(room);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupRoomPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupRoomPolygons));
render(setupRoomPolygons); render(setupRoomPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(room); errorUpdater = () -> displayErrors(room);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupRoomPolygons(AbstractRoom room) { private Set<ConcretePolygon> setupRoomPolygons(AbstractRoom room) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(room, polygons); addPolygons(room, polygons);
for (BoundarySurface bs : room.getBoundarySurfaceList()) { for (BoundarySurface bs : room.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(AbstractFurniture furniture){ public void render(AbstractFurniture furniture) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupFurniturePolygons = setupFurniturePolygons(furniture); Set<ConcretePolygon> setupFurniturePolygons = setupFurniturePolygons(furniture);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupFurniturePolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupFurniturePolygons));
render(setupFurniturePolygons); render(setupFurniturePolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(furniture); errorUpdater = () -> displayErrors(furniture);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupFurniturePolygons(AbstractFurniture furniture) { private Set<ConcretePolygon> setupFurniturePolygons(AbstractFurniture furniture) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(furniture, polygons); addPolygons(furniture, polygons);
for (BoundarySurface bs : furniture.getBoundarySurfaceList()) { for (BoundarySurface bs : furniture.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(Storey storey){ public void render(Storey storey) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupStoreyPolygons = setupStoreyPolygons(storey); Set<ConcretePolygon> setupStoreyPolygons = setupStoreyPolygons(storey);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupStoreyPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupStoreyPolygons));
render(setupStoreyPolygons); render(setupStoreyPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(storey); errorUpdater = () -> displayErrors(storey);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupStoreyPolygons(Storey storey) { private Set<ConcretePolygon> setupStoreyPolygons(Storey storey) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(storey, polygons); addPolygons(storey, polygons);
for (BoundarySurface bs : storey.getBoundarySurfaces()) { for (BoundarySurface bs : storey.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(BuildingUnit buildingUnit){ public void render(BuildingUnit buildingUnit) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupBuildingUnitPolgons = setupBuildingUnitPolygons(buildingUnit); Set<ConcretePolygon> setupBuildingUnitPolgons = setupBuildingUnitPolygons(buildingUnit);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingUnitPolgons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBuildingUnitPolgons));
render(setupBuildingUnitPolgons); render(setupBuildingUnitPolgons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(buildingUnit); errorUpdater = () -> displayErrors(buildingUnit);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBuildingUnitPolygons(BuildingUnit buildingUnit) { private Set<ConcretePolygon> setupBuildingUnitPolygons(BuildingUnit buildingUnit) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(buildingUnit, polygons); addPolygons(buildingUnit, polygons);
for (BoundarySurface bs : buildingUnit.getBoundarySurfaces()) { for (BoundarySurface bs : buildingUnit.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(Tunnel tunnel){ public void render(Tunnel tunnel) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupTunnelPolygons = setupTunnelPolygons(tunnel); Set<ConcretePolygon> setupTunnelPolygons = setupTunnelPolygons(tunnel);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupTunnelPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupTunnelPolygons));
render(setupTunnelPolygons); render(setupTunnelPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(tunnel); errorUpdater = () -> displayErrors(tunnel);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupTunnelPolygons(Tunnel tunnel) { private Set<ConcretePolygon> setupTunnelPolygons(Tunnel tunnel) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(tunnel, polygons); addPolygons(tunnel, polygons);
for (BoundarySurface bs : tunnel.getBoundarySurfaces()) { for (BoundarySurface bs : tunnel.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
for (Installation ti : tunnel.getTunnelInstallations()) { for (Installation ti : tunnel.getTunnelInstallations()) {
addPolygons(ti, polygons); addPolygons(ti, polygons);
for (BoundarySurface bs : ti.getBoundarySurfaces()) { for (BoundarySurface bs : ti.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
} }
for (TunnelHollow th : tunnel.getTunnelHollows()) { for (TunnelHollow th : tunnel.getTunnelHollows()) {
addPolygons(th, polygons); addPolygons(th, polygons);
for (BoundarySurface bs : th.getBoundarySurfaceList()){ for (BoundarySurface bs : th.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (TunnelFurniture tf : tunnel.getTunnelFurnitureList()){ for (TunnelFurniture tf : tunnel.getTunnelFurnitureList()) {
addPolygons(tf, polygons); addPolygons(tf, polygons);
for (BoundarySurface bs : tf.getBoundarySurfaceList()){ for (BoundarySurface bs : tf.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (TunnelPart tp : tunnel.getTunnelParts()) { for (TunnelPart tp : tunnel.getTunnelParts()) {
polygons.addAll(setupTunnelPartPolygons(tp)); polygons.addAll(setupTunnelPartPolygons(tp));
} }
return polygons; return polygons;
} }
private Set<ConcretePolygon> setupTunnelPartPolygons(TunnelPart tp) { private Set<ConcretePolygon> setupTunnelPartPolygons(TunnelPart tp) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(tp, polygons); addPolygons(tp, polygons);
for (BoundarySurface bs : tp.getBoundarySurfaces()) { for (BoundarySurface bs : tp.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
for (Installation bi : tp.getTunnelInstallations()) { for (Installation bi : tp.getTunnelInstallations()) {
addPolygons(bi, polygons); addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) { for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
} }
return polygons; return polygons;
} }
public void render(BridgeObject bridge) { public void render(BridgeObject bridge) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupBridgePolygons = setupBridgePolygons(bridge); Set<ConcretePolygon> setupBridgePolygons = setupBridgePolygons(bridge);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBridgePolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBridgePolygons));
render(setupBridgePolygons); render(setupBridgePolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bridge); errorUpdater = () -> displayErrors(bridge);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBridgePolygons(BridgeObject bridge) { private Set<ConcretePolygon> setupBridgePolygons(BridgeObject bridge) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bridge, polygons); addPolygons(bridge, polygons);
for (BoundarySurface bs : bridge.getBoundarySurfaces()) { for (BoundarySurface bs : bridge.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
for (BridgeConstructiveElement consElement : bridge.getConstructiveElements()) { for (BridgeConstructiveElement consElement : bridge.getConstructiveElements()) {
addPolygons(consElement, polygons); addPolygons(consElement, polygons);
for (BoundarySurface bs : consElement.getBoundarySurfaces()) { for (BoundarySurface bs : consElement.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (Installation inst : bridge.getBridgeInstallations()) { for (Installation inst : bridge.getBridgeInstallations()) {
addPolygons(inst, polygons); addPolygons(inst, polygons);
for (BoundarySurface bs : inst.getBoundarySurfaces()) { for (BoundarySurface bs : inst.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(CityObject co) { public void render(CityObject co) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupCityObjectPolygons = setupCityObjectPolygons(co); Set<ConcretePolygon> setupCityObjectPolygons = setupCityObjectPolygons(co);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons); render(setupCityObjectPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(co); errorUpdater = () -> displayErrors(co);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
public void render(ReliefObject relief) { public void render(ReliefObject relief) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupCityObjectPolygons = setupReliefPolygons(relief); Set<ConcretePolygon> setupCityObjectPolygons = setupReliefPolygons(relief);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons); render(setupCityObjectPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(relief); errorUpdater = () -> displayErrors(relief);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupReliefPolygons(ReliefObject relief) { private Set<ConcretePolygon> setupReliefPolygons(ReliefObject relief) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(relief, polygons); addPolygons(relief, polygons);
for (TinObject tin : relief.getComponents()) { for (TinObject tin : relief.getComponents()) {
addPolygons(tin, polygons); addPolygons(tin, polygons);
} }
return polygons; return polygons;
} }
public void render(Installation bi) { public void render(Installation bi) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupCityObjectPolygons = setupBuildingInstallationPolygons(bi); Set<ConcretePolygon> setupCityObjectPolygons = setupBuildingInstallationPolygons(bi);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityObjectPolygons));
render(setupCityObjectPolygons); render(setupCityObjectPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bi); errorUpdater = () -> displayErrors(bi);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBuildingInstallationPolygons(Installation bi) { private Set<ConcretePolygon> setupBuildingInstallationPolygons(Installation bi) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bi, polygons); addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) { for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(CityFurniture cf) { public void render(CityFurniture cf) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupCityFurniturePolygons = setupCityFurniturePolygons(cf); Set<ConcretePolygon> setupCityFurniturePolygons = setupCityFurniturePolygons(cf);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityFurniturePolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupCityFurniturePolygons));
render(setupCityFurniturePolygons); render(setupCityFurniturePolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(cf); errorUpdater = () -> displayErrors(cf);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupCityFurniturePolygons(CityFurniture cf) { private Set<ConcretePolygon> setupCityFurniturePolygons(CityFurniture cf) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(cf, polygons); addPolygons(cf, polygons);
return polygons; return polygons;
} }
public void render(GenericCityObject gco){ public void render(GenericCityObject gco) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupGenericCityObjectPolygons = setupGenericCityObjectPolygons(gco); Set<ConcretePolygon> setupGenericCityObjectPolygons = setupGenericCityObjectPolygons(gco);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupGenericCityObjectPolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupGenericCityObjectPolygons));
render(setupGenericCityObjectPolygons); render(setupGenericCityObjectPolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(gco); errorUpdater = () -> displayErrors(gco);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupGenericCityObjectPolygons(GenericCityObject gco) { private Set<ConcretePolygon> setupGenericCityObjectPolygons(GenericCityObject gco) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(gco, polygons); addPolygons(gco, polygons);
for (BoundarySurface bs : gco.getBoundarySurfaces()) { for (BoundarySurface bs : gco.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
} }
return polygons; return polygons;
} }
public void render(BoundarySurface bs) { public void render(BoundarySurface bs) {
refresher = () -> { refresher = () -> {
Set<ConcretePolygon> setupBoundarySurfacePolygons = setupBoundarySurfacePolygons(bs); Set<ConcretePolygon> setupBoundarySurfacePolygons = setupBoundarySurfacePolygons(bs);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBoundarySurfacePolygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(setupBoundarySurfacePolygons));
render(setupBoundarySurfacePolygons); render(setupBoundarySurfacePolygons);
Platform.runLater(() -> { Platform.runLater(() -> {
errorUpdater = () -> displayErrors(bs); errorUpdater = () -> displayErrors(bs);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private Set<ConcretePolygon> setupBoundarySurfacePolygons(BoundarySurface bs) { private Set<ConcretePolygon> setupBoundarySurfacePolygons(BoundarySurface bs) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening op : bs.getOpenings()) { for (Opening op : bs.getOpenings()) {
addPolygons(op, polygons); addPolygons(op, polygons);
} }
return polygons; return polygons;
} }
private Set<ConcretePolygon> setupCityObjectPolygons(CityObject co) { private Set<ConcretePolygon> setupCityObjectPolygons(CityObject co) {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
addPolygons(co, polygons); addPolygons(co, polygons);
return polygons; return polygons;
} }
private void addPolygons(CityObject co, Set<ConcretePolygon> polygons) { private void addPolygons(CityObject co, Set<ConcretePolygon> polygons) {
for (Geometry geom : co.getGeometries()) { for (Geometry geom : co.getGeometries()) {
boolean used = false; boolean used = false;
for (ViewFilter filter : lodFilters) { for (ViewFilter filter : lodFilters) {
if (filter.allowedToUse(co, geom)) { if (filter.allowedToUse(co, geom)) {
used = true; used = true;
break; break;
} }
} }
if (used) { if (used) {
if (roofFilter.allowedToUse(co, geom)) { if (roofFilter.allowedToUse(co, geom)) {
addConcretePolygons(polygons, geom); addConcretePolygons(polygons, geom);
} }
} }
} }
} }
private void displayErrors(Checkable c) { private void displayErrors(Checkable c) {
if (!c.isValidated()) { if (!c.isValidated()) {
return; return;
} }
List<CheckError> errors = new ArrayList<>(); List<CheckError> errors = new ArrayList<>();
c.collectContainedErrors(errors); c.collectContainedErrors(errors);
// filter out duplicate errors (polygon can be contained in multiple geometries) // filter out duplicate errors (polygon can be contained in multiple geometries)
Set<CheckError> errorSet = new HashSet<>(errors); Set<CheckError> errorSet = new HashSet<>(errors);
for (CheckError err : errorSet) { for (CheckError err : errorSet) {
ErrorNode node = new ErrorNode(err); ErrorNode node = new ErrorNode(err);
TreeItem<Renderable> errItem = new TreeItem<>(node); TreeItem<Renderable> errItem = new TreeItem<>(node);
ErrorItemVisitor visitor = new ErrorItemVisitor(errItem); ErrorItemVisitor visitor = new ErrorItemVisitor(errItem);
err.accept(visitor); err.accept(visitor);
mainWindow.getErrorTree().getRoot().getChildren().add(errItem); mainWindow.getErrorTree().getRoot().getChildren().add(errItem);
} }
} }
public void render(Geometry geom) { public void render(Geometry geom) {
refresher = () -> { refresher = () -> {
Platform.runLater(this::clearGeometryTrees); Platform.runLater(this::clearGeometryTrees);
currentTriGeom = TriangulatedGeometry.of(geom); currentTriGeom = TriangulatedGeometry.of(geom);
if (geom.getEdges() == null && currentGeometry != null) { if (geom.getEdges() == null && currentGeometry != null) {
// if there are no edges available low memory mode is enabled // if there are no edges available low memory mode is enabled
// clear the old geometry of all meta information // clear the old geometry of all meta information
currentGeometry.clearMetaInformation(); currentGeometry.clearMetaInformation();
} }
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
if (geom.getEdges() == null) { if (geom.getEdges() == null) {
// create edges and vertices so they can be listed in the gui // create edges and vertices so they can be listed in the gui
geom.prepareForChecking(); geom.prepareForChecking();
// remember the geometry, so it can be cleared if another is displayed // remember the geometry, so it can be cleared if another is displayed
currentGeometry = geom; currentGeometry = geom;
} }
addGeometryDataToView(geom); addGeometryDataToView(geom);
mainWindow.zoomOutForBoundingBox(BoundingBox.of(geom.getPolygons())); mainWindow.zoomOutForBoundingBox(BoundingBox.of(geom.getPolygons()));
errorUpdater = () -> displayErrors(geom); errorUpdater = () -> displayErrors(geom);
errorUpdater.run(); errorUpdater.run();
}); });
}; };
refresher.run(); refresher.run();
} }
private void addGeometryDataToView(Geometry geom) { private void addGeometryDataToView(Geometry geom) {
for (Polygon p : geom.getPolygons()) { for (Polygon p : geom.getPolygons()) {
if (p instanceof CompositePolygon){ if (p instanceof CompositePolygon) {
continue; continue;
} }
addPolygonToView(p); addPolygonToView(p);
} }
for (Edge e : geom.getEdges()) { for (Edge e : geom.getEdges()) {
addEdgeToView(e); addEdgeToView(e);
} }
for (Vertex v : geom.getVertices()) { for (Vertex v : geom.getVertices()) {
addVertexToView(v); addVertexToView(v);
} }
} }
private void addVertexToView(Vertex v) { private void addVertexToView(Vertex v) {
Renderable cf = new VertexNode(v); Renderable cf = new VertexNode(v);
TreeItem<Renderable> ti = new TreeItem<>(cf); TreeItem<Renderable> ti = new TreeItem<>(cf);
mainWindow.getVertexView().getRoot().getChildren().add(ti); mainWindow.getVertexView().getRoot().getChildren().add(ti);
} }
private void addEdgeToView(Edge e) { private void addEdgeToView(Edge e) {
EdgeNode cf = new EdgeNode(e); EdgeNode cf = new EdgeNode(e);
TreeItem<Renderable> ti = new TreeItem<>(cf); TreeItem<Renderable> ti = new TreeItem<>(cf);
mainWindow.getEdgeView().getRoot().getChildren().add(ti); mainWindow.getEdgeView().getRoot().getChildren().add(ti);
} }
private void addPolygonToView(Polygon p) { private void addPolygonToView(Polygon p) {
CheckStatus cs = determineCheckStatus(p); CheckStatus cs = determineCheckStatus(p);
PolygonNode cf = new PolygonNode(p, cs); PolygonNode cf = new PolygonNode(p, cs);
TreeItem<Renderable> ti = new TreeItem<>(cf); TreeItem<Renderable> ti = new TreeItem<>(cf);
mainWindow.getPolygonsView().getRoot().getChildren().add(ti); mainWindow.getPolygonsView().getRoot().getChildren().add(ti);
// add linear rings // add linear rings
CheckStatus csRing = determineCheckStatus(p.getExteriorRing()); CheckStatus csRing = determineCheckStatus(p.getExteriorRing());
Renderable ccRing = new LinearRingNode(p.getExteriorRing(), csRing); Renderable ccRing = new LinearRingNode(p.getExteriorRing(), csRing);
TreeItem<Renderable> tiRing = new TreeItem<>(ccRing); TreeItem<Renderable> tiRing = new TreeItem<>(ccRing);
ti.getChildren().add(tiRing); ti.getChildren().add(tiRing);
for (Vertex v : p.getExteriorRing().getVertices()) { for (Vertex v : p.getExteriorRing().getVertices()) {
VertexNode vn = new VertexNode(v); VertexNode vn = new VertexNode(v);
TreeItem<Renderable> tiV = new TreeItem<>(vn); TreeItem<Renderable> tiV = new TreeItem<>(vn);
tiRing.getChildren().add(tiV); tiRing.getChildren().add(tiV);
} }
for (LinearRing lr : p.getInnerRings()) { for (LinearRing lr : p.getInnerRings()) {
CheckStatus csInteriorRing = determineCheckStatus(lr); CheckStatus csInteriorRing = determineCheckStatus(lr);
Renderable ccInteriorRing = new LinearRingNode(lr, csInteriorRing); Renderable ccInteriorRing = new LinearRingNode(lr, csInteriorRing);
TreeItem<Renderable> tiInteriorRing = new TreeItem<>(ccInteriorRing); TreeItem<Renderable> tiInteriorRing = new TreeItem<>(ccInteriorRing);
ti.getChildren().add(tiInteriorRing); ti.getChildren().add(tiInteriorRing);
for (Vertex v : lr.getVertices()) { for (Vertex v : lr.getVertices()) {
VertexNode vn = new VertexNode(v); VertexNode vn = new VertexNode(v);
TreeItem<Renderable> tiV = new TreeItem<>(vn); TreeItem<Renderable> tiV = new TreeItem<>(vn);
tiRing.getChildren().add(tiV); tiRing.getChildren().add(tiV);
} }
} }
} }
private CheckStatus determineCheckStatus(Checkable c) { private CheckStatus determineCheckStatus(Checkable c) {
if (!c.isValidated()) { if (!c.isValidated()) {
return CheckStatus.NOT_CHECKED; return CheckStatus.NOT_CHECKED;
} }
if (c.containsAnyError()) { if (c.containsAnyError()) {
return CheckStatus.ERROR; return CheckStatus.ERROR;
} }
return CheckStatus.OK; return CheckStatus.OK;
} }
private void render(Collection<? extends Polygon> polygons) { private void render(Collection<? extends Polygon> polygons) {
Platform.runLater(this::clearGeometryTrees); Platform.runLater(this::clearGeometryTrees);
currentTriGeom = TriangulatedGeometry.of(polygons); currentTriGeom = TriangulatedGeometry.of(polygons);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
setupRenderState(); setupRenderState();
} }
private void clearGeometryTrees() { private void clearGeometryTrees() {
highlightController.clearHighlights(); highlightController.clearHighlights();
mainWindow.getErrorTree().getRoot().getChildren().clear(); mainWindow.getErrorTree().getRoot().getChildren().clear();
mainWindow.getPolygonsView().getRoot().getChildren().clear(); mainWindow.getPolygonsView().getRoot().getChildren().clear();
mainWindow.getEdgeView().getRoot().getChildren().clear(); mainWindow.getEdgeView().getRoot().getChildren().clear();
mainWindow.getVertexView().getRoot().getChildren().clear(); mainWindow.getVertexView().getRoot().getChildren().clear();
} }
public void renderBuildings(List<Building> objects) { public void renderBuildings(List<Building> objects) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (Building b : objects) { for (Building b : objects) {
collectBuildingPolygons(polygons, b); collectBuildingPolygons(polygons, b);
for (BuildingPart bp : b.getBuildingParts()) { for (BuildingPart bp : b.getBuildingParts()) {
collectBuildingPolygons(polygons, bp); collectBuildingPolygons(polygons, bp);
} }
} }
currentTriGeom = TriangulatedGeometry.of(polygons); currentTriGeom = TriangulatedGeometry.of(polygons);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> { t.setUncaughtExceptionHandler((thread, e) -> {
Platform.runLater(() -> loadingDialog.hide()); Platform.runLater(() -> loadingDialog.hide());
logger.catching(e); logger.catching(e);
}); });
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
public void render(CityDoctorModel model) { public void render(CityDoctorModel model) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
currentTriGeom = TriangulatedGeometry.of(model, lodFilters); currentTriGeom = TriangulatedGeometry.of(model, lodFilters);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(model)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(model));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> { t.setUncaughtExceptionHandler((thread, e) -> {
Platform.runLater(() -> loadingDialog.hide()); Platform.runLater(() -> loadingDialog.hide());
logger.catching(e); logger.catching(e);
}); });
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
public void renderVegetation(List<Vegetation> vegetation) { public void renderVegetation(List<Vegetation> vegetation) {
renderCityObjects(vegetation, Color.LIGHTGREEN); renderCityObjects(vegetation, Color.LIGHTGREEN);
} }
public void renderTransportation(List<TransportationObject> transportation) { public void renderTransportation(List<TransportationObject> transportation) {
renderCityObjects(transportation, Color.YELLOW); renderCityObjects(transportation, Color.YELLOW);
} }
public void renderBridges(List<BridgeObject> bridges) { public void renderBridges(List<BridgeObject> bridges) {
renderCityObjects(bridges, Color.CORAL); renderCityObjects(bridges, Color.CORAL);
} }
public void renderWater(List<WaterObject> water) { public void renderWater(List<WaterObject> water) {
renderCityObjects(water, Color.LIGHTSKYBLUE); renderCityObjects(water, Color.LIGHTSKYBLUE);
} }
public void renderCityFurniture(List<CityFurniture> cityFurniture){ public void renderCityFurniture(List<CityFurniture> cityFurniture) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (CityFurniture cf : cityFurniture) { for (CityFurniture cf : cityFurniture) {
collectCityFurniture(polygons, cf); collectCityFurniture(polygons, cf);
} }
currentTriGeom = TriangulatedGeometry.of(polygons, Color.BLUEVIOLET); currentTriGeom = TriangulatedGeometry.of(polygons, Color.BLUEVIOLET);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> { t.setUncaughtExceptionHandler((thread, e) -> {
Platform.runLater(() -> loadingDialog.hide()); Platform.runLater(() -> loadingDialog.hide());
logger.catching(e); logger.catching(e);
}); });
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
public void renderTerrain(List<CityObject> land) { public void renderTerrain(List<CityObject> land) {
renderLandObjects(land, Color.BROWN); renderLandObjects(land, Color.BROWN);
} }
private void renderLandObjects(List<CityObject> cos, Color baseColor) { private void renderLandObjects(List<CityObject> cos, Color baseColor) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (CityObject co : cos) { for (CityObject co : cos) {
addPolygons(co, polygons); addPolygons(co, polygons);
if (co instanceof ReliefObject) { if (co instanceof ReliefObject) {
ReliefObject relief = (ReliefObject) co; ReliefObject relief = (ReliefObject) co;
for (TinObject tin : relief.getComponents()) { for (TinObject tin : relief.getComponents()) {
addPolygons(tin, polygons); addPolygons(tin, polygons);
} }
} }
} }
currentTriGeom = TriangulatedGeometry.of(polygons, baseColor); currentTriGeom = TriangulatedGeometry.of(polygons, baseColor);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> Platform.runLater(() -> loadingDialog.hide())); t.setUncaughtExceptionHandler((thread, e) -> Platform.runLater(() -> loadingDialog.hide()));
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
public void renderCityObjects(List<? extends CityObject> cos, Color baseColor) { public void renderCityObjects(List<? extends CityObject> cos, Color baseColor) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (CityObject co : cos) { for (CityObject co : cos) {
addPolygons(co, polygons); addPolygons(co, polygons);
} }
currentTriGeom = TriangulatedGeometry.of(polygons, baseColor); currentTriGeom = TriangulatedGeometry.of(polygons, baseColor);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> Platform.runLater(() -> loadingDialog.hide())); t.setUncaughtExceptionHandler((thread, e) -> Platform.runLater(() -> loadingDialog.hide()));
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
public void renderTunnels(List<Tunnel> objects){ public void renderTunnels(List<Tunnel> objects) {
errorUpdater = null; errorUpdater = null;
refresher = () -> { refresher = () -> {
Platform.runLater(() -> { Platform.runLater(() -> {
loadingDialog.show(); loadingDialog.show();
clearGeometryTrees(); clearGeometryTrees();
}); });
Thread t = new Thread(() -> { Thread t = new Thread(() -> {
Set<ConcretePolygon> polygons = new HashSet<>(); Set<ConcretePolygon> polygons = new HashSet<>();
for (Tunnel tunnel : objects) { for (Tunnel tunnel : objects) {
collectTunnelPolygons(polygons, tunnel); collectTunnelPolygons(polygons, tunnel);
for (TunnelPart tp : tunnel.getTunnelParts()) { for (TunnelPart tp : tunnel.getTunnelParts()) {
collectTunnelPolygons(polygons, tp); collectTunnelPolygons(polygons, tp);
} }
} }
currentTriGeom = TriangulatedGeometry.of(polygons); currentTriGeom = TriangulatedGeometry.of(polygons);
errVisitor.setGeometry(currentTriGeom); errVisitor.setGeometry(currentTriGeom);
Platform.runLater(() -> { Platform.runLater(() -> {
setupRenderState(); setupRenderState();
mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons)); mainWindow.zoomOutForBoundingBox(BoundingBox.of(polygons));
loadingDialog.hide(); loadingDialog.hide();
}); });
}); });
t.setUncaughtExceptionHandler((thread, e) -> { t.setUncaughtExceptionHandler((thread, e) -> {
Platform.runLater(() -> loadingDialog.hide()); Platform.runLater(() -> loadingDialog.hide());
logger.catching(e); logger.catching(e);
}); });
t.start(); t.start();
}; };
refresher.run(); refresher.run();
} }
private void collectBuildingPolygons(Set<ConcretePolygon> polygons, AbstractBuilding ab) { private void collectBuildingPolygons(Set<ConcretePolygon> polygons, AbstractBuilding ab) {
addPolygons(ab, polygons); addPolygons(ab, polygons);
for (Installation bi : ab.getBuildingInstallations()) { for (Installation bi : ab.getBuildingInstallations()) {
addPolygons(bi, polygons); addPolygons(bi, polygons);
for (BoundarySurface bs : bi.getBoundarySurfaces()) { for (BoundarySurface bs : bi.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) { for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons); addPolygons(o, polygons);
} }
} }
} }
for (BuildingRoom br : ab.getBuildingRooms()) { for (BuildingRoom br : ab.getBuildingRooms()) {
addPolygons(br, polygons); addPolygons(br, polygons);
for (BoundarySurface bs : br.getBoundarySurfaceList()){ for (BoundarySurface bs : br.getBoundarySurfaceList()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
} }
} }
for (BoundarySurface bs : ab.getBoundarySurfaces()) { for (BoundarySurface bs : ab.getBoundarySurfaces()) {
addPolygons(bs, polygons); addPolygons(bs, polygons);
for (Opening o : bs.getOpenings()) { for (Opening o : bs.getOpenings()) {
addPolygons(o, polygons); addPolygons(o, polygons);
} }
} }
} }
public void collectTunnelPolygons(Set<ConcretePolygon> polygons, AbstractTunnel at) {} public void collectTunnelPolygons(Set<ConcretePolygon> polygons, AbstractTunnel at) {
}
private void collectCityFurniture(Set<ConcretePolygon> polygons, CityFurniture cf) {
addPolygons(cf, polygons); private void collectCityFurniture(Set<ConcretePolygon> polygons, CityFurniture cf) {
} addPolygons(cf, polygons);
}
private void addConcretePolygons(Set<ConcretePolygon> polygons, Geometry geom) {
for (Polygon p : geom.getPolygons()) { private void addConcretePolygons(Set<ConcretePolygon> polygons, Geometry geom) {
if (p.getOriginal().getPartOfSurface() != null && for (Polygon p : geom.getPolygons()) {
!roofFilter.allowedToUse(p.getOriginal().getPartOfSurface(), p.getParent())) continue; if (p.getOriginal().getPartOfSurface() != null &&
if (p instanceof CompositePolygon) continue; !roofFilter.allowedToUse(p.getOriginal().getPartOfSurface(), p.getParent())) continue;
polygons.add(p.getOriginal()); if (p instanceof CompositePolygon) continue;
} polygons.add(p.getOriginal());
} }
}
private void setupRenderState() {
currentTriGeom.setCullFace(currentCulling); private void setupRenderState() {
currentTriGeom.setDrawMode(currentDrawMode); currentTriGeom.setCullFace(currentCulling);
Platform.runLater(() -> { currentTriGeom.setDrawMode(currentDrawMode);
mainWindow.getMeshGroup().getChildren().clear(); Platform.runLater(() -> {
mainWindow.getMeshGroup().getChildren().addAll(currentTriGeom.getMeshes()); mainWindow.getMeshGroup().getChildren().clear();
}); mainWindow.getMeshGroup().getChildren().addAll(currentTriGeom.getMeshes());
mainWindow.getGridButton().setDisable(false); });
mainWindow.getCullingButton().setDisable(false); mainWindow.getGridButton().setDisable(false);
} mainWindow.getCullingButton().setDisable(false);
}
public void showWireFrame(boolean show) {
if (currentTriGeom != null) { public void showWireFrame(boolean show) {
if (show) { if (currentTriGeom != null) {
currentDrawMode = DrawMode.LINE; if (show) {
} else { currentDrawMode = DrawMode.LINE;
currentDrawMode = DrawMode.FILL; } else {
} currentDrawMode = DrawMode.FILL;
currentTriGeom.setDrawMode(currentDrawMode); }
} currentTriGeom.setDrawMode(currentDrawMode);
} }
}
public void enableCulling(boolean enable) {
if (currentTriGeom != null) { public void enableCulling(boolean enable) {
if (enable) { if (currentTriGeom != null) {
currentCulling = CullFace.BACK; if (enable) {
} else { currentCulling = CullFace.BACK;
currentCulling = CullFace.NONE; } else {
} currentCulling = CullFace.NONE;
currentTriGeom.setCullFace(currentCulling); }
} currentTriGeom.setCullFace(currentCulling);
} }
}
public void clearCurrentRender() {
// don't render anything public void clearCurrentRender() {
Platform.runLater(() -> { // don't render anything
mainWindow.getMeshGroup().getChildren().clear(); Platform.runLater(() -> {
clearGeometryTrees(); mainWindow.getMeshGroup().getChildren().clear();
}); clearGeometryTrees();
} });
}
public void highlight(Polygon p) {
highlightController.highlight(p, currentTriGeom); public void highlight(Polygon p) {
} highlightController.highlight(p, currentTriGeom);
}
public void highlight(LinearRing lr) {
highlightController.highlight(lr, currentTriGeom); public void highlight(LinearRing lr) {
} highlightController.highlight(lr, currentTriGeom);
}
public void highlight(Edge e) {
highlightController.highlight(e, currentTriGeom); public void highlight(Edge e) {
} highlightController.highlight(e, currentTriGeom);
}
public void highlight(Vertex v) {
highlightController.highlight(v, currentTriGeom); public void highlight(Vertex v) {
} highlightController.highlight(v, currentTriGeom);
}
public void highlight(List<LinearRing> highlightedRings) {
highlightController.highlight(highlightedRings, currentTriGeom); public void highlight(List<LinearRing> highlightedRings) {
} highlightController.highlight(highlightedRings, currentTriGeom);
}
public void highlightEdges(List<Edge> edges) {
highlightController.highlightEdges(edges, currentTriGeom); public void highlightEdges(List<Edge> edges) {
} highlightController.highlightEdges(edges, currentTriGeom);
}
public void highlightPolygons(List<List<Polygon>> components) {
highlightController.highlightPolygons(components, currentTriGeom); public void highlightPolygons(List<List<Polygon>> components) {
} highlightController.highlightPolygons(components, currentTriGeom);
}
public void addHighlight(Vertex vertex, Color c) {
highlightController.addHighlight(vertex, currentTriGeom, c); public void addHighlight(Vertex vertex, Color c) {
} highlightController.addHighlight(vertex, currentTriGeom, c);
}
public void highlight(CheckError err) {
err.accept(errVisitor); public void highlight(CheckError err) {
} err.accept(errVisitor);
}
public void refresh() {
if (refresher != null) { public void refresh() {
refresher.run(); if (refresher != null) {
} refresher.run();
} }
}
public void updateErrors() {
if (errorUpdater != null) { public void updateErrors() {
errorUpdater.run(); if (errorUpdater != null) {
} errorUpdater.run();
} }
}
public void clearHighlights() {
highlightController.clearHighlights(); public void clearHighlights() {
} highlightController.clearHighlights();
}
public void addHighlight(Polygon p) {
highlightController.addHighlight(p, currentTriGeom); public void addHighlight(Polygon p) {
} highlightController.addHighlight(p, currentTriGeom);
}
public void addHighlight(Triangle3d t) {
highlightController.highlight(t, currentTriGeom); public void addHighlight(Triangle3d t) {
} highlightController.highlight(t, currentTriGeom);
}
public void reset() {
errorUpdater = null; public void reset() {
refresher = null; errorUpdater = null;
} refresher = null;
}
} }
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