Merge branch 'refs/heads/dev' into dev_embedded_geodb

# Conflicts:
#	CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericAttribute.java

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

+package de.hft.stuttgart.citydoctor2.check.error;
+
+import java.io.Serial;
+
+import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
+import de.hft.stuttgart.citydoctor2.check.HealingMethod;
+import de.hft.stuttgart.citydoctor2.check.ModificationListener;
+import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
+
+public abstract class PlanarityError extends PolygonError {
+
+	@Serial
+	private static final long serialVersionUID = 4229597996236974570L;
+
+	public PlanarityError(Polygon poly) {
+		super(poly);
+	}
+	
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
+	}
+	
+	@Override
+	public boolean accept(HealingMethod method, ModificationListener l) {
+		return super.accept(method, l) || method.visit(this, l);
+	}
+
+}

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -30,8 +31,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
 
-import java.io.Serial;
-
 /**
  * If a point of a linear ring touches an edge of the same ring it is considered
  * self intersecting and this error object is created.
@@ -39,25 +38,20 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class PointTouchesEdgeError implements CheckError {
+public class PointTouchesEdgeError extends RingSelfIntersectionError {
 
 	@Serial
 	private static final long serialVersionUID = 3277456707271748954L;
 	
-	private final LinearRing lr;
 	private final Edge e;
 	private final Vertex v;
 
 	public PointTouchesEdgeError(LinearRing lr, Edge e, Vertex v) {
-		this.lr = lr;
+		super(lr);
 		this.e = e;
 		this.v = v;
 	}
 
-	public LinearRing getRing() {
-		return lr;
-	}
-
 	public Edge getEdge() {
 		return e;
 	}
@@ -69,24 +63,25 @@ public class PointTouchesEdgeError implements CheckError {
 	@Override
 	public void report(ErrorReport report) {
 		report.add("type", "point touches edge");
-		report.add(lr);
+		super.report(report);
 		report.add(v);
 		report.add(e);
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "PointTouchesEdgeError [lr=" + lr + ", e=" + e + ", v=" + v + "]";
+		return "PointTouchesEdgeError [lr=" + getRing() + ", e=" + e + ", v=" + v + "]";
 	}
 
 	@Override

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

+package de.hft.stuttgart.citydoctor2.check.error;
+
+import java.io.Serial;
+import java.util.Objects;
+
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.ErrorReport;
+import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
+import de.hft.stuttgart.citydoctor2.check.HealingMethod;
+import de.hft.stuttgart.citydoctor2.check.ModificationListener;
+import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
+
+public abstract class PolygonError implements CheckError {
+	
+	@Serial
+	private static final long serialVersionUID = 7277982425092189736L;
+	
+	private final Polygon poly;
+	
+	public PolygonError(Polygon poly) {
+		Objects.requireNonNull(poly);
+		this.poly = poly;
+	}
+	
+	public Polygon getPolygon() {
+		return poly;
+	}
+	
+	@Override
+	public void report(ErrorReport report) {
+		report.add(poly);
+	}
+	
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		errorVisitor.visit(this);
+	}
+	
+	@Override
+	public boolean accept(HealingMethod method, ModificationListener l) {
+		return method.visit(this, l);
+	}
+
+}

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

@@ -21,7 +21,6 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import java.io.Serial;
 import java.util.List;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -39,40 +38,36 @@ import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
  * @author Matthias Betz
  *
  */
