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

Merge branch 'dev' into 'master' 

Version 3.17.2

See merge request !32
parents 491a5dfd e0e40fdd
Pipeline #11127 canceled with stage
Hide whitespace changes
Inline Side-by-side
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObjectTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.generics.GenericOccupiedSpace;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class GenericCityObjectTest {
@Test
public void testVisitorPropagation() {
GenericCityObject gco = new GenericCityObject();
BoundarySurface mockSurface = mock(BoundarySurface.class);
Geometry mockGeometry = mock(Geometry.class);
gco.addBoundarySurface(mockSurface);
gco.addGeometry(mockGeometry);
AbstractCheck c = new AbstractCheck() {
};
gco.accept(c);
verify(mockSurface).accept(c);
verify(mockGeometry).accept(c);
}
@Test
public void testContainsError() {
GenericCityObject gco = new GenericCityObject();
assertFalse(gco.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(gco.containsError(CheckId.C_GE_P_NON_PLANAR));
gco.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(gco.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(gco.containsError(CheckId.C_GE_P_NON_PLANAR));
gco.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
assertTrue(gco.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(gco.containsError(CheckId.C_GE_P_NON_PLANAR));
}
@Test
public void testClearAllContainedCheckResults() {
GenericCityObject gco = new GenericCityObject();
gco.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertEquals(1, gco.getAllCheckResults().size());
gco.clearAllContainedCheckResults();
assertTrue(gco.getAllCheckResults().isEmpty());
}
@Test
public void testContainsAnyError() {
GenericCityObject gco = new GenericCityObject();
assertFalse(gco.containsAnyError());
gco.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(gco.containsAnyError());
gco.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(gco.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
GenericCityObject gco = new GenericCityObject();
gco.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
gco.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometries() {
GenericCityObject gco = new GenericCityObject();
GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
gco.setGmlObject(gmlGos);
gmlGos.setLod0MultiSurface(new MultiSurfaceProperty());
gmlGos.setLod2MultiSurface(new MultiSurfaceProperty());
gmlGos.setLod3MultiSurface(new MultiSurfaceProperty());
gmlGos.setLod1Solid(new SolidProperty());
gmlGos.setLod2Solid(new SolidProperty());
gmlGos.setLod3Solid(new SolidProperty());
gmlGos.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty());
gmlGos.getDeprecatedProperties().setLod2Geometry(new MultiSurfaceProperty());
gmlGos.getDeprecatedProperties().setLod3Geometry(new MultiSurfaceProperty());
gmlGos.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty());
gco.unsetGmlGeometries();
assertNull(gmlGos.getLod0MultiSurface());
assertNull(gmlGos.getLod2MultiSurface());
assertNull(gmlGos.getLod3MultiSurface());
assertNull(gmlGos.getLod1Solid());
assertNull(gmlGos.getLod2Solid());
assertNull(gmlGos.getLod3Solid());
assertNull(gmlGos.getDeprecatedProperties().getLod1Geometry());
assertNull(gmlGos.getDeprecatedProperties().getLod2Geometry());
assertNull(gmlGos.getDeprecatedProperties().getLod3Geometry());
assertNull(gmlGos.getDeprecatedProperties().getLod4Geometry());
}
@Test
public void testReCreateGeometriesSolid() {
GenericCityObject gco = new GenericCityObject();
GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
gco.setGmlObject(gmlGos);
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
gco.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurface() {
GenericCityObject gco = new GenericCityObject();
GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
gco.setGmlObject(gmlGos);
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
gco.reCreateGeometries(factory, config);
assertNotNull(gmlGos.getLod0MultiSurface());
assertNotNull(gmlGos.getLod0MultiSurface().getObject());
assertNotNull(gmlGos.getLod2MultiSurface());
assertNotNull(gmlGos.getLod2MultiSurface().getObject());
assertNotNull(gmlGos.getLod3MultiSurface());
assertNotNull(gmlGos.getLod3MultiSurface().getObject());
}
}
\ No newline at end of file
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTest.java
View file @ 0d2e9fd5
...@@ -24,6 +24,7 @@ import static org.junit.Assert.assertNotNull; ...@@ -24,6 +24,7 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame; import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
...@@ -31,6 +32,8 @@ import static org.mockito.Mockito.when; ...@@ -31,6 +32,8 @@ import static org.mockito.Mockito.when;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor;
import org.citygml4j.core.model.construction.AbstractConstructionSurface; import org.citygml4j.core.model.construction.AbstractConstructionSurface;
import org.citygml4j.core.model.construction.WallSurface; import org.citygml4j.core.model.construction.WallSurface;
import org.citygml4j.core.util.geometry.GeometryFactory; import org.citygml4j.core.util.geometry.GeometryFactory;
...@@ -44,6 +47,7 @@ import de.hft.stuttgart.citydoctor2.check.ResultStatus; ...@@ -44,6 +47,7 @@ import de.hft.stuttgart.citydoctor2.check.ResultStatus;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
import de.hft.stuttgart.citydoctor2.math.Vector3d; import de.hft.stuttgart.citydoctor2.math.Vector3d;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.mockito.Mockito;
/** /**
* *
...@@ -52,6 +56,20 @@ import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; ...@@ -52,6 +56,20 @@ import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
*/ */
public class GeometryTest { public class GeometryTest {
@Test
public void testVisitorPropagation() {
Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0);
ConcretePolygon mockPolygon = mock(ConcretePolygon.class);
geom.addPolygon(mockPolygon);
AbstractCheck c = new AbstractCheck() {
};
geom.accept(c);
verify(mockPolygon).accept(c);
}
@Test @Test
public void testCreate() { public void testCreate() {
Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0); Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0);
...@@ -282,7 +300,7 @@ public class GeometryTest { ...@@ -282,7 +300,7 @@ public class GeometryTest {
Polygon p = mock(Polygon.class); Polygon p = mock(Polygon.class);
geom.addPolygon(p); geom.addPolygon(p);
geom.clearAllContainedCheckResults(); geom.clearAllContainedCheckResults();
verify(p).clearAllContainedCheckResults(); verify(p).accept(any(ClearCheckResultsVisitor.class));
assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
} }
...@@ -292,11 +310,15 @@ public class GeometryTest { ...@@ -292,11 +310,15 @@ public class GeometryTest {
assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)); assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
Polygon p = mock(Polygon.class);
geom.addPolygon(p); Polygon p = new ConcretePolygon();
p.setExteriorRing(mock(LinearRing.class));
Polygon spyPoly = Mockito.spy(p);
geom.addPolygon(spyPoly);
List<CheckError> errors = new ArrayList<>(); List<CheckError> errors = new ArrayList<>();
geom.collectContainedErrors(errors); geom.collectContainedErrors(errors);
verify(p).collectContainedErrors(errors); verify(spyPoly).collectErrors(errors);
assertEquals(1, errors.size()); assertEquals(1, errors.size());
} }
...@@ -306,12 +328,16 @@ public class GeometryTest { ...@@ -306,12 +328,16 @@ public class GeometryTest {
assertFalse(geom.containsAnyError()); assertFalse(geom.containsAnyError());
geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class))); geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(geom.containsAnyError()); assertTrue(geom.containsAnyError());
Polygon p = mock(Polygon.class);
geom.addPolygon(p); Polygon p = new ConcretePolygon();
p.setExteriorRing(mock(LinearRing.class));
Polygon spyPoly = Mockito.spy(p);
geom.addPolygon(spyPoly);
geom.clearAllContainedCheckResults(); geom.clearAllContainedCheckResults();
assertFalse(geom.containsAnyError()); assertFalse(geom.containsAnyError());
verify(p).containsAnyError(); verify(spyPoly).hasAnyError();
when(p.containsAnyError()).thenReturn(true); spyPoly.addCheckResult((new CheckResult(CheckId.C_GE_R_NOT_CLOSED, ResultStatus.ERROR, mock(CheckError.class))));
assertTrue(geom.containsAnyError()); assertTrue(geom.containsAnyError());
} }
......
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java
View file @ 0d2e9fd5
...@@ -19,11 +19,29 @@ ...@@ -19,11 +19,29 @@
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType; import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
import org.xmlobjects.gml.model.geometry.primitives.AbstractRing;
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.Solid;
import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class GeometryTestUtils { public class GeometryTestUtils {
private static final double[] expectedValues = new double[]{427583.301, 6003502.571, 9.711, 427583.304, 6003502.574, 9.713,
427583.304, 6003502.574, 4.097, 427583.301, 6003502.571, 4.097, 427583.301, 6003502.571, 9.711};
private GeometryTestUtils() { private GeometryTestUtils() {
} }
public static double[] getExpectedValues() {
return expectedValues;
}
public static Geometry createDummyGeometry(GeometryType type) { public static Geometry createDummyGeometry(GeometryType type) {
return createDummyGeometry(type, Lod.LOD2); return createDummyGeometry(type, Lod.LOD2);
...@@ -90,4 +108,22 @@ public class GeometryTestUtils { ...@@ -90,4 +108,22 @@ public class GeometryTestUtils {
return geom; return geom;
} }
public static void assertSolidMatchesExpectedValues(AbstractSolid aSolid) {
assertTrue(aSolid instanceof Solid);
Solid solid = (Solid) aSolid;
Shell geometry = solid.getExterior().getObject();
List<SurfaceProperty> surfaceMember = geometry.getSurfaceMembers();
assertEquals(1, surfaceMember.size());
AbstractSurface polySurface = surfaceMember.get(0).getObject();
assertTrue(polySurface instanceof org.xmlobjects.gml.model.geometry.primitives.Polygon);
var gmlPoly = (org.xmlobjects.gml.model.geometry.primitives.Polygon) polySurface;
AbstractRing ring = gmlPoly.getExterior().getObject();
var gmlRing = (org.xmlobjects.gml.model.geometry.primitives.LinearRing) ring;
List<Double> posList = gmlRing.toCoordinateList3D();
double[] expectedValues = getExpectedValues();
for (int i = 0; i < posList.size(); i++) {
assertEquals(expectedValues[i], posList.get(i), 0.00000001);
}
}
} }
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryTest.java
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.check.AbstractCheck; 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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration; import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.Copy;
import org.citygml4j.core.model.core.ImplicitGeometry; import org.citygml4j.core.model.core.ImplicitGeometry;
import org.citygml4j.core.model.core.TransformationMatrix4x4; import org.citygml4j.core.model.core.TransformationMatrix4x4;
import org.junit.Before; import org.junit.Before;
...@@ -13,20 +18,25 @@ import org.xmlobjects.gml.util.jama.Matrix; ...@@ -13,20 +18,25 @@ import org.xmlobjects.gml.util.jama.Matrix;
import java.nio.file.Path; import java.nio.file.Path;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.Assert.*; import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
public class ImplicitGeometryTest { public class ImplicitGeometryTest {
private Path path;
private ParserConfiguration config; private ParserConfiguration config;
private String pathString = "src/test/resources/ImplicitTestGeom.gml"; private String pathString = "src/test/resources/ImplicitTestGeom.gml";
private Path path = Paths.get(pathString);
private TransformationMatrix4x4 origin; private TransformationMatrix4x4 origin;
private LibraryObject lib;
private ImplicitGeometryHolder igh;
@Before @Before
public void setUp() { public void setUp() {
path = Paths.get(pathString);
config = new ParserConfiguration(8, false); config = new ParserConfiguration(8, false);
Matrix og = new Matrix(4, 4); Matrix og = new Matrix(4, 4);
og.set(0, 0, 1); og.set(0, 0, 1);
...@@ -34,6 +44,17 @@ public class ImplicitGeometryTest { ...@@ -34,6 +44,17 @@ public class ImplicitGeometryTest {
og.set(2, 2, 1); og.set(2, 2, 1);
origin = new TransformationMatrix4x4(og); origin = new TransformationMatrix4x4(og);
lib = LibraryObject.of(path, config);
assertNotNull(lib);
// Create copy for cleanup
lib = Copy.copy(lib);
ImplicitGeometry geom = new ImplicitGeometry();
geom.setTransformationMatrix(origin);
geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(0, 0))));
igh = new ImplicitGeometryHolder(geom, lib);
assertNotNull(igh);
} }
@Test @Test
...@@ -41,43 +62,91 @@ public class ImplicitGeometryTest { ...@@ -41,43 +62,91 @@ public class ImplicitGeometryTest {
LibraryObject lo = LibraryObject.of(path, config); LibraryObject lo = LibraryObject.of(path, config);
assertNotNull(lo); assertNotNull(lo);
LibraryObject lo2 = LibraryObject.of(path, config); LibraryObject lo2 = LibraryObject.of(path, config);
assertNotNull(lo2);
assertSame(lo, lo2); assertSame(lo, lo2);
} }
@Test @Test
public void testObjectTransform() { public void testObjectTransform() {
LibraryObject lo = LibraryObject.of(path, config);
assertNotNull(lo);
ImplicitGeometry geom = new ImplicitGeometry(); ImplicitGeometry geom = new ImplicitGeometry();
geom.setTransformationMatrix(origin); geom.setTransformationMatrix(origin);
geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(0, 0)))); geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(0, 0))));
ImplicitGeometryHolder igh = new ImplicitGeometryHolder(geom, lo); ImplicitGeometryHolder transform1 = new ImplicitGeometryHolder(geom, lib);
assertNotNull(igh); assertNotNull(transform1);
geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(5, 8)))); geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(5, 8))));
ImplicitGeometryHolder igh2 = new ImplicitGeometryHolder(geom, lo); ImplicitGeometryHolder transform2 = new ImplicitGeometryHolder(geom, lib);
assertNotNull(igh2); assertNotNull(transform2);
assertNotEquals(igh, igh2); assertNotEquals(transform1, transform2);
BoundingBox bb1 = BoundingBox.of(igh.getPolygons()); BoundingBox bb1 = BoundingBox.of(transform1.getPolygons());
BoundingBox bb2 = BoundingBox.of(igh2.getPolygons()); BoundingBox bb2 = BoundingBox.of(transform2.getPolygons());
assertNotEquals(bb1, bb2); assertNotEquals(bb1, bb2);
}
@Test
public void testContainsError() {
assertFalse(lib.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(lib.containsError(CheckId.C_GE_P_NON_PLANAR));
igh.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertFalse("ImplicitGeometryHolder's errors should be ignored and delegate the call to the prototype geometry",
lib.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
lib.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(lib.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(lib.containsError(CheckId.C_GE_P_NON_PLANAR));
lib.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, null));
assertTrue(lib.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(lib.containsError(CheckId.C_GE_P_NON_PLANAR));
} }
@Test @Test
public void testAccept() { public void testClearAllContainedCheckResults() {
LibraryObject lib = LibraryObject.of(path, config); lib.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertNotNull(lib);
ImplicitGeometry geom = new ImplicitGeometry(); assertEquals(1, lib.getAllCheckResults().size());
geom.setTransformationMatrix(origin); lib.clearAllContainedCheckResults();
geom.setReferencePoint(new PointProperty(new Point(new DirectPosition(0, 0)))); assertTrue(lib.getAllCheckResults().isEmpty());
}
int polyCount = lib.getPolygons().size(); @Test
public void testContainsAnyError() {
assertFalse(lib.containsAnyError());
igh.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(lib.containsAnyError());
lib.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(lib.containsAnyError());
igh.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertFalse(lib.containsAnyError());
lib.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(lib.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
List<CheckError> errors = new ArrayList<>();
igh.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.ERROR, mock(CheckError.class)));
igh.collectContainedErrors(errors);
assertEquals("ImplicitGeometryHolder's errors should be ignored and delegate the call to the prototype geometry",
0, errors.size());
lib.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
igh.collectContainedErrors(errors);
assertEquals("ImplicitGeometryHolder's errors should be ignored and delegate the call to the prototype geometry",
1, errors.size());
}
ImplicitGeometryHolder igh = new ImplicitGeometryHolder(geom, lib);
@Test
public void testAccept() {
int polyCount = lib.getPolygons().size();
AtomicInteger loCounter = new AtomicInteger(0); AtomicInteger loCounter = new AtomicInteger(0);
......
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/LandUseTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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 org.citygml4j.core.model.landuse.LandUse;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Before;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
public class LandUseTest {
private LandUse lu;
private LandObject land;
@Before
public void setUp() {
lu = new LandUse();
land = new LandObject(lu);
}
@Test
public void testContainsError() {
assertFalse(land.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(land.containsError(CheckId.C_GE_P_NON_PLANAR));
land.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(land.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(land.containsError(CheckId.C_GE_P_NON_PLANAR));
land.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
assertTrue(land.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(land.containsError(CheckId.C_GE_P_NON_PLANAR));
}
@Test
public void testClearAllContainedCheckResults() {
land.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertEquals(1, land.getAllCheckResults().size());
land.clearAllContainedCheckResults();
assertTrue(land.getAllCheckResults().isEmpty());
}
@Test
public void testContainsAnyError() {
assertFalse(land.containsAnyError());
land.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(land.containsAnyError());
land.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(land.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
land.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
land.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGeometries() {
lu.setLod0MultiSurface(new MultiSurfaceProperty());
lu.setLod1MultiSurface(new MultiSurfaceProperty());
lu.setLod2MultiSurface(new MultiSurfaceProperty());
lu.setLod3MultiSurface(new MultiSurfaceProperty());
lu.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
land.clearGmlGeometries();
assertNull(lu.getLod0MultiSurface());
assertNull(lu.getLod1MultiSurface());
assertNull(lu.getLod2MultiSurface());
assertNull(lu.getLod3MultiSurface());
assertNull(lu.getDeprecatedProperties().getLod4MultiSurface());
}
@Test
public void testReCreateGeometries() {
land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
land.reCreateGeometries(factory, config);
assertNotNull(lu.getLod0MultiSurface());
assertNotNull(lu.getLod0MultiSurface().getObject());
assertNotNull(lu.getLod1MultiSurface());
assertNotNull(lu.getLod1MultiSurface().getObject());
assertNotNull(lu.getLod2MultiSurface());
assertNotNull(lu.getLod2MultiSurface().getObject());
assertNotNull(lu.getLod3MultiSurface());
assertNotNull(lu.getLod3MultiSurface().getObject());
assertNotNull(lu.getDeprecatedProperties().getLod4MultiSurface());
assertNotNull(lu.getDeprecatedProperties().getLod4MultiSurface().getObject());
}
}
\ No newline at end of file
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
import org.citygml4j.core.model.relief.ReliefFeature;
import org.junit.Test;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class ReliefObjectTest {
@Test
public void testVisitorPropagationReliefObject() {
ReliefFeature mockRelief = new ReliefFeature();
ReliefObject relief = new ReliefObject(mockRelief);
TinObject mockTin = mock(TinObject.class);
relief.addComponent(mockTin);
AbstractCheck c = new AbstractCheck() {
};
relief.accept(c);
verify(mockTin).accept(c);
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TinObjectTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.relief.TINRelief;
import org.citygml4j.core.model.relief.TinProperty;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class TinObjectTest {
@Test
public void testVisitorPropagation() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
Geometry mockGeometry = mock(Geometry.class);
tin.addGeometry(mockGeometry);
AbstractCheck c = new AbstractCheck() {
};
tin.accept(c);
verify(mockGeometry).accept(c);
}
@Test
public void testContainsError() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
assertFalse(tin.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tin.containsError(CheckId.C_GE_P_NON_PLANAR));
tin.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tin.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tin.containsError(CheckId.C_GE_P_NON_PLANAR));
tin.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
assertTrue(tin.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tin.containsError(CheckId.C_GE_P_NON_PLANAR));
}
@Test
public void testClearAllContainedCheckResults() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
tin.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertEquals(1, tin.getAllCheckResults().size());
tin.clearAllContainedCheckResults();
assertTrue(tin.getAllCheckResults().isEmpty());
}
@Test
public void testContainsAnyError() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
assertFalse(tin.containsAnyError());
tin.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(tin.containsAnyError());
tin.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tin.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
tin.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
tin.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGeometries() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
tir.setTin(new TinProperty());
tin.clearGmlGeometries();
assertNull(tir.getTin());
}
@Test
public void testReCreateGeometries() {
TINRelief tir = new TINRelief();
TinObject tin = new TinObject(tir);
tin.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
tin.reCreateGeometries(factory, config);
assertNotNull(tir.getTin());
assertNotNull(tir.getTin().getObject());
assertEquals(2, tir.getLod());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TopLevelTransportFeatureTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace;
import org.citygml4j.core.model.transportation.Railway;
import org.citygml4j.core.model.transportation.Road;
import org.citygml4j.core.model.transportation.Square;
import org.citygml4j.core.model.transportation.Track;
import org.citygml4j.core.model.transportation.Waterway;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import org.mockito.Mockito;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class TopLevelTransportFeatureTest {
@Test
public void testObjectConstruction() {
TopLevelTransportFeature road = TopLevelTransportFeature.from(Mockito.mock(Road.class));
assertEquals(TransportationObject.TransportationType.ROAD, road.getTransportationType());
TopLevelTransportFeature track = TopLevelTransportFeature.from(Mockito.mock(Track.class));
assertEquals(TransportationObject.TransportationType.TRACK, track.getTransportationType());
TopLevelTransportFeature waterway = TopLevelTransportFeature.from(Mockito.mock(Waterway.class));
assertEquals(TransportationObject.TransportationType.WATERWAY, waterway.getTransportationType());
TopLevelTransportFeature railway = TopLevelTransportFeature.from(Mockito.mock(Railway.class));
assertEquals(TransportationObject.TransportationType.RAILWAY, railway.getTransportationType());
TopLevelTransportFeature square = TopLevelTransportFeature.from(Mockito.mock(Square.class));
assertEquals(TransportationObject.TransportationType.SQUARE, square.getTransportationType());
}
@Test
public void testVisitorPropagation() {
Road road = new Road();
TopLevelTransportFeature top = TopLevelTransportFeature.from(road);
TransportSection mockSection = mock(TransportSection.class);
TransportSection mockIntersection = mock(TransportSection.class);
top.addSection(mockSection);
top.addIntersection(mockIntersection);
AbstractCheck c = new AbstractCheck() {
};
top.accept(c);
verify(mockSection).accept(c);
verify(mockIntersection).accept(c);
}
@Test
public void testContainsError() {
Road road = new Road();
TopLevelTransportFeature top = TopLevelTransportFeature.from(road);
assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(top.containsError(CheckId.C_GE_P_NON_PLANAR));
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(top.containsError(CheckId.C_GE_P_NON_PLANAR));
top.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(top.containsError(CheckId.C_GE_P_NON_PLANAR));
}
@Test
public void testContainsAnyError() {
Road road = new Road();
TopLevelTransportFeature top = TopLevelTransportFeature.from(road);
assertFalse(top.containsAnyError());
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(top.containsAnyError());
top.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(top.containsAnyError());
}
@Test
public void testClearAllContainedCheckResults() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
top.clearAllContainedCheckResults();
assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testCollectContainedErrors() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
top.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometries() {
Road r = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(r);
top.setGmlObject(r);
DeprecatedPropertiesOfAbstractTransportationSpace dSpace = mock(DeprecatedPropertiesOfAbstractTransportationSpace.class);
when(r.getDeprecatedProperties()).thenReturn(dSpace);
dSpace.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
top.unsetGmlGeometries();
assertNull(dSpace.getLod1MultiSurface());
assertNull(r.getLod2MultiSurface());
assertNull(r.getLod3MultiSurface());
assertNull(dSpace.getLod4MultiSurface());
}
@Test
public void testReCreateGeometriesSolid() {
Road gmlRoad = new Road();
TopLevelTransportFeature top = TopLevelTransportFeature.from(gmlRoad);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
top.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurface() {
Road gmlRoad = new Road();
TopLevelTransportFeature top = TopLevelTransportFeature.from(gmlRoad);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
top.reCreateGeometries(factory, config);
assertNotNull(gmlRoad.getLod0MultiSurface());
assertNotNull(gmlRoad.getLod0MultiSurface().getObject());
assertNotNull(gmlRoad.getDeprecatedProperties().getLod1MultiSurface());
assertNotNull(gmlRoad.getDeprecatedProperties().getLod1MultiSurface().getObject());
assertNotNull(gmlRoad.getLod2MultiSurface());
assertNotNull(gmlRoad.getLod2MultiSurface().getObject());
assertNotNull(gmlRoad.getLod3MultiSurface());
assertNotNull(gmlRoad.getLod3MultiSurface().getObject());
assertNotNull(gmlRoad.getDeprecatedProperties().getLod4MultiSurface());
assertNotNull(gmlRoad.getDeprecatedProperties().getLod4MultiSurface().getObject());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficAreaTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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 org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface;
import org.citygml4j.core.model.transportation.TrafficArea;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class TrafficAreaTest {
@Test
public void testContainsError() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tao.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testContainsAnyError() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
assertFalse(tao.containsAnyError());
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(tao.containsAnyError());
tao.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tao.containsAnyError());
}
@Test
public void testClearAllContainedCheckResults() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tao.clearAllContainedCheckResults();
assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testCollectContainedErrors() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
tao.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometries() {
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea r = mock(TrafficArea.class);
ta.setGmlObject(r);
DeprecatedPropertiesOfAbstractThematicSurface dSpace = mock(DeprecatedPropertiesOfAbstractThematicSurface.class);
when(r.getDeprecatedProperties()).thenReturn(dSpace);
r.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
ta.unsetGmlGeometries();
assertNull(r.getLod0MultiSurface());
assertNull(r.getLod1MultiSurface());
assertNull(r.getLod2MultiSurface());
assertNull(r.getLod3MultiSurface());
assertNull(dSpace.getLod4MultiSurface());
}
@Test
public void testReCreateGeometriesMultiSurface() {
TrafficArea gmlAus = new TrafficArea() {
};
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
tao.setGmlObject(gmlAus);
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
tao.reCreateGeometries(factory, config);
assertNotNull(gmlAus.getLod0MultiSurface());
assertNotNull(gmlAus.getLod0MultiSurface().getObject());
assertNotNull(gmlAus.getLod2MultiSurface());
assertNotNull(gmlAus.getLod2MultiSurface().getObject());
assertNotNull(gmlAus.getLod3MultiSurface());
assertNotNull(gmlAus.getLod3MultiSurface().getObject());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor;
import org.citygml4j.core.model.core.AbstractSpaceBoundary;
import org.citygml4j.core.model.core.AbstractUnoccupiedSpace;
import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractCityObject;
import org.citygml4j.core.model.transportation.TrafficSpace;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.citygml4j.core.visitor.ObjectVisitor;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
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.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class TrafficSpaceTest {
@Test
public void testVisitorPropagation() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficAreaObject areaMock = mock(TrafficAreaObject.class);
tso.addTrafficArea(areaMock);
AbstractCheck c = new AbstractCheck() {
};
tso.accept(c);
verify(areaMock).accept(c);
}
@Test
public void testContainsError() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tso.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testContainsAnyError() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
assertFalse(tso.containsAnyError());
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(tso.containsAnyError());
tso.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tso.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
tso.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testClearAllContainedCheckResults() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace tsMock = mock(TrafficSpace.class);
tso.setGmlObject(tsMock);
TrafficAreaObject taMock = mock(TrafficAreaObject.class);
tso.addTrafficArea(taMock);
assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tso.clearAllContainedCheckResults();
assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
verify(taMock).accept(any(ClearCheckResultsVisitor.class));
}
@Test
public void testUnsetGmlGeometries() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace t = mock(TrafficSpace.class);
tso.setGmlObject(t);
DeprecatedPropertiesOfAbstractCityObject dSpace = mock(DeprecatedPropertiesOfAbstractCityObject.class);
when(t.getDeprecatedProperties()).thenReturn(dSpace);
t.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
t.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
t.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
tso.unsetGmlGeometries();
assertNull(t.getLod0MultiSurface());
assertNull(t.getLod2MultiSurface());
assertNull(t.getLod3MultiSurface());
}
@Test
public void testReCreateGeometriesSolid() {
AbstractUnoccupiedSpace gmlAus = new AbstractUnoccupiedSpace() {
@Override
public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
return false;
}
@Override
public void accept(ObjectVisitor visitor) {
}
};
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE) {
};
tso.setGmlObject(gmlAus);
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
tso.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurface() {
AbstractUnoccupiedSpace gmlAus = new AbstractUnoccupiedSpace() {
@Override
public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
return false;
}
@Override
public void accept(ObjectVisitor visitor) {
}
};
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
tso.setGmlObject(gmlAus);
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
tso.reCreateGeometries(factory, config);
assertNotNull(gmlAus.getLod0MultiSurface());
assertNotNull(gmlAus.getLod0MultiSurface().getObject());
assertNotNull(gmlAus.getLod2MultiSurface());
assertNotNull(gmlAus.getLod2MultiSurface().getObject());
assertNotNull(gmlAus.getLod3MultiSurface());
assertNotNull(gmlAus.getLod3MultiSurface().getObject());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationObjectTest.java
View file @ 0d2e9fd5
...@@ -19,41 +19,10 @@ ...@@ -19,41 +19,10 @@
package de.hft.stuttgart.citydoctor2.datastructure; package de.hft.stuttgart.citydoctor2.datastructure;
import static org.junit.Assert.assertEquals; 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.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractCityObject;
import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface;
import org.citygml4j.core.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace;
import org.citygml4j.core.model.transportation.Intersection;
import org.citygml4j.core.model.transportation.Railway;
import org.citygml4j.core.model.transportation.Road; import org.citygml4j.core.model.transportation.Road;
import org.citygml4j.core.model.transportation.Section;
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.Waterway;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test; import org.junit.Test;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
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.TransportationObject.TransportationType;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
public class TransportationObjectTest { public class TransportationObjectTest {
...@@ -63,476 +32,5 @@ public class TransportationObjectTest { ...@@ -63,476 +32,5 @@ public class TransportationObjectTest {
assertEquals(FeatureType.TRANSPORTATION, to.getFeatureType()); assertEquals(FeatureType.TRANSPORTATION, to.getFeatureType());
} }
@Test
public void testObjectConstruction() {
TopLevelTransportFeature road = TopLevelTransportFeature.from(Mockito.mock(Road.class));
assertEquals(TransportationType.ROAD, road.getTransportationType());
TopLevelTransportFeature track = TopLevelTransportFeature.from(Mockito.mock(Track.class));
assertEquals(TransportationType.TRACK, track.getTransportationType());
TopLevelTransportFeature waterway = TopLevelTransportFeature.from(Mockito.mock(Waterway.class));
assertEquals(TransportationType.WATERWAY, waterway.getTransportationType());
TopLevelTransportFeature railway = TopLevelTransportFeature.from(Mockito.mock(Railway.class));
assertEquals(TransportationType.RAILWAY, railway.getTransportationType());
TopLevelTransportFeature square = TopLevelTransportFeature.from(Mockito.mock(Square.class));
assertEquals(TransportationType.SQUARE, square.getTransportationType());
}
@Test(expected = IllegalStateException.class)
public void testReCreateGeometriesSolid() {
TopLevelTransportFeature to = TopLevelTransportFeature.from(Mockito.mock(Road.class));
to.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
GeometryFactory factory = GeometryFactory.newInstance();
to.reCreateGeometries(factory, mock(ParserConfiguration.class));
}
@Test
public void testReCreateGeometriesTransportationSpace() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TransportSection sectionMock = Mockito.mock(TransportSection.class);
TransportSection intersectionMock = Mockito.mock(TransportSection.class);
TrafficSpaceObject tsMock = Mockito.mock(TrafficSpaceObject.class);
TrafficSpaceObject auxTsMock = Mockito.mock(TrafficSpaceObject.class);
top.addSection(sectionMock);
top.addIntersection(intersectionMock);
top.addTrafficSpace(tsMock);
top.addAuxTrafficSpace(auxTsMock);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(roadMock).setLod2MultiSurface(any());
verify(sectionMock).reCreateGeometries(any(), any());
verify(intersectionMock).reCreateGeometries(any(), any());
verify(tsMock).reCreateGeometries(any(), any());
verify(auxTsMock).reCreateGeometries(any(), any());
}
@Test
public void testReCreateGeometriesTrafficSpace() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace tsMock = mock(TrafficSpace.class);
tso.setGmlObject(tsMock);
TrafficAreaObject taoMock = Mockito.mock(TrafficAreaObject.class);
tso.addTrafficArea(taoMock);
tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
GeometryFactory factory = GeometryFactory.newInstance();
tso.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(tsMock).setLod2MultiSurface(any());
verify(taoMock).reCreateGeometries(any(), any());
}
@Test
public void testReCreateGeometriesTrafficArea() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
GeometryFactory factory = GeometryFactory.newInstance();
tao.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(taMock).setLod2MultiSurface(any());
}
@Test
public void testReCreateGeometriesMultiSurfaceLod0() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TrafficSpaceObject ts = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace trafficSpaceMock = mock(TrafficSpace.class);
ts.setGmlObject(trafficSpaceMock);
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea trafficAreaMock = mock(TrafficArea.class);
ta.setGmlObject(trafficAreaMock);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
ts.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
ta.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
ts.reCreateGeometries(factory, mock(ParserConfiguration.class));
ta.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(roadMock).setLod0MultiSurface(any());
verify(trafficSpaceMock).setLod0MultiSurface(any());
verify(trafficAreaMock).setLod0MultiSurface(any());
}
@Test
public void testReCreateGeometriesMultiSurfaceLod1() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea trafficAreaMock = mock(TrafficArea.class);
ta.setGmlObject(trafficAreaMock);
DeprecatedPropertiesOfAbstractTransportationSpace dSpace = mock(DeprecatedPropertiesOfAbstractTransportationSpace.class);
when(roadMock.getDeprecatedProperties()).thenReturn(dSpace);
try {
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
} catch (IllegalArgumentException e) {
fail("Casting of original GML object to AbstractTransportationSpace should work");
}
ta.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
ta.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(dSpace).setLod1MultiSurface(any());
verify(trafficAreaMock).setLod1MultiSurface(any());
}
@Test
public void testReCreateGeometriesMultiSurfaceLod2() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TrafficSpaceObject ts = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace trafficSpaceMock = mock(TrafficSpace.class);
ts.setGmlObject(trafficSpaceMock);
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea trafficAreaMock = mock(TrafficArea.class);
ta.setGmlObject(trafficAreaMock);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
ts.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
ta.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
ts.reCreateGeometries(factory, mock(ParserConfiguration.class));
ta.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(roadMock).setLod2MultiSurface(any());
verify(trafficSpaceMock).setLod2MultiSurface(any());
verify(trafficAreaMock).setLod2MultiSurface(any());
}
@Test
public void testReCreateGeometriesMultiSurfaceLod3() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TrafficSpaceObject ts = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace trafficSpaceMock = mock(TrafficSpace.class);
ts.setGmlObject(trafficSpaceMock);
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea trafficAreaMock = mock(TrafficArea.class);
ta.setGmlObject(trafficAreaMock);
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
ts.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
ta.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
ts.reCreateGeometries(factory, mock(ParserConfiguration.class));
ta.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(roadMock).setLod3MultiSurface(any());
verify(trafficSpaceMock).setLod3MultiSurface(any());
verify(trafficAreaMock).setLod3MultiSurface(any());
}
@Test
public void testReCreateGeometriesMultiSurfaceLod4() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea trafficAreaMock = mock(TrafficArea.class);
ta.setGmlObject(trafficAreaMock);
DeprecatedPropertiesOfAbstractTransportationSpace dSpace = mock(DeprecatedPropertiesOfAbstractTransportationSpace.class);
when(roadMock.getDeprecatedProperties()).thenReturn(dSpace);
DeprecatedPropertiesOfAbstractThematicSurface dArea = mock(DeprecatedPropertiesOfAbstractThematicSurface.class);
when(trafficAreaMock.getDeprecatedProperties()).thenReturn(dArea);
ta.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
try {
top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
} catch (IllegalArgumentException e) {
fail("Casting of original GML object to AbstractTransportationSpace should work");
}
GeometryFactory factory = GeometryFactory.newInstance();
top.reCreateGeometries(factory, mock(ParserConfiguration.class));
ta.reCreateGeometries(factory, mock(ParserConfiguration.class));
verify(dSpace).setLod4MultiSurface(any());
verify(dArea).setLod4MultiSurface(any());
}
@Test
public void testContainsErrorTransportationSpace() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TransportSection sectionMock = Mockito.mock(TransportSection.class);
TransportSection intersectionMock = Mockito.mock(TransportSection.class);
TrafficSpaceObject tsMock = Mockito.mock(TrafficSpaceObject.class);
TrafficSpaceObject auxTsMock = Mockito.mock(TrafficSpaceObject.class);
top.addSection(sectionMock);
top.addIntersection(intersectionMock);
top.addTrafficSpace(tsMock);
top.addAuxTrafficSpace(auxTsMock);
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(top.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
verify(sectionMock).containsError(any());
verify(intersectionMock).containsError(any());
verify(tsMock).containsError(any());
verify(auxTsMock).containsError(any());
}
@Test
public void testContainsErrorTrafficSpace() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace tsMock = mock(TrafficSpace.class);
tso.setGmlObject(tsMock);
TrafficAreaObject taMock = mock(TrafficAreaObject.class);
tso.addTrafficArea(taMock);
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tso.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
verify(taMock).containsError(any());
}
@Test
public void testContainsErrorTrafficArea() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(tao.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testClearAllContainedCheckResultsTransportationSpace() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TransportSection sectionMock = Mockito.mock(TransportSection.class);
TransportSection intersectionMock = Mockito.mock(TransportSection.class);
TrafficSpaceObject tsMock = Mockito.mock(TrafficSpaceObject.class);
TrafficSpaceObject auxTsMock = Mockito.mock(TrafficSpaceObject.class);
top.addSection(sectionMock);
top.addIntersection(intersectionMock);
top.addTrafficSpace(tsMock);
top.addAuxTrafficSpace(auxTsMock);
assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
top.clearAllContainedCheckResults();
assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
verify(sectionMock).clearAllContainedCheckResults();
verify(intersectionMock).clearAllContainedCheckResults();
verify(tsMock).clearAllContainedCheckResults();
verify(auxTsMock).clearAllContainedCheckResults();
}
@Test
public void testClearAllContainedCheckResultsTrafficSpace() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace tsMock = mock(TrafficSpace.class);
tso.setGmlObject(tsMock);
TrafficAreaObject taMock = mock(TrafficAreaObject.class);
tso.addTrafficArea(taMock);
assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tso.clearAllContainedCheckResults();
assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
verify(taMock).clearAllContainedCheckResults();
}
@Test
public void testClearAllContainedCheckResultsTrafficArea() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
tao.clearAllContainedCheckResults();
assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testCollectContainedErrorsTransportationSpace() {
Road roadMock = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
top.setGmlObject(roadMock);
TransportSection sectionMock = Mockito.mock(TransportSection.class);
TransportSection intersectionMock = Mockito.mock(TransportSection.class);
TrafficSpaceObject tsMock = Mockito.mock(TrafficSpaceObject.class);
TrafficSpaceObject auxTsMock = Mockito.mock(TrafficSpaceObject.class);
top.addSection(sectionMock);
top.addIntersection(intersectionMock);
top.addTrafficSpace(tsMock);
top.addAuxTrafficSpace(auxTsMock);
top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
top.collectContainedErrors(errors);
assertEquals(1, errors.size());
verify(sectionMock).collectContainedErrors(errors);
verify(intersectionMock).collectContainedErrors(errors);
verify(tsMock).collectContainedErrors(errors);
verify(auxTsMock).collectContainedErrors(errors);
}
@Test
public void testCollectContainedErrorsTrafficSpace() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace tsMock = mock(TrafficSpace.class);
tso.setGmlObject(tsMock);
TrafficAreaObject taMock = mock(TrafficAreaObject.class);
tso.addTrafficArea(taMock);
tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
tso.collectContainedErrors(errors);
assertEquals(1, errors.size());
verify(taMock).collectContainedErrors(errors);
}
@Test
public void testCollectContainedErrorsTrafficArea() {
TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea taMock = mock(TrafficArea.class);
tao.setGmlObject(taMock);
tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
tao.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometriesTransportationSpace() {
Road r = mock(Road.class);
TopLevelTransportFeature top = TopLevelTransportFeature.from(r);
top.setGmlObject(r);
TransportSection mockSection = mock(TransportSection.class);
TransportSection mockInterestSection = mock(TransportSection.class);
TrafficSpaceObject mockSpace = mock(TrafficSpaceObject.class);
TrafficSpaceObject auxMockSpace = mock(TrafficSpaceObject.class);
top.addSection(mockSection);
top.addIntersection(mockInterestSection);
top.addTrafficSpace(mockSpace);
top.addAuxTrafficSpace(auxMockSpace);
DeprecatedPropertiesOfAbstractTransportationSpace dSpace = mock(DeprecatedPropertiesOfAbstractTransportationSpace.class);
when(r.getDeprecatedProperties()).thenReturn(dSpace);
dSpace.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
top.unsetGmlGeometries();
assertNull(dSpace.getLod1MultiSurface());
assertNull(r.getLod2MultiSurface());
assertNull(r.getLod3MultiSurface());
assertNull(dSpace.getLod4MultiSurface());
verify(mockSection).unsetGmlGeometries();
verify(mockInterestSection).unsetGmlGeometries();
verify(mockSpace).unsetGmlGeometries();
verify(auxMockSpace).unsetGmlGeometries();
}
@Test
public void testUnsetGmlGeometriesTrafficSpace() {
TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
TrafficSpace t = mock(TrafficSpace.class);
tso.setGmlObject(t);
TrafficAreaObject mockArea = mock(TrafficAreaObject.class);
tso.addTrafficArea(mockArea);
DeprecatedPropertiesOfAbstractCityObject dSpace = mock(DeprecatedPropertiesOfAbstractCityObject.class);
when(t.getDeprecatedProperties()).thenReturn(dSpace);
t.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
t.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
t.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
tso.unsetGmlGeometries();
assertNull(t.getLod0MultiSurface());
assertNull(t.getLod2MultiSurface());
assertNull(t.getLod3MultiSurface());
verify(mockArea).unsetGmlGeometries();
}
@Test
public void testUnsetGmlGeometriesTrafficArea() {
TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
TrafficArea r = mock(TrafficArea.class);
ta.setGmlObject(r);
DeprecatedPropertiesOfAbstractThematicSurface dSpace = mock(DeprecatedPropertiesOfAbstractThematicSurface.class);
when(r.getDeprecatedProperties()).thenReturn(dSpace);
r.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
ta.unsetGmlGeometries();
assertNull(r.getLod0MultiSurface());
assertNull(r.getLod1MultiSurface());
assertNull(r.getLod2MultiSurface());
assertNull(r.getLod3MultiSurface());
assertNull(dSpace.getLod4MultiSurface());
}
} }
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpaceTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.transportation.AbstractTransportationSpace;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.citygml4j.core.visitor.ObjectVisitor;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class TransportationSpaceTest {
@Test
public void testVisitorPropagation() {
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
TrafficSpaceObject mockSpace = mock(TrafficSpaceObject.class);
TrafficSpaceObject auxMockSpace = mock(TrafficSpaceObject.class);
space.addTrafficSpace(mockSpace);
space.addAuxTrafficSpace(auxMockSpace);
AbstractCheck c = new AbstractCheck() {
};
space.accept(c);
verify(mockSpace).accept(c);
verify(auxMockSpace).accept(c);
}
@Test
public void testContainsError() {
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
space.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(space.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(space.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testContainsAnyError() {
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
assertFalse(space.containsAnyError());
space.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(space.containsAnyError());
space.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(space.containsAnyError());
}
@Test
public void testCollectContainedErrors() {
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
space.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
space.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testClearAllContainedCheckResults() {
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
assertFalse(space.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
space.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(space.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
space.clearAllContainedCheckResults();
assertFalse(space.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testReCreateGeometriesSolid() {
AbstractTransportationSpace gmlAts = new AbstractTransportationSpace() {
@Override
public void accept(ObjectVisitor visitor) {
}
};
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
space.setGmlObject(gmlAts);
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
space.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurface() {
AbstractTransportationSpace gmlAts = new AbstractTransportationSpace() {
@Override
public void accept(ObjectVisitor visitor) {
}
};
TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
};
space.setGmlObject(gmlAts);
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
space.reCreateGeometries(factory, config);
assertNotNull(gmlAts.getLod0MultiSurface());
assertNotNull(gmlAts.getLod0MultiSurface().getObject());
assertNotNull(gmlAts.getDeprecatedProperties().getLod1MultiSurface());
assertNotNull(gmlAts.getDeprecatedProperties().getLod1MultiSurface().getObject());
assertNotNull(gmlAts.getLod2MultiSurface());
assertNotNull(gmlAts.getLod2MultiSurface().getObject());
assertNotNull(gmlAts.getLod3MultiSurface());
assertNotNull(gmlAts.getLod3MultiSurface().getObject());
assertNotNull(gmlAts.getDeprecatedProperties().getLod4MultiSurface());
assertNotNull(gmlAts.getDeprecatedProperties().getLod4MultiSurface().getObject());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/VegetationTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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 org.citygml4j.core.model.vegetation.PlantCover;
import org.citygml4j.core.model.vegetation.SolitaryVegetationObject;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.GeometryProperty;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSolidProperty;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
public class VegetationTest {
//TODO: Recreate geometries tests
@Test
public void testContainsError() {
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
veg.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(veg.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(veg.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testContainsAnyError() {
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
assertFalse(veg.containsAnyError());
veg.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(veg.containsAnyError());
veg.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(veg.containsAnyError());
}
@Test
public void testClearAllContainedCheckResults() {
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
assertFalse(veg.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
veg.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(veg.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
veg.clearAllContainedCheckResults();
assertFalse(veg.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testCollectContainedErrors() {
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
veg.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
veg.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometriesPlantCover() {
Vegetation plantCover = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
PlantCover gmlCover = new PlantCover();
plantCover.setGmlObject(gmlCover);
gmlCover.setLod0MultiSurface(new MultiSurfaceProperty());
gmlCover.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty());
gmlCover.setLod2MultiSurface(new MultiSurfaceProperty());
gmlCover.setLod3MultiSurface(new MultiSurfaceProperty());
gmlCover.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
gmlCover.setLod1Solid(new SolidProperty());
gmlCover.setLod2Solid(new SolidProperty());
gmlCover.setLod3Solid(new SolidProperty());
gmlCover.getDeprecatedProperties().setLod1MultiSolid(new MultiSolidProperty());
gmlCover.getDeprecatedProperties().setLod2MultiSolid(new MultiSolidProperty());
gmlCover.getDeprecatedProperties().setLod3MultiSolid(new MultiSolidProperty());
gmlCover.getDeprecatedProperties().setLod4MultiSolid(new MultiSolidProperty());
plantCover.clearGmlGeometries();
assertNull(gmlCover.getLod0MultiSurface());
assertNull(gmlCover.getDeprecatedProperties().getLod1MultiSurface());
assertNull(gmlCover.getLod2MultiSurface());
assertNull(gmlCover.getLod3MultiSurface());
assertNull(gmlCover.getDeprecatedProperties().getLod4MultiSurface());
assertNull(gmlCover.getLod1Solid());
assertNull(gmlCover.getLod2Solid());
assertNull(gmlCover.getLod3Solid());
assertNull(gmlCover.getDeprecatedProperties().getLod1MultiSolid());
assertNull(gmlCover.getDeprecatedProperties().getLod2MultiSolid());
assertNull(gmlCover.getDeprecatedProperties().getLod3MultiSolid());
assertNull(gmlCover.getDeprecatedProperties().getLod4MultiSolid());
}
@Test
public void testUnsetGmlGeometriesSolitaryVegetationObject() {
Vegetation solitary = new Vegetation(Vegetation.VegetationType.SOLITARY_VEGETATION_OBJECT);
SolitaryVegetationObject gmlSolitary = new SolitaryVegetationObject();
solitary.setGmlObject(gmlSolitary);
gmlSolitary.setLod0MultiSurface(new MultiSurfaceProperty());
gmlSolitary.setLod2MultiSurface(new MultiSurfaceProperty());
gmlSolitary.setLod3MultiSurface(new MultiSurfaceProperty());
gmlSolitary.setLod1Solid(new SolidProperty());
gmlSolitary.setLod2Solid(new SolidProperty());
gmlSolitary.setLod3Solid(new SolidProperty());
gmlSolitary.getDeprecatedProperties().setLod1Geometry(new GeometryProperty<>());
gmlSolitary.getDeprecatedProperties().setLod2Geometry(new GeometryProperty<>());
gmlSolitary.getDeprecatedProperties().setLod3Geometry(new GeometryProperty<>());
gmlSolitary.getDeprecatedProperties().setLod4Geometry(new GeometryProperty<>());
solitary.clearGmlGeometries();
assertNull(gmlSolitary.getLod0MultiSurface());
assertNull(gmlSolitary.getLod2MultiSurface());
assertNull(gmlSolitary.getLod3MultiSurface());
assertNull(gmlSolitary.getLod1Solid());
assertNull(gmlSolitary.getLod2Solid());
assertNull(gmlSolitary.getLod3Solid());
assertNull(gmlSolitary.getDeprecatedProperties().getLod1Geometry());
assertNull(gmlSolitary.getDeprecatedProperties().getLod2Geometry());
assertNull(gmlSolitary.getDeprecatedProperties().getLod3Geometry());
assertNull(gmlSolitary.getDeprecatedProperties().getLod4Geometry());
}
@Test
public void testReCreateGeometriesSolidPlantCover() {
PlantCover gmlPC = new PlantCover();
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
veg.setGmlObject(gmlPC);
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
veg.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurfacePlantCover() {
PlantCover gmlPC = new PlantCover();
Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
veg.setGmlObject(gmlPC);
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
veg.reCreateGeometries(factory, config);
assertNotNull(gmlPC.getLod0MultiSurface());
assertNotNull(gmlPC.getLod0MultiSurface().getObject());
assertNotNull(gmlPC.getDeprecatedProperties().getLod1MultiSurface());
assertNotNull(gmlPC.getDeprecatedProperties().getLod1MultiSurface().getObject());
assertNotNull(gmlPC.getLod2MultiSurface());
assertNotNull(gmlPC.getLod2MultiSurface().getObject());
assertNotNull(gmlPC.getLod3MultiSurface());
assertNotNull(gmlPC.getLod3MultiSurface().getObject());
assertNotNull(gmlPC.getDeprecatedProperties().getLod4MultiSurface());
assertNotNull(gmlPC.getDeprecatedProperties().getLod4MultiSurface().getObject());
}
@Test
public void testReCreateGeometriesSolidSolitaryVegetationObject() {
SolitaryVegetationObject gmlPC = new SolitaryVegetationObject();
Vegetation veg = new Vegetation(Vegetation.VegetationType.SOLITARY_VEGETATION_OBJECT);
veg.setGmlObject(gmlPC);
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
veg.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod3Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurfaceSolitaryVegetationObject() {
SolitaryVegetationObject gmlPC = new SolitaryVegetationObject();
Vegetation veg = new Vegetation(Vegetation.VegetationType.SOLITARY_VEGETATION_OBJECT);
veg.setGmlObject(gmlPC);
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
veg.reCreateGeometries(factory, config);
assertNotNull(gmlPC.getLod0MultiSurface());
assertNotNull(gmlPC.getLod0MultiSurface().getObject());
assertNotNull(gmlPC.getDeprecatedProperties().getLod1Geometry());
assertNotNull(gmlPC.getDeprecatedProperties().getLod1Geometry().getObject());
assertNotNull(gmlPC.getLod2MultiSurface());
assertNotNull(gmlPC.getLod2MultiSurface().getObject());
assertNotNull(gmlPC.getLod3MultiSurface());
assertNotNull(gmlPC.getLod3MultiSurface().getObject());
assertNotNull(gmlPC.getDeprecatedProperties().getLod4Geometry());
assertNotNull(gmlPC.getDeprecatedProperties().getLod4Geometry().getObject());
}
}
CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/WaterTest.java 0 → 100644
View file @ 0d2e9fd5
package de.hft.stuttgart.citydoctor2.datastructure;
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.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import org.citygml4j.core.model.waterbody.WaterBody;
import org.citygml4j.core.util.geometry.GeometryFactory;
import org.junit.Test;
import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class WaterTest {
@Test
public void testVisitorPropagation() {
WaterObject water = new WaterObject();
BoundarySurface bsMock = mock(BoundarySurface.class);
BoundarySurface bsMock2 = mock(BoundarySurface.class);
water.addBoundarySurface(bsMock);
water.addBoundarySurface(bsMock2);
AbstractCheck c = new AbstractCheck() {
};
water.accept(c);
verify(bsMock).accept(c);
verify(bsMock2).accept(c);
}
@Test
public void testContainsError() {
WaterObject water = new WaterObject();
water.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(water.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
assertFalse(water.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
}
@Test
public void testContainsAnyError() {
WaterObject water = new WaterObject();
assertFalse(water.containsAnyError());
water.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
assertFalse(water.containsAnyError());
water.addCheckResult(
new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(water.containsAnyError());
}
@Test
public void testClearAllContainedCheckResults() {
WaterObject water = new WaterObject();
assertFalse(water.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
water.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
assertTrue(water.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
water.clearAllContainedCheckResults();
assertFalse(water.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
}
@Test
public void testCollectContainedErrors() {
WaterObject water = new WaterObject();
water.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
List<CheckError> errors = new ArrayList<>();
water.collectContainedErrors(errors);
assertEquals(1, errors.size());
}
@Test
public void testUnsetGmlGeometries() {
WaterObject water = new WaterObject();
WaterBody gmlWater = new WaterBody();
water.setGmlObject(gmlWater);
gmlWater.setLod0MultiSurface(new MultiSurfaceProperty());
gmlWater.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty());
gmlWater.setLod2MultiSurface(new MultiSurfaceProperty());
gmlWater.setLod3MultiSurface(new MultiSurfaceProperty());
gmlWater.setLod1Solid(new SolidProperty());
gmlWater.setLod2Solid(new SolidProperty());
gmlWater.setLod3Solid(new SolidProperty());
gmlWater.getDeprecatedProperties().setLod4Solid(new SolidProperty());
water.clearGmlGeometries();
assertNull(gmlWater.getLod0MultiSurface());
assertNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface());
assertNull(gmlWater.getLod2MultiSurface());
assertNull(gmlWater.getLod3MultiSurface());
assertNull(gmlWater.getLod1Solid());
assertNull(gmlWater.getLod2Solid());
assertNull(gmlWater.getLod3Solid());
assertNull(gmlWater.getDeprecatedProperties().getLod4Solid());
}
@Test
public void testReCreateGeometriesSolid() {
WaterBody gmlWater = new WaterBody();
WaterObject water = new WaterObject();
water.setGmlObject(gmlWater);
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
water.reCreateGeometries(factory, config);
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod1Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod2Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod3Solid().getObject());
GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getDeprecatedProperties().getLod4Solid().getObject());
}
@Test
public void testReCreateGeometriesMultiSurface() {
WaterBody gmlWater = new WaterBody();
WaterObject water = new WaterObject();
water.setGmlObject(gmlWater);
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
GeometryFactory factory = GeometryFactory.newInstance();
ParserConfiguration config = new ParserConfiguration(8, false);
water.reCreateGeometries(factory, config);
assertNotNull(gmlWater.getLod0MultiSurface());
assertNotNull(gmlWater.getLod0MultiSurface().getObject());
assertNotNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface());
assertNotNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface().getObject());
assertNotNull(gmlWater.getLod2MultiSurface());
assertNotNull(gmlWater.getLod2MultiSurface().getObject());
assertNotNull(gmlWater.getLod3MultiSurface());
assertNotNull(gmlWater.getLod3MultiSurface().getObject());
}
}
CityDoctorParent/CityDoctorValidation/pom.xml
View file @ 0d2e9fd5
...@@ -4,7 +4,7 @@ ...@@ -4,7 +4,7 @@
<parent> <parent>
<groupId>de.hft.stuttgart</groupId> <groupId>de.hft.stuttgart</groupId>
<artifactId>CityDoctorParent</artifactId> <artifactId>CityDoctorParent</artifactId>
<version>3.17.1</version> <version>3.17.2</version>
</parent> </parent>
<artifactId>CityDoctorValidation</artifactId> <artifactId>CityDoctorValidation</artifactId>
<name>CityDoctorValidation</name> <name>CityDoctorValidation</name>
......
CityDoctorParent/CityDoctorValidation/src/main/java/de/hft/stuttgart/citydoctor2/reporting/pdf/PdfStreamReporter.java
View file @ 0d2e9fd5
...@@ -590,7 +590,7 @@ public class PdfStreamReporter implements StreamReporter { ...@@ -590,7 +590,7 @@ public class PdfStreamReporter implements StreamReporter {
for (Geometry geom : af.getGeometries()) { for (Geometry geom : af.getGeometries()) {
writeCheckResultForGeometry(geom, root); writeCheckResultForGeometry(geom, root);
} }
for (BoundarySurface bs : af.getBoundarySurfaceList()) { for (BoundarySurface bs : af.getBoundarySurfaces()) {
writeCheckResultForBoundarySurface(bs, root); writeCheckResultForBoundarySurface(bs, root);
} }
} }
......
CityDoctorParent/CityDoctorValidation/src/test/java/de/hft/stuttgart/citydoctor2/checks/geometry/NullAreaCheckTest.java
View file @ 0d2e9fd5
...@@ -90,7 +90,7 @@ public class NullAreaCheckTest { ...@@ -90,7 +90,7 @@ public class NullAreaCheckTest {
LinearRing r = setupErrorGeometry(); LinearRing r = setupErrorGeometry();
NullAreaCheck nac = new NullAreaCheck(); NullAreaCheck nac = new NullAreaCheck();
nac.check(r); nac.check(r);
Assert.assertTrue(r.hasAnyError()); Assert.assertTrue(r.hasAnyErrorWithoutDependencies());
} }
...@@ -100,7 +100,7 @@ public class NullAreaCheckTest { ...@@ -100,7 +100,7 @@ public class NullAreaCheckTest {
LinearRing r = setupValidGeometry(); LinearRing r = setupValidGeometry();
NullAreaCheck nac = new NullAreaCheck(); NullAreaCheck nac = new NullAreaCheck();
nac.check(r); nac.check(r);
Assert.assertFalse(r.hasAnyError()); Assert.assertFalse(r.hasAnyErrorWithoutDependencies());
} }
} }
CityDoctorParent/Extensions/CityDoctorAutoPro/pom.xml
View file @ 0d2e9fd5
...@@ -6,7 +6,7 @@ ...@@ -6,7 +6,7 @@
<parent> <parent>
<groupId>de.hft.stuttgart</groupId> <groupId>de.hft.stuttgart</groupId>
<artifactId>CityDoctorParent</artifactId> <artifactId>CityDoctorParent</artifactId>
<version>3.17.1</version> <version>3.17.2</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>CityDoctorAutoPro</artifactId> <artifactId>CityDoctorAutoPro</artifactId>
......
CityDoctorParent/Extensions/CityDoctorGUI/pom.xml
View file @ 0d2e9fd5
...@@ -6,7 +6,7 @@ ...@@ -6,7 +6,7 @@
<parent> <parent>
<groupId>de.hft.stuttgart</groupId> <groupId>de.hft.stuttgart</groupId>
<artifactId>CityDoctorParent</artifactId> <artifactId>CityDoctorParent</artifactId>
<version>3.17.1</version> <version>3.17.2</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>CityDoctorGUI</artifactId> <artifactId>CityDoctorGUI</artifactId>
......
CityDoctorParent/Extensions/CityDoctorGUI/src/main/java/de/hft/stuttgart/citydoctor2/gui/CityDoctorController.java
View file @ 0d2e9fd5
...@@ -9,6 +9,11 @@ import de.hft.stuttgart.citydoctor2.datastructure.*; ...@@ -9,6 +9,11 @@ import de.hft.stuttgart.citydoctor2.datastructure.*;
import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException; import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
import de.hft.stuttgart.citydoctor2.gui.table.ErrorStat; import de.hft.stuttgart.citydoctor2.gui.table.ErrorStat;
import de.hft.stuttgart.citydoctor2.gui.tree.*; import de.hft.stuttgart.citydoctor2.gui.tree.*;
import de.hft.stuttgart.citydoctor2.gui.tree.node.CityObjectGroupNode;
import de.hft.stuttgart.citydoctor2.gui.tree.node.CityObjectNode;
import de.hft.stuttgart.citydoctor2.gui.tree.node.GeometryNode;
import de.hft.stuttgart.citydoctor2.gui.tree.node.OpeningNode;
import de.hft.stuttgart.citydoctor2.gui.tree.node.TopLevelCityObjectNode;
import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler; import de.hft.stuttgart.citydoctor2.mapper.citygml3.GMLValidationHandler;
import de.hft.stuttgart.citydoctor2.parser.*; import de.hft.stuttgart.citydoctor2.parser.*;
import de.hft.stuttgart.citydoctor2.utils.ArchivePacker; import de.hft.stuttgart.citydoctor2.utils.ArchivePacker;
...@@ -24,6 +29,7 @@ import javafx.scene.control.ButtonType; ...@@ -24,6 +29,7 @@ import javafx.scene.control.ButtonType;
import javafx.scene.control.Dialog; import javafx.scene.control.Dialog;
import javafx.scene.control.TreeItem; import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeView; import javafx.scene.control.TreeView;
import javafx.scene.paint.Color;
import javafx.stage.FileChooser; import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter; import javafx.stage.FileChooser.ExtensionFilter;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
...@@ -268,15 +274,15 @@ public class CityDoctorController { ...@@ -268,15 +274,15 @@ public class CityDoctorController {
public void buildTrees() { public void buildTrees() {
resetFeatureChunks(); resetFeatureChunks();
buildBuildings(model); buildBuildings(model);
buildVegetation(model.getVegetation()); buildVegetation(model);
buildTransportation(model.getTransportation()); buildTransportation(model);
buildTunnel(model.getTunnels()); buildTunnel(model);
buildBridges(model); buildBridges(model);
buildWater(model); buildWater(model);
buildLand(model); buildLand(model);
buildCityFurniture(model); buildCityFurniture(model);
buildOtherCityObjects(model); buildOtherCityObjects(model);
buildTunnel(model.getTunnels()); buildTunnel(model);
} }
private void resetFeatureChunks() { private void resetFeatureChunks() {
...@@ -296,7 +302,8 @@ public class CityDoctorController { ...@@ -296,7 +302,8 @@ public class CityDoctorController {
return; return;
} }
TreeView<Renderable> landView = mainWindow.getTerrainView(); TreeView<Renderable> landView = mainWindow.getTerrainView();
TreeItem<Renderable> landRoot = new TreeItem<>(new AllTerrainNode(model.getLand())); TreeItem<Renderable> landRoot = new TreeItem<>(new CityObjectGroupNode(model.getLand(), "Land",
Color.BROWN));
landRoot.setExpanded(true); landRoot.setExpanded(true);
landView.setRoot(landRoot); landView.setRoot(landRoot);
buildLandFromList(model.getLand(), landView.getRoot()); buildLandFromList(model.getLand(), landView.getRoot());
...@@ -308,50 +315,26 @@ public class CityDoctorController { ...@@ -308,50 +315,26 @@ public class CityDoctorController {
for (int i = landChunk * MAX_FEATURES_PER_CHUNK; i < (landChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = landChunk * MAX_FEATURES_PER_CHUNK; i < (landChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
CityObject land = list.get(i); CityObject land = list.get(i);
Renderable node; CityObjectNode node = new CityObjectNode(land);
if (land instanceof ReliefObject relief) {
node = new ReliefNode(relief);
} else if (land instanceof TinObject tin) {
node = new TinNode(tin);
} else {
node = new LandUseNode((LandObject) land);
}
TreeItem<Renderable> item = new TreeItem<>(node); TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true); item.setExpanded(true);
root.getChildren().add(item); root.getChildren().add(item);
createGeometryNodes(land, item); createGeometryNodes(land, item);
if (land instanceof ReliefObject relief) {
createTinNodes(relief, item);
}
}
}
private void createTinNodes(ReliefObject relief, TreeItem<Renderable> item) {
if (relief.getComponents().isEmpty()) {
return;
}
AllTinNode allTinText = new AllTinNode(relief.getComponents());
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allTinText);
item.getChildren().add(allBpsTextItem);
for (TinObject tin : relief.getComponents()) {
TinNode tinNode = new TinNode(tin);
TreeItem<Renderable> tinNodeItem = new TreeItem<>(tinNode);
tinNodeItem.setExpanded(true);
allBpsTextItem.getChildren().add(tinNodeItem);
createGeometryNodes(tin, tinNodeItem);
} }
} }
private void buildCityFurniture(CityDoctorModel model) { private void buildCityFurniture(CityDoctorModel model) {
if (model.getCityFurniture().isEmpty()) { if (model.getCityFurniture().isEmpty()) {
return; return;
} }
TreeView<Renderable> cityFurnitureView = mainWindow.getCityFurnitureView(); TreeView<Renderable> cityFurnitureView = mainWindow.getCityFurnitureView();
TreeItem<Renderable> cityFurnitureRoot = new TreeItem<>(new AllCityFurnitureNode(model.getCityFurniture())); TreeItem<Renderable> cityFurnitureRoot = new TreeItem<>(new CityObjectGroupNode(model.getCityFurniture(),
"City Furniture", Color.BLUEVIOLET));
cityFurnitureRoot.setExpanded(true); cityFurnitureRoot.setExpanded(true);
cityFurnitureView.setRoot(cityFurnitureRoot); cityFurnitureView.setRoot(cityFurnitureRoot);
buildTreeFromList(model.getCityFurniture(), cityFurnitureView.getRoot(), cityFurnitureChunkNr); buildCityFurnitureTreeFromList(model.getCityFurniture(), cityFurnitureView.getRoot());
addMoreButtonIfNecessary(model.getCityFurniture(), cityFurnitureView, cityFurnitureRoot, cityFurnitureChunkNr); addMoreButtonIfNecessary(model.getCityFurniture(), cityFurnitureView, cityFurnitureRoot, cityFurnitureChunkNr);
} }
...@@ -360,10 +343,11 @@ public class CityDoctorController { ...@@ -360,10 +343,11 @@ public class CityDoctorController {
return; return;
} }
TreeView<Renderable> otherObjectsView = mainWindow.getGenericCityObjectView(); TreeView<Renderable> otherObjectsView = mainWindow.getGenericCityObjectView();
TreeItem<Renderable> otherObjectsRoot = new TreeItem<>(new AllOtherObjectsNode(model.getGenericCityObjects())); TreeItem<Renderable> otherObjectsRoot = new TreeItem<>(new CityObjectGroupNode(model.getGenericCityObjects(),
"Generic CityObjects", Color.DARKGRAY));
otherObjectsRoot.setExpanded(true); otherObjectsRoot.setExpanded(true);
otherObjectsView.setRoot(otherObjectsRoot); otherObjectsView.setRoot(otherObjectsRoot);
buildTreeFromList(model.getGenericCityObjects(), otherObjectsView.getRoot(), genericCityObjectsChunkNr); buildGenericCityObjectTreeFromList(model.getGenericCityObjects(), otherObjectsView.getRoot());
addMoreButtonIfNecessary(model.getGenericCityObjects(), otherObjectsView, otherObjectsRoot, genericCityObjectsChunkNr); addMoreButtonIfNecessary(model.getGenericCityObjects(), otherObjectsView, otherObjectsRoot, genericCityObjectsChunkNr);
} }
...@@ -372,10 +356,11 @@ public class CityDoctorController { ...@@ -372,10 +356,11 @@ public class CityDoctorController {
return; return;
} }
TreeView<Renderable> waterView = mainWindow.getWaterView(); TreeView<Renderable> waterView = mainWindow.getWaterView();
TreeItem<Renderable> waterRoot = new TreeItem<>(new AllWaterNode(model.getWater())); TreeItem<Renderable> waterRoot = new TreeItem<>(new CityObjectGroupNode(model.getWater(), "Water",
Color.LIGHTSKYBLUE));
waterRoot.setExpanded(true); waterRoot.setExpanded(true);
waterView.setRoot(waterRoot); waterView.setRoot(waterRoot);
buildTreeFromList(model.getWater(), waterView.getRoot(), waterChunkNr); buildWaterTreeFromList(model.getWater(), waterRoot);
addMoreButtonIfNecessary(model.getWater(), waterView, waterRoot, waterChunkNr); addMoreButtonIfNecessary(model.getWater(), waterView, waterRoot, waterChunkNr);
} }
...@@ -384,47 +369,51 @@ public class CityDoctorController { ...@@ -384,47 +369,51 @@ public class CityDoctorController {
return; return;
} }
TreeView<Renderable> bridgeView = mainWindow.getBridgeView(); TreeView<Renderable> bridgeView = mainWindow.getBridgeView();
TreeItem<Renderable> bridgeRoot = new TreeItem<>(new AllBridgesNode(model.getBridges())); TreeItem<Renderable> bridgeRoot = new TreeItem<>(new CityObjectGroupNode(model.getBridges(), "Bridges",
Color.CORAL));
bridgeRoot.setExpanded(true); bridgeRoot.setExpanded(true);
bridgeView.setRoot(bridgeRoot); bridgeView.setRoot(bridgeRoot);
buildBridgeTreeFromList(model.getBridges(), bridgeView.getRoot()); buildBridgeTreeFromList(model.getBridges(), bridgeView.getRoot());
addMoreButtonIfNecessary(model.getBridges(), bridgeView, bridgeRoot, bridgeChunkNr); addMoreButtonIfNecessary(model.getBridges(), bridgeView, bridgeRoot, bridgeChunkNr);
} }
private void buildTransportation(List<TransportationObject> trans) { private void buildTransportation(CityDoctorModel model) {
if (trans.isEmpty()) { if (model.getTransportation().isEmpty()) {
return; return;
} }
TreeView<Renderable> transView = mainWindow.getTransportationView(); TreeView<Renderable> transView = mainWindow.getTransportationView();
TreeItem<Renderable> transRoot = new TreeItem<>(new AllTransportationNode(model.getTransportation())); TreeItem<Renderable> transRoot = new TreeItem<>(new CityObjectGroupNode(model.getTransportation(),
"Transportation", Color.YELLOW));
transRoot.setExpanded(true); transRoot.setExpanded(true);
transView.setRoot(transRoot); transView.setRoot(transRoot);
buildTransportationTreeFromList(trans, transView.getRoot()); buildTransportationTreeFromList(model.getTransportation(), transView.getRoot());
addMoreButtonIfNecessary(trans, transView, transRoot, transportationChunkNr); addMoreButtonIfNecessary(model.getTransportation(), transView, transRoot, transportationChunkNr);
} }
private void buildTunnel(List<Tunnel> tunnels) { private void buildTunnel(CityDoctorModel model) {
if (tunnels.isEmpty()) { if (model.getTunnels().isEmpty()) {
return; return;
} }
TreeView<Renderable> transView = mainWindow.getTunnelView(); TreeView<Renderable> tunnelView = mainWindow.getTunnelView();
TreeItem<Renderable> transRoot = new TreeItem<>(new AllTunnelsNode(model.getTunnels())); TreeItem<Renderable> tunnelRoot = new TreeItem<>(new CityObjectGroupNode(model.getTunnels(), "Tunnel",
transRoot.setExpanded(true); Color.SLATEGRAY));
transView.setRoot(transRoot); tunnelRoot.setExpanded(true);
buildTreeFromList(tunnels, transView.getRoot(), tunnelChunkNr); tunnelView.setRoot(tunnelRoot);
addMoreButtonIfNecessary(tunnels, transView, transRoot, tunnelChunkNr); buildTunnelTreeFromList(model.getTunnels(), tunnelRoot);
addMoreButtonIfNecessary(model.getTunnels(), tunnelView, tunnelRoot, tunnelChunkNr);
} }
private void buildVegetation(List<Vegetation> veg) { private void buildVegetation(CityDoctorModel model) {
if (veg.isEmpty()) { if (model.getVegetation().isEmpty()) {
return; return;
} }
TreeView<Renderable> vegetationsView = mainWindow.getVegetationView(); TreeView<Renderable> vegetationsView = mainWindow.getVegetationView();
TreeItem<Renderable> vegRoot = new TreeItem<>(new AllVegetationNode(model.getVegetation())); TreeItem<Renderable> vegRoot = new TreeItem<>(new CityObjectGroupNode(model.getVegetation(),
"Vegetation", Color.LIGHTGREEN));
vegRoot.setExpanded(true); vegRoot.setExpanded(true);
vegetationsView.setRoot(vegRoot); vegetationsView.setRoot(vegRoot);
buildTreeFromListWithProducer(veg, vegetationsView.getRoot(), vegetationChunkNr, VegetationNode::new); buildVegetationTreeFromList(model.getVegetation(), vegRoot);
addMoreButtonIfNecessary(veg, vegetationsView, vegRoot, vegetationChunkNr); addMoreButtonIfNecessary(model.getVegetation(), vegetationsView, vegRoot, vegetationChunkNr);
} }
private void addMoreButtonIfNecessary(List<? extends CityObject> list, TreeView<Renderable> view, private void addMoreButtonIfNecessary(List<? extends CityObject> list, TreeView<Renderable> view,
...@@ -439,6 +428,7 @@ public class CityDoctorController { ...@@ -439,6 +428,7 @@ public class CityDoctorController {
root.getChildren().remove(root.getChildren().size() - 1); root.getChildren().remove(root.getChildren().size() - 1);
chunkCounter.incrementAndGet(); chunkCounter.incrementAndGet();
int visibleFeatures = countVisibleNodes(view); int visibleFeatures = countVisibleNodes(view);
buildTreeFromList(list, root, chunkCounter); buildTreeFromList(list, root, chunkCounter);
updateTree(root); updateTree(root);
if (selectedIndex >= 0) { if (selectedIndex >= 0) {
...@@ -460,11 +450,13 @@ public class CityDoctorController { ...@@ -460,11 +450,13 @@ public class CityDoctorController {
return; return;
} }
TreeView<Renderable> buildingsView = mainWindow.getBuildingsView(); TreeView<Renderable> buildingsView = mainWindow.getBuildingsView();
TreeItem<Renderable> root = new TreeItem<>(new AllBuildingsNode(model.getBuildings())); TreeItem<Renderable> root = new TreeItem<>(new CityObjectGroupNode(model.getBuildings(), "Buildings",
Color.WHITE));
root.setExpanded(true); root.setExpanded(true);
buildingsView.setRoot(root);
buildBuildingTreeFromList(model.getBuildings(), root); buildBuildingTreeFromList(model.getBuildings(), root);
addMoreButtonToBuildingsIfNecessary(model.getBuildings(), buildingsView, root, buildingChunkNr); addMoreButtonToBuildingsIfNecessary(model.getBuildings(), buildingsView, root, buildingChunkNr);
buildingsView.setRoot(root);
} }
private void addMoreButtonToBuildingsIfNecessary(List<Building> list, TreeView<Renderable> view, private void addMoreButtonToBuildingsIfNecessary(List<Building> list, TreeView<Renderable> view,
...@@ -557,17 +549,46 @@ public class CityDoctorController { ...@@ -557,17 +549,46 @@ public class CityDoctorController {
mainWindow.getVertexView().getRoot().getChildren().clear(); mainWindow.getVertexView().getRoot().getChildren().clear();
} }
private TreeItem<Renderable> buildTopLevelCityObjectNode(CityObject co, TreeItem<Renderable> root) {
return buildTopLevelCityObjectNode(co, root, Collections.emptyList());
}
private TreeItem<Renderable> buildTopLevelCityObjectNode(CityObject co, TreeItem<Renderable> root,
List<BoundarySurface> surfaces) {
TopLevelCityObjectNode node = new TopLevelCityObjectNode(co);
TreeItem<Renderable> nodeItem = new TreeItem<>(node);
nodeItem.setExpanded(true);
root.getChildren().add(nodeItem);
createGeometryNodes(co, nodeItem);
if (!surfaces.isEmpty()) {
createBoundarySurfaceNodes(surfaces, nodeItem);
}
return nodeItem;
}
private TreeItem<Renderable> buildCityObjectNode(CityObject co, TreeItem<Renderable> root) {
return buildCityObjectNode(co, root, Collections.emptyList());
}
private TreeItem<Renderable> buildCityObjectNode(CityObject co, TreeItem<Renderable> root, List<BoundarySurface> surfaces) {
CityObjectNode node = new CityObjectNode(co);
TreeItem<Renderable> nodeItem = new TreeItem<>(node);
nodeItem.setExpanded(false);
root.getChildren().add(nodeItem);
createGeometryNodes(co, nodeItem);
if (!surfaces.isEmpty()) {
createBoundarySurfaceNodes(surfaces, nodeItem);
}
return nodeItem;
}
private void buildBuildingTreeFromList(List<Building> list, TreeItem<Renderable> root) { private void buildBuildingTreeFromList(List<Building> list, TreeItem<Renderable> root) {
int buildingChunk = buildingChunkNr.get(); int buildingChunk = buildingChunkNr.get();
for (int i = buildingChunk * MAX_FEATURES_PER_CHUNK; i < (buildingChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = buildingChunk * MAX_FEATURES_PER_CHUNK; i < (buildingChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
Building b = list.get(i); Building b = list.get(i);
BuildingNode node = new BuildingNode(b); TreeItem<Renderable> item = buildTopLevelCityObjectNode(b, root, b.getBoundarySurfaces());
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(b, item);
createBoundarySurfaceNodes(b.getBoundarySurfaces(), item);
createBuildingInstallationNodes(b, item); createBuildingInstallationNodes(b, item);
createBuildingRoomNodes(b, item); createBuildingRoomNodes(b, item);
createBuildingFurnitureNodes(b, item); createBuildingFurnitureNodes(b, item);
...@@ -582,12 +603,8 @@ public class CityDoctorController { ...@@ -582,12 +603,8 @@ public class CityDoctorController {
for (int i = bridgeChunk * MAX_FEATURES_PER_CHUNK; i < (bridgeChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = bridgeChunk * MAX_FEATURES_PER_CHUNK; i < (bridgeChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
BridgeObject bridge = list.get(i); BridgeObject bridge = list.get(i);
BridgeNode node = new BridgeNode(bridge); TreeItem<Renderable> item = buildTopLevelCityObjectNode(bridge, root, bridge.getBoundarySurfaces());
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(bridge, item);
createBoundarySurfaceNodes(bridge.getBoundarySurfaces(), item);
createBridgeRoomNodes(bridge, item); createBridgeRoomNodes(bridge, item);
createBridgeInstallationNodes(bridge, item); createBridgeInstallationNodes(bridge, item);
createBridgeFurnitureNodes(bridge, item); createBridgeFurnitureNodes(bridge, item);
...@@ -602,11 +619,7 @@ public class CityDoctorController { ...@@ -602,11 +619,7 @@ public class CityDoctorController {
for (int i = transportChunk * MAX_FEATURES_PER_CHUNK; i < (transportChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = transportChunk * MAX_FEATURES_PER_CHUNK; i < (transportChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
TransportationObject t = list.get(i); TransportationObject t = list.get(i);
TransportationObjectNode node = new TransportationObjectNode(t); TreeItem<Renderable> item = buildTopLevelCityObjectNode(t, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(t, item);
createTransportSectionNodes(t, item); createTransportSectionNodes(t, item);
createTrafficSpacesNodes(t, item); createTrafficSpacesNodes(t, item);
} }
...@@ -617,11 +630,7 @@ public class CityDoctorController { ...@@ -617,11 +630,7 @@ public class CityDoctorController {
for (int i = vegetationChunk * MAX_FEATURES_PER_CHUNK; i < (vegetationChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = vegetationChunk * MAX_FEATURES_PER_CHUNK; i < (vegetationChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
Vegetation v = list.get(i); Vegetation v = list.get(i);
VegetationNode node = new VegetationNode(v); buildTopLevelCityObjectNode(v, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(v, item);
} }
} }
...@@ -630,11 +639,7 @@ public class CityDoctorController { ...@@ -630,11 +639,7 @@ public class CityDoctorController {
for (int i = waterChunk * MAX_FEATURES_PER_CHUNK; i < (waterChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = waterChunk * MAX_FEATURES_PER_CHUNK; i < (waterChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
WaterObject w = list.get(i); WaterObject w = list.get(i);
CityObjectNode node = new CityObjectNode(w); buildTopLevelCityObjectNode(w, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(w, item);
} }
} }
...@@ -643,11 +648,7 @@ public class CityDoctorController { ...@@ -643,11 +648,7 @@ public class CityDoctorController {
for (int i = cityFurnChunk * MAX_FEATURES_PER_CHUNK; i < (cityFurnChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = cityFurnChunk * MAX_FEATURES_PER_CHUNK; i < (cityFurnChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
CityFurniture cf = list.get(i); CityFurniture cf = list.get(i);
CityObjectNode node = new CityObjectNode(cf); buildTopLevelCityObjectNode(cf, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(cf, item);
} }
} }
...@@ -656,44 +657,32 @@ public class CityDoctorController { ...@@ -656,44 +657,32 @@ public class CityDoctorController {
for (int i = genericObjectChunk * MAX_FEATURES_PER_CHUNK; i < (genericObjectChunk + 1) * MAX_FEATURES_PER_CHUNK for (int i = genericObjectChunk * MAX_FEATURES_PER_CHUNK; i < (genericObjectChunk + 1) * MAX_FEATURES_PER_CHUNK
&& i < list.size(); i++) { && i < list.size(); i++) {
GenericCityObject goc = list.get(i); GenericCityObject goc = list.get(i);
CityObjectNode node = new CityObjectNode(goc); buildTopLevelCityObjectNode(goc, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(goc, item);
} }
} }
private void createTransportSectionNodes(TransportationObject t, TreeItem<Renderable> root) { private void createTransportSectionNodes(TransportationObject t, TreeItem<Renderable> root) {
if (t instanceof TopLevelTransportFeature top) { if (t instanceof TopLevelTransportFeature top) {
if (!top.getSections().isEmpty()) { if (!top.getSections().isEmpty()) {
AllTransportSectionNode allSectionsNode = new AllTransportSectionNode(top.getSections(), CityObjectGroupNode sectionsGroupNode = new CityObjectGroupNode(top.getSections(),
TransportSection.SectionType.SECTION); "Sections", Color.YELLOW);
TreeItem<Renderable> allSectionsNodeTextItem = new TreeItem<>(allSectionsNode); TreeItem<Renderable> sectionsGroupItem = new TreeItem<>(sectionsGroupNode);
root.getChildren().add(allSectionsNodeTextItem); root.getChildren().add(sectionsGroupItem);
for (TransportSection ts : top.getSections()) { for (TransportSection ts : top.getSections()) {
TransportationObjectNode tsNode = new TransportationObjectNode(ts); TreeItem<Renderable> tsNodeItem = buildCityObjectNode(ts, sectionsGroupItem);
TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
tsNodeItem.setExpanded(false);
allSectionsNodeTextItem.getChildren().add(tsNodeItem);
createGeometryNodes(ts, tsNodeItem);
createTrafficSpacesNodes(ts, tsNodeItem); createTrafficSpacesNodes(ts, tsNodeItem);
} }
} }
if (!top.getIntersections().isEmpty()) { if (!top.getIntersections().isEmpty()) {
AllTransportSectionNode allIntersectionsNode = new AllTransportSectionNode(top.getIntersections(), CityObjectGroupNode intersectionsGroupNode = new CityObjectGroupNode(top.getIntersections(),
TransportSection.SectionType.INTERSECTION); "Intersections", Color.YELLOW);
TreeItem<Renderable> allIntersectionsNodeTextItem = new TreeItem<>(allIntersectionsNode); TreeItem<Renderable> intersectionsGroupItem = new TreeItem<>(intersectionsGroupNode);
root.getChildren().add(allIntersectionsNodeTextItem); root.getChildren().add(intersectionsGroupItem);
for (TransportSection ts : top.getIntersections()) { for (TransportSection ts : top.getIntersections()) {
TransportationObjectNode tsNode = new TransportationObjectNode(ts); TreeItem<Renderable> tsNodeItem = buildCityObjectNode(ts, intersectionsGroupItem);
TreeItem<Renderable> tsNodeItem = new TreeItem<>(tsNode);
tsNodeItem.setExpanded(false);
allIntersectionsNodeTextItem.getChildren().add(tsNodeItem);
createGeometryNodes(ts, tsNodeItem);
createTrafficSpacesNodes(ts, tsNodeItem); createTrafficSpacesNodes(ts, tsNodeItem);
} }
} }
...@@ -703,34 +692,26 @@ public class CityDoctorController { ...@@ -703,34 +692,26 @@ public class CityDoctorController {
private void createTrafficSpacesNodes(TransportationObject t, TreeItem<Renderable> root) { private void createTrafficSpacesNodes(TransportationObject t, TreeItem<Renderable> root) {
if (t instanceof TransportationSpace space) { if (t instanceof TransportationSpace space) {
if (!space.getTrafficSpaces().isEmpty()) { if (!space.getTrafficSpaces().isEmpty()) {
AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getTrafficSpaces(), CityObjectGroupNode trafficSpacesGroupNode = new CityObjectGroupNode(space.getTrafficSpaces(),
TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE); "TRAFFIC_SPACE", Color.YELLOW);
TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode); TreeItem<Renderable> trafficSpacesGroupItem = new TreeItem<>(trafficSpacesGroupNode);
root.getChildren().add(allTSNodeTextItem); root.getChildren().add(trafficSpacesGroupItem);
allTSNodeTextItem.setExpanded(true); trafficSpacesGroupItem.setExpanded(true);
for (TrafficSpaceObject tso : space.getTrafficSpaces()) { for (TrafficSpaceObject tso : space.getTrafficSpaces()) {
TransportationObjectNode tsoNode = new TransportationObjectNode(tso); TreeItem<Renderable> tsoNodeItem = buildCityObjectNode(tso, trafficSpacesGroupItem);
TreeItem<Renderable> tsoNodeItem = new TreeItem<>(tsoNode);
tsoNodeItem.setExpanded(false);
allTSNodeTextItem.getChildren().add(tsoNodeItem);
createGeometryNodes(tso, tsoNodeItem);
createTrafficAreaNodes(tso, tsoNodeItem, TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA); createTrafficAreaNodes(tso, tsoNodeItem, TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
} }
} }
if (!space.getAuxTrafficSpaces().isEmpty()) { if (!space.getAuxTrafficSpaces().isEmpty()) {
AllTrafficSpacesNode allTSNode = new AllTrafficSpacesNode(space.getAuxTrafficSpaces(), CityObjectGroupNode auxTrafficSpacesGroupNode = new CityObjectGroupNode(space.getAuxTrafficSpaces(),
TrafficSpaceObject.TrafficSpaceType.AUXILIARY_TRAFFIC_SPACE); "AUXILIARY_TRAFFIC_SPACE", Color.YELLOW);
TreeItem<Renderable> allTSNodeTextItem = new TreeItem<>(allTSNode); TreeItem<Renderable> auxTrafficSpacesGroupItem = new TreeItem<>(auxTrafficSpacesGroupNode);
root.getChildren().add(allTSNodeTextItem); root.getChildren().add(auxTrafficSpacesGroupItem);
allTSNodeTextItem.setExpanded(true); auxTrafficSpacesGroupItem.setExpanded(true);
for (TrafficSpaceObject atso : space.getAuxTrafficSpaces()) { for (TrafficSpaceObject atso : space.getAuxTrafficSpaces()) {
TransportationObjectNode atsoNode = new TransportationObjectNode(atso); TreeItem<Renderable> atsoNodeItem = buildCityObjectNode(atso, auxTrafficSpacesGroupItem);
TreeItem<Renderable> atsoNodeItem = new TreeItem<>(atsoNode);
atsoNodeItem.setExpanded(false);
allTSNodeTextItem.getChildren().add(atsoNodeItem);
createGeometryNodes(atso, atsoNodeItem);
createTrafficAreaNodes(atso, atsoNodeItem, TrafficAreaObject.TrafficAreaType.AUXILIARY_TRAFFIC_AREA); createTrafficAreaNodes(atso, atsoNodeItem, TrafficAreaObject.TrafficAreaType.AUXILIARY_TRAFFIC_AREA);
} }
} }
...@@ -739,16 +720,13 @@ public class CityDoctorController { ...@@ -739,16 +720,13 @@ public class CityDoctorController {
public void createTrafficAreaNodes(TransportationObject t, TreeItem<Renderable> root, TrafficAreaObject.TrafficAreaType type) { public void createTrafficAreaNodes(TransportationObject t, TreeItem<Renderable> root, TrafficAreaObject.TrafficAreaType type) {
if (t instanceof TrafficSpaceObject space && !space.getTrafficAreas().isEmpty()) { if (t instanceof TrafficSpaceObject space && !space.getTrafficAreas().isEmpty()) {
AllTrafficAreaNode allTANode = new AllTrafficAreaNode(space.getTrafficAreas(), type); CityObjectGroupNode trafficAreaGroupNode = new CityObjectGroupNode(space.getTrafficAreas(), type.toString(), Color.YELLOW);
TreeItem<Renderable> allTANodeTextItem = new TreeItem<>(allTANode); TreeItem<Renderable> trafficAreaGroupItem = new TreeItem<>(trafficAreaGroupNode);
root.getChildren().add(allTANodeTextItem); root.getChildren().add(trafficAreaGroupItem);
allTANodeTextItem.setExpanded(true); trafficAreaGroupItem.setExpanded(true);
for (TrafficAreaObject tao : space.getTrafficAreas()) { for (TrafficAreaObject tao : space.getTrafficAreas()) {
TransportationObjectNode taoNode = new TransportationObjectNode(tao); buildCityObjectNode(tao, trafficAreaGroupItem);
TreeItem<Renderable> taoNodeTextItem = new TreeItem<>(taoNode);
taoNodeTextItem.setExpanded(true);
allTANodeTextItem.getChildren().add(taoNodeTextItem);
createGeometryNodes(tao, taoNodeTextItem);
} }
} }
...@@ -758,12 +736,8 @@ public class CityDoctorController { ...@@ -758,12 +736,8 @@ public class CityDoctorController {
int tunnelChunk = tunnelChunkNr.get(); int tunnelChunk = tunnelChunkNr.get();
for (int i = tunnelChunk * MAX_FEATURES_PER_CHUNK; i < (tunnelChunk + 1) * MAX_FEATURES_PER_CHUNK && i < list.size(); i++) { for (int i = tunnelChunk * MAX_FEATURES_PER_CHUNK; i < (tunnelChunk + 1) * MAX_FEATURES_PER_CHUNK && i < list.size(); i++) {
Tunnel tunnel = list.get(i); Tunnel tunnel = list.get(i);
TunnelNode node = new TunnelNode(tunnel); TreeItem<Renderable> item = buildTopLevelCityObjectNode(tunnel, root);
TreeItem<Renderable> item = new TreeItem<>(node);
item.setExpanded(true);
root.getChildren().add(item);
createGeometryNodes(tunnel, item);
createBoundarySurfaceNodes(tunnel.getBoundarySurfaces(), item);
createTunnelHollowNodes(tunnel, item); createTunnelHollowNodes(tunnel, item);
createTunnelInstallationNodes(tunnel, item); createTunnelInstallationNodes(tunnel, item);
createTunnelFurnitureNodes(tunnel, item); createTunnelFurnitureNodes(tunnel, item);
...@@ -788,17 +762,14 @@ public class CityDoctorController { ...@@ -788,17 +762,14 @@ public class CityDoctorController {
if (tunnel.getTunnelConstructiveElements().isEmpty()){ if (tunnel.getTunnelConstructiveElements().isEmpty()){
return; return;
} }
AllTunnelConstructiveElementsNode allTceNode = new AllTunnelConstructiveElementsNode(tunnel.getTunnelConstructiveElements());
TreeItem<Renderable> allTceNodeTextItem = new TreeItem<>(allTceNode); CityObjectGroupNode constructiveElementsGroupNode = new CityObjectGroupNode(tunnel.getTunnelConstructiveElements(),
root.getChildren().add(allTceNodeTextItem); "Constructive Elements", Color.DARKGRAY);
TreeItem<Renderable> constructiveElementsGroupItem = new TreeItem<>(constructiveElementsGroupNode);
root.getChildren().add(constructiveElementsGroupItem);
for (TunnelConstructiveElement tce : tunnel.getTunnelConstructiveElements()) { for (TunnelConstructiveElement tce : tunnel.getTunnelConstructiveElements()) {
TunnelConstructiveElementNode tceNode = new TunnelConstructiveElementNode(tce); buildCityObjectNode(tce, constructiveElementsGroupItem, tce.getBoundarySurfaces());
TreeItem<Renderable> tceNodeItem = new TreeItem<>(tceNode);
tceNodeItem.setExpanded(true);
allTceNodeTextItem.getChildren().add(tceNodeItem);
createGeometryNodes(tce, tceNodeItem);
createBoundarySurfaceNodes(tce.getBoundarySurfaces(), tceNodeItem);
} }
} }
...@@ -806,17 +777,18 @@ public class CityDoctorController { ...@@ -806,17 +777,18 @@ public class CityDoctorController {
if (tunnel.getTunnelParts().isEmpty()) { if (tunnel.getTunnelParts().isEmpty()) {
return; return;
} }
AllTunnelPartsNode allTpsText = new AllTunnelPartsNode(tunnel.getTunnelParts());
TreeItem<Renderable> allTpsTextItem = new TreeItem<>(allTpsText); CityObjectGroupNode tunnelPartsGroupNode = new CityObjectGroupNode(tunnel.getTunnelParts(), "Tunnel parts", Color.DARKGRAY);
root.getChildren().add(allTpsTextItem); TreeItem<Renderable> tunnelPartsGroupItem = new TreeItem<>(tunnelPartsGroupNode);
root.getChildren().add(tunnelPartsGroupItem);
for (TunnelPart tp : tunnel.getTunnelParts()) { for (TunnelPart tp : tunnel.getTunnelParts()) {
TunnelPartNode tpNode = new TunnelPartNode(tp); TreeItem<Renderable> tpNodeItem = buildCityObjectNode(tp, tunnelPartsGroupItem, tp.getBoundarySurfaces());
TreeItem<Renderable> tpNodeItem = new TreeItem<>(tpNode);
tpNodeItem.setExpanded(true); createTunnelHollowNodes(tunnel, tpNodeItem);
allTpsTextItem.getChildren().add(tpNodeItem); createTunnelInstallationNodes(tunnel, tpNodeItem);
createGeometryNodes(tp, tpNodeItem); createTunnelFurnitureNodes(tunnel, tpNodeItem);
createBoundarySurfaceNodes(tp.getBoundarySurfaces(), tpNodeItem); createTunnelConstructiveElementsNodes(tunnel, tpNodeItem);
} }
} }
...@@ -836,18 +808,14 @@ public class CityDoctorController { ...@@ -836,18 +808,14 @@ public class CityDoctorController {
if (bridge.getConstructiveElements().isEmpty()) { if (bridge.getConstructiveElements().isEmpty()) {
return; return;
} }
AllBridgeConstructiveElementsNode allBceNode = new AllBridgeConstructiveElementsNode(
bridge.getConstructiveElements()); CityObjectGroupNode constructiveElementsGroupNode = new CityObjectGroupNode(
TreeItem<Renderable> allBceNodeTextItem = new TreeItem<>(allBceNode); bridge.getConstructiveElements(), "Constructive Elements", Color.CORAL);
item.getChildren().add(allBceNodeTextItem); TreeItem<Renderable> constructiveElementsGroupItem = new TreeItem<>(constructiveElementsGroupNode);
item.getChildren().add(constructiveElementsGroupItem);
for (BridgeConstructiveElement bce : bridge.getConstructiveElements()) { for (BridgeConstructiveElement bce : bridge.getConstructiveElements()) {
BridgeConstructiveElementNode bceNode = new BridgeConstructiveElementNode(bce); buildCityObjectNode(bce, constructiveElementsGroupItem, bce.getBoundarySurfaces());
TreeItem<Renderable> bceNodeItem = new TreeItem<>(bceNode);
bceNodeItem.setExpanded(true);
allBceNodeTextItem.getChildren().add(bceNodeItem);
createGeometryNodes(bce, bceNodeItem);
createBoundarySurfaceNodes(bce.getBoundarySurfaces(), bceNodeItem);
} }
} }
...@@ -855,21 +823,22 @@ public class CityDoctorController { ...@@ -855,21 +823,22 @@ public class CityDoctorController {
if (bridge.getParts().isEmpty()) { if (bridge.getParts().isEmpty()) {
return; return;
} }
AllBridgePartsNode allBpsText = new AllBridgePartsNode(bridge.getParts());
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBpsText); CityObjectGroupNode bridgePartsGroupNode = new CityObjectGroupNode(bridge.getParts(), "Bridge Parts", Color.CORAL);
item.getChildren().add(allBpsTextItem); TreeItem<Renderable> bridgePartsGroupItem = new TreeItem<>(bridgePartsGroupNode);
item.getChildren().add(bridgePartsGroupItem);
for (BridgeObject bp : bridge.getParts()) { for (BridgeObject bp : bridge.getParts()) {
BridgeNode bpNode = new BridgeNode(bp); TreeItem<Renderable> bpNodeItem = buildCityObjectNode(bp, bridgePartsGroupItem, bp.getBoundarySurfaces());
TreeItem<Renderable> bpNodeItem = new TreeItem<>(bpNode);
bpNodeItem.setExpanded(true); createBridgeRoomNodes(bp, bpNodeItem);
allBpsTextItem.getChildren().add(bpNodeItem); createBridgeInstallationNodes(bp, bpNodeItem);
createGeometryNodes(bp, bpNodeItem); createBridgeFurnitureNodes(bp, bpNodeItem);
createBoundarySurfaceNodes(bp.getBoundarySurfaces(), bpNodeItem); createBridgeConstructiveElementsNodes(bp, bpNodeItem);
} }
} }
private void createBuildingInstallationNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingInstallationNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createInstallationNodes(ab.getBuildingInstallations(), root); createInstallationNodes(ab.getBuildingInstallations(), root);
} }
...@@ -878,20 +847,16 @@ public class CityDoctorController { ...@@ -878,20 +847,16 @@ public class CityDoctorController {
return; return;
} }
AllInstallationsNode allBiNode = new AllInstallationsNode(installations); CityObjectGroupNode installationsGroupNode = new CityObjectGroupNode(installations, "Installations", null);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBiNode); TreeItem<Renderable> installationsGroupItem = new TreeItem<>(installationsGroupNode);
root.getChildren().add(allBpsTextItem); root.getChildren().add(installationsGroupItem);
for (Installation bi : installations) { for (Installation bi : installations) {
InstallationNode biNode = new InstallationNode(bi); buildCityObjectNode(bi, installationsGroupItem, bi.getBoundarySurfaces());
TreeItem<Renderable> biItem = new TreeItem<>(biNode);
biItem.setExpanded(true);
allBpsTextItem.getChildren().add(biItem);
createGeometryNodes(bi, biItem);
createBoundarySurfaceNodes(bi.getBoundarySurfaces(), biItem);
} }
} }
private void createBuildingRoomNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingRoomNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createRoomNodes(ab.getBuildingRooms(), root); createRoomNodes(ab.getBuildingRooms(), root);
} }
...@@ -900,58 +865,48 @@ public class CityDoctorController { ...@@ -900,58 +865,48 @@ public class CityDoctorController {
return; return;
} }
AllRoomsNode allRoNode = new AllRoomsNode(rooms); CityObjectGroupNode roomsGroupNode = new CityObjectGroupNode(rooms, "Rooms", null);
TreeItem<Renderable> allRoNodeTextItem = new TreeItem<>(allRoNode); TreeItem<Renderable> roomsGroupItem = new TreeItem<>(roomsGroupNode);
root.getChildren().add(allRoNodeTextItem); root.getChildren().add(roomsGroupItem);
for (AbstractRoom room : rooms) { for (AbstractRoom room : rooms) {
RoomNode roomNode = new RoomNode(room); buildCityObjectNode(room, roomsGroupItem, room.getBoundarySurfaces());
TreeItem<Renderable> roomNodeTextItem = new TreeItem<>(roomNode);
roomNodeTextItem.setExpanded(true);
allRoNodeTextItem.getChildren().add(roomNodeTextItem);
createGeometryNodes(room, roomNodeTextItem);
createBoundarySurfaceNodes(room.getBoundarySurfaces(), roomNodeTextItem);
} }
} }
private void createBuildingStoreyNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingStoreyNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
List<Storey> storeys = ab.getBuildingStoreys(); List<Storey> storeys = ab.getBuildingStoreys();
if (storeys.isEmpty()) { if (storeys.isEmpty()) {
return; return;
} }
AllStoreysNode allSNode = new AllStoreysNode(storeys);
TreeItem<Renderable> allSNodeTextItem = new TreeItem<>(allSNode); CityObjectGroupNode storeysGroupNode = new CityObjectGroupNode(storeys, "Storeys", null);
root.getChildren().add(allSNodeTextItem); TreeItem<Renderable> storeysGroupItem = new TreeItem<>(storeysGroupNode);
root.getChildren().add(storeysGroupItem);
for (Storey storey : storeys) { for (Storey storey : storeys) {
StoreyNode storeyNode = new StoreyNode(storey); buildCityObjectNode(storey, storeysGroupItem, storey.getBoundarySurfaces());
TreeItem<Renderable> storeyNodeTextItem = new TreeItem<>(storeyNode);
storeyNodeTextItem.setExpanded(true);
allSNodeTextItem.getChildren().add(storeyNodeTextItem);
createGeometryNodes(storey, storeyNodeTextItem);
createBoundarySurfaceNodes(storey.getBoundarySurfaces(), storeyNodeTextItem);
} }
} }
public void createBuildingUnitNodes(Building ab, TreeItem<Renderable> root) { public void createBuildingUnitNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
List<BuildingUnit> buildingUnits = ab.getBuildingUnits(); List<BuildingUnit> buildingUnits = ab.getBuildingUnits();
if (buildingUnits.isEmpty()) { if (buildingUnits.isEmpty()) {
return; return;
} }
AllBuildingUnitsNode allSNode = new AllBuildingUnitsNode(buildingUnits);
TreeItem<Renderable> allSNodeTextItem = new TreeItem<>(allSNode); CityObjectGroupNode buildingUnitsGroupNode = new CityObjectGroupNode(buildingUnits, "Building Units", null);
root.getChildren().add(allSNodeTextItem); TreeItem<Renderable> buildingUnitsGroupItem = new TreeItem<>(buildingUnitsGroupNode);
root.getChildren().add(buildingUnitsGroupItem);
for (BuildingUnit buildingUnit : buildingUnits) { for (BuildingUnit buildingUnit : buildingUnits) {
BuildingUnitNode buildingUnitNode = new BuildingUnitNode(buildingUnit); buildCityObjectNode(buildingUnit, buildingUnitsGroupItem, buildingUnit.getBoundarySurfaces());
TreeItem<Renderable> storeyNodeTextItem = new TreeItem<>(buildingUnitNode);
storeyNodeTextItem.setExpanded(true);
allSNodeTextItem.getChildren().add(storeyNodeTextItem);
createGeometryNodes(buildingUnit, storeyNodeTextItem);
createBoundarySurfaceNodes(buildingUnit.getBoundarySurfaces(), storeyNodeTextItem);
} }
} }
private void createBuildingFurnitureNodes(Building ab, TreeItem<Renderable> root) { private void createBuildingFurnitureNodes(AbstractBuilding ab, TreeItem<Renderable> root) {
createFurnitureNodes(ab.getBuildingRoomFurnitureList(), root); createFurnitureNodes(ab.getBuildingRoomFurnitureList(), root);
} }
...@@ -960,16 +915,12 @@ public class CityDoctorController { ...@@ -960,16 +915,12 @@ public class CityDoctorController {
return; return;
} }
AllFurnitureNode allFnNode = new AllFurnitureNode(furniture); CityObjectGroupNode furnitureGroupNode = new CityObjectGroupNode(furniture, "Furniture", null);
TreeItem<Renderable> allFnNodeTextItem = new TreeItem<>(allFnNode); TreeItem<Renderable> furnitureGroupItem = new TreeItem<>(furnitureGroupNode);
root.getChildren().add(allFnNodeTextItem); root.getChildren().add(furnitureGroupItem);
for (AbstractFurniture fn : furniture) { for (AbstractFurniture fn : furniture) {
FurnitureNode fnNode = new FurnitureNode(fn); buildCityObjectNode(fn, furnitureGroupItem, fn.getBoundarySurfaces());
TreeItem<Renderable> fnNodeTextItem = new TreeItem<>(fnNode);
fnNodeTextItem.setExpanded(true);
allFnNodeTextItem.getChildren().add(fnNodeTextItem);
createGeometryNodes(fn, fnNodeTextItem);
createBoundarySurfaceNodes(fn.getBoundarySurfaceList(), fnNodeTextItem);
} }
} }
...@@ -977,25 +928,26 @@ public class CityDoctorController { ...@@ -977,25 +928,26 @@ public class CityDoctorController {
if (bsList.isEmpty()) { if (bsList.isEmpty()) {
return; return;
} }
AllBoundarySurfacesNode allBsText = new AllBoundarySurfacesNode(bsList);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBsText);
root.getChildren().add(allBpsTextItem);
allBpsTextItem.getChildren().add(new TreeItem<>()); CityObjectGroupNode boundarySurfacesGroupNode = new CityObjectGroupNode(bsList, "Boundary Surfaces", null);
TreeItem<Renderable> boundarySurfacesGroupItem = new TreeItem<>(boundarySurfacesGroupNode);
root.getChildren().add(boundarySurfacesGroupItem);
allBpsTextItem.expandedProperty().addListener((obs, old, newV) -> { boundarySurfacesGroupItem.getChildren().add(new TreeItem<>());
if (Boolean.TRUE.equals(newV) && allBpsTextItem.getChildren().size() == 1) {
boundarySurfacesGroupItem.expandedProperty().addListener((obs, old, newV) -> {
if (Boolean.TRUE.equals(newV) && boundarySurfacesGroupItem.getChildren().size() == 1) {
Platform.runLater(() -> { Platform.runLater(() -> {
allBpsTextItem.getChildren().clear(); boundarySurfacesGroupItem.getChildren().clear();
for (BoundarySurface bs : bsList) { for (BoundarySurface bs : bsList) {
BoundarySurfaceNode bsText = new BoundarySurfaceNode(bs); CityObjectNode bsText = new CityObjectNode(bs);
TreeItem<Renderable> bsTextItem = new TreeItem<>(bsText); TreeItem<Renderable> bsTextItem = new TreeItem<>(bsText);
bsTextItem.setExpanded(true); bsTextItem.setExpanded(true);
allBpsTextItem.getChildren().add(bsTextItem); boundarySurfacesGroupItem.getChildren().add(bsTextItem);
createGeometryNodes(bs, bsTextItem); createGeometryNodes(bs, bsTextItem);
createOpeningNodes(bs.getOpenings(), bsTextItem); createOpeningNodes(bs.getOpenings(), bsTextItem);
} }
updateTree(allBpsTextItem); updateTree(boundarySurfacesGroupItem);
}); });
} }
}); });
...@@ -1005,31 +957,35 @@ public class CityDoctorController { ...@@ -1005,31 +957,35 @@ public class CityDoctorController {
if (openings == null || openings.isEmpty()) { if (openings == null || openings.isEmpty()) {
return; return;
} }
AllOpeningsNode allOpeningsNode = new AllOpeningsNode(openings);
TreeItem<Renderable> allOpeningsItem = new TreeItem<>(allOpeningsNode); CityObjectGroupNode openingsGroupNode = new CityObjectGroupNode(openings, "Openings", null);
TreeItem<Renderable> openingsGroupItem = new TreeItem<>(openingsGroupNode);
root.getChildren().add(openingsGroupItem);
for (Opening o : openings) { for (Opening o : openings) {
OpeningNode openingNode = new OpeningNode(o); OpeningNode openingNode = new OpeningNode(o);
TreeItem<Renderable> openingsItem = new TreeItem<>(openingNode); TreeItem<Renderable> openingItem = new TreeItem<>(openingNode);
allOpeningsItem.getChildren().add(openingsItem); openingsGroupItem.getChildren().add(openingItem);
} }
root.getChildren().add(allOpeningsItem);
} }
private void createBuildingPartNodes(Building ab, TreeItem<Renderable> item) { private void createBuildingPartNodes(Building ab, TreeItem<Renderable> item) {
if (ab.getBuildingParts().isEmpty()) { if (ab.getBuildingParts().isEmpty()) {
return; return;
} }
AllBuildingPartsNode allBpsText = new AllBuildingPartsNode(ab.getBuildingParts()); CityObjectGroupNode buildingPartsGroupNode = new CityObjectGroupNode(ab.getBuildingParts(), "Building Parts", null);
TreeItem<Renderable> allBpsTextItem = new TreeItem<>(allBpsText); TreeItem<Renderable> buildingPartsGroupItem = new TreeItem<>(buildingPartsGroupNode);
item.getChildren().add(allBpsTextItem); item.getChildren().add(buildingPartsGroupItem);
for (BuildingPart bp : ab.getBuildingParts()) { for (BuildingPart bp : ab.getBuildingParts()) {
BuildingPartNode bpNode = new BuildingPartNode(bp); TreeItem<Renderable> bpNodeItem = buildCityObjectNode(bp, buildingPartsGroupItem, bp.getBoundarySurfaces());
TreeItem<Renderable> bpNodeItem = new TreeItem<>(bpNode);
bpNodeItem.setExpanded(true); createBuildingInstallationNodes(bp, bpNodeItem);
allBpsTextItem.getChildren().add(bpNodeItem); createBuildingRoomNodes(bp, bpNodeItem);
createGeometryNodes(bp, bpNodeItem); createBuildingFurnitureNodes(bp, bpNodeItem);
createBoundarySurfaceNodes(bp.getBoundarySurfaces(), bpNodeItem); createBuildingStoreyNodes(bp, bpNodeItem);
createBuildingUnitNodes(bp, bpNodeItem);
} }
} }
...@@ -1043,11 +999,15 @@ public class CityDoctorController { ...@@ -1043,11 +999,15 @@ public class CityDoctorController {
public void startChecks(ValidationConfiguration config, ProgressListener l) { public void startChecks(ValidationConfiguration config, ProgressListener l) {
if (model == null) { if (model == null) {
logger.warn(Localization.getText("CityDoctorController.noDatamodel")); if (logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noDatamodel"));
}
return; return;
} }
if (sourceFile == null) { if (sourceFile == null) {
logger.warn(Localization.getText("CityDoctorController.noSourceFile")); if (logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noSourceFile"));
}
return; return;
} }
try { try {
...@@ -1083,9 +1043,10 @@ public class CityDoctorController { ...@@ -1083,9 +1043,10 @@ public class CityDoctorController {
public void startZipFileChecks(ValidationConfiguration config, ProgressListener l, boolean lowMemoryMode, public void startZipFileChecks(ValidationConfiguration config, ProgressListener l, boolean lowMemoryMode,
Path outputPath, boolean pdfReports, boolean xmlReports) { Path outputPath, boolean pdfReports, boolean xmlReports) {
if (zipArchive == null) { if (zipArchive == null && logger.isWarnEnabled()) {
logger.warn(Localization.getText("CityDoctorController.noZipFile")); logger.warn(Localization.getText("CityDoctorController.noZipFile"));
} }
if (lowMemoryMode) { if (lowMemoryMode) {
startZipFileCheckStream(config, outputPath, pdfReports, xmlReports); startZipFileCheckStream(config, outputPath, pdfReports, xmlReports);
return; return;
...@@ -1262,6 +1223,7 @@ public class CityDoctorController { ...@@ -1262,6 +1223,7 @@ public class CityDoctorController {
addErrorStats(stats, model.getBridges()); addErrorStats(stats, model.getBridges());
addErrorStats(stats, model.getBuildings()); addErrorStats(stats, model.getBuildings());
addErrorStats(stats, model.getLand()); addErrorStats(stats, model.getLand());
addErrorStats(stats, model.getTunnels());
addErrorStats(stats, model.getTransportation()); addErrorStats(stats, model.getTransportation());
addErrorStats(stats, model.getVegetation()); addErrorStats(stats, model.getVegetation());
addErrorStats(stats, model.getWater()); addErrorStats(stats, model.getWater());
...@@ -1578,7 +1540,7 @@ public class CityDoctorController { ...@@ -1578,7 +1540,7 @@ public class CityDoctorController {
updateTree(mainWindow.getBuildingsView().getRoot()); updateTree(mainWindow.getBuildingsView().getRoot());
break; break;
case VEGETATION: case VEGETATION:
buildVegetation(model.getVegetation()); buildVegetation(model);
updateTree(mainWindow.getVegetationView().getRoot()); updateTree(mainWindow.getVegetationView().getRoot());
break; break;
case BRIDGE: case BRIDGE:
...@@ -1590,15 +1552,14 @@ public class CityDoctorController { ...@@ -1590,15 +1552,14 @@ public class CityDoctorController {
updateTree(mainWindow.getTerrainView().getRoot()); updateTree(mainWindow.getTerrainView().getRoot());
break; break;
case TRANSPORTATION: case TRANSPORTATION:
buildTransportation(model.getTransportation()); buildTransportation(model);
updateTree(mainWindow.getTransportationView().getRoot()); updateTree(mainWindow.getTransportationView().getRoot());
break; break;
case TUNNEL: case TUNNEL:
buildTunnel(model.getTunnels()); buildTunnel(model);
updateTree(mainWindow.getTunnelView().getRoot()); updateTree(mainWindow.getTunnelView().getRoot());
break; break;
case WATER: case WATER:
buildWater(model); buildWater(model);
updateTree(mainWindow.getWaterView().getRoot()); updateTree(mainWindow.getWaterView().getRoot());
break; break;
...@@ -1664,12 +1625,13 @@ public class CityDoctorController { ...@@ -1664,12 +1625,13 @@ public class CityDoctorController {
public void delete(TreeItem<Renderable> selectedItem) { public void delete(TreeItem<Renderable> selectedItem) {
if (model == null) { if (model == null) {
return; return;
} }/* TODO: Rework this properly via Renderable implementation
Renderable render = selectedItem.getValue(); Renderable render = selectedItem.getValue();
if (render instanceof BuildingNode node) { if (render instanceof BuildingNode node) {
model.getBuildings().remove(node.getBuilding()); model.getBuildings().remove(node.getBuilding());
mainWindow.getBuildingsView().getRoot().getChildren().remove(selectedItem); mainWindow.getBuildingsView().getRoot().getChildren().remove(selectedItem);
} }
*/
} }
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

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