diff --git a/CHANGELOG.md b/CHANGELOG.md index 396f849e4ddde0cdf80dd16c5bd580bae16de652..9b6855d9528832010d53d42bf687330b88225dff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [3.17.3] (2025-07-09) + +- Fixed global errors not being cleared upon validation rerun +- Fixed ConstructiveElements of Buildings not being parsed +- Fixed PolygonPatches being added twice to Geometry +- Fixed missing uom and value for valid QualityADE output +- Reduced FOP-logging verbosity +- Added a facing property to Geometry, denoting whether it is facing inwards or outwards + ## [3.17.2] (2025-06-05) - Rework of AbstractCheck, allowing the implementation of Visitors that use the CheckEngine to traverse the internal diff --git a/CityDoctorParent/CityDoctorCheckResult/pom.xml b/CityDoctorParent/CityDoctorCheckResult/pom.xml index ff3c3418204e3050726e17900c6f634da0ea23c0..6a9d0d2c0f84cd723536a134dc5c72735ecb58bb 100644 --- a/CityDoctorParent/CityDoctorCheckResult/pom.xml +++ b/CityDoctorParent/CityDoctorCheckResult/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 CityDoctorCheckResult diff --git a/CityDoctorParent/CityDoctorEdge/pom.xml b/CityDoctorParent/CityDoctorEdge/pom.xml index 21d72c9b50692f4e40337bb7eec8bb9b547d179a..e7a5d0ab4acb426bea35b571123d2ffa3b66fb53 100644 --- a/CityDoctorParent/CityDoctorEdge/pom.xml +++ b/CityDoctorParent/CityDoctorEdge/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 CityDoctorEdge diff --git a/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/IntersectionErrorsTest.java b/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/IntersectionErrorsTest.java index 72d007be363db22f1bec1159bd6670768b59f6b2..7d0ed99ee60840279f96a4953ae8acc48348ac53 100644 --- a/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/IntersectionErrorsTest.java +++ b/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/IntersectionErrorsTest.java @@ -32,12 +32,13 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; public class IntersectionErrorsTest { @Test public void testWrongIntersection() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); ConcretePolygon p1 = new ConcretePolygon(); diff --git a/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/MeshSurfaceUtilsTest.java b/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/MeshSurfaceUtilsTest.java index 9cee97c34730d80ce4258c6187cb8180dde52b3a..89fa9deffd0fe7a9999b6d9db6577ca5a541e9f0 100644 --- a/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/MeshSurfaceUtilsTest.java +++ b/CityDoctorParent/CityDoctorEdge/src/test/java/de/hft/stuttgart/citydoctor2/edge/MeshSurfaceUtilsTest.java @@ -43,12 +43,13 @@ import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoTrianglesOneSharedEdgeInPlane() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -161,7 +162,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTwoSharedEdges() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -212,7 +213,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsOneSharedEdgeIntersectionPolygonPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -276,7 +277,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsOneSharedEdgeIntersectionPolygonPlanar2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -339,7 +340,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsOneSharedEdgeCloseEdgePlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -393,7 +394,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsOneSharedEdgeNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -447,7 +448,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsOneSharedPointNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -508,7 +509,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTouchingInOnePointNoIntersectionNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -561,7 +562,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTouchingInOnePointNoIntersectionNotPlanar2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -616,7 +617,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsNotInSamePlaneBelow() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -670,7 +671,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsNotInSamePlaneAbove() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -724,7 +725,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsNotInSamePlaneAboveInverted() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -778,7 +779,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTouchingNoPointsSameNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -834,7 +835,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTouchingEdgeNoPointsSameNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -890,7 +891,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTouchingEdgeInPointNoPointsSameNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -946,7 +947,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsTwoTouchingEdgesNotPlanar() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -1002,7 +1003,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsPlanarInnerRingsContained() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -1067,7 +1068,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsPlanarInnerRingsContainedConnected() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -1128,7 +1129,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsInnerRingsConnected() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); @@ -1191,7 +1192,7 @@ public class MeshSurfaceUtilsTest { @Test public void testIntersectionTwoPolygonsInnerRingsThroughHole() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p1 = new ConcretePolygon(); geom.addPolygon(p1); diff --git a/CityDoctorParent/CityDoctorModel/pom.xml b/CityDoctorParent/CityDoctorModel/pom.xml index a5a024e3dbb5032651b9a734c8c549aa240a321c..b02bd6e5fed526a042211232aff7241085d21be9 100644 --- a/CityDoctorParent/CityDoctorModel/pom.xml +++ b/CityDoctorParent/CityDoctorModel/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ${project.version}-${git.commit.id.abbrev} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractCheck.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractCheck.java deleted file mode 100644 index 7910cdb0fd92052a1b9f80b26e262926b6326d70..0000000000000000000000000000000000000000 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractCheck.java +++ /dev/null @@ -1,60 +0,0 @@ -/*- - * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart - * - * This file is part of CityDoctor2. - * - * CityDoctor2 is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * CityDoctor2 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with CityDoctor2. If not, see . - */ -package de.hft.stuttgart.citydoctor2.check; - -import java.util.Collections; -import java.util.Set; - -/** - * - * This class serves as a Parent for non-validating checks that want to use the CheckEngine's Visitor-pattern for the - * implementation of utility functions like e.g. collecting the sub-CityObjects in a Feature. - * - * - * @author Matthias Betz - * - */ -public abstract class AbstractCheck extends Check { - - @Override - public Set appliesToRequirements() { - return Collections.emptySet(); - } - - @Override - public CheckId getCheckId() { - return null; - } - - @Override - public RequirementType getType() { - return null; - } - - @Override - public Check createNewInstance() { - return null; - } - - @Override - public final boolean isValidator() { - return false; - } - -} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractErrorVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractErrorVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..6ddc35c44cbaae3be5840d511639828f64900ab2 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/AbstractErrorVisitor.java @@ -0,0 +1,210 @@ +package de.hft.stuttgart.citydoctor2.check; + +import de.hft.stuttgart.citydoctor2.check.error.AllPolygonsWrongOrientationError; +import de.hft.stuttgart.citydoctor2.check.error.AttributeInvalidError; +import de.hft.stuttgart.citydoctor2.check.error.AttributeMissingError; +import de.hft.stuttgart.citydoctor2.check.error.AttributeValueWrongError; +import de.hft.stuttgart.citydoctor2.check.error.ConsecutivePointSameError; +import de.hft.stuttgart.citydoctor2.check.error.DegeneratedRingError; +import de.hft.stuttgart.citydoctor2.check.error.DependenciesNotMetError; +import de.hft.stuttgart.citydoctor2.check.error.MultipleConnectedComponentsError; +import de.hft.stuttgart.citydoctor2.check.error.NestedRingError; +import de.hft.stuttgart.citydoctor2.check.error.NonManifoldEdgeError; +import de.hft.stuttgart.citydoctor2.check.error.NonManifoldVertexError; +import de.hft.stuttgart.citydoctor2.check.error.NonPlanarPolygonDistancePlaneError; +import de.hft.stuttgart.citydoctor2.check.error.NonPlanarPolygonNormalsDeviation; +import de.hft.stuttgart.citydoctor2.check.error.NotCeilingError; +import de.hft.stuttgart.citydoctor2.check.error.NotFloorError; +import de.hft.stuttgart.citydoctor2.check.error.NotGroundError; +import de.hft.stuttgart.citydoctor2.check.error.NotWallError; +import de.hft.stuttgart.citydoctor2.check.error.NullAreaError; +import de.hft.stuttgart.citydoctor2.check.error.PlanarityError; +import de.hft.stuttgart.citydoctor2.check.error.PointTouchesEdgeError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonHoleOutsideError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonInteriorDisconnectedError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonIntersectingRingsError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonSameOrientationError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonWithoutSurfaceError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonWrongOrientationError; +import de.hft.stuttgart.citydoctor2.check.error.RingDuplicatePointError; +import de.hft.stuttgart.citydoctor2.check.error.RingEdgeIntersectionError; +import de.hft.stuttgart.citydoctor2.check.error.RingError; +import de.hft.stuttgart.citydoctor2.check.error.RingNotClosedError; +import de.hft.stuttgart.citydoctor2.check.error.RingSelfIntersectionError; +import de.hft.stuttgart.citydoctor2.check.error.RingTooFewPointsError; +import de.hft.stuttgart.citydoctor2.check.error.SchematronError; +import de.hft.stuttgart.citydoctor2.check.error.SolidError; +import de.hft.stuttgart.citydoctor2.check.error.SolidNotClosedError; +import de.hft.stuttgart.citydoctor2.check.error.SolidSelfIntError; +import de.hft.stuttgart.citydoctor2.check.error.SurfaceUnfragmentedError; +import de.hft.stuttgart.citydoctor2.check.error.TooFewPolygonsError; +import de.hft.stuttgart.citydoctor2.check.error.UnknownCheckError; + +public abstract class AbstractErrorVisitor implements ErrorVisitor { + + @Override + public void visit(RingError err) { + } + + @Override + public void visit(PolygonError err) { + } + + @Override + public void visit(RingSelfIntersectionError err) { + } + + @Override + public void visit(PlanarityError err) { + } + + @Override + public void visit(PolygonHoleOutsideError err) { + } + + @Override + public void visit(NonManifoldEdgeError err) { + } + + @Override + public void visit(MultipleConnectedComponentsError err) { + } + + @Override + public void visit(NestedRingError err) { + } + + @Override + public void visit(NonManifoldVertexError err) { + } + + @Override + public void visit(PolygonWrongOrientationError err) { + } + + @Override + public void visit(PolygonSameOrientationError err) { + } + + @Override + public void visit(SolidNotClosedError err) { + } + + @Override + public void visit(DependenciesNotMetError err) { + } + + @Override + public void visit(UnknownCheckError err) { + } + + @Override + public void visit(RingNotClosedError err) { + } + + @Override + public void visit(ConsecutivePointSameError err) { + } + + @Override + public void visit(AllPolygonsWrongOrientationError err) { + } + + @Override + public void visit(PolygonInteriorDisconnectedError err) { + } + + @Override + public void visit(NullAreaError err) { + } + + @Override + public void visit(RingTooFewPointsError err) { + } + + @Override + public void visit(NonPlanarPolygonNormalsDeviation err) { + } + + @Override + public void visit(NonPlanarPolygonDistancePlaneError err) { + } + + @Override + public void visit(PolygonIntersectingRingsError err) { + } + + @Override + public void visit(SolidSelfIntError err) { + } + + @Override + public void visit(TooFewPolygonsError err) { + } + + @Override + public void visit(RingDuplicatePointError err) { + } + + @Override + public void visit(RingEdgeIntersectionError err) { + } + + @Override + public void visit(PointTouchesEdgeError err) { + } + + @Override + public void visit(NotCeilingError err) { + } + + @Override + public void visit(NotFloorError err) { + } + + @Override + public void visit(NotWallError err) { + } + + @Override + public void visit(NotGroundError err) { + } + + @Override + public void visit(CheckError err) { + } + + @Override + public void visit(SchematronError err) { + } + + @Override + public void visit(SurfaceUnfragmentedError err) { + } + + @Override + public void visit(DegeneratedRingError err) { + } + + @Override + public void visit(AttributeMissingError err) { + } + + @Override + public void visit(AttributeValueWrongError err) { + } + + @Override + public void visit(AttributeInvalidError err) { + } + + @Override + public void visit(PolygonWithoutSurfaceError err) { + } + + @Override + public void visit(SolidError err) { + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Check.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Check.java index a50d6bcfbc5dc0b64a7ea4c3f8dd9ec62f404499..e81369a1496db63586c44fad4181c7e0ae6bf1dc 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Check.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Check.java @@ -49,7 +49,7 @@ import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; * @author Matthias Betz * */ -public abstract class Check { +public abstract non-sealed class Check implements CheckableVisitor { private final List> applicableToClasses = new ArrayList<>(2); @@ -67,11 +67,6 @@ public abstract class Check { } } - /** - * Returns all classes for which the check needs to be executed - * - * @return a list of classes which the check applies to - */ public List> getApplicableToClasses() { return applicableToClasses; } @@ -108,22 +103,21 @@ public abstract class Check { * * @return true if it validates, false otherwise */ + @Override public boolean isValidator() { return true; } /** - * Checks whether the check can be executed on this checkable, meaning the - * checkable or its content can not have any error of any check dependent on - * this check.
- * If the check cannot be executed a CheckResult will be created with the + * Checks whether this Check can execute on the Checkable, meaning the Checkable contains no error from + * this Check's dependencies and is applicable to this Check.
+ * If the check cannot be executed due to not fulfilling the dependencies a CheckResult will be created with the * ResultStatus = DEPENDENCIES_NOT_MET. - * + * * @param c the checkable - * @param crc container for all check results - * @return true if the check can be executed, false if the checkable itself or - * one of its containing checkables have an error. + * @return true if the check can be executed, false otherwise */ + @Override public boolean canExecute(Checkable c) { // ignore objects where this check doesn't apply to if (!canBeApplied(c)) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Checkable.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Checkable.java index eee6292b740b02a30cc93eb80fe95a3af61868b4..c9b941243b99b37ea58449057e8fe05e416762bd 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Checkable.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Checkable.java @@ -26,7 +26,7 @@ import java.util.Map; import de.hft.stuttgart.citydoctor2.utils.CheckErrorFound; import de.hft.stuttgart.citydoctor2.utils.visitors.CheckableErrorCollector; -import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor; +import de.hft.stuttgart.citydoctor2.utils.visitors.ClearVisitorResultsVisitor; import de.hft.stuttgart.citydoctor2.utils.visitors.ClearMetaInformationVisitor; import de.hft.stuttgart.citydoctor2.utils.visitors.ContainsAnyErrorVisitor; import de.hft.stuttgart.citydoctor2.utils.visitors.ContainsErrorVisitor; @@ -74,7 +74,7 @@ public abstract class Checkable implements Serializable { * @param c the check from which the check method is called with the Checkable * instance as parameter. */ - public void accept(Check c) { + public void accept(CheckableVisitor c) { if (c.canExecute(this)) { c.check(this); } @@ -232,7 +232,7 @@ public abstract class Checkable implements Serializable { * Clears the checkResults list of this checkable and all child objects in its datastructure. */ public final void clearAllContainedCheckResults() { - this.accept(new ClearCheckResultsVisitor()); + this.accept(new ClearVisitorResultsVisitor()); } /** diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableUtilsVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableUtilsVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..0034c8c093c7cd4691deb8f0dfe9dbcbde915525 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableUtilsVisitor.java @@ -0,0 +1,168 @@ +/*- + * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart + * + * This file is part of CityDoctor2. + * + * CityDoctor2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CityDoctor2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with CityDoctor2. If not, see . + */ +package de.hft.stuttgart.citydoctor2.check; + +import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding; +import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface; +import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject; +import de.hft.stuttgart.citydoctor2.datastructure.Building; +import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart; +import de.hft.stuttgart.citydoctor2.datastructure.CityFurniture; +import de.hft.stuttgart.citydoctor2.datastructure.CityObject; +import de.hft.stuttgart.citydoctor2.datastructure.GenericCityObject; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry; +import de.hft.stuttgart.citydoctor2.datastructure.Installation; +import de.hft.stuttgart.citydoctor2.datastructure.LandObject; +import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; +import de.hft.stuttgart.citydoctor2.datastructure.Opening; +import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.ReliefObject; +import de.hft.stuttgart.citydoctor2.datastructure.TinObject; +import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject; +import de.hft.stuttgart.citydoctor2.datastructure.Vegetation; +import de.hft.stuttgart.citydoctor2.datastructure.WaterObject; + +/** + * + * This class serves as the base for CheckableVisitors which fulfill utility functions, like e.g. collecting all + * sub-CityObjects in the datastructure of a CityObject. + *

+ * Visitors extending from this class will not change the validated-flag of the visited Checkables. + * + */ +public abstract non-sealed class CheckableUtilsVisitor implements CheckableVisitor { + + /** + * This function is used for checking of dependencies in {@link Check}. Since UtilsVisitors do not have + * dependencies this function will always return true. + * + * @param c a Checkable + * @return true + */ + @Override + public boolean canExecute(Checkable c) { + return true; + } + + @Override + public final boolean isValidator() { + return false; + } + + @Override + public void check(Checkable checkable) { + + } + + @Override + public void check(AbstractBuilding ab) { + + } + + @Override + public void check(BoundarySurface bs) { + + } + + @Override + public void check(BridgeObject bo) { + + } + + @Override + public void check(Building b) { + + } + + @Override + public void check(Installation bi) { + + } + + @Override + public void check(BuildingPart bp) { + + } + + @Override + public void check(CityObject co) { + + } + + @Override + public void check(LandObject lo) { + + } + + @Override + public void check(Opening o) { + + } + + @Override + public void check(TransportationObject to) { + + } + + @Override + public void check(Vegetation veg) { + + } + + @Override + public void check(WaterObject wo) { + + } + + @Override + public void check(Geometry geom) { + + } + + @Override + public void check(Polygon poly) { + + } + + @Override + public void check(LinearRing ring) { + + } + + @Override + public void check(TinObject tin) { + + } + + @Override + public void check(ReliefObject relief) { + + } + + @Override + public void check(CityFurniture cf) { + + } + + @Override + public void check(GenericCityObject gco) { + + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..7830c5a8b155f3529bbae00a82b9640387d394b8 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/CheckableVisitor.java @@ -0,0 +1,72 @@ +package de.hft.stuttgart.citydoctor2.check; + +import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding; +import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface; +import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject; +import de.hft.stuttgart.citydoctor2.datastructure.Building; +import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart; +import de.hft.stuttgart.citydoctor2.datastructure.CityFurniture; +import de.hft.stuttgart.citydoctor2.datastructure.CityObject; +import de.hft.stuttgart.citydoctor2.datastructure.GenericCityObject; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry; +import de.hft.stuttgart.citydoctor2.datastructure.Installation; +import de.hft.stuttgart.citydoctor2.datastructure.LandObject; +import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; +import de.hft.stuttgart.citydoctor2.datastructure.Opening; +import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.ReliefObject; +import de.hft.stuttgart.citydoctor2.datastructure.TinObject; +import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject; +import de.hft.stuttgart.citydoctor2.datastructure.Vegetation; +import de.hft.stuttgart.citydoctor2.datastructure.WaterObject; + +public sealed interface CheckableVisitor permits Check, CheckableUtilsVisitor { + + /** + * Returns whether a Checkable should be flagged as validated after accepting this Visitor. + */ + boolean isValidator(); + + boolean canExecute(Checkable c); + + void check(Checkable checkable); + + void check(AbstractBuilding ab); + + void check(BoundarySurface bs); + + void check(BridgeObject bo); + + void check(Building b); + + void check(Installation bi); + + void check(BuildingPart bp); + + void check(CityObject co); + + void check(LandObject lo); + + void check(Opening o); + + void check(TransportationObject to); + + void check(Vegetation veg); + + void check(WaterObject wo); + + void check(Geometry geom); + + void check(Polygon poly); + + void check(LinearRing ring); + + void check(TinObject tin); + + void check(ReliefObject relief); + + void check(CityFurniture cf); + + void check(GenericCityObject gco); + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/ErrorVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/ErrorVisitor.java index 231213631be162d965b26c00f666ccfc5ddef7d0..23f95ee03bf3e8c5e35c3bd0963f2099d2de5d84 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/ErrorVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/ErrorVisitor.java @@ -23,6 +23,7 @@ import de.hft.stuttgart.citydoctor2.check.error.AttributeInvalidError; import de.hft.stuttgart.citydoctor2.check.error.AttributeMissingError; import de.hft.stuttgart.citydoctor2.check.error.AttributeValueWrongError; import de.hft.stuttgart.citydoctor2.check.error.ConsecutivePointSameError; +import de.hft.stuttgart.citydoctor2.check.error.DegeneratedRingError; import de.hft.stuttgart.citydoctor2.check.error.DependenciesNotMetError; import de.hft.stuttgart.citydoctor2.check.error.MultipleConnectedComponentsError; import de.hft.stuttgart.citydoctor2.check.error.NestedRingError; @@ -35,7 +36,9 @@ import de.hft.stuttgart.citydoctor2.check.error.NotFloorError; import de.hft.stuttgart.citydoctor2.check.error.NotGroundError; import de.hft.stuttgart.citydoctor2.check.error.NotWallError; import de.hft.stuttgart.citydoctor2.check.error.NullAreaError; +import de.hft.stuttgart.citydoctor2.check.error.PlanarityError; import de.hft.stuttgart.citydoctor2.check.error.PointTouchesEdgeError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonError; import de.hft.stuttgart.citydoctor2.check.error.PolygonHoleOutsideError; import de.hft.stuttgart.citydoctor2.check.error.PolygonInteriorDisconnectedError; import de.hft.stuttgart.citydoctor2.check.error.PolygonIntersectingRingsError; @@ -44,13 +47,15 @@ import de.hft.stuttgart.citydoctor2.check.error.PolygonWithoutSurfaceError; import de.hft.stuttgart.citydoctor2.check.error.PolygonWrongOrientationError; import de.hft.stuttgart.citydoctor2.check.error.RingDuplicatePointError; import de.hft.stuttgart.citydoctor2.check.error.RingEdgeIntersectionError; +import de.hft.stuttgart.citydoctor2.check.error.RingError; import de.hft.stuttgart.citydoctor2.check.error.RingNotClosedError; +import de.hft.stuttgart.citydoctor2.check.error.RingSelfIntersectionError; import de.hft.stuttgart.citydoctor2.check.error.RingTooFewPointsError; import de.hft.stuttgart.citydoctor2.check.error.SchematronError; +import de.hft.stuttgart.citydoctor2.check.error.SolidError; import de.hft.stuttgart.citydoctor2.check.error.SolidNotClosedError; import de.hft.stuttgart.citydoctor2.check.error.SolidSelfIntError; import de.hft.stuttgart.citydoctor2.check.error.SurfaceUnfragmentedError; -import de.hft.stuttgart.citydoctor2.check.error.DegeneratedRingError; import de.hft.stuttgart.citydoctor2.check.error.TooFewPolygonsError; import de.hft.stuttgart.citydoctor2.check.error.UnknownCheckError; @@ -62,7 +67,15 @@ import de.hft.stuttgart.citydoctor2.check.error.UnknownCheckError; * */ public interface ErrorVisitor { + + public void visit(RingError err); + public void visit(PolygonError err); + + public void visit(RingSelfIntersectionError err); + + public void visit(PlanarityError err); + public void visit(PolygonHoleOutsideError err); public void visit(NonManifoldEdgeError err); @@ -119,8 +132,6 @@ public interface ErrorVisitor { public void visit(NotGroundError err); - public void visit(CheckError err); - public void visit(SchematronError err); public void visit(SurfaceUnfragmentedError err); @@ -134,5 +145,9 @@ public interface ErrorVisitor { public void visit(AttributeInvalidError err); public void visit(PolygonWithoutSurfaceError err); + + public void visit(CheckError err); + + public void visit(SolidError err); } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/QualityAdeErrorVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/QualityAdeErrorVisitor.java index 3a7e2dc795cac9e9c99a769416aa7d16fa33c53e..741dfc57c03475a800f9c5dafcccad4b9abca429 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/QualityAdeErrorVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/QualityAdeErrorVisitor.java @@ -89,7 +89,7 @@ import de.hft.stuttgart.quality.model.types.SolidSelfIntersectionError; import de.hft.stuttgart.quality.model.types.SolidTooFewPolygonsError; import de.hft.stuttgart.quality.model.types.ValidationResult; -public class QualityAdeErrorVisitor implements ErrorVisitor { +public class QualityAdeErrorVisitor extends AbstractErrorVisitor { private final ValidationResult res; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Unit.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Unit.java index 9ea57be535d72ff4bee31e53444e55f53e34d6f3..7dcfb00c51a4e47825c68a9c73d636b39ff82adc 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Unit.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/Unit.java @@ -29,7 +29,7 @@ import de.hft.stuttgart.citydoctor2.utils.Localization; */ public enum Unit { - KWH("kWh", "kWh"), METER("m", "m"), SQUARE_METER("m²", "m2"), CUBIC_METER("m³", "m3"), RADIAN(Localization.getText("Unit.Radian"), "rad"), NONE("", null), DEGREE(Localization.getText("Unit.Degree"), "deg"); + KWH("kWh", "kWh"), METER("m", "m"), SQUARE_METER("m²", "m2"), CUBIC_METER("m³", "m3"), RADIAN(Localization.getText("Unit.Radian"), "rad"), NONE("", ""), DEGREE(Localization.getText("Unit.Degree"), "deg"); private final String representation; private final String gmlRep; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationError.java index 38958e9dbda66088f299ab38e5b928d7b25115b3..3f595e014a20781981cdb53eb56c90201555a74f 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationError.java @@ -18,9 +18,9 @@ */ 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; import de.hft.stuttgart.citydoctor2.check.ErrorVisitor; import de.hft.stuttgart.citydoctor2.check.HealingMethod; @@ -28,47 +28,35 @@ 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; - /** * Error when all polygons are oriented wrong. * * @author Matthias Betz * */ -public class AllPolygonsWrongOrientationError implements CheckError { +public class AllPolygonsWrongOrientationError extends SolidError { @Serial private static final long serialVersionUID = 2263993313732858840L; - private final Geometry geom; - public AllPolygonsWrongOrientationError(Geometry geom) { - this.geom = geom; - } - - public Geometry getGeometry() { - return geom; + super(geom); } @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 "AllPolygonsWrongOrientationError [geom=" + geom + "]"; - } - - @Override - public void report(ErrorReport report) { - report.add(geom); + return "AllPolygonsWrongOrientationError [geom=" + getGeometry() + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/ConsecutivePointSameError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/ConsecutivePointSameError.java index 0e93cc11dc4dbd84c53ffc64f53199349c2bfe1e..bb9d92f86704978df669a9bd358b3a27af3e451e 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/ConsecutivePointSameError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/ConsecutivePointSameError.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 two points are too close to each other and are consecutive in a linear * ring, this error is created. @@ -38,25 +37,20 @@ import java.io.Serial; * @author Matthias Betz * */ -public class ConsecutivePointSameError implements CheckError { +public class ConsecutivePointSameError extends RingError { @Serial private static final long serialVersionUID = -6355935751554777494L; - private final LinearRing lr; private final Vertex p1; private final Vertex p2; public ConsecutivePointSameError(LinearRing lr, Vertex p1, Vertex p2) { - this.lr = lr; + super(lr); this.p1 = p1; this.p2 = p2; } - public LinearRing getRing() { - return lr; - } - public Vertex getVertex1() { return p1; } @@ -67,22 +61,23 @@ public class ConsecutivePointSameError 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 "ConsecutivePointSameError [lr=" + lr + ", p1=" + p1 + ", p2=" + p2 + "]"; + return "ConsecutivePointSameError [lr=" + getRing() + ", p1=" + p1 + ", p2=" + p2 + "]"; } @Override public void report(ErrorReport report) { - report.add(lr); + super.report(report); report.add("duplicate point 1", p1); report.add("duplicate point 2", p2); } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/DegeneratedRingError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/DegeneratedRingError.java index 4735816b66fcc5474b8fe3f5a8e4d6d1d1302743..49c4ec77a07faa6abce23f325ee5127fc4774790 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/DegeneratedRingError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/DegeneratedRingError.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,37 +29,30 @@ 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; - -public class DegeneratedRingError implements CheckError { +public class DegeneratedRingError extends RingSelfIntersectionError { @Serial private static final long serialVersionUID = 865493182529055651L; - private final LinearRing lr; - public DegeneratedRingError(LinearRing lr) { - this.lr = lr; + super(lr); } - public LinearRing getRing() { - return lr; - } - @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("type", "degenerated ring"); - report.add(getRing()); + super.report(report); } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsError.java index 6edc7ae23965dce35a894e2a89b2e613b905ff9d..76aa81fad3d63542b2f788d9332cd2b27e687872 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsError.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 MultipleConnectedComponentsError implements CheckError { +public class MultipleConnectedComponentsError extends SolidError { @Serial private static final long serialVersionUID = 2152069835068857036L; - private final Geometry geom; private final List> components; public MultipleConnectedComponentsError(Geometry geom, List> components) { - this.geom = geom; + super(geom); this.components = components; } - public Geometry getGeometry() { - return geom; - } - public List> getComponents() { return components; } @Override public void report(ErrorReport report) { - report.add(geom); + super.report(report); for (int i = 0; i < components.size(); i++) { List polygons = components.get(i); report.addPolygons("component nr: " + (i + 1), polygons); @@ -71,17 +65,18 @@ public class MultipleConnectedComponentsError 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 "MultipleConnectedComponentsError [geom=" + geom + ", components=" + components + "]"; + return "MultipleConnectedComponentsError [geom=" + getGeometry() + ", components=" + components + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NestedRingError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NestedRingError.java index 2f900dd52723ab4e9f5c2b9619362be725f3de26..9aa5638ba094eea472b93a9369b6279948c2b7dd 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NestedRingError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NestedRingError.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,32 +30,26 @@ 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 an inner ring is with in the boundaries of another, this error is created. * * @author Matthias Betz * */ -public class NestedRingError implements CheckError { +public class NestedRingError extends PolygonError { @Serial private static final long serialVersionUID = -3396113374745830193L; - private final Polygon p; private final LinearRing innerRing; private final LinearRing withinRing; public NestedRingError(Polygon p, LinearRing innerRing, LinearRing withinRing) { - this.p = p; + super(p); this.innerRing = innerRing; this.withinRing = withinRing; } - public Polygon getPolygon() { - return p; - } public LinearRing getInnerRing() { return innerRing; @@ -66,23 +61,24 @@ public class NestedRingError implements CheckError { @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 "NestedRingError [p=" + p + ", innerRing=" + innerRing + "]"; + return "NestedRingError [p=" + getPolygon() + ", innerRing=" + innerRing + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeError.java index 47b7734214c70444149f2a4387095c6b876ced96..5697dee50bd3491851742301a4933f47d77a04ce 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeError.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; @@ -38,48 +37,44 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement; * @author Matthias Betz * */ -public class NonManifoldEdgeError implements CheckError { +public class NonManifoldEdgeError extends SolidError { @Serial private static final long serialVersionUID = -6742948557014332402L; private final List edges; - private final Geometry geom; public NonManifoldEdgeError(Geometry geom, List edges) { + super(geom); this.edges = edges; - this.geom = geom; } public List getEdges() { return edges; } - public Geometry getGeometry() { - return geom; - } - @Override public void report(ErrorReport report) { - report.add(geom); + super.report(report); for (Edge e : edges) { 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 "ManifoldEdgeError [edges=" + edges + ", geom=" + geom + "]"; + return "ManifoldEdgeError [edges=" + edges + ", geom=" + getGeometry() + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexError.java index f9005c64db297940c072edfc653d5094ddd880e6..a7fd574ef8e53f50040b38898d7a124e641de5b8 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexError.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; @@ -40,17 +39,16 @@ import de.hft.stuttgart.citydoctor2.datastructure.Vertex; * @author Matthias Betz * */ -public class NonManifoldVertexError implements CheckError { +public class NonManifoldVertexError extends SolidError { @Serial private static final long serialVersionUID = -3915669943428175777L; private final List> components; - private final Geometry geom; private final Vertex v; public NonManifoldVertexError(Geometry geom, List> components, Vertex v) { - this.geom = geom; + super(geom); this.components = components; this.v = v; } @@ -59,17 +57,13 @@ public class NonManifoldVertexError implements CheckError { return components; } - public Geometry getGeometry() { - return geom; - } - public Vertex getVertex() { return v; } @Override public void report(ErrorReport report) { - report.add(geom); + super.report(report); report.add(v); for (int i = 0; i < components.size(); i++) { List polygons = components.get(i); @@ -83,17 +77,18 @@ public class NonManifoldVertexError 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 "NonManifoldVertexError [components=" + components + ", geom=" + geom + ", v=" + v + "]"; + return "NonManifoldVertexError [components=" + components + ", geom=" + getGeometry() + ", v=" + v + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonDistancePlaneError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonDistancePlaneError.java index 7cb1d2df03051fd21eaedeed104b860b83c30b35..2ebfb2f2d14d83881b99acd39270fb4ed34dcbe0 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonDistancePlaneError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonDistancePlaneError.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; @@ -31,8 +32,6 @@ import de.hft.stuttgart.citydoctor2.datastructure.Vertex; import de.hft.stuttgart.citydoctor2.math.Plane; import de.hft.stuttgart.citydoctor2.utils.Localization; -import java.io.Serial; - /** * Error object for planarity errors containing the polygon, the regression * plane and the distance to the plane. @@ -40,18 +39,17 @@ import java.io.Serial; * @author Matthias Betz * */ -public class NonPlanarPolygonDistancePlaneError implements CheckError { +public class NonPlanarPolygonDistancePlaneError extends PlanarityError { @Serial private static final long serialVersionUID = -3504364055236383519L; - private final Polygon p; private final double distance; private final Vertex v; private final Plane plane; public NonPlanarPolygonDistancePlaneError(Polygon p, double distance, Vertex v, Plane plane) { - this.p = p; + super(p); this.distance = distance; this.v = v; this.plane = plane; @@ -61,10 +59,6 @@ public class NonPlanarPolygonDistancePlaneError implements CheckError { return plane; } - public Polygon getPolygon() { - return p; - } - public double getDistance() { return distance; } @@ -75,24 +69,25 @@ public class NonPlanarPolygonDistancePlaneError 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 void report(ErrorReport report) { - report.add(p); + super.report(report); report.add(v); report.add(Localization.getText("DistanceError.distanceFromPlane"), distance); } @Override public String toString() { - return "NonPlanarPolygonDistancePlaneError [p=" + p + ", distance=" + distance + ", v=" + v + ", plane=" + plane + "]"; + return "NonPlanarPolygonDistancePlaneError [p=" + getPolygon() + ", distance=" + distance + ", v=" + v + ", plane=" + plane + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonNormalsDeviation.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonNormalsDeviation.java index 388a026b32dc09d5a3e3d6fbd5d97516ee0e6c46..8ca5d235c9ab504c26db053ea3a14996517cc56d 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonNormalsDeviation.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NonPlanarPolygonNormalsDeviation.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.Polygon; -import java.io.Serial; - /** * When the normal of the triangles created from the triangulation of the * polygon have a too large angle between them, this error is created. @@ -37,46 +36,42 @@ import java.io.Serial; * @author Matthias Betz * */ -public class NonPlanarPolygonNormalsDeviation implements CheckError { +public class NonPlanarPolygonNormalsDeviation extends PlanarityError { @Serial private static final long serialVersionUID = 69073161885265794L; - private final Polygon p; private final double deviation; public NonPlanarPolygonNormalsDeviation(Polygon p, double deviation) { - this.p = p; + super(p); this.deviation = deviation; } - public Polygon getPolygon() { - return p; - } - public double getDeviation() { return deviation; } @Override public void report(ErrorReport report) { - report.add(p); + super.report(report); report.add("normal deviation (in rad)", deviation); } @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 "NormalDeviationError [p=" + p + ", deviation=" + deviation + "]"; + return "NormalDeviationError [p=" + getPolygon() + ", deviation=" + deviation + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NullAreaError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NullAreaError.java index d3fdbe6e59052d2c2293ab0257fa69db2bf6013f..a51eaa4935e4fb1b16b3ba9fea36909ba650473c 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NullAreaError.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/NullAreaError.java @@ -18,9 +18,9 @@ */ 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; import de.hft.stuttgart.citydoctor2.check.ErrorVisitor; import de.hft.stuttgart.citydoctor2.check.HealingMethod; @@ -28,47 +28,35 @@ 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; - /** * When a linear ring has a near zero area this error is created. * * @author Matthias Betz * */ -public class NullAreaError implements CheckError { +public class NullAreaError extends RingError { @Serial private static final long serialVersionUID = 1358910429039553687L; - private final LinearRing lr; - public NullAreaError(LinearRing lr) { - this.lr = lr; - } - - public LinearRing getRing() { - return lr; - } - - @Override - public void report(ErrorReport report) { - report.add(lr); + super(lr); } @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 "NullAreaError [lr=" + lr + "]"; + return "NullAreaError [lr=" + getRing() + "]"; } @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PlanarityError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PlanarityError.java new file mode 100644 index 0000000000000000000000000000000000000000..dbf60d4f4f1cf7d9cad5f31599f7e30dbaeff966 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PlanarityError.java @@ -0,0 +1,29 @@ +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); + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PointTouchesEdgeError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PointTouchesEdgeError.java index 79cfb8799dd46f6eb5771ce907aa1bba721421e8..d58ae6142f0fb360ad6cdcbbf91c1feb30aba746 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PointTouchesEdgeError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonError.java new file mode 100644 index 0000000000000000000000000000000000000000..c71bd3b630e3baea0d7e57b25c81cfd67e12eae8 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonError.java @@ -0,0 +1,44 @@ +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); + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonHoleOutsideError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonHoleOutsideError.java index c290554fcdce6e86d56aa3dee68c76cc3f6d0c92..294fb2fda87567141ff64be16037125d5a1807a3 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonHoleOutsideError.java +++ b/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 holesOutside; - private final Polygon p; public PolygonHoleOutsideError(Polygon p, List holesOutside) { - this.p = p; + super(p); this.holesOutside = holesOutside; } - public Polygon getPolygon() { - return p; - } - public List 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonInteriorDisconnectedError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonInteriorDisconnectedError.java index 0cb0c51dd40ad3856092eba327805eaea6496135..4e48fb139e30878d812bff6a4aa6294cd619f1b0 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonInteriorDisconnectedError.java +++ b/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 connectedRings; public PolygonInteriorDisconnectedError(Polygon p, List connectedRings) { - this.p = p; + super(p); this.connectedRings = connectedRings; } - public Polygon getPolygon() { - return p; - } - public List 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonIntersectingRingsError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonIntersectingRingsError.java index 771fb1d59fca52e52e4f31ac7e088e54269417fd..aa3d5a8a9b72222b939eeb8ad7a5bcae91cd1666 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonIntersectingRingsError.java +++ b/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 intersectingRings; public PolygonIntersectingRingsError(Polygon p, SerializablePair intersectingRings) { - this.p = p; + super(p); this.intersectingRings = intersectingRings; } - public Polygon getPolygon() { - return p; - } - public SerializablePair 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonSameOrientationError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonSameOrientationError.java index 3904d526e9f4919ff25b2d1e0af4a9970bcd88e8..17780d7edb7a7ff99751bf4c2e79489757ee4556 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonSameOrientationError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationError.java index 10633e1f1233a979a08fff8e5108d796a4b8e4b9..601f5161bdf2a1bd9e1afb615dbb24ea52f74283 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationError.java +++ b/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 edges; - private final Geometry g; public PolygonWrongOrientationError(Geometry g, List edges) { + super(g); this.edges = edges; - this.g = g; } public List getEdges() { return edges; } - public Geometry getGeometry() { - return g; - } - @Override public void report(ErrorReport report) { - report.add(g); + super.report(report); Set 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingDuplicatePointError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingDuplicatePointError.java index aaef3e1f283c4dbeee68a0591e357480ca1d2a19..3a2a865c7bf8a93899ecf85d710d1263ce99b31a 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingDuplicatePointError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingEdgeIntersectionError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingEdgeIntersectionError.java index 45572d7cfcd87c3d5d2340940c440ef585ab3667..96c7e9f4200718ef9b4e8b1cd45344efcc46e457 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingEdgeIntersectionError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingError.java new file mode 100644 index 0000000000000000000000000000000000000000..45dad9c1e8e3cc1a5a1bccb570813d8a2213a30b --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingError.java @@ -0,0 +1,44 @@ +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); + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingNotClosedError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingNotClosedError.java index 80477a15caa367e77e2b988d5e4f800bb5bd13e9..6e20a396b5ce849402360d80dc7d61da5575ce22 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingNotClosedError.java +++ b/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; - } - - public LinearRing getRing() { - return ring; + super(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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingSelfIntersectionError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingSelfIntersectionError.java new file mode 100644 index 0000000000000000000000000000000000000000..04e3ce18bfa2142c6acc9d898b297db58b7de9e3 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingSelfIntersectionError.java @@ -0,0 +1,30 @@ +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); + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingTooFewPointsError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingTooFewPointsError.java index 4922a454479602ca4b311c9aaaca753f6089f077..10b32a7f7eef3575c338368b5bd7037805f8264c 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/RingTooFewPointsError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidError.java new file mode 100644 index 0000000000000000000000000000000000000000..490772ab003fe80a5377877d6b587f44a1833238 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidError.java @@ -0,0 +1,42 @@ +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); + } + +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedError.java index f1b449be16a6ef4b9d493df915e8e2e4ba1c5101..a3d19b6d9aaa41ed71f4a2de18d9e472c219722e 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedError.java +++ b/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 errorEdges; - private final Geometry g; public SolidNotClosedError(Geometry g, List errorEdges) { + super(g); this.errorEdges = errorEdges; - this.g = g; - } - - public Geometry getGeometry() { - return g; } public List 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntError.java index a679392549eb74807fe9467ff8e45c23a6da91f7..c7961ab4c7b5cd41fd5da3619d3314166dee3612 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntError.java +++ b/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 intersections; public SolidSelfIntError(Geometry g, List 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 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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsError.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsError.java index 4f0e8294708c7f0de08450e52b9e346ab21e9596..09429a27815130d9c8eb37d2e599396e3ad49d70 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsError.java +++ b/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 diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuilding.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuilding.java index e1923eceb6234e8cadfe9767e15b799f4a910170..f1e033ba11d975f3e7215a9753209d1bc851771c 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuilding.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuilding.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import org.apache.logging.log4j.LogManager; @@ -53,6 +53,7 @@ public abstract class AbstractBuilding extends CityObject { private final List buildingStoreys = new ArrayList<>(); private final List buildingUnits = new ArrayList<>(); private final List buildingRoomFurnitureList = new ArrayList<>(); + private final List 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 getConstructiveElements() { + return buildingConstructiveElements; + } + @Override public void unsetGmlGeometries() { ab.setLod1Solid(null); @@ -160,7 +165,7 @@ public abstract class AbstractBuilding extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); @@ -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; } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.java index 6142cb32c2cd6a26d91fcca6b34096c6c5ea0c6d..7ada0f2da6b547898a084aa7d8dfa5258ba0ffab 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingSubdivision.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import org.apache.logging.log4j.LogManager; @@ -136,7 +136,7 @@ public abstract class AbstractBuildingSubdivision extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractFurniture.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractFurniture.java index 774ca2bb05336fb43a9eedea3104f53c4db87313..002ac4f745673758b63acf837316204099ddd0a4 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractFurniture.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractFurniture.java @@ -1,7 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; - +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; @@ -30,7 +29,7 @@ public abstract class AbstractFurniture extends CityObject { private org.citygml4j.core.model.construction.AbstractFurniture af; @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoom.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoom.java index 79c08f545924ce7a67ef9c2a40fc94d23d8522da..b656ae69af91189dad7c99e5df32a9cd7f98974b 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoom.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoom.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import org.citygml4j.core.model.core.AbstractCityObject; @@ -32,7 +32,7 @@ public abstract class AbstractRoom extends CityObject { @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnel.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnel.java index 7da0c979e13612276805cf9992745e11a77ab5bd..0ea9909b4e869189d04bc9aba2066f247b999a01 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnel.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnel.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -143,7 +143,7 @@ public abstract class AbstractTunnel extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurface.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurface.java index 977202495bc739068a722a7f52f225b8d0263be4..9fa5066c6b7917a93c983831d4a05b99df03c0c3 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurface.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurface.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -145,7 +145,7 @@ public class BoundarySurface extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeConstructiveElement.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeConstructiveElement.java index 6eeea1c765e72613d05934ece006d7c7cda32a22..01b892c7ed3621693eec2a2a020957d2d379ef79 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeConstructiveElement.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeConstructiveElement.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -95,7 +95,7 @@ public class BridgeConstructiveElement extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObject.java index 0fcad336f33239b1e06b2ffe4c3e58f6c63fe2a0..b87b232e05b2edcbb9c3d544dd78271b920c6ff1 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -191,7 +191,7 @@ public class BridgeObject extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Building.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Building.java index dcd6073e1fe457c49b8c1048f769514bc4e00282..f21df6e366ac701b09aa8697ccf270c402313fd8 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Building.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Building.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import org.citygml4j.core.model.building.BuildingInstallation; import org.citygml4j.core.model.building.BuildingInstallationProperty; import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty; @@ -45,7 +45,7 @@ public class Building extends AbstractBuilding { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingConstructiveElement.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingConstructiveElement.java new file mode 100644 index 0000000000000000000000000000000000000000..06763aeb0424a67c0874014f45468214d09a18f7 --- /dev/null +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingConstructiveElement.java @@ -0,0 +1,167 @@ +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 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 getBoundarySurfaces() { + return boundarySurfaceList; + } +} diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingUnit.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingUnit.java index 9a9bd5c800b5710e87dea68ea9b13044ab589ccd..785d9cd62386861cfaed179cc01a8b8a6aded664 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingUnit.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingUnit.java @@ -1,8 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; -import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; -import org.citygml4j.core.util.geometry.GeometryFactory; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import java.io.Serial; import java.util.ArrayList; @@ -16,7 +14,7 @@ public class BuildingUnit extends AbstractBuildingSubdivision { private final List storeys = new ArrayList<>(); @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); for (Storey storey : storeys) { storey.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java index 918188982eecb6b9b9fe7de5129f52190ef72f53..41b2b003f4b2a7581b20a263405e6c2db74b3d17 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityDoctorModel.java @@ -18,8 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; @@ -147,7 +146,7 @@ public class CityDoctorModel { folder.mkdirs(); createFeatureStream().forEach(co -> { Map> polygonMap = new EnumMap<>(Lod.class); - Check c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(Geometry geom) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java index b92ace7b2ec77e6c31239f664cf73319637bd542..8e7002b21dc75065591209a7f9913d8e4f7bf879 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -21,7 +21,7 @@ public class CityFurniture extends CityObject { private org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCityFurniture; @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java index 1291a8de7031c57beb110e577766374084b20628..19eadd874ac460a4f4cb566e23a8a9419416dd41 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder; import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; @@ -185,7 +185,7 @@ public abstract class CityObject extends GmlElement { public abstract FeatureType getFeatureType(); @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java index c5c99a5ee696c96f7c991dda086c80c6460880aa..3aa734d4137c7d9fdd6722527cbad5cb98b1f149 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java @@ -18,8 +18,8 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; import de.hft.stuttgart.citydoctor2.check.Checkable; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.tesselation.JoglTesselator; import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon; @@ -180,7 +180,7 @@ public class ConcretePolygon extends Polygon { * citydoctor2.check.Check) */ @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java index 0af9643fa21b4f9e8996088b5ff826c76752b127..df1165057ca654423f0ccf7f5dab26e343b4ed08 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java @@ -48,9 +48,6 @@ public class Edge implements Serializable { this.to = to; } - private Edge() { - } - public Vertex getFrom() { return from; } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java index e55e63632570a659c01d3e36d31777d61fe24fe0..34a0d022d9975433061979ff8043e724dd38f5b8 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -33,7 +33,7 @@ public class GenericCityObject extends CityObject { private final List boundarySurfaceList = new ArrayList<>(); @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java index 5525115c75dd5eea78e8bd82c69c7f37ca624956..d7c17240faa18fbbd5a789468956d4ac75983b18 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java @@ -18,8 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; - +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.math.Triangle3d; import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon; @@ -41,6 +40,10 @@ public class Geometry extends GmlElement { @Serial private static final long serialVersionUID = 2539031030917731575L; + + public enum Orientation { + INWARD, OUTWARD + } private static final Random r = new Random(); @@ -53,11 +56,20 @@ public class Geometry extends GmlElement { private List edges; private Map, Edge> edgeMap; private List vertices; + private Orientation orientation; - public Geometry(GeometryType type, Lod lod) { + public Geometry(GeometryType type, Lod lod, Orientation orientation) { this.lod = lod; this.type = type; + if (type == GeometryType.SOLID) { + Objects.requireNonNull(orientation); + } + this.orientation = orientation; } + + public Orientation getOrientation() { + return orientation; + } void setParent(CityObject parent) { this.parent = parent; @@ -206,7 +218,7 @@ public class Geometry extends GmlElement { @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java index 49e07c810c006cfac294d3b9faf941390773d761..872725ee41cc8342b4314d99e00aaf3ba7eeee05 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java @@ -1,13 +1,10 @@ package de.hft.stuttgart.citydoctor2.datastructure; import java.io.Serial; -import java.util.List; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import org.citygml4j.core.model.core.ImplicitGeometry; -import de.hft.stuttgart.citydoctor2.check.Check; -import de.hft.stuttgart.citydoctor2.check.CheckError; -import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.math.TransformationMatrix; /** @@ -26,7 +23,7 @@ public class ImplicitGeometryHolder extends Geometry { private final Geometry prototypeGeometry; public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, LibraryObject libObject) { - super(libObject.getType(), libObject.getLod()); + super(libObject.getType(), libObject.getLod(), libObject.getOrientation()); prototypeGeometry = libObject; type = PrototypeGeometryType.LIBRARY_OBJECT; this.cgmlImplicitGeometry = cgmlImplicitGeometry; @@ -34,7 +31,7 @@ public class ImplicitGeometryHolder extends Geometry { } public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, RelativeGeometry relativeGeometry) { - super(relativeGeometry.getType(), relativeGeometry.getLod()); + super(relativeGeometry.getType(), relativeGeometry.getLod(), relativeGeometry.getOrientation()); prototypeGeometry = relativeGeometry; type = PrototypeGeometryType.RELATIVE_GEOMETRY; this.cgmlImplicitGeometry = cgmlImplicitGeometry; @@ -58,7 +55,7 @@ public class ImplicitGeometryHolder extends Geometry { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { prototypeGeometry.accept(c); } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java index 7258df5ad410960fbc9663002f0a2d47e30c9148..cbe4459bd308c254bc6866860215da7fb96af105 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java @@ -18,8 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; - +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; @@ -130,7 +129,7 @@ public class Installation extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java index d4ab4acae72b4089e8638e17af97cff9776ba16b..d77b9e51fba1f90ab2a03369aad19d7deebe6894 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -89,7 +89,7 @@ public class LandObject extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java index 660194ae8ecc1f3d1c1a000db397bf93ac5f5b64..f757da769a1b138b12fed1a530cc3f0d1f3b6934 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java @@ -37,7 +37,7 @@ public class LibraryObject extends Geometry { if (protoGeom == null) { return null; } - LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod()); + LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod(), protoGeom.getOrientation()); protoGeom.getPolygons().forEach(libOb::addPolygon); libOb.updateEdgesAndVertices(); libraryObjects.put(path.toString(), libOb); @@ -53,15 +53,15 @@ public class LibraryObject extends Geometry { if (protoGeom == null) { return null; } - LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod()); + LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod(), protoGeom.getOrientation()); protoGeom.getPolygons().forEach(libOb::addPolygon); libOb.updateEdgesAndVertices(); libraryObjects.put(fileName, libOb); return libOb; } - private LibraryObject(GeometryType type, Lod lod) { - super(type, lod); + private LibraryObject(GeometryType type, Lod lod, Orientation orientation) { + super(type, lod, orientation); } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRing.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRing.java index 2f48bcdce4039bd1e1d2bd97da1b8056c82da480..88d621670b860df72860d252edd6655e17cf2ea4 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRing.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRing.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.math.*; import java.io.Serial; @@ -226,7 +226,7 @@ public class LinearRing extends GmlElement { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java index 1c940c1a0def4f5f1a4f898117485e1ce96f6114..d915d8dc753388796ae9c332f42cbb2cdd507932 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java @@ -21,6 +21,7 @@ package de.hft.stuttgart.citydoctor2.datastructure; import de.hft.stuttgart.citydoctor2.check.Check; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon; import javafx.scene.paint.Color; @@ -43,9 +44,6 @@ public class LinkedPolygon extends Polygon { private Geometry parent; private ConcretePolygon poly; - private LinkedPolygon() { - } - /** * @param poly polygon this is linked to * @param parent the parent of the linked polygon @@ -105,7 +103,7 @@ public class LinkedPolygon extends Polygon { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { // linked polygons are not checked setValidated(true); } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Opening.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Opening.java index 19990e966ff1710e74c22ffff6315bf9fc830791..b64487de6c20dc229d8e3f46debc50b5e2bc06e9 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Opening.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Opening.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -114,7 +114,7 @@ public class Opening extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/RelativeGeometry.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/RelativeGeometry.java index 8abe39a197cf6027b7864991d43b125be8d2fae0..bbf61550e200a9c5311e30834649065cd55b9bf3 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/RelativeGeometry.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/RelativeGeometry.java @@ -20,14 +20,14 @@ public class RelativeGeometry extends Geometry { if (relativeGeometries.containsKey(geom)) { return relativeGeometries.get(geom); } - RelativeGeometry relGeo = new RelativeGeometry(geom.getType(), geom.getLod()); + RelativeGeometry relGeo = new RelativeGeometry(geom.getType(), geom.getLod(), geom.getOrientation()); geom.getPolygons().forEach(relGeo::addPolygon); relGeo.updateEdgesAndVertices(); relativeGeometries.put(geom, relGeo); return relGeo; } - private RelativeGeometry(GeometryType type, Lod lod) { - super(type, lod); + private RelativeGeometry(GeometryType type, Lod lod, Orientation orientation) { + super(type, lod, orientation); } } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObject.java index b27b485e4788126cfe17fa0c57dc5a400bc5446d..7400731bf27ec57b981ac97f84a3a66267ed359e 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import javafx.scene.paint.Color; import org.citygml4j.core.model.relief.ReliefFeature; @@ -42,7 +42,7 @@ public class ReliefObject extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Storey.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Storey.java index c5cea9b5b65dd1725fe12e1e730e71711ef6d0a1..7978ade21fedc90222afa05c3888ec128f110bec 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Storey.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Storey.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import org.citygml4j.core.util.geometry.GeometryFactory; @@ -22,7 +22,7 @@ public class Storey extends AbstractBuildingSubdivision { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); for (BuildingUnit buildingUnit : buildingUnits) { buildingUnit.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TinObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TinObject.java index 4fde9c9ea3263d2aa84ce13f35b84b5818296311..e01a7bf9cc3a1105f5ccc415880d6a53ee213810 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TinObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TinObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -50,7 +50,7 @@ public class TinObject extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeature.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeature.java index 8b41c6993481bede6295851d78dc58f7034a6d97..1e52a55d060b48283d7a60daa9c227dff2d68667 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeature.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeature.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import org.citygml4j.core.model.deprecated.transportation.TransportationComplex; import org.citygml4j.core.model.transportation.Railway; import org.citygml4j.core.model.transportation.Road; @@ -76,7 +76,7 @@ public class TopLevelTransportFeature extends TransportationSpace { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceObject.java index fb60aa918287b7ba8eebe1698486b983c8521f70..bfc06e7138880a79c6796521a0fd44db89c77787 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceObject.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import org.citygml4j.core.model.core.AbstractSpace; @@ -95,7 +95,7 @@ public class TrafficSpaceObject extends TransportationObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpace.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpace.java index 16e7ef946d745908380dd6db82b3288ecc38854a..388117176c79ae4a233a54f05faaf6f1d2aa654d 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpace.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpace.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils; import org.citygml4j.core.model.core.AbstractSpace; @@ -121,7 +121,7 @@ public abstract class TransportationSpace extends TransportationObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java index 54013c4a9da76c9d818bd798d6cbd39ad13a96e2..72c7b341e0963855f87a5960b6a3d41a5aca427e 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +import de.hft.stuttgart.citydoctor2.check.CheckableVisitor; import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty; import org.citygml4j.core.model.tunnel.TunnelInstallation; import org.citygml4j.core.model.tunnel.TunnelInstallationProperty; @@ -27,7 +27,7 @@ public class Tunnel extends AbstractTunnel { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelConstructiveElement.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelConstructiveElement.java index d1f896b962974aab94e45701d29cd746ddd83c13..0284f2b5d62cc99c1921a68b0beeeb1e0e5392f9 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelConstructiveElement.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelConstructiveElement.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -87,7 +87,7 @@ public class TunnelConstructiveElement extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java index 79aec2a5dde1e3697fa80011e65be85c8c356c30..62d75bb7525dde9c137c43859dea23097b10ab90 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -27,15 +27,12 @@ import org.citygml4j.core.model.vegetation.AbstractVegetationObject; import org.citygml4j.core.model.vegetation.PlantCover; import org.citygml4j.core.model.vegetation.SolitaryVegetationObject; import org.citygml4j.core.util.geometry.GeometryFactory; -import org.xmlobjects.gml.model.geometry.aggregates.MultiSolid; -import org.xmlobjects.gml.model.geometry.aggregates.MultiSolidProperty; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.primitives.Solid; import org.xmlobjects.gml.model.geometry.primitives.SolidProperty; import java.io.Serial; -import java.util.Collections; /** * Representation of CityGML vegetation objects @@ -172,7 +169,7 @@ public class Vegetation extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java index 278a8fad0dab6718b1b1276e6390f12353684cc5..035d303eec1c591590d4e33f1a682db65bc6040f 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java @@ -18,7 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.Check; +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; @@ -141,7 +141,7 @@ public class WaterObject extends CityObject { } @Override - public void accept(Check c) { + public void accept(CheckableVisitor c) { super.accept(c); if (c.canExecute(this)) { c.check(this); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3FeatureMapper.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3FeatureMapper.java index 0754938df0dd50ae21ebe32552ec3adb6cc9c2d5..e5f5c5435c06b98da11fb7e5a6af8c074cbb315f 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3FeatureMapper.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3FeatureMapper.java @@ -18,32 +18,45 @@ */ package de.hft.stuttgart.citydoctor2.mapper.citygml3; -import de.hft.stuttgart.citydoctor2.datastructure.AbstractBuilding; -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.BuildingPart; -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.TunnelConstructiveElement; -import de.hft.stuttgart.citydoctor2.datastructure.TunnelFurniture; -import de.hft.stuttgart.citydoctor2.datastructure.TunnelPart; -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 de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntry; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.citygml4j.core.model.CityGMLVersion; -import org.citygml4j.core.model.bridge.*; +import org.citygml4j.core.model.bridge.AbstractBridge; +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.AbstractBuildingSubdivisionProperty; +import org.citygml4j.core.model.building.BuildingConstructiveElement; +import org.citygml4j.core.model.building.BuildingConstructiveElementProperty; +import org.citygml4j.core.model.building.BuildingFurniture; +import org.citygml4j.core.model.building.BuildingFurnitureProperty; +import org.citygml4j.core.model.building.BuildingInstallationProperty; +import org.citygml4j.core.model.building.BuildingPartProperty; +import org.citygml4j.core.model.building.BuildingRoomProperty; import org.citygml4j.core.model.building.BuildingUnit; 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.core.*; +import org.citygml4j.core.model.core.AbstractCityObject; +import org.citygml4j.core.model.core.AbstractFeatureWithLifespan; +import org.citygml4j.core.model.core.AbstractGenericAttributeProperty; +import org.citygml4j.core.model.core.AbstractOccupiedSpace; +import org.citygml4j.core.model.core.AbstractPhysicalSpace; +import org.citygml4j.core.model.core.AbstractSpace; +import org.citygml4j.core.model.core.AbstractSpaceBoundary; +import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty; +import org.citygml4j.core.model.core.AbstractThematicSurface; +import org.citygml4j.core.model.core.AbstractUnoccupiedSpace; +import org.citygml4j.core.model.core.CityModel; +import org.citygml4j.core.model.core.ImplicitGeometry; import org.citygml4j.core.model.deprecated.transportation.TransportationComplex; import org.citygml4j.core.model.landuse.LandUse; import org.citygml4j.core.model.relief.AbstractReliefComponentProperty; @@ -52,9 +65,28 @@ import org.citygml4j.core.model.relief.MassPointRelief; import org.citygml4j.core.model.relief.RasterRelief; import org.citygml4j.core.model.relief.ReliefFeature; import org.citygml4j.core.model.relief.TINRelief; -import org.citygml4j.core.model.transportation.*; +import org.citygml4j.core.model.transportation.AbstractTransportationSpace; +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.IntersectionProperty; +import org.citygml4j.core.model.transportation.Railway; +import org.citygml4j.core.model.transportation.Road; +import org.citygml4j.core.model.transportation.SectionProperty; +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.transportation.Waterway; +import org.citygml4j.core.model.tunnel.HollowSpace; +import org.citygml4j.core.model.tunnel.HollowSpaceProperty; import org.citygml4j.core.model.tunnel.Tunnel; -import org.citygml4j.core.model.tunnel.*; +import org.citygml4j.core.model.tunnel.TunnelConstructiveElementProperty; +import org.citygml4j.core.model.tunnel.TunnelFurnitureProperty; +import org.citygml4j.core.model.tunnel.TunnelInstallation; +import org.citygml4j.core.model.tunnel.TunnelInstallationProperty; +import org.citygml4j.core.model.tunnel.TunnelPartProperty; import org.citygml4j.core.model.vegetation.AbstractVegetationObject; import org.citygml4j.core.model.vegetation.PlantCover; import org.citygml4j.core.model.vegetation.SolitaryVegetationObject; @@ -67,13 +99,65 @@ 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.*; +import org.xmlobjects.gml.model.geometry.primitives.AbstractSolid; +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 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.AbstractBuilding; +import de.hft.stuttgart.citydoctor2.datastructure.AbstractTunnel; +import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface; +import de.hft.stuttgart.citydoctor2.datastructure.BridgeConstructiveElement; +import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject; +import de.hft.stuttgart.citydoctor2.datastructure.Building; +import de.hft.stuttgart.citydoctor2.datastructure.BuildingPart; +import de.hft.stuttgart.citydoctor2.datastructure.BuildingRoom; +import de.hft.stuttgart.citydoctor2.datastructure.BuildingRoomFurniture; +import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel; +import de.hft.stuttgart.citydoctor2.datastructure.CityFurniture; +import de.hft.stuttgart.citydoctor2.datastructure.CityObject; +import de.hft.stuttgart.citydoctor2.datastructure.CompositeCollection; +import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon; +import de.hft.stuttgart.citydoctor2.datastructure.GenericAttribute; +import de.hft.stuttgart.citydoctor2.datastructure.GenericCityObject; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; +import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; +import de.hft.stuttgart.citydoctor2.datastructure.GmlElement; +import de.hft.stuttgart.citydoctor2.datastructure.GmlId; +import de.hft.stuttgart.citydoctor2.datastructure.ImplicitGeometryHolder; +import de.hft.stuttgart.citydoctor2.datastructure.Installation; +import de.hft.stuttgart.citydoctor2.datastructure.LandObject; +import de.hft.stuttgart.citydoctor2.datastructure.LibraryObject; +import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; +import de.hft.stuttgart.citydoctor2.datastructure.LinkedPolygon; +import de.hft.stuttgart.citydoctor2.datastructure.Lod; +import de.hft.stuttgart.citydoctor2.datastructure.Opening; +import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.RelativeGeometry; +import de.hft.stuttgart.citydoctor2.datastructure.ReliefObject; +import de.hft.stuttgart.citydoctor2.datastructure.TinObject; +import de.hft.stuttgart.citydoctor2.datastructure.TopLevelTransportFeature; +import de.hft.stuttgart.citydoctor2.datastructure.TrafficAreaObject; +import de.hft.stuttgart.citydoctor2.datastructure.TrafficSpaceObject; +import de.hft.stuttgart.citydoctor2.datastructure.TransportSection; +import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject; +import de.hft.stuttgart.citydoctor2.datastructure.TransportationSpace; +import de.hft.stuttgart.citydoctor2.datastructure.TunnelConstructiveElement; +import de.hft.stuttgart.citydoctor2.datastructure.TunnelFurniture; +import de.hft.stuttgart.citydoctor2.datastructure.TunnelHollow; +import de.hft.stuttgart.citydoctor2.datastructure.TunnelPart; +import de.hft.stuttgart.citydoctor2.datastructure.Vegetation; +import de.hft.stuttgart.citydoctor2.datastructure.Vegetation.VegetationType; +import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.WaterObject; +import de.hft.stuttgart.citydoctor2.math.graph.KDTree; +import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; +import de.hft.stuttgart.citydoctor2.utils.Localization; +import de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntry; public class Citygml3FeatureMapper extends ObjectWalker { @@ -123,7 +207,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { public void visit(org.citygml4j.core.model.cityfurniture.CityFurniture gmlCityFurniture) { CityFurniture cf = new CityFurniture(); cf.setGmlObject(gmlCityFurniture); - mapAbstractOccupiedSpace(gmlCityFurniture, cf); + mapAbstractOccupiedSpace(gmlCityFurniture, cf, Orientation.OUTWARD); finishCityObjectConstruction(cf); model.addCityFurniture(cf); } @@ -141,10 +225,10 @@ public class Citygml3FeatureMapper extends ObjectWalker { if (agLod4.getObject() instanceof MultiSurface ms) { gco.addGeometry(parseMultiSurface(ms, Lod.LOD4)); } else if (agLod4.getObject() instanceof AbstractSolid solid) { - gco.addGeometry(parseSolid(solid, Lod.LOD4)); + gco.addGeometry(parseSolid(solid, Lod.LOD4, Orientation.OUTWARD)); } } - mapAbstractOccupiedSpace(gos, gco); + mapAbstractOccupiedSpace(gos, gco, Orientation.OUTWARD); finishCityObjectConstruction(gco); model.addGenericCityObject(gco); } @@ -168,9 +252,9 @@ public class Citygml3FeatureMapper extends ObjectWalker { public void visit(WaterBody waterBody) { WaterObject wo = new WaterObject(); wo.setGmlObject(waterBody); - mapAbstractOccupiedSpace(waterBody, wo); + mapAbstractOccupiedSpace(waterBody, wo, Orientation.OUTWARD); parseAndAddMultiSurface(waterBody.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, wo); - parseAndAddSolid(waterBody.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, wo); + parseAndAddSolid(waterBody.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, wo, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : waterBody.getBoundaries()) { @@ -257,7 +341,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { reliefObject.addComponent(to); Citygml3GeometryMapper tinMapper = new Citygml3GeometryMapper(config, vertexMap); relief.getTin().getObject().accept(tinMapper); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, reliefLod); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, reliefLod, Orientation.OUTWARD); tinMapper.getPolygons().forEach(geom::addPolygon); to.addGeometry(geom); } @@ -282,39 +366,39 @@ public class Citygml3FeatureMapper extends ObjectWalker { mapAbstractVegetationObject(solitaryVegetationObject, veg); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod1Geometry(), Lod.LOD1, - veg); + veg, Orientation.OUTWARD); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod2Geometry(), Lod.LOD2, - veg); + veg, Orientation.OUTWARD); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod3Geometry(), Lod.LOD3, - veg); + veg, Orientation.OUTWARD); parseAndAddAbstractGeometry(solitaryVegetationObject.getDeprecatedProperties().getLod4Geometry(), Lod.LOD4, - veg); + veg, Orientation.OUTWARD); finishCityObjectConstruction(veg); model.addVegetation(veg); } private void mapAbstractVegetationObject(AbstractVegetationObject avo, Vegetation veg) { - mapAbstractOccupiedSpace(avo, veg); + mapAbstractOccupiedSpace(avo, veg, Orientation.OUTWARD); } - private void mapAbstractOccupiedSpace(AbstractOccupiedSpace aos, CityObject co) { - mapAbstractPhysicalSpace(aos, co); - parseImplicitGeometry(aos, co); + private void mapAbstractOccupiedSpace(AbstractOccupiedSpace aos, CityObject co, Orientation orientation) { + mapAbstractPhysicalSpace(aos, co, orientation); + parseImplicitGeometry(aos, co, orientation); } - private void mapAbstractPhysicalSpace(AbstractPhysicalSpace aps, CityObject co) { - mapAbstractSpace(aps, co); + private void mapAbstractPhysicalSpace(AbstractPhysicalSpace aps, CityObject co, Orientation orientation) { + mapAbstractSpace(aps, co, orientation); } - private void mapAbstractSpace(AbstractSpace as, CityObject co) { + private void mapAbstractSpace(AbstractSpace as, CityObject co, Orientation orientation) { mapAbstractFeature(as, 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); + parseAndAddSolid(as.getLod1Solid(), Lod.LOD1, co, orientation); + parseAndAddSolid(as.getLod2Solid(), Lod.LOD2, co, orientation); + parseAndAddSolid(as.getLod3Solid(), Lod.LOD3, co, orientation); parseAndAddGenericAttributes(as, co); } @@ -331,7 +415,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { // parse deprecated geometries parseAndAddMultiSurface(bridge.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, bo); parseAndAddMultiSurface(bridge.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, bo); - parseAndAddSolid(bridge.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, bo); + parseAndAddSolid(bridge.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, bo, Orientation.OUTWARD); mapAbstractBridge(bridge, bo); for (BridgePartProperty bPartProperty : bridge.getBridgeParts()) { @@ -403,13 +487,13 @@ public class Citygml3FeatureMapper extends ObjectWalker { private Installation mapBridgeInstallation(BridgeInstallation gmlBi) { Installation bi = new Installation(); bi.setGmlObject(gmlBi); - mapAbstractOccupiedSpace(gmlBi, bi); + mapAbstractOccupiedSpace(gmlBi, bi, Orientation.OUTWARD); GeometryProperty lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry(); - parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi); + parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi, Orientation.OUTWARD); GeometryProperty lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry(); - parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi); + parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi, Orientation.OUTWARD); GeometryProperty lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry(); - parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi); + parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) { @@ -459,13 +543,13 @@ public class Citygml3FeatureMapper extends ObjectWalker { } private void readAbstractTunnel(org.citygml4j.core.model.tunnel.AbstractTunnel gmlTunnel, AbstractTunnel cdTunnel) { - mapAbstractOccupiedSpace(gmlTunnel, cdTunnel); + mapAbstractOccupiedSpace(gmlTunnel, cdTunnel, Orientation.OUTWARD); cdTunnel.setGmlObject(gmlTunnel); // parse deprecated geometries parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdTunnel); parseAndAddMultiSurface(gmlTunnel.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdTunnel); - parseAndAddSolid(gmlTunnel.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdTunnel); + parseAndAddSolid(gmlTunnel.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdTunnel, Orientation.OUTWARD); parseTunnelInstallations(gmlTunnel, cdTunnel); parseHollowSpaces(gmlTunnel, cdTunnel); @@ -540,21 +624,21 @@ public class Citygml3FeatureMapper extends ObjectWalker { // ignore empty properties continue; } - Installation ti = mapTunnelInstallation(gmlTi); + Installation ti = mapTunnelInstallation(gmlTi, Orientation.OUTWARD); cdTunnel.addTunnelInstallation(ti); } } - private Installation mapTunnelInstallation(TunnelInstallation gmlTi) { + private Installation mapTunnelInstallation(TunnelInstallation gmlTi, Orientation orientation) { Installation ti = new Installation(); ti.setGmlObject(gmlTi); - mapAbstractOccupiedSpace(gmlTi, ti); + mapAbstractOccupiedSpace(gmlTi, ti, Orientation.OUTWARD); GeometryProperty lod2Prop = gmlTi.getDeprecatedProperties().getLod2Geometry(); - parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, ti); + parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, ti, orientation); GeometryProperty lod3Prop = gmlTi.getDeprecatedProperties().getLod3Geometry(); - parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, ti); + parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, ti, orientation); GeometryProperty lod4Prop = gmlTi.getDeprecatedProperties().getLod4Geometry(); - parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, ti); + parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, ti, orientation); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); @@ -586,7 +670,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private TunnelHollow mapTunnelHollow(HollowSpace gmlHo) { TunnelHollow tHollow = new TunnelHollow(); tHollow.setGmlObject(gmlHo); - mapAbstractUnoccupiedSpace(gmlHo, tHollow); + mapAbstractUnoccupiedSpace(gmlHo, tHollow, Orientation.INWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlHo.getBoundaries()) { @@ -610,7 +694,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { // ignore empty properties continue; } - Installation bi = mapTunnelInstallation(gmlTi); + Installation bi = mapTunnelInstallation(gmlTi, Orientation.INWARD); tHollow.addRoomInstallation(bi); } for (TunnelFurnitureProperty tfProp : gmlHo.getTunnelFurniture()) { @@ -626,7 +710,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private TunnelFurniture mapTunnelFurniture(org.citygml4j.core.model.tunnel.TunnelFurniture gmlTf) { TunnelFurniture tf = new TunnelFurniture(); tf.setGmlObject(gmlTf); - mapAbstractOccupiedSpace(gmlTf, tf); + mapAbstractOccupiedSpace(gmlTf, tf, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlTf.getBoundaries()) { @@ -650,7 +734,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private TunnelConstructiveElement mapTunnelConstructiveElement( org.citygml4j.core.model.tunnel.TunnelConstructiveElement gmlTe) { TunnelConstructiveElement te = new TunnelConstructiveElement(gmlTe); - mapAbstractOccupiedSpace(gmlTe, te); + mapAbstractOccupiedSpace(gmlTe, te, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlTe.getBoundaries()) { if (!surfaceProp.isSetObject()) { @@ -700,11 +784,11 @@ public class Citygml3FeatureMapper extends ObjectWalker { private void mapAbstractConstructiveElement(org.citygml4j.core.model.bridge.BridgeConstructiveElement ele, BridgeConstructiveElement bce) { - mapAbstractOccupiedSpace(ele, bce); + mapAbstractOccupiedSpace(ele, bce, Orientation.OUTWARD); } private void mapAbstractConstruction(AbstractConstruction ac, BridgeObject bo) { - mapAbstractOccupiedSpace(ac, bo); + mapAbstractOccupiedSpace(ac, bo, Orientation.OUTWARD); } @Override @@ -839,7 +923,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private void mapTrafficSpace(TrafficSpace ts, TrafficSpaceObject tso) { tso.setGmlObject(ts); - mapAbstractUnoccupiedSpace(ts, tso); + mapAbstractUnoccupiedSpace(ts, tso, Orientation.OUTWARD); for (AbstractSpaceBoundaryProperty boundary : ts.getBoundaries()) { if (boundary.isSetObject()) { TrafficArea area = (TrafficArea) boundary.getObject(); @@ -853,7 +937,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private void mapAuxiliaryTrafficSpace(AuxiliaryTrafficSpace ats, TrafficSpaceObject tso) { tso.setGmlObject(ats); - mapAbstractUnoccupiedSpace(ats, tso); + mapAbstractUnoccupiedSpace(ats, tso, Orientation.OUTWARD); for (AbstractSpaceBoundaryProperty boundary : ats.getBoundaries()) { if (boundary.isSetObject()) { AuxiliaryTrafficArea area = (AuxiliaryTrafficArea) boundary.getObject(); @@ -885,8 +969,8 @@ public class Citygml3FeatureMapper extends ObjectWalker { finishCityObjectConstruction(tao); } - private void mapAbstractUnoccupiedSpace(AbstractUnoccupiedSpace aus, CityObject co) { - mapAbstractPhysicalSpace(aus, co); + private void mapAbstractUnoccupiedSpace(AbstractUnoccupiedSpace aus, CityObject co, Orientation orientation) { + mapAbstractPhysicalSpace(aus, co, orientation); } private void parseAbstractTransportationSpaceGeometries(AbstractTransportationSpace space, CityObject co) { @@ -894,16 +978,6 @@ public class Citygml3FeatureMapper extends ObjectWalker { parseAndAddMultiSurface(space.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, co); } - private void parseAbstractSpaceGeometries(AbstractSpace as, CityObject 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); - - } - private void parseAndAddMultiSurface(MultiSurfaceProperty msp, Lod lod, CityObject co) { if (msp == null || msp.getObject() == null) { return; @@ -912,24 +986,24 @@ public class Citygml3FeatureMapper extends ObjectWalker { co.addGeometry(geom); } - private void parseAndAddSolid(SolidProperty sp, Lod lod, CityObject co) { + private void parseAndAddSolid(SolidProperty sp, Lod lod, CityObject co, Orientation orientation) { if (sp == null || sp.getObject() == null) { return; } - Geometry geom = parseSolid(sp.getObject(), lod); + Geometry geom = parseSolid(sp.getObject(), lod, orientation); if (geom != null) { co.addGeometry(geom); } } - private void parseImplicitGeometry(AbstractOccupiedSpace aos, CityObject co) { + private void parseImplicitGeometry(AbstractOccupiedSpace aos, CityObject co, Orientation orientation) { for (int i = 1; i <= 3; i++) { if (aos.getImplicitRepresentation(i) == null) { continue; } if (aos.getImplicitRepresentation(i).getObject() != null) { ImplicitGeometry impGeom = aos.getImplicitRepresentation(i).getObject(); - ImplicitGeometryHolder igh = resolveImplicitGeometry(impGeom, i); + ImplicitGeometryHolder igh = resolveImplicitGeometry(impGeom, i, orientation); if (igh != null) { co.addGeometry(igh); } @@ -943,7 +1017,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { } - private ImplicitGeometryHolder resolveImplicitGeometry(ImplicitGeometry ig, int lodInt) { + private ImplicitGeometryHolder resolveImplicitGeometry(ImplicitGeometry ig, int lodInt, Orientation orientation) { ImplicitGeometryHolder igh = null; if (ig.getLibraryObject() != null) { LibraryObject libObj = null; @@ -967,7 +1041,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { if (aGeom instanceof MultiSurface ms) { geom = parseMultiSurface(ms, lod); } else if (aGeom instanceof Solid s) { - geom = parseSolid(s, lod); + geom = parseSolid(s, lod, orientation); } else if (aGeom instanceof CompositeSurface cs) { geom = parseCompositeSurface(cs, lod); } @@ -1024,13 +1098,14 @@ public class Citygml3FeatureMapper extends ObjectWalker { private void readAbstractBuilding(org.citygml4j.core.model.building.AbstractBuilding gmlAb, AbstractBuilding cdBuilding) { - mapAbstractOccupiedSpace(gmlAb, cdBuilding); + mapAbstractOccupiedSpace(gmlAb, cdBuilding, Orientation.OUTWARD); cdBuilding.setGmlObject(gmlAb); // parse deprecated geometries parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod1MultiSurface(), Lod.LOD1, cdBuilding); parseAndAddMultiSurface(gmlAb.getDeprecatedProperties().getLod4MultiSurface(), Lod.LOD4, cdBuilding); - parseAndAddSolid(gmlAb.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdBuilding); + parseAndAddSolid(gmlAb.getDeprecatedProperties().getLod4Solid(), Lod.LOD4, cdBuilding, Orientation.OUTWARD); + parseBuildingConstructiveElements(gmlAb, cdBuilding); parseBuildingInstallations(gmlAb, cdBuilding); parseBuildingRooms(gmlAb, cdBuilding); parseBuildingSubdivisions(gmlAb, cdBuilding); @@ -1084,6 +1159,19 @@ public class Citygml3FeatureMapper extends ObjectWalker { } } + private void parseBuildingConstructiveElements(org.citygml4j.core.model.building.AbstractBuilding gmlAb, AbstractBuilding cdBuilding) { + for (BuildingConstructiveElementProperty bceProp : gmlAb.getBuildingConstructiveElements()) { + var gmlBCE = bceProp.getObject(); + if (gmlBCE == null) { + continue; + } + de.hft.stuttgart.citydoctor2.datastructure.BuildingConstructiveElement bce = + new de.hft.stuttgart.citydoctor2.datastructure.BuildingConstructiveElement(gmlBCE); + mapBuildingConstructiveElement(bce, gmlBCE); + cdBuilding.addConstructiveElement(bce); + } + } + private void parseBuildingRooms(org.citygml4j.core.model.building.AbstractBuilding gmlAb, AbstractBuilding cdBuilding) { for (BuildingRoomProperty brProp : gmlAb.getBuildingRooms()) { var gmlBr = brProp.getObject(); @@ -1120,7 +1208,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { BuildingRoom br = new BuildingRoom(); br.setGmlObject(gmlBr); - mapAbstractUnoccupiedSpace(gmlBr, br); + mapAbstractUnoccupiedSpace(gmlBr, br, Orientation.INWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlBr.getBoundaries()) { @@ -1161,7 +1249,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private BuildingRoomFurniture mapBuildingFurniture(BuildingFurniture gmlAF) { BuildingRoomFurniture bf = new BuildingRoomFurniture(); bf.setGmlObject(gmlAF); - mapAbstractOccupiedSpace(gmlAF, bf); + mapAbstractOccupiedSpace(gmlAF, bf, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlAF.getBoundaries()) { if (!surfaceProp.isSetObject()) { @@ -1182,10 +1270,25 @@ public class Citygml3FeatureMapper extends ObjectWalker { } + private void mapBuildingConstructiveElement(de.hft.stuttgart.citydoctor2.datastructure.BuildingConstructiveElement bce, BuildingConstructiveElement ele) { + mapAbstractOccupiedSpace(ele, bce, Orientation.OUTWARD); + SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); + for (AbstractSpaceBoundaryProperty surfaceProp : ele.getBoundaries()) { + if (!surfaceProp.isSetObject()) { + continue; + } + AbstractSpaceBoundary surface = surfaceProp.getObject(); + surface.accept(surfaceMapper); + } + for (BoundarySurface bs : surfaceMapper.getSurfaces()) { + bce.addBoundarySurface(bs); + } + } + 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); + mapAbstractSpace(gmlStorey, storey, Orientation.INWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlStorey.getBoundaries()) { if (!surfaceProp.isSetObject()) { @@ -1208,7 +1311,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { private de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit mapBuildingUnit(BuildingUnit gmlBU) { de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit bu = new de.hft.stuttgart.citydoctor2.datastructure.BuildingUnit(); bu.setGmlObject(gmlBU); - mapAbstractSpace(gmlBU, bu); + mapAbstractSpace(gmlBU, bu, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlBU.getBoundaries()) { if (!surfaceProp.isSetObject()) { @@ -1242,13 +1345,13 @@ public class Citygml3FeatureMapper extends ObjectWalker { private Installation mapBuildingInstallation(org.citygml4j.core.model.building.BuildingInstallation gmlBi) { Installation bi = new Installation(); bi.setGmlObject(gmlBi); - mapAbstractOccupiedSpace(gmlBi, bi); + mapAbstractOccupiedSpace(gmlBi, bi, Orientation.OUTWARD); GeometryProperty lod2Prop = gmlBi.getDeprecatedProperties().getLod2Geometry(); - parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi); + parseAndAddAbstractGeometry(lod2Prop, Lod.LOD2, bi, Orientation.OUTWARD); GeometryProperty lod3Prop = gmlBi.getDeprecatedProperties().getLod3Geometry(); - parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi); + parseAndAddAbstractGeometry(lod3Prop, Lod.LOD3, bi, Orientation.OUTWARD); GeometryProperty lod4Prop = gmlBi.getDeprecatedProperties().getLod4Geometry(); - parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi); + parseAndAddAbstractGeometry(lod4Prop, Lod.LOD4, bi, Orientation.OUTWARD); SurfaceMapper surfaceMapper = new SurfaceMapper(polygonMap, references, compositeMap, vertexMap, config); for (AbstractSpaceBoundaryProperty surfaceProp : gmlBi.getBoundaries()) { @@ -1276,7 +1379,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { return bi; } - private void parseAndAddAbstractGeometry(GeometryProperty geomProp, Lod lod, CityObject co) { + private void parseAndAddAbstractGeometry(GeometryProperty geomProp, Lod lod, CityObject co, Orientation orientation) { if (geomProp == null || geomProp.getObject() == null) { return; } @@ -1285,7 +1388,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { Geometry geom = parseMultiSurface(ms, lod); co.addGeometry(geom); } else if (abstractGeometry instanceof Solid solid) { - Geometry geom = parseSolid(solid, lod); + Geometry geom = parseSolid(solid, lod, orientation); if (geom != null) { co.addGeometry(geom); } @@ -1294,9 +1397,9 @@ public class Citygml3FeatureMapper extends ObjectWalker { } } - private Geometry parseSolid(AbstractSolid abstractSolid, Lod lod) { + private Geometry parseSolid(AbstractSolid abstractSolid, Lod lod, Orientation orientation) { if (abstractSolid instanceof Solid s) { - return handleSolidGeometry(s, lod); + return handleSolidGeometry(s, lod, orientation); } else { logger.warn("Cannot handle solid class {}, can only process pure solids", abstractSolid.getClass().getSimpleName()); @@ -1304,13 +1407,13 @@ public class Citygml3FeatureMapper extends ObjectWalker { } } - private Geometry handleSolidGeometry(Solid solid, Lod lod) { + private Geometry handleSolidGeometry(Solid solid, Lod lod, Orientation orientation) { ShellProperty exteriorProperty = solid.getExterior(); if (exteriorProperty == null || exteriorProperty.getObject() == null) { logger.warn("Found solid {} without exterior hull, ignoring", solid.getId()); return null; } - Geometry geom = new Geometry(GeometryType.SOLID, lod); + Geometry geom = new Geometry(GeometryType.SOLID, lod, orientation); Shell exterior = solid.getExterior().getObject(); Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap); readSurfaceMember(geom, geometryMapper, exterior.getSurfaceMembers()); @@ -1318,7 +1421,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { } private Geometry parseMultiSurface(MultiSurface ms, Lod lod) { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod, null); Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap); readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember()); return geom; @@ -1348,7 +1451,7 @@ public class Citygml3FeatureMapper extends ObjectWalker { } private Geometry parseCompositeSurface(CompositeSurface cs, Lod lod) { - Geometry geom = new Geometry(GeometryType.COMPOSITE_SURFACE, lod); + Geometry geom = new Geometry(GeometryType.COMPOSITE_SURFACE, lod, null); Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap); readSurfaceMember(geom, geometryMapper, cs.getSurfaceMembers()); return geom; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3GeometryMapper.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3GeometryMapper.java index 7b08ba8c40e566388c920054ea0f21e83dd31bec..8722c2250a4392ff7017c54fafbe0f12a9d76897 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3GeometryMapper.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/Citygml3GeometryMapper.java @@ -111,7 +111,6 @@ public class Citygml3GeometryMapper extends GeometryWalker { conc.addInteriorRing(currentRing); } collection.addPatchMember(conc); - polygons.add(conc); } private void parsePolygon(String id, AbstractRingProperty exterior, List interior) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/SurfaceMapper.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/SurfaceMapper.java index bbad97e13c0242e626fa7671ace2dd77098e70e2..c8e8495283789b7a046d17517687595816dda05f 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/SurfaceMapper.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/mapper/citygml3/SurfaceMapper.java @@ -107,7 +107,7 @@ public class SurfaceMapper extends ObjectWalker { } private Geometry parseMultiSurface(MultiSurface ms, Lod lod) { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, lod, null); Citygml3GeometryMapper geometryMapper = new Citygml3GeometryMapper(config, vertexMap); readSurfaceMember(geom, geometryMapper, ms.getSurfaceMember()); return geom; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlConsumer.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlConsumer.java index c824423c9bb9cce034c2a89e2484d9983c3f33d1..0400e60d84b3b4442c08de564d36b839bd8f8c30 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlConsumer.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlConsumer.java @@ -32,4 +32,6 @@ public interface CityGmlConsumer { } +// public void endOfFile(); + } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlParser.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlParser.java index a01ae6bdda5ed1a63e62f8ee1c10d4391178b194..06d42a00208f77a9d5cd43bb017d77dd3c9b02e6 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlParser.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/parser/CityGmlParser.java @@ -18,26 +18,42 @@ */ package de.hft.stuttgart.citydoctor2.parser; -import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel; -import de.hft.stuttgart.citydoctor2.datastructure.CityObject; -import de.hft.stuttgart.citydoctor2.mapper.citygml3.Citygml3FeatureMapper; -import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler; -import de.hft.stuttgart.citydoctor2.math.Vector3d; -import de.hft.stuttgart.citydoctor2.utils.Localization; -import de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntry; -import de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntryFile; -import de.hft.stuttgart.quality.QualityADEContext; -import de.hft.stuttgart.quality.QualityADEModule; +import java.io.BufferedInputStream; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.xml.XMLConstants; +import javax.xml.namespace.QName; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; +import javax.xml.transform.Source; +import javax.xml.transform.stream.StreamSource; +import javax.xml.validation.Schema; +import javax.xml.validation.SchemaFactory; +import javax.xml.validation.Validator; + import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.citygml4j.core.ade.ADEException; import org.citygml4j.core.ade.ADERegistry; import org.citygml4j.core.model.CityGMLVersion; -import org.citygml4j.core.model.ade.ADEProperty; import org.citygml4j.core.model.core.AbstractCityObject; import org.citygml4j.core.model.core.AbstractCityObjectProperty; import org.citygml4j.core.model.core.AbstractFeature; +import org.citygml4j.core.model.core.AbstractFeatureProperty; import org.citygml4j.core.model.core.CityModel; import org.citygml4j.core.util.CityGMLConstants; import org.citygml4j.xml.CityGMLContext; @@ -68,30 +84,16 @@ import org.xmlobjects.schema.SchemaHandlerException; import org.xmlobjects.stream.XMLReader; import org.xmlobjects.stream.XMLReaderFactory; -import javax.xml.XMLConstants; -import javax.xml.namespace.QName; -import javax.xml.parsers.ParserConfigurationException; -import javax.xml.parsers.SAXParser; -import javax.xml.parsers.SAXParserFactory; -import javax.xml.transform.Source; -import javax.xml.transform.stream.StreamSource; -import javax.xml.validation.Schema; -import javax.xml.validation.SchemaFactory; -import javax.xml.validation.Validator; -import java.io.BufferedInputStream; -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.nio.charset.StandardCharsets; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel; +import de.hft.stuttgart.citydoctor2.datastructure.CityObject; +import de.hft.stuttgart.citydoctor2.mapper.citygml3.Citygml3FeatureMapper; +import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler; +import de.hft.stuttgart.citydoctor2.math.Vector3d; +import de.hft.stuttgart.citydoctor2.utils.Localization; +import de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntry; +import de.hft.stuttgart.citydoctor2.zip.CityGmlZipEntryFile; +import de.hft.stuttgart.quality.QualityADEContext; +import de.hft.stuttgart.quality.QualityADEModule; /** * Utility class to parse CityGML files. @@ -430,6 +432,7 @@ public class CityGmlParser { writer.writeMember(chunk); } } + // end of stream logger.debug("End of gml file stream"); } catch (CityGMLReadException e) { @@ -447,11 +450,11 @@ public class CityGmlParser { } } - private static void writeCityModel(CityGMLChunkWriter writer, CityModel cModel) { + private static void writeCityModel(CityGMLChunkWriter writer, CityModel cModel) throws CityGMLWriteException { if (writer != null) { - for (ADEProperty genEle : cModel.getADEProperties()) { - writer.getCityModelInfo().addADEProperty(genEle); - } + for (AbstractFeatureProperty featureProp : cModel.getFeatureMembers()) { + writer.writeMember(featureProp.getObject()); + } } } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CheckErrorFound.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CheckErrorFound.java index cd7d13cd2dec0f357eb8b2f5946c532ef8a34279..602373e804d17cac3fd37a0bb85b700e44315625 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CheckErrorFound.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/CheckErrorFound.java @@ -1,12 +1,16 @@ package de.hft.stuttgart.citydoctor2.utils; +import java.io.Serial; + /** * This Throwable signals that a requested CheckError was found. */ public class CheckErrorFound extends Throwable { + @Serial + private static final long serialVersionUID = -2066876428396230230L; - public CheckErrorFound() { + public CheckErrorFound() { super("CheckError was found", null, true, false); } } diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CheckableErrorCollector.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CheckableErrorCollector.java index d6af6749a758392eef1b2b288dc930aeb391488e..1f6c05c3679d1126c7cb8b116b094e275445b203 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CheckableErrorCollector.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CheckableErrorCollector.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.Checkable; @@ -9,7 +9,7 @@ import java.util.List; /** * This Visitor collects all CheckErrors in the datastructure of a checkable. */ -public class CheckableErrorCollector extends AbstractCheck { +public class CheckableErrorCollector extends CheckableUtilsVisitor { List errors; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CityObjectCollector.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CityObjectCollector.java index 31948813b2bc3eaed43c26d43af59814a7fca384..a504462fb09872da554cd0b134e6ae21f19ca0ad 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CityObjectCollector.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/CityObjectCollector.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.datastructure.CityObject; import java.util.HashSet; @@ -9,7 +9,7 @@ import java.util.Set; /** * This Visitor collects all sub-CityObjects that are in the datastructure of a CityObject (including itself) in a Set. */ -public class CityObjectCollector extends AbstractCheck { +public class CityObjectCollector extends CheckableUtilsVisitor { private final Set objects = new HashSet<>(); diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearMetaInformationVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearMetaInformationVisitor.java index b08ed1368c041f91fcd5030cdca79e919b9a9cd0..42449d742c6a805b518ea0691289678533ad3a28 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearMetaInformationVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearMetaInformationVisitor.java @@ -1,12 +1,12 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.datastructure.Geometry; /** * This Visitor removes the metadata created by the {@link PrepareForCheckingVisitor} for the low-memory consumption mode. */ -public class ClearMetaInformationVisitor extends AbstractCheck { +public class ClearMetaInformationVisitor extends CheckableUtilsVisitor { @Override public void check(Geometry geometry) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearCheckResultsVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearVisitorResultsVisitor.java similarity index 70% rename from CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearCheckResultsVisitor.java rename to CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearVisitorResultsVisitor.java index 18019a708e3404d22b1ca5377fb2831e1801891f..15436a7ea731ce461b70449795359e3314baebea 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearCheckResultsVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ClearVisitorResultsVisitor.java @@ -1,12 +1,12 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.Checkable; /** * This Visitor removes the check results from a CityObject and the objects in its datastructure. */ -public class ClearCheckResultsVisitor extends AbstractCheck { +public class ClearVisitorResultsVisitor extends CheckableUtilsVisitor { @Override public void check(Checkable checkable) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsAnyErrorVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsAnyErrorVisitor.java index 02a9a5b28fdd1a4659438190f273b574d3814cdb..5dd9cf0196e3e146e01499ea0c91e02c0c558652 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsAnyErrorVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsAnyErrorVisitor.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.Checkable; import de.hft.stuttgart.citydoctor2.utils.CheckErrorFound; import de.hft.stuttgart.citydoctor2.utils.ThrowUtils; @@ -11,7 +11,7 @@ import de.hft.stuttgart.citydoctor2.utils.ThrowUtils; * This visitor's check method terminates early by throwing an unchecked {@link CheckErrorFound}, * use {@link #checkObject(Checkable) ContainsAnyErrorVisitor.checkObject(Checkable)} to handle the Throwable. */ -public class ContainsAnyErrorVisitor extends AbstractCheck { +public class ContainsAnyErrorVisitor extends CheckableUtilsVisitor { /** * Checks if a Checkable, or any Object in its datastructure, contains any error. diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsErrorVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsErrorVisitor.java index 9ddc69c5a4783d3eb27f0b8cfcf7feb2cba228aa..e4e4ee7fce29d245237960db51a543681f986032 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsErrorVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/ContainsErrorVisitor.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.Checkable; import de.hft.stuttgart.citydoctor2.utils.CheckErrorFound; @@ -12,7 +12,7 @@ import de.hft.stuttgart.citydoctor2.utils.ThrowUtils; * This visitor's check method terminates early by throwing an unchecked {@link CheckErrorFound}, * use {@link #checkObject(Checkable, CheckId) ContainsAnyErrorVisitor.checkObject(Checkable, CheckId)} to handle the Throwable. */ -public class ContainsErrorVisitor extends AbstractCheck { +public class ContainsErrorVisitor extends CheckableUtilsVisitor { private CheckId checkId; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java index cd74226b236c7224c547dd94dab356d286d86c3a..fb199eacf09c040e3dbf009108906805403ca6f5 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.datastructure.CityObject; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import org.citygml4j.core.util.geometry.GeometryFactory; @@ -11,7 +11,7 @@ import java.util.Objects; * This Visitor recreates the Geometries of the original CityGml object from the associated Geometries in CityDoctor's * internal model. */ -public class GmlGeometryRebuilder extends AbstractCheck { +public class GmlGeometryRebuilder extends CheckableUtilsVisitor { private final GeometryFactory factory; private final ParserConfiguration config; diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/PrepareForCheckingVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/PrepareForCheckingVisitor.java index 3388da78df300fb146387d2f6155c99ea89247f4..8cc4d2e4803548b6717789799a3199ca31b110ff 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/PrepareForCheckingVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/PrepareForCheckingVisitor.java @@ -1,12 +1,12 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.datastructure.Geometry; /** * This Visitor prepares the {@link Geometry Geometries} in a Checkable for low-memory consumption mode. */ -public class PrepareForCheckingVisitor extends AbstractCheck { +public class PrepareForCheckingVisitor extends CheckableUtilsVisitor { @Override public void check(Geometry geom) { diff --git a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/UnsetGeometriesVisitor.java b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/UnsetGeometriesVisitor.java index d24948d605f0d4c5bec6b24802309d4cbf3fa119..4c65708ac76ad75a2db605864fcf7e21bf79bc04 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/UnsetGeometriesVisitor.java +++ b/CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/UnsetGeometriesVisitor.java @@ -1,13 +1,13 @@ package de.hft.stuttgart.citydoctor2.utils.visitors; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.datastructure.CityObject; /** * This Visitor removes the GmlGeometries from the linked original GmlObjects in a CityObject's datastructure to reduce * memory bloat. */ -public class UnsetGeometriesVisitor extends AbstractCheck { +public class UnsetGeometriesVisitor extends CheckableUtilsVisitor { @Override diff --git a/CityDoctorParent/CityDoctorModel/src/main/resources/log4j2.xml b/CityDoctorParent/CityDoctorModel/src/main/resources/log4j2.xml index 824c970ea59ec6330aec704410ff00c70fe085a6..4e951d6be8c184c776c0a02290cc32671d09c3de 100644 --- a/CityDoctorParent/CityDoctorModel/src/main/resources/log4j2.xml +++ b/CityDoctorParent/CityDoctorModel/src/main/resources/log4j2.xml @@ -11,5 +11,8 @@ + + + \ No newline at end of file diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/CheckableTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/CheckableTest.java index 715bec55df6140a934ef46ccd3c645217f0eb243..c247a1a506012e36d478b20faf761275214f6f8f 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/CheckableTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/CheckableTest.java @@ -31,6 +31,7 @@ import org.junit.Test; import de.hft.stuttgart.citydoctor2.check.error.SchematronError; import de.hft.stuttgart.citydoctor2.datastructure.Building; import de.hft.stuttgart.citydoctor2.datastructure.Geometry; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; @@ -90,7 +91,7 @@ public class CheckableTest { @Test public void testContainsError() { Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); b.addGeometry(geom); assertFalse(b.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); assertFalse(b.containsAnyError()); @@ -148,7 +149,7 @@ public class CheckableTest { @Test public void testCollectAllContainedErrors() { Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); b.addGeometry(geom); b.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, new SchematronError(null, null, null, null))); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationErrorTest.java index ed1947234d96e61fb432d68c8f5e31f02709802a..43b491b3d6dcb94d9abe6fceb308696539ab6e88 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationErrorTest.java @@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.types.AbstractError; import de.hft.stuttgart.quality.model.types.AllPolygonsOrientedWrongError; @@ -39,7 +40,7 @@ public class AllPolygonsWrongOrientationErrorTest { @Test public void testAddToValidationResult() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId gmlId = new GmlId("testId"); geom.setGmlId(gmlId); AllPolygonsWrongOrientationError err = new AllPolygonsWrongOrientationError(geom); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsErrorTest.java index 10da9e457f838298a7188cd93074efd2dc7315e4..80d1bb9395ff2c2aff9bb39c25565e0f39c35885 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsErrorTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.properties.PolygonIdListProperty; import de.hft.stuttgart.quality.model.types.AbstractError; @@ -44,7 +45,7 @@ public class MultipleConnectedComponentsErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); Polygon p1 = new ConcretePolygon(); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeErrorTest.java index 57cdf42a53566fbfe1421b6e8bcdc46b4a9198da..ba10ccbd4b8215e51fcdf57c536f0588fef8f23b 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeErrorTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.properties.EdgeProperty; import de.hft.stuttgart.quality.model.types.AbstractError; @@ -42,7 +43,7 @@ public class NonManifoldEdgeErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexErrorTest.java index 5c38a3640f8b3e4b72c790e2b3b0dc1ded88b8cf..6c11d1027f34ddc13cb2ac672b1606194a940add 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexErrorTest.java @@ -34,6 +34,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.types.AbstractError; import de.hft.stuttgart.quality.model.types.ValidationResult; @@ -42,7 +43,7 @@ public class NonManifoldVertexErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); Polygon p1 = new ConcretePolygon(); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationErrorTest.java index 9da1e3ac58029565c5330298089aeb8e89f5055b..fdfb77aa0a9b363f5b2dd2bfcea520f16963947f 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationErrorTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.properties.EdgeProperty; import de.hft.stuttgart.quality.model.types.AbstractError; @@ -42,7 +43,7 @@ public class PolygonWrongOrientationErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedErrorTest.java index 0b35cfdee141972164b45f27cb4ec52dd15294b9..4bbaf9fabe40bf5b589d9d406b0a0c61a850b189 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedErrorTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.properties.EdgeProperty; import de.hft.stuttgart.quality.model.types.AbstractError; @@ -42,7 +43,7 @@ public class SolidNotClosedErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntErrorTest.java index 13af8edc92bd63a540170916147282adca7709d5..1e880dae112a95cb54a1837e161194ba5c3eb285 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntErrorTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.utils.PolygonIntersection; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.types.AbstractError; @@ -43,7 +44,7 @@ public class SolidSelfIntErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); Polygon p1 = new ConcretePolygon(); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsErrorTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsErrorTest.java index 2ad7a7d68100f8abc8b6ea8830d62d20ae23be05..d3edd85cca99b3ff5d9b3fbb30b3f722a2e4b684 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsErrorTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsErrorTest.java @@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.GmlId; import de.hft.stuttgart.citydoctor2.datastructure.Lod; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty; import de.hft.stuttgart.quality.model.types.AbstractError; import de.hft.stuttgart.quality.model.types.SolidTooFewPolygonsError; @@ -39,7 +40,7 @@ public class TooFewPolygonsErrorTest { @Test public void testConvertToQualityAdeDatastructure() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); GmlId geomId = new GmlId("geomId"); geom.setGmlId(geomId); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java index 0c8e436c0ec16c760bc761a54f02b0fb57d36fde..e0cf17f401bbd06eab2b60104016a88afb399be2 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java @@ -24,7 +24,6 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -32,9 +31,7 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; -import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor; import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder; -import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; import org.citygml4j.core.model.construction.WallSurface; import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty; import org.citygml4j.core.util.geometry.GeometryFactory; @@ -43,7 +40,7 @@ import org.mockito.Mockito; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; import org.xmlobjects.gml.model.geometry.primitives.SolidProperty; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -62,7 +59,7 @@ public class AbstractBuildingTest { AtomicInteger abCounter = new AtomicInteger(0); AtomicInteger bsCounter = new AtomicInteger(0); AtomicInteger biCounter = new AtomicInteger(0); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(AbstractBuilding ab) { @@ -79,7 +76,7 @@ public class AbstractBuildingTest { assertEquals(1, bsCounter.intValue()); assertEquals(0, biCounter.intValue()); - AbstractCheck c2 = new AbstractCheck() { + CheckableUtilsVisitor c2 = new CheckableUtilsVisitor() { @Override public void check(Installation bi) { @@ -95,6 +92,7 @@ public class AbstractBuildingTest { AbstractBuilding ab = createAbstractBuilding(); BuildingRoom mockRoom = mock(BuildingRoom.class); Installation mockInstallation = mock(Installation.class); + BuildingConstructiveElement mockConstructiveElement = mock(BuildingConstructiveElement.class); BuildingRoomFurniture mockBuildingRoomFurniture = mock(BuildingRoomFurniture.class); BuildingUnit mockBuildingUnit = mock(BuildingUnit.class); Storey mockStorey = mock(Storey.class); @@ -103,18 +101,20 @@ public class AbstractBuildingTest { ab.addBuildingRoom(mockRoom); ab.addBuildingInstallation(mockInstallation); + ab.addConstructiveElement(mockConstructiveElement); ab.addBuildingRoomFurniture(mockBuildingRoomFurniture); ab.addBuildingUnit(mockBuildingUnit); ab.addStorey(mockStorey); ab.addBoundarySurface(mockBSurface); ab.addGeometry(mockGeometry); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; ab.accept(c); verify(mockRoom).accept(c); verify(mockInstallation).accept(c); + verify(mockConstructiveElement).accept(c); verify(mockBuildingRoomFurniture).accept(c); verify(mockBuildingUnit).accept(c); verify(mockStorey).accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoomTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoomTest.java index 5f57517990b8e7c32b7058537e26f7e0d0a9436c..dcab6ed3c68faade8e20f40d91620cd056f476ca 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoomTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoomTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -50,7 +50,7 @@ public class AbstractRoomTest { abRoom.addBoundarySurface(mockBoundarySurface); abRoom.addGeometry(geometry); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; abRoom.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnelTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnelTest.java index ee3f289a6d0146777404dbbf2c883f73de947933..4deedb3685f55268f34756eee71f1ff82d0b020f 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnelTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnelTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -52,7 +52,7 @@ public class AbstractTunnelTest { at.addBoundarySurface(mockBoundarySurface); at.addGeometry(mockGeometry); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; at.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java index 458739aceb847430e8251d4f68d508d1bde9e0a7..1275cc857af29974dfcd4e6a959f63b7c3297f82 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java @@ -30,7 +30,7 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; -import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor; +import de.hft.stuttgart.citydoctor2.utils.visitors.ClearVisitorResultsVisitor; import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder; import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; import org.citygml4j.core.model.construction.AbstractConstructionSurface; @@ -41,11 +41,12 @@ import org.junit.Test; import org.mockito.Mockito; import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; import de.hft.stuttgart.citydoctor2.check.ResultStatus; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; public class BoundarySurfaceTest { @@ -58,7 +59,7 @@ public class BoundarySurfaceTest { Opening oMock = Mockito.mock(Opening.class); bs.addOpening(oMock); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; bs.accept(c); @@ -71,7 +72,7 @@ public class BoundarySurfaceTest { Opening oMock = Mockito.mock(Opening.class); bs.addOpening(oMock); AtomicInteger bsCounter = new AtomicInteger(0); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(BoundarySurface bs) { @@ -89,7 +90,7 @@ public class BoundarySurfaceTest { Opening oMock = Mockito.mock(Opening.class); bs.addOpening(oMock); AtomicInteger bsCounter = new AtomicInteger(0); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(BridgeObject bo) { @@ -104,7 +105,7 @@ public class BoundarySurfaceTest { @Test public void testPrepareForChecking() { BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); Geometry spyGeom = Mockito.spy(geom); bs.addGeometry(spyGeom); bs.prepareForChecking(); @@ -142,7 +143,7 @@ public class BoundarySurfaceTest { assertFalse(bs.getAllCheckResults().isEmpty()); bs.addOpening(oMock); bs.clearAllContainedCheckResults(); - verify(oMock).accept(any(ClearCheckResultsVisitor.class)); + verify(oMock).accept(any(ClearVisitorResultsVisitor.class)); assertTrue(bs.getAllCheckResults().isEmpty()); } diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObjectTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObjectTest.java index d8e23400532ed5969f96628e190560d0523129c2..d185d272673832131bfd175d24d84cb43161a643 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObjectTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObjectTest.java @@ -32,21 +32,22 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; -import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; import org.citygml4j.core.model.bridge.AbstractBridge; import org.citygml4j.core.model.deprecated.bridge.DeprecatedPropertiesOfAbstractBridge; import org.citygml4j.core.util.geometry.GeometryFactory; import org.citygml4j.core.visitor.ObjectVisitor; import org.junit.Test; +import org.mockito.Mockito; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.ResultStatus; import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject.BridgeType; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; -import org.mockito.Mockito; +import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; public class BridgeObjectTest { @@ -58,7 +59,7 @@ public class BridgeObjectTest { bo.addBoundarySurface(new BoundarySurface(null)); AtomicInteger boCounter = new AtomicInteger(0); AtomicInteger bsCounter = new AtomicInteger(0); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(BridgeObject bo) { @@ -75,7 +76,7 @@ public class BridgeObjectTest { assertEquals(1, bsCounter.intValue()); AtomicInteger boCounter2 = new AtomicInteger(0); - c = new AbstractCheck() { + c = new CheckableUtilsVisitor() { }; bo.accept(c); assertEquals(0, boCounter2.intValue()); @@ -101,7 +102,7 @@ public class BridgeObjectTest { bo.addBoundarySurface(bsMock); bo.addGeometry(geomMock); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; bo.accept(c); @@ -117,7 +118,7 @@ public class BridgeObjectTest { @Test public void testPrepareForChecking() { BridgeObject bo = new BridgeObject(mock(AbstractBridge.class)); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); Geometry spyGeom = Mockito.spy(geom); bo.addGeometry(spyGeom); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingTest.java index 458556544609cc00fdb4686df6baddd47b69a0d7..a27eee4343fe5532d21b52b972e779275295417b 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingTest.java @@ -26,12 +26,13 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import org.citygml4j.core.model.construction.RoofSurface; import org.junit.Test; import org.mockito.Mockito; import org.xmlobjects.gml.model.basictypes.Code; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.utils.Copy; @@ -55,7 +56,7 @@ public class BuildingTest { lr.addVertex(v1); lr.addVertex(v2); lr.addVertex(v1); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); geom.addPolygon(p); geom.updateEdgesAndVertices(); b.addGeometry(geom); @@ -64,7 +65,7 @@ public class BuildingTest { RoofSurface rs = new RoofSurface(); rs.setId("testRoof"); BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.ROOF, rs); - Geometry geomSurface = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geomSurface = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geomSurface.addPolygon(new LinkedPolygon(p, geomSurface)); geomSurface.updateEdgesAndVertices(); surface.addGeometry(geomSurface); @@ -151,7 +152,7 @@ public class BuildingTest { bp.addStorey(mockStorey); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; b.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/CityObjectTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/CityObjectTest.java index e0d7dae4b27ef39ea6a8ff9dc327e6aa3df9e1b8..f09849abd3528aba70bb7516cfe5aa1ff078634a 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/CityObjectTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/CityObjectTest.java @@ -1,26 +1,31 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import java.util.ArrayList; +import java.util.List; + +import org.citygml4j.core.model.core.AbstractCityObject; +import org.citygml4j.core.util.geometry.GeometryFactory; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; + import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.ResultStatus; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder; import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor; -import org.citygml4j.core.model.core.AbstractCityObject; -import org.citygml4j.core.util.geometry.GeometryFactory; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mockito; - -import java.util.ArrayList; -import java.util.List; - -import static org.junit.Assert.*; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; public class CityObjectTest { @@ -31,7 +36,7 @@ public class CityObjectTest { Geometry mockGeometry = mock(Geometry.class); co.addGeometry(mockGeometry); - AbstractCheck check = new AbstractCheck() { + CheckableUtilsVisitor check = new CheckableUtilsVisitor() { }; co.accept(check); @@ -101,10 +106,10 @@ public class CityObjectTest { @Test public void testGetHighestLodGeometry() { - Geometry geometryLod1 = new Geometry(GeometryType.SOLID, Lod.LOD1); - Geometry geometryLod2 = new Geometry(GeometryType.SOLID, Lod.LOD2); - Geometry geometryLod3 = new Geometry(GeometryType.SOLID, Lod.LOD3); - Geometry geometryLod4 = new Geometry(GeometryType.SOLID, Lod.LOD4); + Geometry geometryLod1 = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); + Geometry geometryLod2 = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); + Geometry geometryLod3 = new Geometry(GeometryType.SOLID, Lod.LOD3, Orientation.OUTWARD); + Geometry geometryLod4 = new Geometry(GeometryType.SOLID, Lod.LOD4, Orientation.OUTWARD); assertNull(co.getHighestLodGeometry()); co.addGeometry(geometryLod1); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObjectTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObjectTest.java index 00aab2b1d32e8c11ddc9d531a26d153c5865b373..bca67f1c3018651b117ebf3005120a5ade8f26b1 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObjectTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObjectTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -30,7 +30,7 @@ public class GenericCityObjectTest { gco.addBoundarySurface(mockSurface); gco.addGeometry(mockGeometry); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; gco.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTest.java index dde2b7df269065fe4b061a234367965cca175434..a37077ae28fbca4d79961e9bb2a5141afabdbe79 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTest.java @@ -32,8 +32,8 @@ import static org.mockito.Mockito.when; import java.util.ArrayList; import java.util.List; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; -import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; +import de.hft.stuttgart.citydoctor2.utils.visitors.ClearVisitorResultsVisitor; import org.citygml4j.core.model.construction.AbstractConstructionSurface; import org.citygml4j.core.model.construction.WallSurface; import org.citygml4j.core.util.geometry.GeometryFactory; @@ -44,6 +44,7 @@ import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; import de.hft.stuttgart.citydoctor2.check.ResultStatus; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; @@ -58,12 +59,12 @@ public class GeometryTest { @Test public void testVisitorPropagation() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); ConcretePolygon mockPolygon = mock(ConcretePolygon.class); geom.addPolygon(mockPolygon); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; geom.accept(c); @@ -72,7 +73,7 @@ public class GeometryTest { @Test public void testCreate() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); assertNotNull(geom); assertSame(GeometryType.SOLID, geom.getType()); @@ -81,7 +82,7 @@ public class GeometryTest { @Test public void testAddPolygon() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -99,7 +100,7 @@ public class GeometryTest { var gmlBi = new org.citygml4j.core.model.building.BuildingInstallation(); Installation bi = new Installation(); bi.setGmlObject(gmlBi); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); ConcretePolygon p = new ConcretePolygon(); LinearRing lr = new LinearRing(LinearRingType.EXTERIOR); @@ -112,7 +113,7 @@ public class GeometryTest { bs.addGeometry(geom); - Geometry biGeom = new Geometry(GeometryType.COMPOSITE_SURFACE, Lod.LOD2); + Geometry biGeom = new Geometry(GeometryType.COMPOSITE_SURFACE, Lod.LOD2, Orientation.OUTWARD); biGeom.addPolygon(new LinkedPolygon(p, biGeom)); bi.addGeometry(biGeom); @@ -133,7 +134,7 @@ public class GeometryTest { ParserConfiguration config = new ParserConfiguration(4, false); AbstractConstructionSurface abs = new WallSurface(); BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, abs); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); ConcretePolygon p = new ConcretePolygon(); LinearRing lr = new LinearRing(LinearRingType.EXTERIOR); @@ -159,7 +160,7 @@ public class GeometryTest { var gmlBi = new org.citygml4j.core.model.building.BuildingInstallation(); Installation bi = new Installation(); bi.setGmlObject(gmlBi); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); ConcretePolygon p = new ConcretePolygon(); LinearRing lr = new LinearRing(LinearRingType.EXTERIOR); @@ -171,7 +172,7 @@ public class GeometryTest { p.setPartOfSurface(bs); p.setPartOfInstallation(bi); - Geometry biGeom = new Geometry(GeometryType.COMPOSITE_SURFACE, Lod.LOD2); + Geometry biGeom = new Geometry(GeometryType.COMPOSITE_SURFACE, Lod.LOD2, Orientation.OUTWARD); LinkedPolygon linkedPolygon = new LinkedPolygon(p, biGeom); biGeom.addPolygon(linkedPolygon); bi.addGeometry(biGeom); @@ -197,7 +198,7 @@ public class GeometryTest { Installation bi = new Installation(); bi.setGmlObject(gmlBi); bi.addBoundarySurface(bs); - Geometry geom2 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom2 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); ConcretePolygon p = new ConcretePolygon(); geom2.addPolygon(p); LinearRing lr = new LinearRing(LinearRingType.EXTERIOR); @@ -210,7 +211,7 @@ public class GeometryTest { p.setPartOfInstallation(bi); bs.addGeometry(geom2); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); Polygon linkedPoly = new LinkedPolygon(p, geom); geom.addPolygon(linkedPoly); @@ -241,7 +242,7 @@ public class GeometryTest { @Test public void testSetParent() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); CityObject co = mock(CityObject.class); geom.setParent(co); assertEquals(co, geom.getParent()); @@ -262,7 +263,7 @@ public class GeometryTest { @Test public void testSetType() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geom.setType(GeometryType.SOLID); assertEquals(GeometryType.SOLID, geom.getType()); } @@ -278,7 +279,7 @@ public class GeometryTest { @Test public void testContainsError() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); @@ -293,20 +294,20 @@ public class GeometryTest { @Test public void testClearAllContainedCheckResults() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); Polygon p = mock(Polygon.class); geom.addPolygon(p); geom.clearAllContainedCheckResults(); - verify(p).accept(any(ClearCheckResultsVisitor.class)); + verify(p).accept(any(ClearVisitorResultsVisitor.class)); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); } @Test public void testCollectContainedErrors() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); @@ -324,7 +325,7 @@ public class GeometryTest { @Test public void testContainsAnyError() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); assertFalse(geom.containsAnyError()); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); assertTrue(geom.containsAnyError()); @@ -343,7 +344,7 @@ public class GeometryTest { @Test public void testAccept() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Check c = mock(Check.class); geom.accept(c); when(c.canExecute(geom)).thenReturn(true); @@ -434,7 +435,7 @@ public class GeometryTest { @Test public void testContainsPolygon() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); ConcretePolygon cdPoly = new ConcretePolygon(); geom.addPolygon(cdPoly); cdPoly.setGmlId(new GmlId("test1")); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java index 95a0fe0f7b6ab5ed000b8abb0a24414e7be0d742..7185ebf2450f62cb809948a7d7dc7fd3278eea8d 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java @@ -18,6 +18,7 @@ */ package de.hft.stuttgart.citydoctor2.datastructure; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import org.xmlobjects.gml.model.geometry.primitives.AbstractRing; import org.xmlobjects.gml.model.geometry.primitives.AbstractSolid; @@ -48,7 +49,7 @@ public class GeometryTestUtils { } public static Geometry createDummyGeometry(GeometryType type, Lod lod) { - Geometry geom = new Geometry(type, lod); + Geometry geom = new Geometry(type, lod, Orientation.OUTWARD); ConcretePolygon polygon = new ConcretePolygon(); geom.getPolygons().add(polygon); polygon.setParent(geom); @@ -68,7 +69,7 @@ public class GeometryTestUtils { } public static Geometry createDummyGeometryWithInnerRingWithNeighboringPolygon(GeometryType type, Lod lod) { - Geometry geom = new Geometry(type, lod); + Geometry geom = new Geometry(type, lod, Orientation.OUTWARD); ConcretePolygon polygon = new ConcretePolygon(); geom.getPolygons().add(polygon); polygon.setParent(geom); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryTest.java index 6050b20f2eeefa625c188222c8e8e05c003e7b97..42d0f073594d0a797d0ba189759d6462cfc80113 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -150,7 +150,7 @@ public class ImplicitGeometryTest { AtomicInteger loCounter = new AtomicInteger(0); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { @Override public void check(Polygon lo) { loCounter.incrementAndGet(); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java index d97059d14bf13cdb82b34e0cc4246d59856b0d48..806564603296c0f4fb1ca862b1e6b48829fd25b5 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import org.citygml4j.core.model.relief.ReliefFeature; import org.junit.Test; @@ -16,7 +16,7 @@ public class ReliefObjectTest { TinObject mockTin = mock(TinObject.class); relief.addComponent(mockTin); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; relief.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TinObjectTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TinObjectTest.java index b635e2a660a11bf0cf9d526e4f05e533b0a9116b..a93e87b95f2333e59c13941ff73eb18a2e390b33 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TinObjectTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TinObjectTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -32,7 +32,7 @@ public class TinObjectTest { tin.addGeometry(mockGeometry); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; tin.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeatureTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeatureTest.java index 0f3a157249f8f2e3285716e70f0f97ebe4633e48..f5bd5b8e416cb6d1d66bc6160007109a11c15a7e 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeatureTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeatureTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -54,7 +54,7 @@ public class TopLevelTransportFeatureTest { top.addSection(mockSection); top.addIntersection(mockIntersection); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; top.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceTest.java index bb6c592e7319ad73529432513cf48fd0937a1c47..42759031ebce3b99c84e96fd47add0c8db4e6e7b 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceTest.java @@ -1,12 +1,12 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; import de.hft.stuttgart.citydoctor2.check.ResultStatus; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; -import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor; +import de.hft.stuttgart.citydoctor2.utils.visitors.ClearVisitorResultsVisitor; import org.citygml4j.core.model.core.AbstractSpaceBoundary; import org.citygml4j.core.model.core.AbstractUnoccupiedSpace; import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractCityObject; @@ -37,7 +37,7 @@ public class TrafficSpaceTest { TrafficAreaObject areaMock = mock(TrafficAreaObject.class); tso.addTrafficArea(areaMock); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; tso.accept(c); @@ -91,7 +91,7 @@ public class TrafficSpaceTest { tso.clearAllContainedCheckResults(); assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); - verify(taMock).accept(any(ClearCheckResultsVisitor.class)); + verify(taMock).accept(any(ClearVisitorResultsVisitor.class)); } @Test diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpaceTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpaceTest.java index e30557c26b54d64880dc3a7ba2dcf0b0d600fbdc..827f9896c48fa728cfe7f8d54a5f8af75a046e67 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpaceTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpaceTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -32,7 +32,7 @@ public class TransportationSpaceTest { space.addTrafficSpace(mockSpace); space.addAuxTrafficSpace(auxMockSpace); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; space.accept(c); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/VertexTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/VertexTest.java index ad7286df9156b6ab71b361d60e88c033a3cd6be6..6dc58ddafe95ef33ee08df12b7e3bc65e14a12a3 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/VertexTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/VertexTest.java @@ -25,6 +25,7 @@ import java.util.Set; import org.junit.Test; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.math.Vector3d; @@ -46,7 +47,7 @@ public class VertexTest { @Test public void testGetAdjacentRings() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -64,7 +65,7 @@ public class VertexTest { @Test(expected = IllegalStateException.class) public void testGetAdjacentRingsGeometryNotContainingVertex() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/WaterTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/WaterTest.java index b028922870fc2224361d6752f89bbdd3ea0a2904..3dd2077d0977bf6086675098fe2507d9d6f60f4e 100644 --- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/WaterTest.java +++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/WaterTest.java @@ -1,6 +1,6 @@ package de.hft.stuttgart.citydoctor2.datastructure; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.CheckResult; @@ -33,7 +33,7 @@ public class WaterTest { water.addBoundarySurface(bsMock); water.addBoundarySurface(bsMock2); - AbstractCheck c = new AbstractCheck() { + CheckableUtilsVisitor c = new CheckableUtilsVisitor() { }; water.accept(c); diff --git a/CityDoctorParent/CityDoctorValidation/pom.xml b/CityDoctorParent/CityDoctorValidation/pom.xml index 619937fffb44a1d5c946bfc7e9ac069f016266a2..48329e28a6d195e3d605b2a8052b3adceae93f8a 100644 --- a/CityDoctorParent/CityDoctorValidation/pom.xml +++ b/CityDoctorParent/CityDoctorValidation/pom.xml @@ -4,7 +4,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 CityDoctorValidation CityDoctorValidation diff --git a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/Checker.java b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/Checker.java index 6f742f23c948c5fca01110ee4d7899e0e6eb7c6a..061e4184ca9c36eb99b6e61d5fe35c81c9b30e56 100644 --- a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/Checker.java +++ b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/Checker.java @@ -264,6 +264,8 @@ public class Checker { DefaultParameter defaultP = getDefaultParameter(e.getKey(), reqs, param.getKey()); if (defaultP != null) { p.setUom(defaultP.getUnitType().getGmlRepresentation()); + } else { + p.setUom(""); } p.setName(param.getKey()); p.setValue(param.getValue()); @@ -280,22 +282,29 @@ public class Checker { correct.setEnabled(config.getSchematronFilePath() != null); plan.getRequirements().add(new RequirementProperty(missing)); plan.getRequirements().add(new RequirementProperty(correct)); + + de.hft.stuttgart.quality.model.types.GlobalParameters globParams = new de.hft.stuttgart.quality.model.types.GlobalParameters(); + plan.setGlobalParameters(new GlobalParametersProperty(globParams)); Parameter numRounding = new Parameter(); numRounding.setName("numberOfRoundingPlaces"); + numRounding.setUom("amount"); numRounding.setValue("" + config.getNumberOfRoundingPlaces()); + globParams.getParameters().add(new ParameterProperty(numRounding)); + Parameter minVertexDistance = new Parameter(); minVertexDistance.setName("minVertexDistance"); minVertexDistance.setUom("m"); minVertexDistance.setValue("" + config.getMinVertexDistance()); - Parameter schematronFile = new Parameter(); - schematronFile.setName("schematronFile"); - schematronFile.setValue(config.getSchematronFilePath()); - de.hft.stuttgart.quality.model.types.GlobalParameters globParams = new de.hft.stuttgart.quality.model.types.GlobalParameters(); - plan.setGlobalParameters(new GlobalParametersProperty(globParams)); - globParams.getParameters().add(new ParameterProperty(numRounding)); globParams.getParameters().add(new ParameterProperty(minVertexDistance)); - globParams.getParameters().add(new ParameterProperty(schematronFile)); + + if (config.getSchematronFilePath() != null) { + Parameter schematronFile = new Parameter(); + schematronFile.setName("schematronFile"); + schematronFile.setUom("path"); + schematronFile.setValue(config.getSchematronFilePath()); + globParams.getParameters().add(new ParameterProperty(schematronFile)); + } return plan; } @@ -620,6 +629,9 @@ public class Checker { private void checkCityModel(CityDoctorModel model, ProgressListener l) { Stream features = model.createFeatureStream(); float featureSum = model.getNumberOfFeatures(); + // clear global errors + model.getGlobalErrors().clear(); + // stupid lamda with final variable restrictions int[] currentFeature = new int[1]; features.forEach(co -> { @@ -887,9 +899,6 @@ public class Checker { * @param co the city object to be checked */ public void checkFeature(XmlStreamReporter xmlReporter, PdfStreamReporter pdfReporter, CityObject co) { - if (logger.isDebugEnabled()) { - logger.debug(Localization.getText("Checker.checkFeature"), co); - } executeChecksForCityObject(co); if (xmlReporter != null) { xmlReporter.report(co); diff --git a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/StreamCityGmlConsumer.java b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/StreamCityGmlConsumer.java index f555a8ea6d0f24519033c40bfb69b3e038da4b6e..c3ff365c3980e47e729bb0d2d940938cd3dcb7f0 100644 --- a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/StreamCityGmlConsumer.java +++ b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/check/StreamCityGmlConsumer.java @@ -29,11 +29,6 @@ import java.util.Set; import java.util.UUID; import java.util.concurrent.atomic.AtomicInteger; -import de.hft.stuttgart.citydoctor2.datastructure.AbstractTunnel; -import de.hft.stuttgart.citydoctor2.datastructure.CityFurniture; -import de.hft.stuttgart.citydoctor2.datastructure.GenericCityObject; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import org.citygml4j.core.model.core.AbstractFeatureProperty; import org.citygml4j.core.model.core.CityModel; import org.citygml4j.core.util.geometry.GeometryFactory; @@ -42,9 +37,12 @@ import org.xmlobjects.gml.model.base.Reference; import de.hft.stuttgart.citydoctor2.check.error.SchematronError; import de.hft.stuttgart.citydoctor2.checks.SvrlContentHandler; import de.hft.stuttgart.citydoctor2.checks.util.FeatureCheckedListener; +import de.hft.stuttgart.citydoctor2.datastructure.AbstractTunnel; import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject; import de.hft.stuttgart.citydoctor2.datastructure.Building; +import de.hft.stuttgart.citydoctor2.datastructure.CityFurniture; import de.hft.stuttgart.citydoctor2.datastructure.CityObject; +import de.hft.stuttgart.citydoctor2.datastructure.GenericCityObject; import de.hft.stuttgart.citydoctor2.datastructure.LandObject; import de.hft.stuttgart.citydoctor2.datastructure.TransportationObject; import de.hft.stuttgart.citydoctor2.datastructure.Vegetation; @@ -64,8 +62,6 @@ import de.hft.stuttgart.quality.model.types.ValidationPlan; public class StreamCityGmlConsumer implements CityGmlConsumer { - private static final Logger logger = LogManager.getLogger(StreamCityGmlConsumer.class); - private final Checker c; private final XmlStreamReporter xmlReporter; private final PdfStreamReporter pdfReporter; @@ -82,7 +78,7 @@ public class StreamCityGmlConsumer implements CityGmlConsumer { private final FeatureStatistics waterStatistics; private final Validation val; private final FeatureCheckedListener l; - + public StreamCityGmlConsumer(Checker c, XmlStreamReporter xmlReporter, PdfStreamReporter pdfReporter, SvrlContentHandler handler, ValidationConfiguration config, FeatureCheckedListener l) { this.c = c; @@ -116,10 +112,6 @@ public class StreamCityGmlConsumer implements CityGmlConsumer { @Override public void accept(CityObject co) { - if (logger.isDebugEnabled()) { - logger.debug(Localization.getText("Checker.checkFeature"), co); - } - // check without reporters, nothing will be put into the reports like that // this will also clear old check results if any (though in stream mode there // won't be any) diff --git a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/checks/geometry/AllPolygonsWrongOrientationCheck.java b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/checks/geometry/AllPolygonsWrongOrientationCheck.java index 9b4df54b9511ef057e9850aad8fd4c780215d3ad..277026e8e0e6b945301be3c48a1a0ed451e0cacd 100644 --- a/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/checks/geometry/AllPolygonsWrongOrientationCheck.java +++ b/CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/checks/geometry/AllPolygonsWrongOrientationCheck.java @@ -35,6 +35,7 @@ import de.hft.stuttgart.citydoctor2.checks.util.CollectionUtils; import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.math.Ray; import de.hft.stuttgart.citydoctor2.math.Triangle3d; import de.hft.stuttgart.citydoctor2.math.Vector3d; @@ -76,6 +77,10 @@ public class AllPolygonsWrongOrientationCheck extends Check { return; } boolean isOutwardOriented = geometryIsOutwardOrientedJava(g); + // invert outward direction for inward facing geometries + if (g.getOrientation() == Orientation.INWARD) { + isOutwardOriented = !isOutwardOriented; + } CheckResult cr; if (isOutwardOriented) { cr = new CheckResult(this, ResultStatus.OK, null); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DegeneratedPolygonCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DegeneratedPolygonCheckTest.java index dcd00336183e6d3ed09d8274ab1dbccc932a303a..98669c4056f985bc14c0f1e834afb584f6182bb3 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DegeneratedPolygonCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DegeneratedPolygonCheckTest.java @@ -41,6 +41,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.quality.model.enums.RequirementId; @@ -48,7 +49,7 @@ public class DegeneratedPolygonCheckTest { @Test public void testDegeneratedPolygon() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1, Orientation.OUTWARD); ConcretePolygon polygon = new ConcretePolygon(); geom.getPolygons().add(polygon); polygon.setParent(geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DuplicatePointsCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DuplicatePointsCheckTest.java index 6cdeb012eb552cf9d563e1d1d5631da8f9d7adb3..57d993b59f352703e16037eff005a4fc937ce099 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DuplicatePointsCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/DuplicatePointsCheckTest.java @@ -34,6 +34,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -90,7 +91,7 @@ public class DuplicatePointsCheckTest { @Test public void testCheckSelfInt() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = new Vertex(1, 1, 1); Vertex v1 = new Vertex(2, 2, 2); Vertex v2 = new Vertex(3, 3, 3); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/FaceOutCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/FaceOutCheckTest.java index 68ecbbceecbec40232ff694c2b7e9e8f69f01637..0ac69f2040e85e2f8ec1061a3ea21327902ecfee 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/FaceOutCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/FaceOutCheckTest.java @@ -31,6 +31,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -40,7 +41,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Vertex; public class FaceOutCheckTest { private Geometry createBadGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = createVertex(0, 0, 0, geom); Vertex v1 = createVertex(10, 0, 0, geom); @@ -62,7 +63,7 @@ public class FaceOutCheckTest { } private Geometry createGoodGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = createVertex(0, 0, 0, geom); Vertex v1 = createVertex(10, 0, 0, geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/HoleOutsideCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/HoleOutsideCheckTest.java index a3ef2f2c93bd16a723741fd7af5b1fc0e479d2bb..74433ad050f3dd81f6e341cededfd57a77979837 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/HoleOutsideCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/HoleOutsideCheckTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -43,7 +44,7 @@ public class HoleOutsideCheckTest { @Test public void testHoleOutside() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -79,7 +80,7 @@ public class HoleOutsideCheckTest { @Test public void testPolygonGood() { - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/InteriorDisconnectedCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/InteriorDisconnectedCheckTest.java index 314afcf7ad8d5b077771f9c00390a56adc637291..44d136aaaeeebea54df2fe5258bd0d16e1c80d03 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/InteriorDisconnectedCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/InteriorDisconnectedCheckTest.java @@ -31,6 +31,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -44,7 +45,7 @@ public class InteriorDisconnectedCheckTest { */ @Test public void testBadPolygon1() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -89,7 +90,7 @@ public class InteriorDisconnectedCheckTest { */ @Test public void testBadPolygon2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -145,7 +146,7 @@ public class InteriorDisconnectedCheckTest { */ @Test public void testBadPolygon3() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -213,7 +214,7 @@ public class InteriorDisconnectedCheckTest { */ @Test public void testGoodPolygon3() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -274,7 +275,7 @@ public class InteriorDisconnectedCheckTest { @Test public void testGoodPolygon2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/ManifoldVertexCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/ManifoldVertexCheckTest.java index d7ae5e733b34858b253a2263cfabaf936c4fc4ca..336bb39412dfa7d5de0edb277e402ce1fcdac8ad 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/ManifoldVertexCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/ManifoldVertexCheckTest.java @@ -31,6 +31,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -41,7 +42,7 @@ public class ManifoldVertexCheckTest { @Test public void testNonManifoldVertex() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v12 = createVertex(10, 10, 3, geom); Vertex v13 = createVertex(10, 10, 0, geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NestedRingsCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NestedRingsCheckTest.java index 4bfb51069c5341f7a3b94b02b12689edc32b6a68..34d5c60b0060023fd0787291809f2c8a2b272075 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NestedRingsCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NestedRingsCheckTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -43,7 +44,7 @@ public class NestedRingsCheckTest { @Test public void testNestedRings() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -90,7 +91,7 @@ public class NestedRingsCheckTest { @Test public void testPolygonGood() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NullAreaCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NullAreaCheckTest.java index ea5d367a3d9a707abd8999cf24f58fc2e1a965ca..550ef455476a55910ffd50ad6eb9866a4cc57661 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NullAreaCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NullAreaCheckTest.java @@ -29,6 +29,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -38,7 +39,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Vertex; public class NullAreaCheckTest { private LinearRing setupValidGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -62,7 +63,7 @@ public class NullAreaCheckTest { } private LinearRing setupErrorGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PlanarCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PlanarCheckTest.java index 9a8d9e6b1292fe7077283b9bbe2e0941408b55f3..4ae6fe6159699597af47bfaeab72e90b203b8378 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PlanarCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PlanarCheckTest.java @@ -31,6 +31,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -41,7 +42,7 @@ public class PlanarCheckTest { @Test public void testCheckPolygonOK() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = new Vertex(0, 0, 0); Vertex v1 = new Vertex(0, 0, 1); Vertex v2 = new Vertex(1, 0, 1); @@ -62,7 +63,7 @@ public class PlanarCheckTest { @Test public void testCheckPolygonDistanceERROR() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = new Vertex(0, 0, 0); Vertex v1 = new Vertex(0, 0.06, 1); Vertex v2 = new Vertex(1, 1, 1); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSameOrientationCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSameOrientationCheckTest.java index 959505ab8916f07f34f4793bc2f18e50092f29d9..8e7d07e2b2c36757e77efe062491b614d3d9bcbe 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSameOrientationCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSameOrientationCheckTest.java @@ -34,6 +34,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -44,7 +45,7 @@ public class PolygonSameOrientationCheckTest { @Test public void testSameOrientation() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = GeometryTestUtils.createVertex(0, 0, 0, geom); Vertex v1 = GeometryTestUtils.createVertex(6, 0, 0, geom); @@ -76,7 +77,7 @@ public class PolygonSameOrientationCheckTest { @Test public void testGoodPoly() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = GeometryTestUtils.createVertex(0, 0, 0, geom); Vertex v1 = GeometryTestUtils.createVertex(6, 0, 0, geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSelfIntCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSelfIntCheckTest.java index 468ab96b3c4476ae1334d88bdb3efb054aeb351a..6afa6c8d4a231e474d136c5064dd2c49b732f5fa 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSelfIntCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/PolygonSelfIntCheckTest.java @@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -45,7 +46,7 @@ public class PolygonSelfIntCheckTest { @Test public void testPolygonInteriorIntersectExterior() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -95,7 +96,7 @@ public class PolygonSelfIntCheckTest { @Test public void testPolygonGood() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -143,7 +144,7 @@ public class PolygonSelfIntCheckTest { @Test public void test2InteriorRingsIntersecting() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -211,7 +212,7 @@ public class PolygonSelfIntCheckTest { @Test public void test2InteriorRingsNotIntersecting() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/RingSelfIntCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/RingSelfIntCheckTest.java index b93fd42e59412da3c8a25895ceda0e022257a16d..c5118554cf6f730d1efee36815dc393112b64fd4 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/RingSelfIntCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/RingSelfIntCheckTest.java @@ -38,6 +38,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; /** @@ -49,7 +50,7 @@ public class RingSelfIntCheckTest { @Test public void testIntersect() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -88,7 +89,7 @@ public class RingSelfIntCheckTest { @Test public void testNonIntersect() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -121,7 +122,7 @@ public class RingSelfIntCheckTest { @Test public void testTouching() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -159,7 +160,7 @@ public class RingSelfIntCheckTest { @Test public void testNotTouching() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/IsWallCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/IsWallCheckTest.java index fbd41aef6a58f178a6dd06337c8f5989dcbb6323..08a1f59688127edc7b7b752ac6b6a37aa847916b 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/IsWallCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/IsWallCheckTest.java @@ -38,6 +38,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; /** @@ -64,7 +65,7 @@ public class IsWallCheckTest { Polygon p = new ConcretePolygon(); p.setExteriorRing(lr); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geom.addPolygon(p); BoundarySurface bs = new BoundarySurface(null); @@ -97,7 +98,7 @@ public class IsWallCheckTest { Polygon p = new ConcretePolygon(); p.setExteriorRing(lr); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geom.addPolygon(p); BoundarySurface bs = new BoundarySurface(null); @@ -129,7 +130,7 @@ public class IsWallCheckTest { Polygon p = new ConcretePolygon(); p.setExteriorRing(lr); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geom.addPolygon(p); BoundarySurface bs = new BoundarySurface(null); @@ -162,7 +163,7 @@ public class IsWallCheckTest { Polygon p = new ConcretePolygon(); p.setExteriorRing(lr); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); geom.addPolygon(p); BoundarySurface bs = new BoundarySurface(null); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/PolygonWithoutSurfaceCheckTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/PolygonWithoutSurfaceCheckTest.java index 0bbb3fdf4b879f00ce94d5faded4996c4aa443e1..fcab4a52083ffd9fa9ce7d574287ed049a45c589 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/PolygonWithoutSurfaceCheckTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/semantics/PolygonWithoutSurfaceCheckTest.java @@ -20,12 +20,13 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; public class PolygonWithoutSurfaceCheckTest { @Test public void testPolygonWithoutSurface() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); PolygonWithoutSurfaceCheck check = new PolygonWithoutSurfaceCheck(); @@ -44,7 +45,7 @@ public class PolygonWithoutSurfaceCheckTest { @Test public void testPolygonWithSurface() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); BoundarySurface bs = new BoundarySurface(null); bs.addGeometry(geom); @@ -61,7 +62,7 @@ public class PolygonWithoutSurfaceCheckTest { @Test public void testPolygonWithWrongLod() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); BoundarySurface bs = new BoundarySurface(null); bs.addGeometry(geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/GeometryTestUtils.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/GeometryTestUtils.java index 0c4db51a209d6003b4d4923dbbd20d7a26ca1ac7..bd821d333d1a812470fceabcdd4a6d5a691baab2 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/GeometryTestUtils.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/GeometryTestUtils.java @@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; /** * @@ -39,7 +40,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Vertex; public class GeometryTestUtils { public static Geometry createGoodGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = createVertex(0, 0, 0, geom); Vertex v1 = createVertex(10, 0, 0, geom); @@ -65,7 +66,7 @@ public class GeometryTestUtils { } public static Geometry createBadGeometry() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Vertex v0 = createVertex(0, 0, 0, geom); Vertex v1 = createVertex(10, 0, 0, geom); diff --git a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/SelfIntersectionUtilTest.java b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/SelfIntersectionUtilTest.java index cc6d728a9f6c36722038fa68e759698bc5dba7b8..35a7c10e15df66f47f81f557a70061513135e024 100644 --- a/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/SelfIntersectionUtilTest.java +++ b/CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/util/SelfIntersectionUtilTest.java @@ -37,6 +37,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.math.Segment3d; import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; @@ -806,7 +807,7 @@ public class SelfIntersectionUtilTest { @Test public void testIsSimpleGood() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -837,7 +838,7 @@ public class SelfIntersectionUtilTest { @Test public void testIsSimpleFail() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); @@ -867,7 +868,7 @@ public class SelfIntersectionUtilTest { @Test public void testIsSimpleGood2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon poly = new ConcretePolygon(); geom.addPolygon(poly); diff --git a/CityDoctorParent/Extensions/CityDoctorAutoPro/pom.xml b/CityDoctorParent/Extensions/CityDoctorAutoPro/pom.xml index 5a8882854f59dd20ebd5355fa68f30b8426f908d..52eb30300a1e7c9c0e4598c22aad858328aedfee 100644 --- a/CityDoctorParent/Extensions/CityDoctorAutoPro/pom.xml +++ b/CityDoctorParent/Extensions/CityDoctorAutoPro/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ../../pom.xml CityDoctorAutoPro diff --git a/CityDoctorParent/Extensions/CityDoctorGUI/pom.xml b/CityDoctorParent/Extensions/CityDoctorGUI/pom.xml index 8093a13373ecb71c3bc78e8b32870c2e96d62903..2b07c026a5b412210ccdb584563acf42de815420 100644 --- a/CityDoctorParent/Extensions/CityDoctorGUI/pom.xml +++ b/CityDoctorParent/Extensions/CityDoctorGUI/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ../../pom.xml CityDoctorGUI diff --git a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java index 7c80b871b0e271c250cf89ca933f92f981e6c3b2..fd4320d151d592a80b308899e5d09ac3a3d691fe 100644 --- a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java +++ b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java @@ -590,6 +590,7 @@ public class CityDoctorController { TreeItem item = buildTopLevelCityObjectNode(b, root, b.getBoundarySurfaces()); createBuildingInstallationNodes(b, item); + createBuildingConstructiveElementsNodes(b, item); createBuildingRoomNodes(b, item); createBuildingFurnitureNodes(b, item); createBuildingStoreyNodes(b, item); @@ -860,6 +861,21 @@ public class CityDoctorController { createRoomNodes(ab.getBuildingRooms(), root); } + private void createBuildingConstructiveElementsNodes(AbstractBuilding ab, TreeItem root) { + if (ab.getConstructiveElements().isEmpty()) { + return; + } + + CityObjectGroupNode constructiveElementsGroupNode = new CityObjectGroupNode( + ab.getConstructiveElements(), "Constructive Elements", Color.CORAL); + TreeItem constructiveElementsGroupItem = new TreeItem<>(constructiveElementsGroupNode); + root.getChildren().add(constructiveElementsGroupItem); + + for (BuildingConstructiveElement bce : ab.getConstructiveElements()) { + buildCityObjectNode(bce, constructiveElementsGroupItem, bce.getBoundarySurfaces()); + } + } + private void createRoomNodes(List rooms, TreeItem root) { if (rooms.isEmpty()) { return; @@ -1030,7 +1046,7 @@ public class CityDoctorController { updateTree(mainWindow.getPolygonsView().getRoot()); for (CheckError e : model.getGlobalErrors()) { if (e instanceof SchematronError se) { - mainWindow.getGlobalErrorsView().getItems().add(se.getErrorIdString()); + mainWindow.getGlobalErrorsView().getItems().add(se.getErrorIdString() + " - " + se.getNameOfAttribute()); } } renderer.refresh(); @@ -1083,7 +1099,7 @@ public class CityDoctorController { updateTree(mainWindow.getPolygonsView().getRoot()); for (CheckError e : model.getGlobalErrors()) { if (e instanceof SchematronError se) { - mainWindow.getGlobalErrorsView().getItems().add(se.getErrorIdString()); + mainWindow.getGlobalErrorsView().getItems().add(se.getErrorIdString() + " - " + se.getNameOfAttribute()); } } renderer.refresh(); diff --git a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/ListErrorVisitor.java b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/ListErrorVisitor.java index ae8c3112f9c2434cc53829ef38b315e666535ede..34f7132a16b242b0775b72c626e208df3b0b7ff2 100644 --- a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/ListErrorVisitor.java +++ b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/ListErrorVisitor.java @@ -22,7 +22,9 @@ import de.hft.stuttgart.citydoctor2.check.error.NotFloorError; import de.hft.stuttgart.citydoctor2.check.error.NotGroundError; import de.hft.stuttgart.citydoctor2.check.error.NotWallError; import de.hft.stuttgart.citydoctor2.check.error.NullAreaError; +import de.hft.stuttgart.citydoctor2.check.error.PlanarityError; import de.hft.stuttgart.citydoctor2.check.error.PointTouchesEdgeError; +import de.hft.stuttgart.citydoctor2.check.error.PolygonError; import de.hft.stuttgart.citydoctor2.check.error.PolygonHoleOutsideError; import de.hft.stuttgart.citydoctor2.check.error.PolygonInteriorDisconnectedError; import de.hft.stuttgart.citydoctor2.check.error.PolygonIntersectingRingsError; @@ -31,9 +33,12 @@ import de.hft.stuttgart.citydoctor2.check.error.PolygonWithoutSurfaceError; import de.hft.stuttgart.citydoctor2.check.error.PolygonWrongOrientationError; import de.hft.stuttgart.citydoctor2.check.error.RingDuplicatePointError; import de.hft.stuttgart.citydoctor2.check.error.RingEdgeIntersectionError; +import de.hft.stuttgart.citydoctor2.check.error.RingError; import de.hft.stuttgart.citydoctor2.check.error.RingNotClosedError; +import de.hft.stuttgart.citydoctor2.check.error.RingSelfIntersectionError; import de.hft.stuttgart.citydoctor2.check.error.RingTooFewPointsError; import de.hft.stuttgart.citydoctor2.check.error.SchematronError; +import de.hft.stuttgart.citydoctor2.check.error.SolidError; import de.hft.stuttgart.citydoctor2.check.error.SolidNotClosedError; import de.hft.stuttgart.citydoctor2.check.error.SolidSelfIntError; import de.hft.stuttgart.citydoctor2.check.error.SurfaceUnfragmentedError; @@ -265,4 +270,29 @@ public class ListErrorVisitor implements ErrorVisitor { public void visit(PolygonWithoutSurfaceError err) { controller.highlight(err.getPolygon(), geom); } + + @Override + public void visit(RingError err) { + // nothing to display + } + + @Override + public void visit(PolygonError err) { + // nothing to display + } + + @Override + public void visit(RingSelfIntersectionError err) { + // nothing to display + } + + @Override + public void visit(PlanarityError err) { + // nothing to display + } + + @Override + public void visit(SolidError err) { + // nothing to display + } } diff --git a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/ErrorItemVisitor.java b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/ErrorItemVisitor.java index 943954cc70a49df4d6fb87e11e2e428df9037872..1f23d576ca485543ec11c412f20b077264fc8e8b 100644 --- a/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/ErrorItemVisitor.java +++ b/CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/tree/ErrorItemVisitor.java @@ -2,13 +2,14 @@ package de.hft.stuttgart.citydoctor2.gui.tree; import java.util.List; +import de.hft.stuttgart.citydoctor2.check.AbstractErrorVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; -import de.hft.stuttgart.citydoctor2.check.ErrorVisitor; import de.hft.stuttgart.citydoctor2.check.error.AllPolygonsWrongOrientationError; import de.hft.stuttgart.citydoctor2.check.error.AttributeInvalidError; import de.hft.stuttgart.citydoctor2.check.error.AttributeMissingError; import de.hft.stuttgart.citydoctor2.check.error.AttributeValueWrongError; import de.hft.stuttgart.citydoctor2.check.error.ConsecutivePointSameError; +import de.hft.stuttgart.citydoctor2.check.error.DegeneratedRingError; import de.hft.stuttgart.citydoctor2.check.error.DependenciesNotMetError; import de.hft.stuttgart.citydoctor2.check.error.MultipleConnectedComponentsError; import de.hft.stuttgart.citydoctor2.check.error.NestedRingError; @@ -36,7 +37,6 @@ import de.hft.stuttgart.citydoctor2.check.error.SchematronError; import de.hft.stuttgart.citydoctor2.check.error.SolidNotClosedError; import de.hft.stuttgart.citydoctor2.check.error.SolidSelfIntError; import de.hft.stuttgart.citydoctor2.check.error.SurfaceUnfragmentedError; -import de.hft.stuttgart.citydoctor2.check.error.DegeneratedRingError; import de.hft.stuttgart.citydoctor2.check.error.TooFewPolygonsError; import de.hft.stuttgart.citydoctor2.check.error.UnknownCheckError; import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon; @@ -57,7 +57,7 @@ import de.hft.stuttgart.citydoctor2.utils.PolygonIntersection; import de.hft.stuttgart.citydoctor2.utils.PolygonIntersection.IntersectionType; import javafx.scene.control.TreeItem; -public class ErrorItemVisitor implements ErrorVisitor { +public class ErrorItemVisitor extends AbstractErrorVisitor { private static String nameOfAttribute = Localization.getText("ErrorItemVisitor.nameOfAttribute") + ": "; private static String childId = Localization.getText("ErrorItemVisitor.childId") + ": "; diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/pom.xml b/CityDoctorParent/Extensions/CityDoctorHealer/pom.xml index 3383ecabc5223635f3aaa0a07603ed51255df1af..1d031a02f9edca6ee6beb9876ef77c4bdcc21f1c 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/pom.xml +++ b/CityDoctorParent/Extensions/CityDoctorHealer/pom.xml @@ -6,7 +6,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ../../pom.xml CityDoctorHealer diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healer/Healer.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healer/Healer.java index 544a6856d9a6f0d3a410c8b0509dfdc6bc2bf657..98a7c8835c0644e8b5f8c578f31b3f5900634a7c 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healer/Healer.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healer/Healer.java @@ -26,7 +26,7 @@ import org.citygml4j.xml.writer.CityGMLWriteException; import org.citygml4j.xml.writer.CityGMLWriter; import de.hft.stuttgart.citydoctor2.CityDoctorValidation; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.Checker; import de.hft.stuttgart.citydoctor2.check.HealingMethod; @@ -353,7 +353,7 @@ public class Healer { private void filterOutDuplicateVertices(CityObject co) { Map map = new HashMap<>(); - co.accept(new AbstractCheck() { + co.accept(new CheckableUtilsVisitor() { @Override public void check(LinearRing ring) { for (int i = 0; i < ring.getVertices().size(); i++) { diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolid.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolid.java index 301d639b7772ea8faa29541cea4e243383a08a27..558cca0c7d20029c43c341c384b8ce71618ed3ea 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolid.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolid.java @@ -24,7 +24,7 @@ import java.util.List; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.HealingID; import de.hft.stuttgart.citydoctor2.check.HealingMethod; import de.hft.stuttgart.citydoctor2.check.ModificationListener; @@ -42,6 +42,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlElement; import de.hft.stuttgart.citydoctor2.datastructure.LinkedPolygon; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; public class HealMissingSolid implements HealingMethod { @@ -103,7 +104,7 @@ public class HealMissingSolid implements HealingMethod { private List collectPolygons(CityObject co) { List polygons = new ArrayList<>(); - AbstractCheck polygonCheck = new AbstractCheck() { + CheckableUtilsVisitor polygonCheck = new CheckableUtilsVisitor() { @Override public void check(Polygon p) { if (!p.isLink()) { @@ -116,7 +117,7 @@ public class HealMissingSolid implements HealingMethod { } private boolean createSolidInFeature(Lod lod, AbstractBuilding building) { - Geometry geom = new Geometry(GeometryType.SOLID, lod); + Geometry geom = new Geometry(GeometryType.SOLID, lod, Orientation.OUTWARD); List polygons = collectPolygons(building, lod, geom); for (Polygon p : polygons) { geom.addPolygon(p); diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealPolygonWithoutSurface.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealPolygonWithoutSurface.java index 174fd6b547b35275ebd17d1cfdbd8085efde3e7e..6864a994220326e5e5f28eee8c7e1c1636f0d243 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealPolygonWithoutSurface.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healing/HealPolygonWithoutSurface.java @@ -19,6 +19,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.datastructure.GeometryType; import de.hft.stuttgart.citydoctor2.datastructure.LinkedPolygon; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.math.Vector3d; public class HealPolygonWithoutSurface implements HealingMethod { @@ -60,7 +61,7 @@ public class HealPolygonWithoutSurface implements HealingMethod { Geometry parentGeometry = cp.getParent(); parentGeometry.getPolygons().remove(cp); ab.addBoundarySurface(bs); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, parentGeometry.getLod()); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, parentGeometry.getLod(), Orientation.OUTWARD); bs.addGeometry(geom); geom.addPolygon(cp); parentGeometry.addPolygon(new LinkedPolygon(cp, parentGeometry)); diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealHoleOutsideErrorTest.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealHoleOutsideErrorTest.java index b5118c94420faaa08c85cd69cc08b6a4ec1c57fb..50ca0b4724383000d63d397cba99c30eeadc0b8b 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealHoleOutsideErrorTest.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealHoleOutsideErrorTest.java @@ -2,16 +2,14 @@ package de.hft.stuttgart.citydoctor2.healing; import java.io.IOException; -import de.hft.stuttgart.citydoctor2.datastructure.BoundarySurface; -import de.hft.stuttgart.citydoctor2.datastructure.Building; import org.junit.Assert; import org.junit.Test; import de.hft.stuttgart.citydoctor2.check.CheckId; import de.hft.stuttgart.citydoctor2.check.Checker; import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration; +import de.hft.stuttgart.citydoctor2.datastructure.Building; import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel; -import de.hft.stuttgart.citydoctor2.datastructure.Geometry; import de.hft.stuttgart.citydoctor2.healer.Healer; import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException; diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolidTest.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolidTest.java index 74ab22ad1246a345c4fe249f73b608d64a8790af..0b064845520f1581bb84717742cdb6b60c523d1d 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolidTest.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealMissingSolidTest.java @@ -55,6 +55,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinkedPolygon; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException; import de.hft.stuttgart.citydoctor2.healer.Healer; import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; @@ -75,7 +76,7 @@ public class HealMissingSolidTest { model.addBuilding(b); b.setGmlObject(new org.citygml4j.core.model.building.Building()); - Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); ConcretePolygon p1 = new ConcretePolygon(); LinearRing ext1 = createTestRing(); @@ -84,7 +85,7 @@ public class HealMissingSolidTest { BoundarySurface bs1 = new BoundarySurface(mock(AbstractThematicSurface.class)); b.addBoundarySurface(bs1); - Geometry geom2 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom2 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); bs1.addGeometry(geom2); ConcretePolygon p2 = new ConcretePolygon(); LinearRing ext2 = createTestRing(); @@ -95,7 +96,7 @@ public class HealMissingSolidTest { Installation bi = new Installation(); b.addBuildingInstallation(bi); - Geometry geom3 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom3 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); bi.addGeometry(geom3); ConcretePolygon p3 = new ConcretePolygon(); LinearRing ext3 = createTestRing(); @@ -104,7 +105,7 @@ public class HealMissingSolidTest { BoundarySurface bs2 = new BoundarySurface(mock(AbstractThematicSurface.class)); bi.addBoundarySurface(bs2); - Geometry geom4 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2); + Geometry geom4 = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD); bs2.addGeometry(geom4); ConcretePolygon p4 = new ConcretePolygon(); LinearRing ext4 = createTestRing(); diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealPlanarPolygonErrorTest.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealPlanarPolygonErrorTest.java index 94a3ec0a6cb4e7ee61e4b8b24e26582497a6606e..7b5576bdf330e218e813c323b28ada149660d73e 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealPlanarPolygonErrorTest.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealPlanarPolygonErrorTest.java @@ -27,6 +27,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.healer.Healer; import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException; @@ -57,7 +58,7 @@ public class HealPlanarPolygonErrorTest { public void testNonplanarPolygon() { CppInitializer.initCpp(); Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); @@ -162,7 +163,7 @@ public class HealPlanarPolygonErrorTest { public void testNonplanarPolygon_Split() { CppInitializer.initCpp(); Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); @@ -276,7 +277,7 @@ public class HealPlanarPolygonErrorTest { public void testNonplanarPolygon_Split2() { CppInitializer.initCpp(); Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealRingSelfIntErrorTest.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealRingSelfIntErrorTest.java index 078c96b1ba0d862eafe9b88915b38d214e53d93e..8a33573b70cbd02ac734d900e0fbf0321d0724da 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealRingSelfIntErrorTest.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealRingSelfIntErrorTest.java @@ -27,6 +27,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.healer.Healer; import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException; @@ -35,7 +36,7 @@ public class HealRingSelfIntErrorTest { @Test public void testIntersectingEdges1() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -92,7 +93,7 @@ public class HealRingSelfIntErrorTest { @Test public void testDuplicatePoint1() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); @@ -137,7 +138,7 @@ public class HealRingSelfIntErrorTest { @Test public void testDuplicatePoint2() { - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD1, Orientation.OUTWARD); Polygon p = new ConcretePolygon(); geom.addPolygon(p); diff --git a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealSolidNotClosedErrorTest.java b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealSolidNotClosedErrorTest.java index 4dbf3d636bffe8211369933da968780f2a519993..5a8713a8664a8429f9b8550f9aaad5abe6d99f65 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealSolidNotClosedErrorTest.java +++ b/CityDoctorParent/Extensions/CityDoctorHealer/src/test/java/de/hft/stuttgart/citydoctor2/healing/HealSolidNotClosedErrorTest.java @@ -29,6 +29,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; import de.hft.stuttgart.citydoctor2.datastructure.Vertex; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.healer.Healer; import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException; import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException; @@ -42,7 +43,7 @@ public class HealSolidNotClosedErrorTest { public void testVertexCloseToEdge() { CppInitializer.initCpp(); Building b = new Building(); //Angelika: als Test eingefügt - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); //Original + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); //Original // Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); //Angelika: Test b.addGeometry(geom); //Angelika: als Test eingefügt @@ -166,7 +167,7 @@ public class HealSolidNotClosedErrorTest { public void testMissingPolygon() { CppInitializer.initCpp(); Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); @@ -255,7 +256,7 @@ public class HealSolidNotClosedErrorTest { @Test public void test2MissingPolygons() { Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); @@ -345,7 +346,7 @@ public class HealSolidNotClosedErrorTest { public void test2MissingPolygonsCpp() { CppInitializer.initCpp(); Building b = new Building(); - Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2); + Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD); b.addGeometry(geom); Vertex v0 = new Vertex(0, 0, 0); diff --git a/CityDoctorParent/Extensions/CityDoctorHealerGUI/pom.xml b/CityDoctorParent/Extensions/CityDoctorHealerGUI/pom.xml index bd7e1290c174e7a323fed9edbbfc9d1e2b76da9b..8eb1cfeeaf651e273121b1da6c586d02b89e23aa 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealerGUI/pom.xml +++ b/CityDoctorParent/Extensions/CityDoctorHealerGUI/pom.xml @@ -7,7 +7,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ../../pom.xml CityDoctorHealerGUI diff --git a/CityDoctorParent/Extensions/CityDoctorHealerGUI/src/main/java/de/hft/stuttgart/citydoctor2/healer/gui/HealerController.java b/CityDoctorParent/Extensions/CityDoctorHealerGUI/src/main/java/de/hft/stuttgart/citydoctor2/healer/gui/HealerController.java index 9fe9b17294b973e7cdf56d838de9bf10f9728601..4cb6311c9c39331b6edb3e83e54295e99c94239a 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealerGUI/src/main/java/de/hft/stuttgart/citydoctor2/healer/gui/HealerController.java +++ b/CityDoctorParent/Extensions/CityDoctorHealerGUI/src/main/java/de/hft/stuttgart/citydoctor2/healer/gui/HealerController.java @@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.LinkedPolygon; import de.hft.stuttgart.citydoctor2.datastructure.Lod; import de.hft.stuttgart.citydoctor2.datastructure.Opening; import de.hft.stuttgart.citydoctor2.datastructure.Polygon; +import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation; import de.hft.stuttgart.citydoctor2.gui.AutoProWindow; import de.hft.stuttgart.citydoctor2.gui.HighlightController; import de.hft.stuttgart.citydoctor2.gui.ListErrorVisitor; @@ -614,7 +615,7 @@ public class HealerController { List newPolygons = availablePolygons.get(lod); if (newPolygons != null) { // found polygons to be added - Geometry newGeometry = new Geometry(GeometryType.SOLID, lod); + Geometry newGeometry = new Geometry(GeometryType.SOLID, lod, Orientation.OUTWARD); Set polygons = existingPolygons.get(lod); if (polygons != null) { // add existing polygons diff --git a/CityDoctorParent/Extensions/CityDoctorHealerGenetic/pom.xml b/CityDoctorParent/Extensions/CityDoctorHealerGenetic/pom.xml index 2e649ddddc44901e4fc23ce06a4855af9948576f..352b8af31ec441acd47ac26c80fe0a1b5d885110 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealerGenetic/pom.xml +++ b/CityDoctorParent/Extensions/CityDoctorHealerGenetic/pom.xml @@ -4,7 +4,7 @@ de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 ../../pom.xml CityDoctorHealerGenetic diff --git a/CityDoctorParent/Extensions/CityDoctorHealerGenetic/src/test/java/de/hft/stuttgart/citydoctor2/healer/genetic/NonPlanarGenetic.java b/CityDoctorParent/Extensions/CityDoctorHealerGenetic/src/test/java/de/hft/stuttgart/citydoctor2/healer/genetic/NonPlanarGenetic.java index aad5053da4b1e852a02cc5035e74529ebb3d7a40..f4711cc36c82224f19beb8c0743639b55db01014 100644 --- a/CityDoctorParent/Extensions/CityDoctorHealerGenetic/src/test/java/de/hft/stuttgart/citydoctor2/healer/genetic/NonPlanarGenetic.java +++ b/CityDoctorParent/Extensions/CityDoctorHealerGenetic/src/test/java/de/hft/stuttgart/citydoctor2/healer/genetic/NonPlanarGenetic.java @@ -36,10 +36,8 @@ import java.util.Map.Entry; import java.util.Random; import java.util.Set; -import org.junit.Test; - import Jama.EigenvalueDecomposition; -import de.hft.stuttgart.citydoctor2.check.AbstractCheck; +import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor; import de.hft.stuttgart.citydoctor2.check.CheckError; import de.hft.stuttgart.citydoctor2.check.Checker; import de.hft.stuttgart.citydoctor2.check.ValidationConfiguration; @@ -448,7 +446,7 @@ public class NonPlanarGenetic { private Polygon findPolygonInFeature(CityObject copy, Polygon polygon) { Polygon[] result = new Polygon[1]; - copy.accept(new AbstractCheck() { + copy.accept(new CheckableUtilsVisitor() { @Override public void check(Polygon p) { diff --git a/CityDoctorParent/pom.xml b/CityDoctorParent/pom.xml index 7c218dcc4d442417c675cf027e8964def1c5838a..84bc1df25c5d4d94f4944e7658f82a353383d70b 100644 --- a/CityDoctorParent/pom.xml +++ b/CityDoctorParent/pom.xml @@ -5,7 +5,7 @@ 4.0.0 de.hft.stuttgart CityDoctorParent - 3.17.2 + 3.17.3 pom CityDoctorParent