-public class PolygonHoleOutsideError implements CheckError {
+public class PolygonHoleOutsideError extends PolygonError {
 
 	@Serial
 	private static final long serialVersionUID = -4522153084655775231L;
 	
 	private final List<LinearRing> holesOutside;
-	private final Polygon p;
 
 	public PolygonHoleOutsideError(Polygon p, List<LinearRing> holesOutside) {
-		this.p = p;
+		super(p);
 		this.holesOutside = holesOutside;
 	}
 
-	public Polygon getPolygon() {
-		return p;
-	}
-
 	public List<LinearRing> getHolesOutside() {
 		return holesOutside;
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(p);
+		super.report(report);
 		for (LinearRing lr : holesOutside) {
 			report.add(lr);
 		}
@@ -80,7 +75,7 @@ public class PolygonHoleOutsideError implements CheckError {
 
 	@Override
 	public String toString() {
-		return "HoleOutsideError [holesOutside=" + holesOutside + ", p=" + p + "]";
+		return "HoleOutsideError [holesOutside=" + holesOutside + ", p=" + getPolygon() + "]";
 	}
 
 	@Override

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

@@ -21,7 +21,6 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import java.io.Serial;
 import java.util.List;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -39,30 +38,25 @@ import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
  * @author Matthias Betz
  *
  */
-public class PolygonInteriorDisconnectedError implements CheckError {
+public class PolygonInteriorDisconnectedError extends PolygonError {
 
 	@Serial
 	private static final long serialVersionUID = 511849016699842395L;
 	
-	private final Polygon p;
 	private final List<LinearRing> connectedRings;
 
 	public PolygonInteriorDisconnectedError(Polygon p, List<LinearRing> connectedRings) {
-		this.p = p;
+		super(p);
 		this.connectedRings = connectedRings;
 	}
 
-	public Polygon getPolygon() {
-		return p;
-	}
-
 	public List<LinearRing> getConnectedRings() {
 		return connectedRings;
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(p);
+		super.report(report);
 		report.add("connected rings", "");
 		for (LinearRing lr : connectedRings) {
 			report.add(lr);
@@ -71,17 +65,18 @@ public class PolygonInteriorDisconnectedError implements CheckError {
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "InteriorDisconnectedError [p=" + p + ", connectedRings=" + connectedRings + "]";
+		return "InteriorDisconnectedError [polygon=" + getPolygon() + ", connectedRings=" + connectedRings + "]";
 	}
 
 	@Override

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -30,8 +31,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
 
-import java.io.Serial;
-
 /**
  * If the exterior ring and interior rings are intersecting each other, it
  * results in a polygon self intersection and this error is created.
@@ -39,47 +38,43 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class PolygonIntersectingRingsError implements CheckError {
+public class PolygonIntersectingRingsError extends PolygonError {
 
 	@Serial
 	private static final long serialVersionUID = -7043521697085991901L;
 	
-	private final Polygon p;
 	private final SerializablePair<LinearRing, LinearRing> intersectingRings;
 
 	public PolygonIntersectingRingsError(Polygon p, SerializablePair<LinearRing, LinearRing> intersectingRings) {
-		this.p = p;
+		super(p);
 		this.intersectingRings = intersectingRings;
 	}
 
-	public Polygon getPolygon() {
-		return p;
-	}
-
 	public SerializablePair<LinearRing, LinearRing> getIntersectingRings() {
 		return intersectingRings;
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(p);
+		super.report(report);
 		report.add(intersectingRings.getValue0());
 		report.add(intersectingRings.getValue1());
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "PolygonSelfIntError [p=" + p + ", intersectingRings=" + intersectingRings + "]";
+		return "PolygonSelfIntError [polygon=" + getPolygon() + ", intersectingRings=" + intersectingRings + "]";
 	}
 
 	@Override

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -29,8 +30,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 
-import java.io.Serial;
-
 /**
  * If the interior rings have the same orientation as the exterior ring, this
  * error is created.
@@ -38,46 +37,42 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class PolygonSameOrientationError implements CheckError {
+public class PolygonSameOrientationError extends PolygonError {
 
 	@Serial
 	private static final long serialVersionUID = -6192337889977667459L;
 	
-	private final Polygon p;
 	private final LinearRing innerRing;
 
 	public PolygonSameOrientationError(Polygon p, LinearRing inner) {
-		this.p = p;
+		super(p);
 		this.innerRing = inner;
 	}
 
-	public Polygon getPolygon() {
-		return p;
-	}
-
 	public LinearRing getInnerRing() {
 		return innerRing;
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(p);
+		super.report(report);
 		report.add(innerRing);
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "SameOrientationError [p=" + p + ", innerRing=" + innerRing + "]";
+		return "SameOrientationError [polygon=" + getPolygon() + ", innerRing=" + innerRing + "]";
 	}
 
 	@Override

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

@@ -23,7 +23,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -43,30 +42,25 @@ import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
  * @author Matthias Betz
  *
  */
-public class PolygonWrongOrientationError implements CheckError {
+public class PolygonWrongOrientationError extends SolidError {
 
 	@Serial
 	private static final long serialVersionUID = -3006643655816847097L;
 	
 	private final List<Edge> edges;
-	private final Geometry g;
 
 	public PolygonWrongOrientationError(Geometry g, List<Edge> edges) {
+		super(g);
 		this.edges = edges;
-		this.g = g;
 	}
 
 	public List<Edge> getEdges() {
 		return edges;
 	}
 
-	public Geometry getGeometry() {
-		return g;
-	}
-
 	@Override
 	public void report(ErrorReport report) {
-		report.add(g);
+		super.report(report);
 		Set<Polygon> possiblePolygons = new HashSet<>();
 		for (Edge e : edges) {
 			possiblePolygons.addAll(e.getAdjacentPolygons());
@@ -76,17 +70,18 @@ public class PolygonWrongOrientationError implements CheckError {
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "PolygonWrongOrientationError [edges=" + edges + ", g=" + g + "]";
+		return "PolygonWrongOrientationError [edges=" + edges + ", g=" + getGeometry() + "]";
 	}
 
 	@Override

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -29,8 +30,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
 
-import java.io.Serial;
-
 /**
  * When a point is repeated in a linear ring, but is not consecutive. This
  * results in a self intersection of the ring and this error object is created.
@@ -38,30 +37,20 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class RingDuplicatePointError implements CheckError {
+public class RingDuplicatePointError extends RingSelfIntersectionError {
 
 	@Serial
 	private static final long serialVersionUID = 7208982075173209953L;
 	
-	private final LinearRing r;
 	private final Vertex v1;
 	private final Vertex v2;
 
 	public RingDuplicatePointError(LinearRing r, Vertex v1, Vertex v2) {
-		this.r = r;
+		super(r);
 		this.v1 = v1;
 		this.v2 = v2;
 	}
 
-	@Override
-	public void accept(ErrorVisitor errorVisitor) {
-		errorVisitor.visit(this);
-	}
-
-	public LinearRing getRing() {
-		return r;
-	}
-
 	public Vertex getVertex1() {
 		return v1;
 	}
@@ -70,21 +59,27 @@ public class RingDuplicatePointError implements CheckError {
 		return v2;
 	}
 
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
+		errorVisitor.visit(this);
+	}
+
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(r);
+		super.report(report);
 		report.add("duplicate point 1", v1);
 		report.add("duplicate point 2", v2);
 	}
 
 	@Override
 	public String toString() {
-		return "DuplicatePointError [r=" + r + ", v1=" + v1 + ", v2=" + v2 + "]";
+		return "DuplicatePointError [r=" + getRing() + ", v1=" + v1 + ", v2=" + v2 + "]";
 	}
 
 	@Override

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -30,8 +31,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 
-import java.io.Serial;
-
 /**
  * When two edges of the same linear ring are intersecting with each other this
  * error object is created.
@@ -39,7 +38,7 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class RingEdgeIntersectionError implements CheckError {
+public class RingEdgeIntersectionError extends RingSelfIntersectionError {
 
 	@Serial
 	private static final long serialVersionUID = 4923311259469198172L;
@@ -47,20 +46,15 @@ public class RingEdgeIntersectionError implements CheckError {
 	private final Edge e1;
 	private final Edge e2;
 	private final Vector3d intersection;
-	private final LinearRing lr;
 
 	public RingEdgeIntersectionError(LinearRing lr, Edge e1, Edge e2, Vector3d intersection) {
-		if (e1 == null || e2 == null || lr == null || intersection == null) {
+		super(lr);
+		if (e1 == null || e2 == null || intersection == null) {
 			throw new IllegalArgumentException("Parameters may not be null");
 		}
 		this.e1 = e1;
 		this.e2 = e2;
 		this.intersection = intersection;
-		this.lr = lr;
-	}
-
-	public LinearRing getRing() {
-		return lr;
 	}
 
 	public Edge getEdge1() {
@@ -78,7 +72,7 @@ public class RingEdgeIntersectionError implements CheckError {
 	@Override
 	public void report(ErrorReport report) {
 		report.add("type", "edge intersection");
-		report.add(lr);
+		super.report(report);
 		report.add(e1);
 		report.add(e2);
 		report.add("intersection point", intersection);
@@ -86,17 +80,18 @@ public class RingEdgeIntersectionError implements CheckError {
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "EdgeIntersectionError [e1=" + e1 + ", e2=" + e2 + ", intersection=" + intersection + ", lr=" + lr + "]";
+		return "EdgeIntersectionError [e1=" + e1 + ", e2=" + e2 + ", intersection=" + intersection + ", lr=" + getRing() + "]";
 	}
 
 	@Override

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

+package de.hft.stuttgart.citydoctor2.check.error;
+
+import java.io.Serial;
+import java.util.Objects;
+
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.ErrorReport;
+import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
+import de.hft.stuttgart.citydoctor2.check.HealingMethod;
+import de.hft.stuttgart.citydoctor2.check.ModificationListener;
+import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
+
+public abstract class RingError implements CheckError {
+	
+	@Serial
+	private static final long serialVersionUID = -1579410065481104979L;
+	
+	private final LinearRing ring;
+	
+	public RingError(LinearRing ring) {
+		Objects.requireNonNull(ring);
+		this.ring = ring;
+	}
+	
+	public LinearRing getRing() {
+		return ring;
+	}
+	
+	@Override
+	public void report(ErrorReport report) {
+		report.add(ring);
+	}
+	
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		errorVisitor.visit(this);
+	}
+	
+	@Override
+	public boolean accept(HealingMethod method, ModificationListener l) {
+		return method.visit(this, l);
+	}
+
+}

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -28,8 +29,6 @@ import de.hft.stuttgart.citydoctor2.check.ModificationListener;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 
-import java.io.Serial;
-
 /**
  * If the first and last point of a linear ring are not the same, this error is
  * created.
@@ -37,39 +36,34 @@ import java.io.Serial;
  * @author Matthias Betz
  *
  */
-public class RingNotClosedError implements CheckError {
-
-	@Serial
-	private static final long serialVersionUID = 2554099996830579201L;
-	
-	private final LinearRing ring;
+public class RingNotClosedError extends RingError {
 
 	public RingNotClosedError(LinearRing ring) {
-		this.ring = ring;
+		super(ring);
 	}
 
-	public LinearRing getRing() {
-		return ring;
-	}
+	@Serial
+	private static final long serialVersionUID = 2554099996830579201L;
 	
 	@Override
 	public void report(ErrorReport report) {
-		report.add(ring);
+		super.report(report);
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "RingNotClosedError [ring=" + ring + "]";
+		return "RingNotClosedError [ring=" + getRing() + "]";
 	}
 
 	@Override

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

+package de.hft.stuttgart.citydoctor2.check.error;
+
+import java.io.Serial;
+
+import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
+import de.hft.stuttgart.citydoctor2.check.HealingMethod;
+import de.hft.stuttgart.citydoctor2.check.ModificationListener;
+import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
+
+public abstract class RingSelfIntersectionError extends RingError {
+
+	@Serial
+	private static final long serialVersionUID = -4528714710581552235L;
+
+	public RingSelfIntersectionError(LinearRing ring) {
+		super(ring);
+	}
+	
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
+		errorVisitor.visit(this);
+	}
+
+	@Override
+	public boolean accept(HealingMethod method, ModificationListener l) {
+		return super.accept(method, l) || method.visit(this, l);
+	}
+
+}

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -28,47 +29,40 @@ import de.hft.stuttgart.citydoctor2.check.ModificationListener;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 
-import java.io.Serial;
-
 /**
  * If a linear ring has less than 4 distinct points, it is has too few points.
  * 
  * @author Matthias Betz
  *
  */
-public class RingTooFewPointsError implements CheckError {
+public class RingTooFewPointsError extends RingError {
 
 	@Serial
 	private static final long serialVersionUID = 7207518573842743261L;
 	
-	private final LinearRing lr;
-
 	public RingTooFewPointsError(LinearRing lr) {
-		this.lr = lr;
-	}
-
-	public LinearRing getRing() {
-		return lr;
+		super(lr);
 	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(lr);
+		super.report(report);
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "TooFewPointsError [lr=" + lr + "]";
+		return "TooFewPointsError [ring=" + getRing() + "]";
 	}
 
 	@Override

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

+package de.hft.stuttgart.citydoctor2.check.error;
+
+import java.io.Serial;
+
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.ErrorReport;
+import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
+import de.hft.stuttgart.citydoctor2.check.HealingMethod;
+import de.hft.stuttgart.citydoctor2.check.ModificationListener;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+
+public abstract class SolidError implements CheckError {
+	
+	@Serial
+	private static final long serialVersionUID = 4251342593056430783L;
+	
+	private Geometry geom;
+	
+	public SolidError(Geometry geom) {
+		this.geom = geom;
+	}
+	
+	public Geometry getGeometry() {
+		return geom;
+	}
+	
+	@Override
+	public void report(ErrorReport report) {
+		report.add(geom);
+	}
+	
+	@Override
+	public void accept(ErrorVisitor errorVisitor) {
+		errorVisitor.visit(this);
+	}
+	
+	@Override
+	public boolean accept(HealingMethod method, ModificationListener l) {
+		return method.visit(this, l);
+	}
+
+}

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

@@ -21,7 +21,6 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import java.io.Serial;
 import java.util.List;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -39,21 +38,16 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
  * @author Matthias Betz
  *
  */
-public class SolidNotClosedError implements CheckError {
+public class SolidNotClosedError extends SolidError {
 
 	@Serial
 	private static final long serialVersionUID = 8256385219885788891L;
 	
 	private final List<Edge> errorEdges;
-	private final Geometry g;
 
 	public SolidNotClosedError(Geometry g, List<Edge> errorEdges) {
+		super(g);
 		this.errorEdges = errorEdges;
-		this.g = g;
-	}
-
-	public Geometry getGeometry() {
-		return g;
 	}
 
 	public List<Edge> getErrorEdges() {
@@ -62,23 +56,24 @@ public class SolidNotClosedError implements CheckError {
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(g);
+		super.report(report);
 		report.addEdges("open edges", errorEdges);
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "SolidNotClosedError [errorEdges=" + errorEdges + ", g=" + g + "]";
+		return "SolidNotClosedError [errorEdges=" + errorEdges + ", g=" + getGeometry() + "]";
 	}
 
 	@Override

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

@@ -21,9 +21,7 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import java.io.Serial;
 import java.util.List;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
-import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
 import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
 import de.hft.stuttgart.citydoctor2.check.HealingMethod;
@@ -38,46 +36,37 @@ import de.hft.stuttgart.citydoctor2.utils.PolygonIntersection;
  * @author Matthias Betz
  *
  */
-public class SolidSelfIntError implements CheckError {
+public class SolidSelfIntError extends SolidError {
 
 	@Serial
 	private static final long serialVersionUID = -4479936555545861422L;
 	
-	private final Geometry g;
 	
 	private final List<PolygonIntersection> intersections;
 
 	public SolidSelfIntError(Geometry g, List<PolygonIntersection> intersections) {
-		this.g = g;
+		super(g);
 		this.intersections = intersections;
 	}
 
-	public Geometry getGeometry() {
-		return g;
-	}
-
-	@Override
-	public void report(ErrorReport report) {
-		report.add(g);
-	}
-
 	public List<PolygonIntersection> getIntersections() {
 		return intersections;
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "SolidSelfIntError [g=" + g + ", intersection=" + intersections + "]";
+		return "SolidSelfIntError [g=" + getGeometry() + ", intersection=" + intersections + "]";
 	}
 
 	@Override

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

@@ -18,7 +18,8 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import de.hft.stuttgart.citydoctor2.check.CheckError;
+import java.io.Serial;
+
 import de.hft.stuttgart.citydoctor2.check.ErrorId;
 import de.hft.stuttgart.citydoctor2.check.ErrorReport;
 import de.hft.stuttgart.citydoctor2.check.ErrorType;
@@ -28,48 +29,42 @@ import de.hft.stuttgart.citydoctor2.check.ModificationListener;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlElement;
 
-import java.io.Serial;
-
 /**
  * When a geometry has less than 4 polygons, it cannot form a valid solid.
  * 
  * @author Matthias Betz
  *
  */
-public class TooFewPolygonsError implements CheckError {
+public class TooFewPolygonsError extends SolidError {
 
 	@Serial
 	private static final long serialVersionUID = 5800732409355221678L;
 	
-	private final Geometry g;
-
 	public TooFewPolygonsError(Geometry g) {
-		this.g = g;
+		super(g);
 	}
 
-	public Geometry getGeometry() {
-		return g;
-	}
 
 	@Override
 	public void report(ErrorReport report) {
-		report.add(g);
-		report.add("number of polygons", g.getPolygons().size());
+		super.report(report);
+		report.add("number of polygons", getGeometry().getPolygons().size());
 	}
 
 	@Override
 	public void accept(ErrorVisitor errorVisitor) {
+		super.accept(errorVisitor);
 		errorVisitor.visit(this);
 	}
 
 	@Override
 	public boolean accept(HealingMethod method, ModificationListener l) {
-		return method.visit(this, l);
+		return super.accept(method, l) || method.visit(this, l);
 	}
 
 	@Override
 	public String toString() {
-		return "TooFewPolygonsError [g=" + g + "]";
+		return "TooFewPolygonsError [g=" + getGeometry() + "]";
 	}
 
 	@Override

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

@@ -53,6 +53,7 @@ public abstract class AbstractBuilding extends CityObject {
     private final List<Storey> buildingStoreys = new ArrayList<>();
     private final List<BuildingUnit> buildingUnits = new ArrayList<>();
     private final List<BuildingRoomFurniture> buildingRoomFurnitureList = new ArrayList<>();
+    private final List<BuildingConstructiveElement> buildingConstructiveElements = new ArrayList<>();
     private org.citygml4j.core.model.building.AbstractBuilding ab;
 
     /**
@@ -74,6 +75,10 @@ public abstract class AbstractBuilding extends CityObject {
         return FeatureType.BUILDING;
     }
 
+    public List<BuildingConstructiveElement> getConstructiveElements() {
+        return buildingConstructiveElements;
+    }
+
     @Override
     public void unsetGmlGeometries() {
         ab.setLod1Solid(null);
@@ -171,6 +176,9 @@ public abstract class AbstractBuilding extends CityObject {
         for (BoundarySurface bs : boundarySurfaceList) {
             bs.accept(c);
         }
+        for (BuildingConstructiveElement bce : buildingConstructiveElements) {
+            bce.accept(c);
+        }
         for (BuildingRoom br : buildingRooms) {
             br.accept(c);
         }
@@ -219,6 +227,11 @@ public abstract class AbstractBuilding extends CityObject {
         buildingUnit.setParent(this);
     }
 
+    public void addConstructiveElement(BuildingConstructiveElement constructiveElement) {
+        buildingConstructiveElements.add(constructiveElement);
+        constructiveElement.setParent(this);
+    }
+
     public void setGmlObject(org.citygml4j.core.model.building.AbstractBuilding ab) {
         this.ab = ab;
     }

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import javafx.scene.paint.Color;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
+import org.citygml4j.core.model.deprecated.bridge.DeprecatedPropertiesOfBridgeConstructiveElement;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.GeometryProperty;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
+import org.xmlobjects.gml.model.geometry.primitives.Solid;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BuildingConstructiveElement extends CityObject {
+
+    private static final Logger logger = LogManager.getLogger(BuildingConstructiveElement.class);
+
+    private static final String CANNOT_ADD = "Cannot add ";
+
+    @Serial
+    private static final long serialVersionUID = 7353233899458901155L;
+
+    private final org.citygml4j.core.model.building.BuildingConstructiveElement gmlBuildingElement;
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+    private AbstractBuilding parent;
+
+    public BuildingConstructiveElement(org.citygml4j.core.model.building.BuildingConstructiveElement gmlObject) {
+        this.gmlBuildingElement = gmlObject;
+    }
+
+    public void setParent(AbstractBuilding parent) {
+        this.parent = parent;
+    }
+
+    public AbstractBuilding getParent() {
+        return parent;
+    }
+
+    @Override
+    public Color getRenderColor() {
+        return parent.getRenderColor().brighter();
+    }
+
+    @Override
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
+        // only handles CityGML2 for now
+        // unknown which CityGML is handled here
+        // need context information to decide
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            switch (geom.getType()) {
+                case SOLID:
+                    Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                    setSolidAccordingToLod(geom, solid);
+                    break;
+                case MULTI_SURFACE:
+                    MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                    setMultiSurfaceAccordingToLod(geom, ms);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void accept(CheckableVisitor c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : gmlBuildingElement.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from BridgeConstructiveElement", bs.getGmlId());
+                    gmlBuildingElement.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                gmlBuildingElement.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                gmlBuildingElement.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                gmlBuildingElement.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                gmlBuildingElement.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                gmlBuildingElement.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                gmlBuildingElement.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException(CANNOT_ADD + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    @Override
+    public org.citygml4j.core.model.building.BuildingConstructiveElement getGmlObject() {
+        return gmlBuildingElement;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        gmlBuildingElement.setLod0MultiSurface(null);
+        gmlBuildingElement.setLod2MultiSurface(null);
+        gmlBuildingElement.setLod3MultiSurface(null);
+        gmlBuildingElement.setLod1Solid(null);
+        gmlBuildingElement.setLod2Solid(null);
+        gmlBuildingElement.setLod3Solid(null);
+    }
+
+    @Override
+    public CityObject getTopLevelCityObject() {
+        return getParent().getTopLevelCityObject();
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.BRIDGE_CONSTRUCTION_ELEMENT;
+    }
+
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
+
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+}