diff --git a/pom.xml b/pom.xml index 3ebaf0b52b56aa65608dba63fda646067c661f7a..8b0aede389f4cf385901b6188c5f320f76f62bd4 100644 --- a/pom.xml +++ b/pom.xml @@ -7,8 +7,8 @@ UTF-8 - 1.8 - 1.8 + 17 + 17 3.2.3 1.10.1 @@ -65,17 +65,24 @@ - + org.citygml4j - citygml4j - 3.0.0-rc.2 + citygml4j-core + 3.0.0-rc.4 + + + + + org.citygml4j + citygml4j-xml + 3.0.0-rc.4 org.locationtech.proj4j proj4j - 1.1.3 + 1.1.5 org.lwjgl diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/CityGMLViewer.java b/src/main/java/de/hft/stuttgart/citygml/viewer/CityGMLViewer.java index eb9fae20cad1be54161b8ab0ea2cecaebc843023..0dd1f295bcd62c247f3c0178c88138d41414ceab 100644 --- a/src/main/java/de/hft/stuttgart/citygml/viewer/CityGMLViewer.java +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/CityGMLViewer.java @@ -25,17 +25,24 @@ import java.nio.DoubleBuffer; import java.nio.FloatBuffer; import java.util.ArrayList; import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; import javax.imageio.ImageIO; +import javax.xml.namespace.QName; import javax.xml.parsers.ParserConfigurationException; -import org.citygml4j.CityGMLContext; -import org.citygml4j.CityGMLContextException; -import org.citygml4j.model.core.AbstractCityObject; -import org.citygml4j.model.core.AbstractFeature; -import org.citygml4j.xml.reader.ChunkingOptions; +import org.citygml4j.core.model.core.AbstractFeature; +import org.citygml4j.core.util.CityGMLConstants; +import org.citygml4j.xml.CityGMLContext; +import org.citygml4j.xml.CityGMLContextException; +import org.citygml4j.xml.reader.ChunkOptions; +import org.citygml4j.xml.reader.CityGMLChunk; import org.citygml4j.xml.reader.CityGMLInputFactory; import org.citygml4j.xml.reader.CityGMLReadException; import org.citygml4j.xml.reader.CityGMLReader; @@ -58,6 +65,7 @@ import org.xml.sax.SAXException; import com.jogamp.opengl.GLException; import de.hft.stuttgart.citygml.viewer.datastructure.BoundingBox; +import de.hft.stuttgart.citygml.viewer.datastructure.Polygon; import de.hft.stuttgart.citygml.viewer.math.Vector3d; import de.hft.stuttgart.citygml.viewer.parser.CityGMLParser; import de.hft.stuttgart.citygml.viewer.parser.FeatureMapper; @@ -86,6 +94,15 @@ public class CityGMLViewer { private static ProgressBar bar; + private static final String CITY_OBJECT_MEMBER = "cityObjectMember"; + private static List chunkProperties = new ArrayList<>(); + + static { + chunkProperties.add(new QName(CityGMLConstants.CITYGML_1_0_CORE_NAMESPACE, CITY_OBJECT_MEMBER)); + chunkProperties.add(new QName(CityGMLConstants.CITYGML_2_0_CORE_NAMESPACE, CITY_OBJECT_MEMBER)); + chunkProperties.add(new QName(CityGMLConstants.CITYGML_3_0_CORE_NAMESPACE, CITY_OBJECT_MEMBER)); + } + public static void main(String[] args) { File f = null; if (args != null && args.length == 1) { @@ -173,9 +190,8 @@ public class CityGMLViewer { GLFW.glfwDefaultWindowHints(); // Loads GLFW's default window settings GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE); // Sets window to be visible GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_TRUE); // Sets whether the window is resizable - GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_PROFILE, GLFW.GLFW_OPENGL_CORE_PROFILE); GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MAJOR, 3); - GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 3); + GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 0); GLFW.glfwWindowHint(GLFW.GLFW_SAMPLES, 2); windowId = GLFW.glfwCreateWindow(width, height, title, 0, 0); @@ -271,8 +287,8 @@ public class CityGMLViewer { // NO_CURRENT_CONTEXT error org.lwjgl.opengl.GLCapabilities caps = GL.createCapabilities(); // Will let lwjgl know we want to use this // context as the context to draw with - if (!caps.OpenGL33) { - log.warning("OpenGL 33 is not supported"); + if (!caps.OpenGL30) { + log.warning("OpenGL 3.0 is not supported"); } GLFW.glfwSwapInterval(1); // How many draws to swap the buffer @@ -284,7 +300,7 @@ public class CityGMLViewer { GLFW.glfwShowWindow(windowId); // Shows the window if (log.isLoggable(Level.INFO)) { - log.info("OpenGL error code after displaying the window: " + GL11.glGetError()); + log.fine("OpenGL error code after displaying the window: " + GL11.glGetError()); } FloatBuffer clearColor = null; @@ -293,24 +309,19 @@ public class CityGMLViewer { try { Shader program = new Shader("vertex.vert", "fragment.frag"); program.use(); - if (log.isLoggable(Level.INFO)) { - log.info("OpenGL error code after shader loading: " + GL11.glGetError()); - } + log.fine(() -> "OpenGL error code after shader loading: " + GL11.glGetError()); camera = new Camera(program); camera.setOrtho(true); camera.reshape(width, height, cameraViewDistance); bar = new ProgressBar(windowId, width, height); bar.drawProgress(0); - if (log.isLoggable(Level.INFO)) { - log.info("OpenGL error code after drawing initial progress bar: " + GL11.glGetError()); - } + log.fine(() -> "OpenGL error code after drawing initial progress bar: " + GL11.glGetError()); loadGmlFile(f); + log.fine(() -> "OpenGL error code after loading GML file: " + GL11.glGetError()); bar.free(); bar = null; - if (log.isLoggable(Level.INFO)) { - log.info("OpenGL error code after loading GML file: " + GL11.glGetError()); - } + camera.setOrtho(false); camera.reshape(width, height, cameraViewDistance); @@ -319,9 +330,7 @@ public class CityGMLViewer { clearDepth = MemoryUtil.memAllocFloat(1); clearDepth.put(0, 1f); - if (log.isLoggable(Level.INFO)) { - log.info("OpenGL error code before loop: " + GL11.glGetError()); - } + log.fine(() -> "OpenGL error code before loop: " + GL11.glGetError()); while (!GLFW.glfwWindowShouldClose(windowId)) { /* Do something */ GL30.glClearBufferfv(GL11.GL_COLOR, 0, clearColor); @@ -359,44 +368,74 @@ public class CityGMLViewer { CityGMLParser.parseEpsgCodeFromFile(file, config); CityGMLContext context = CityGMLContext.newInstance(); CityGMLInputFactory in = context.createCityGMLInputFactory() - .withChunking(ChunkingOptions.chunkByCityModelMembers()); + .withChunking(ChunkOptions.chunkByProperties(chunkProperties).skipCityModel(true)); try (ObservedInputStream ois = new ObservedInputStream(file); CityGMLReader reader = in.createCityGMLReader(file.getAbsolutePath(), ois)) { ois.addListener(p -> bar.drawProgress((int) (p * 82))); - FeatureMapper mapper = new FeatureMapper(config); + + int threads = Runtime.getRuntime().availableProcessors(); + ExecutorService service = Executors.newFixedThreadPool(threads); + List> mappers = new ArrayList<>(); while (reader.hasNext()) { - AbstractFeature chunk = reader.next(); - if (chunk instanceof AbstractCityObject) { - AbstractCityObject aco = (AbstractCityObject) chunk; - aco.accept(mapper); - } + CityGMLChunk nextChunk = reader.nextChunk(); + mappers.add(service.submit(() -> { + FeatureMapper mapper = new FeatureMapper(config); + AbstractFeature feature = nextChunk.build(); + feature.accept(mapper); + return mapper; + })); } - BoundingBox bbox = BoundingBox.of(mapper); + service.shutdown(); + service.awaitTermination(20, TimeUnit.MINUTES); + List lod1Polygons = new ArrayList<>(); + List lod2Polygons = new ArrayList<>(); + List lod3Polygons = new ArrayList<>(); + List lod4Polygons = new ArrayList<>(); + List fMappers = mappers.stream().map(t -> { + try { + return t.get(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + log.severe("Could not finish parsing file in 20 minutes, aborting"); + throw new IllegalStateException(e); + } catch (ExecutionException e) { + log.severe("Could not parsing file completely, cause: " + e.getCause().getMessage()); + throw new IllegalStateException(e); + } + }).toList(); + fMappers.stream().forEach(m -> { + lod1Polygons.addAll(m.getLod1Polygons()); + lod2Polygons.addAll(m.getLod2Polygons()); + lod3Polygons.addAll(m.getLod3Polygons()); + lod4Polygons.addAll(m.getLod4Polygons()); + }); + BoundingBox bbox = BoundingBox.of(lod1Polygons, lod2Polygons, lod3Polygons, lod4Polygons); bar.drawProgress(81); Vector3d center = bbox.getCenter(); - mapper.movePolygonsBy(center); + fMappers.forEach(m -> m.movePolygonsBy(center)); bar.drawProgress(82); - long nrOfPolygons = (long) mapper.getLod1Polygons().size() + mapper.getLod2Polygons().size() - + mapper.getLod3Polygons().size() + mapper.getLod4Polygons().size(); + long nrOfPolygons = (long) lod1Polygons.size() + lod2Polygons.size() + + lod3Polygons.size() + lod4Polygons.size(); long[] count = new long[1]; + log.info(() -> "Found " + nrOfPolygons + " polygons"); PolygonListener l = () -> { count[0]++; bar.drawProgress(82 + (int) (count[0] * 9 / nrOfPolygons)); }; - if (!mapper.getLod1Polygons().isEmpty()) { - PolygonViewInformation lod1ViewInfo = new PolygonViewInformation(mapper.getLod1Polygons(), l); + if (!lod1Polygons.isEmpty()) { + PolygonViewInformation lod1ViewInfo = new PolygonViewInformation(lod1Polygons, l); viewing.add(lod1ViewInfo); } - if (!mapper.getLod2Polygons().isEmpty()) { - PolygonViewInformation lod2ViewInfo = new PolygonViewInformation(mapper.getLod2Polygons(), l); + if (!lod2Polygons.isEmpty()) { + PolygonViewInformation lod2ViewInfo = new PolygonViewInformation(lod2Polygons, l); viewing.add(lod2ViewInfo); } - if (!mapper.getLod3Polygons().isEmpty()) { - PolygonViewInformation lod3ViewInfo = new PolygonViewInformation(mapper.getLod3Polygons(), l); + if (!lod3Polygons.isEmpty()) { + PolygonViewInformation lod3ViewInfo = new PolygonViewInformation(lod3Polygons, l); viewing.add(lod3ViewInfo); } - if (!mapper.getLod3Polygons().isEmpty()) { - PolygonViewInformation lod4ViewInfo = new PolygonViewInformation(mapper.getLod4Polygons(), l); + if (!lod4Polygons.isEmpty()) { + PolygonViewInformation lod4ViewInfo = new PolygonViewInformation(lod4Polygons, l); viewing.add(lod4ViewInfo); } @@ -406,6 +445,9 @@ public class CityGMLViewer { camera.setDistance((float) translateZ); cameraViewDistance = (float) longestSide * 20f; camera.reshape(width, height, cameraViewDistance); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + log.severe("Could not finish parsing file in 20 minutes, aborting"); } } catch (GLException | IOException | ParserConfigurationException | SAXException | CityGMLContextException | CityGMLReadException e) { diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/PolygonViewInformation.java b/src/main/java/de/hft/stuttgart/citygml/viewer/PolygonViewInformation.java index 15b0e417f67244b5a90a3d020fbd12b8ebda1e34..c0820ba8f9946d9596b85738f58b5b5f515b433d 100644 --- a/src/main/java/de/hft/stuttgart/citygml/viewer/PolygonViewInformation.java +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/PolygonViewInformation.java @@ -26,12 +26,10 @@ import java.util.List; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL15; +import org.lwjgl.opengl.GL20; import org.lwjgl.opengl.GL30; -import org.lwjgl.opengl.GL44; -import org.lwjgl.opengl.GL45; import org.lwjgl.system.MemoryUtil; -import de.hft.stuttgart.citygml.viewer.datastructure.BufferConstants; import de.hft.stuttgart.citygml.viewer.datastructure.Polygon; import de.hft.stuttgart.citygml.viewer.datastructure.TesselatedPolygon; import de.hft.stuttgart.citygml.viewer.datastructure.Triangle3d; @@ -41,34 +39,37 @@ public class PolygonViewInformation { private static final Vector3d AXIS = new Vector3d(19, 0.8, 1.5).normalize(); - private int vao; - private IntBuffer buffers; private boolean draw = false; private int elements; private PolygonListener listener; + private int posVbo; + private int colorVbo; + private int indexVbo; + public PolygonViewInformation(List polygons, PolygonListener listener) { this.listener = listener; - vao = GL45.glCreateVertexArrays(); - GL45.glVertexArrayAttribBinding(vao, BufferConstants.ATTRIBUTE_POSITION, BufferConstants.BINDING_INDEX_0); - GL45.glVertexArrayAttribBinding(vao, BufferConstants.ATTRIBUTE_COLOR, BufferConstants.BINDING_INDEX_0); - - GL45.glVertexArrayAttribFormat(vao, BufferConstants.ATTRIBUTE_POSITION, 3, GL_FLOAT, false, 0); - GL45.glVertexArrayAttribFormat(vao, BufferConstants.ATTRIBUTE_COLOR, 3, GL_FLOAT, false, 3 * 4); - - GL45.glEnableVertexArrayAttrib(vao, BufferConstants.ATTRIBUTE_POSITION); - GL45.glEnableVertexArrayAttrib(vao, BufferConstants.ATTRIBUTE_COLOR); - - buffers = MemoryUtil.memAllocInt(BufferConstants.SIZE); - GL45.glCreateBuffers(buffers); - GL45.glVertexArrayElementBuffer(vao, buffers.get(BufferConstants.ELEMENT)); - GL45.glVertexArrayVertexBuffer(vao, BufferConstants.BINDING_INDEX_0, buffers.get(BufferConstants.VERTEX), 0, (3 + 3) * 4); - setupBuffers(polygons); + vao = GL30.glGenVertexArrays(); + GL30.glBindVertexArray(vao); + + posVbo = GL15.glGenBuffers(); + GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, posVbo); + GL20.glEnableVertexAttribArray(0); + GL20.glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0); + + colorVbo = GL15.glGenBuffers(); + GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, colorVbo); + GL20.glEnableVertexAttribArray(1); + GL20.glVertexAttribPointer(1, 3, GL_FLOAT, false, 0, 0); + + indexVbo = GL15.glGenBuffers(); + setupBuffers(polygons, posVbo, colorVbo, indexVbo); + GL30.glBindVertexArray(0); } - private void setupBuffers(List polys) { + private void setupBuffers(List polys, int posVbo, int colorVbo, int indexVbo) { List tessPolys = new ArrayList<>(); for (Polygon poly : polys) { tessPolys.add(TesselatedPolygon.of(poly)); @@ -81,8 +82,11 @@ public class PolygonViewInformation { } // 6 float for 3 vertices per triangle - int moreSpace = nrOfTriangles * 3 * 3 * 2; - FloatBuffer vertexData = MemoryUtil.memAllocFloat(moreSpace); + int vertexDataSize = nrOfTriangles * 3 * 3; + FloatBuffer vertexData = MemoryUtil.memAllocFloat(vertexDataSize); + int colorDataSize = nrOfTriangles * 3 * 3; + FloatBuffer colorData = MemoryUtil.memAllocFloat(colorDataSize); + IntBuffer elementData = MemoryUtil.memAllocInt(nrOfTriangles * 3); float[] rgba = new float[4]; for (TesselatedPolygon tessPoly : tessPolys) { @@ -96,9 +100,9 @@ public class PolygonViewInformation { (int) (baseColor.getBlue() * acos)); derivedColor.getComponents(rgba); for (Triangle3d tri : tessPoly.getTriangles()) { - addPoint(vertexData, tri.getP1(), rgba[0], rgba[1], rgba[2]); - addPoint(vertexData, tri.getP2(), rgba[0], rgba[1], rgba[2]); - addPoint(vertexData, tri.getP3(), rgba[0], rgba[1], rgba[2]); + addPoint(vertexData, colorData, tri.getP1(), rgba[0], rgba[1], rgba[2]); + addPoint(vertexData, colorData, tri.getP2(), rgba[0], rgba[1], rgba[2]); + addPoint(vertexData, colorData, tri.getP3(), rgba[0], rgba[1], rgba[2]); } listener.finishedPolygon(); } @@ -106,30 +110,35 @@ public class PolygonViewInformation { elementData.put(i); } ((Buffer) elementData).flip(); + ((Buffer) colorData).flip(); ((Buffer) vertexData).flip(); - GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, buffers.get(BufferConstants.VERTEX)); - GL44.glBufferStorage(GL15.GL_ARRAY_BUFFER, vertexData, 0); + GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, posVbo); + GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexData, GL15.GL_STATIC_DRAW); + + GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, colorVbo); + GL15.glBufferData(GL15.GL_ARRAY_BUFFER, colorData, GL15.GL_STATIC_DRAW); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); - GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, buffers.get(BufferConstants.ELEMENT)); - GL44.glBufferStorage(GL15.GL_ELEMENT_ARRAY_BUFFER, elementData, 0); + GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, indexVbo); + GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, elementData, GL15.GL_STATIC_DRAW); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0); - + MemoryUtil.memFree(elementData); + MemoryUtil.memFree(colorData); MemoryUtil.memFree(vertexData); draw = true; elements = elementData.capacity(); } - private static void addPoint(FloatBuffer lod1VertexData, Vector3d point, float red, float green, float blue) { - lod1VertexData.put((float) point.getX()); - lod1VertexData.put((float) point.getY()); - lod1VertexData.put((float) point.getZ()); - lod1VertexData.put(red); - lod1VertexData.put(green); - lod1VertexData.put(blue); + private static void addPoint(FloatBuffer vertexData, FloatBuffer colorData, Vector3d point, float red, float green, float blue) { + vertexData.put((float) point.getX()); + vertexData.put((float) point.getY()); + vertexData.put((float) point.getZ()); + colorData.put(red); + colorData.put(green); + colorData.put(blue); } public boolean shouldDraw() { @@ -145,13 +154,16 @@ public class PolygonViewInformation { } public void destroy() { - MemoryUtil.memFree(buffers); + GL15.glDeleteBuffers(colorVbo); + GL15.glDeleteBuffers(posVbo); + GL15.glDeleteBuffers(indexVbo); + GL30.glDeleteVertexArrays(vao); } public void draw() { if (draw) { GL30.glBindVertexArray(vao); - GL11.glDrawElements(GL11.GL_TRIANGLES, elements, GL11.GL_UNSIGNED_INT, 0); + GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, elements); } } } diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/datastructure/BoundingBox.java b/src/main/java/de/hft/stuttgart/citygml/viewer/datastructure/BoundingBox.java index ebf1033933d5136e7d6acd37461aae58f0fa5ad0..1fa9ba1d3002e838314ab462cc7f7bd477f6c7eb 100644 --- a/src/main/java/de/hft/stuttgart/citygml/viewer/datastructure/BoundingBox.java +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/datastructure/BoundingBox.java @@ -162,4 +162,10 @@ public class BoundingBox { public String toString() { return Arrays.toString(bbox); } + + public static BoundingBox of(List lod1Polygons, List lod2Polygons, List lod3Polygons, + List lod4Polygons) { + return BoundingBoxCalculator.calculateBoundingBox(lod1Polygons, lod2Polygons, lod3Polygons, lod4Polygons); + + } } diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/math/BoundingBoxCalculator.java b/src/main/java/de/hft/stuttgart/citygml/viewer/math/BoundingBoxCalculator.java index 46973e521dfc65d58d8fe92c47a4812a8bfd54b8..3be59452ff884fa999cbd79b70bfe355375a7ff4 100644 --- a/src/main/java/de/hft/stuttgart/citygml/viewer/math/BoundingBoxCalculator.java +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/math/BoundingBoxCalculator.java @@ -116,11 +116,16 @@ public class BoundingBoxCalculator { } public static BoundingBox calculateBoundingBox(FeatureMapper mapper) { + return calculateBoundingBox(mapper.getLod1Polygons(), mapper.getLod2Polygons(), mapper.getLod3Polygons(), mapper.getLod4Polygons()); + } + + public static BoundingBox calculateBoundingBox(List lod1Polygons, List lod2Polygons, + List lod3Polygons, List lod4Polygons) { List> polygonList = new ArrayList<>(); - polygonList.add(mapper.getLod1Polygons()); - polygonList.add(mapper.getLod2Polygons()); - polygonList.add(mapper.getLod3Polygons()); - polygonList.add(mapper.getLod4Polygons()); + polygonList.add(lod1Polygons); + polygonList.add(lod2Polygons); + polygonList.add(lod3Polygons); + polygonList.add(lod4Polygons); double lowX = Double.MAX_VALUE; double highX = Double.NEGATIVE_INFINITY; diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/parser/ColorHandler.java b/src/main/java/de/hft/stuttgart/citygml/viewer/parser/ColorHandler.java new file mode 100644 index 0000000000000000000000000000000000000000..a7f2708a59c70ef80142acc1d2e947c3b5fb50ab --- /dev/null +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/parser/ColorHandler.java @@ -0,0 +1,131 @@ +package de.hft.stuttgart.citygml.viewer.parser; + +import java.awt.Color; +import java.io.FileReader; +import java.util.Properties; +import java.util.logging.Logger; + +public class ColorHandler { + + private static final Logger logger = Logger.getLogger(ColorHandler.class.getName()); + + private static Color groundColor = new Color(0.9411765f, 0.9019608f, 0.54901963f); + private static Color roofColor = Color.RED; + private static Color doorColor = Color.ORANGE; + private static Color windowColor = new Color(0.0f, 0.5019608f, 0.5019608f); + private static Color wallColor = Color.WHITE; + private static Color bridgeColor = new Color(1.0f, 0.49803922f, 0.3137255f); + private static Color landColor = new Color(0.64705884f, 0.16470589f, 0.16470589f); + private static Color transportationColor = new Color(1.0f, 1.0f, 0.0f); + private static Color vegetationColor = new Color(0.5647059f, 0.93333334f, 0.5647059f); + private static Color waterColor = new Color(0.5294118f, 0.80784315f, 0.98039216f); + + static { + try (FileReader reader = new FileReader("color.properties")) { + Properties props = new Properties(); + props.load(reader); + Color parsedGroundColor = parseColor(props.getProperty("groundColor")); + if (parsedGroundColor != null) { + groundColor = parsedGroundColor; + } + Color parsedRoofColor = parseColor(props.getProperty("roofColor")); + if (parsedRoofColor != null) { + roofColor = parsedRoofColor; + } + Color parsedDoorColor = parseColor(props.getProperty("doorColor")); + if (parsedDoorColor != null) { + doorColor = parsedDoorColor; + } + Color parsedWindowColor = parseColor(props.getProperty("windowColor")); + if (parsedWindowColor != null) { + windowColor = parsedWindowColor; + } + Color parsedWallColor = parseColor(props.getProperty("wallColor")); + if (parsedWallColor != null) { + wallColor = parsedWallColor; + } + Color parsedBridgeColor = parseColor(props.getProperty("bridgeColor")); + if (parsedBridgeColor != null) { + bridgeColor = parsedBridgeColor; + } + Color parsedLandColor = parseColor(props.getProperty("landColor")); + if (parsedLandColor != null) { + landColor = parsedLandColor; + } + Color parsedTransportationColor = parseColor(props.getProperty("transportationColor")); + if (parsedTransportationColor != null) { + transportationColor = parsedTransportationColor; + } + Color parsedVegetationColor = parseColor(props.getProperty("vegetationColor")); + if (parsedVegetationColor != null) { + vegetationColor = parsedVegetationColor; + } + Color parsedWaterColor = parseColor(props.getProperty("waterColor")); + if (parsedWaterColor != null) { + waterColor = parsedWaterColor; + } + }catch (Exception e) { + logger.warning(() -> "Failed to read color properties file: " + e.getMessage()); + } + } + + private ColorHandler() { + } + + private static Color parseColor(String colorString) { + if (colorString == null) { + return null; + } + try { + String[] split = colorString.split(" "); + float r = Float.parseFloat(split[0]); + float g = Float.parseFloat(split[1]); + float b = Float.parseFloat(split[2]); + return new Color(r, g, b); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + public static Color getGroundColor() { + return groundColor; + } + + public static Color getRoofColor() { + return roofColor; + } + + public static Color getDoorColor() { + return doorColor; + } + + public static Color getWindowColor() { + return windowColor; + } + + public static Color getWallColor() { + return wallColor; + } + + public static Color getBridgeColor() { + return bridgeColor; + } + + public static Color getLandColor() { + return landColor; + } + + public static Color getTransportationColor() { + return transportationColor; + } + + public static Color getVegetationColor() { + return vegetationColor; + } + + public static Color getWaterColor() { + return waterColor; + } + +} diff --git a/src/main/java/de/hft/stuttgart/citygml/viewer/parser/FeatureMapper.java b/src/main/java/de/hft/stuttgart/citygml/viewer/parser/FeatureMapper.java index 680894e521d3de41f27e5963f7379a804650a4cf..9bb358e2d790ab3aeae4c39f5036ab5b19d34836 100644 --- a/src/main/java/de/hft/stuttgart/citygml/viewer/parser/FeatureMapper.java +++ b/src/main/java/de/hft/stuttgart/citygml/viewer/parser/FeatureMapper.java @@ -16,50 +16,49 @@ package de.hft.stuttgart.citygml.viewer.parser; import java.awt.Color; -import java.io.FileReader; -import java.io.IOException; import java.util.ArrayList; import java.util.List; -import java.util.Properties; - -import org.citygml4j.model.bridge.AbstractBridge; -import org.citygml4j.model.building.AbstractBuilding; -import org.citygml4j.model.building.BuildingInstallation; -import org.citygml4j.model.construction.AbstractFillingElement; -import org.citygml4j.model.construction.Door; -import org.citygml4j.model.construction.GroundSurface; -import org.citygml4j.model.construction.RoofSurface; -import org.citygml4j.model.construction.Window; -import org.citygml4j.model.core.AbstractThematicSurface; -import org.citygml4j.model.core.ImplicitGeometry; -import org.citygml4j.model.core.ImplicitGeometryProperty; -import org.citygml4j.model.deprecated.bridge.DeprecatedPropertiesOfAbstractBridge; -import org.citygml4j.model.deprecated.building.DeprecatedPropertiesOfAbstractBuilding; -import org.citygml4j.model.deprecated.building.DeprecatedPropertiesOfBuildingInstallation; -import org.citygml4j.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface; -import org.citygml4j.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace; -import org.citygml4j.model.deprecated.transportation.TransportationComplex; -import org.citygml4j.model.deprecated.vegetation.DeprecatedPropertiesOfPlantCover; -import org.citygml4j.model.deprecated.vegetation.DeprecatedPropertiesOfSolitaryVegetationObject; -import org.citygml4j.model.deprecated.waterbody.DeprecatedPropertiesOfWaterBody; -import org.citygml4j.model.landuse.LandUse; -import org.citygml4j.model.relief.TINRelief; -import org.citygml4j.model.transportation.AuxiliaryTrafficArea; -import org.citygml4j.model.transportation.TrafficArea; -import org.citygml4j.model.vegetation.PlantCover; -import org.citygml4j.model.vegetation.SolitaryVegetationObject; -import org.citygml4j.model.waterbody.WaterBody; -import org.citygml4j.visitor.ObjectWalker; + +import org.citygml4j.core.model.bridge.AbstractBridge; +import org.citygml4j.core.model.building.AbstractBuilding; +import org.citygml4j.core.model.building.BuildingInstallation; +import org.citygml4j.core.model.cityfurniture.CityFurniture; +import org.citygml4j.core.model.cityobjectgroup.CityObjectGroup; +import org.citygml4j.core.model.construction.AbstractFillingElement; +import org.citygml4j.core.model.construction.Door; +import org.citygml4j.core.model.construction.GroundSurface; +import org.citygml4j.core.model.construction.OtherConstruction; +import org.citygml4j.core.model.construction.RoofSurface; +import org.citygml4j.core.model.construction.Window; +import org.citygml4j.core.model.core.AbstractSpace; +import org.citygml4j.core.model.core.AbstractThematicSurface; +import org.citygml4j.core.model.core.ImplicitGeometry; +import org.citygml4j.core.model.core.ImplicitGeometryProperty; +import org.citygml4j.core.model.deprecated.building.DeprecatedPropertiesOfAbstractBuilding; +import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface; +import org.citygml4j.core.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace; +import org.citygml4j.core.model.generics.GenericLogicalSpace; +import org.citygml4j.core.model.generics.GenericOccupiedSpace; +import org.citygml4j.core.model.generics.GenericThematicSurface; +import org.citygml4j.core.model.generics.GenericUnoccupiedSpace; +import org.citygml4j.core.model.landuse.LandUse; +import org.citygml4j.core.model.relief.TINRelief; +import org.citygml4j.core.model.transportation.AbstractTransportationSpace; +import org.citygml4j.core.model.vegetation.PlantCover; +import org.citygml4j.core.model.vegetation.SolitaryVegetationObject; +import org.citygml4j.core.model.waterbody.WaterBody; +import org.citygml4j.core.visitor.ObjectWalker; import org.locationtech.proj4j.BasicCoordinateTransform; import org.locationtech.proj4j.ProjCoordinate; import org.xmlobjects.gml.model.geometry.AbstractGeometry; import org.xmlobjects.gml.model.geometry.GeometricPositionList; import org.xmlobjects.gml.model.geometry.GeometryProperty; +import org.xmlobjects.gml.model.geometry.aggregates.MultiSolidProperty; import org.xmlobjects.gml.model.geometry.primitives.AbstractRing; import org.xmlobjects.gml.model.geometry.primitives.AbstractRingProperty; import org.xmlobjects.gml.model.geometry.primitives.LinearRing; +import org.xmlobjects.gml.model.geometry.primitives.SolidProperty; import org.xmlobjects.gml.model.geometry.primitives.Triangle; -import org.xmlobjects.gml.model.geometry.primitives.TriangulatedSurface; import de.hft.stuttgart.citygml.viewer.datastructure.Polygon; import de.hft.stuttgart.citygml.viewer.datastructure.Ring; @@ -67,17 +66,6 @@ import de.hft.stuttgart.citygml.viewer.math.Vector3d; public class FeatureMapper extends ObjectWalker { - private Color groundColor = new Color(0.9411765f, 0.9019608f, 0.54901963f); - private Color roofColor = Color.RED; - private Color doorColor = Color.ORANGE; - private Color windowColor = new Color(0.0f, 0.5019608f, 0.5019608f); - private Color wallColor = Color.WHITE; - private Color bridgeColor = new Color(1.0f, 0.49803922f, 0.3137255f); - private Color landColor = new Color(0.64705884f, 0.16470589f, 0.16470589f); - private Color transportationColor = new Color(1.0f, 1.0f, 0.0f); - private Color vegetationColor = new Color(0.5647059f, 0.93333334f, 0.5647059f); - private Color waterColor = new Color(0.5294118f, 0.80784315f, 0.98039216f); - private ParserConfiguration config; private List lod1Polygons; private List lod2Polygons; @@ -91,51 +79,8 @@ public class FeatureMapper extends ObjectWalker { private ProjCoordinate p1 = new ProjCoordinate(); private ProjCoordinate p2 = new ProjCoordinate(); - public FeatureMapper(ParserConfiguration config) throws IOException { - try (FileReader reader = new FileReader("color.properties")) { - Properties props = new Properties(); - props.load(reader); - Color parsedGroundColor = parseColor(props.getProperty("groundColor")); - if (parsedGroundColor != null) { - groundColor = parsedGroundColor; - } - Color parsedRoofColor = parseColor(props.getProperty("roofColor")); - if (parsedRoofColor != null) { - roofColor = parsedRoofColor; - } - Color parsedDoorColor = parseColor(props.getProperty("doorColor")); - if (parsedDoorColor != null) { - doorColor = parsedDoorColor; - } - Color parsedWindowColor = parseColor(props.getProperty("windowColor")); - if (parsedWindowColor != null) { - windowColor = parsedWindowColor; - } - Color parsedWallColor = parseColor(props.getProperty("wallColor")); - if (parsedWallColor != null) { - wallColor = parsedWallColor; - } - Color parsedBridgeColor = parseColor(props.getProperty("bridgeColor")); - if (parsedBridgeColor != null) { - bridgeColor = parsedBridgeColor; - } - Color parsedLandColor = parseColor(props.getProperty("landColor")); - if (parsedLandColor != null) { - landColor = parsedLandColor; - } - Color parsedTransportationColor = parseColor(props.getProperty("transportationColor")); - if (parsedTransportationColor != null) { - transportationColor = parsedTransportationColor; - } - Color parsedVegetationColor = parseColor(props.getProperty("vegetationColor")); - if (parsedVegetationColor != null) { - vegetationColor = parsedVegetationColor; - } - Color parsedWaterColor = parseColor(props.getProperty("waterColor")); - if (parsedWaterColor != null) { - waterColor = parsedWaterColor; - } - } + public FeatureMapper(ParserConfiguration config) { + currentColor = ColorHandler.getWallColor(); this.config = config; lod1Polygons = new ArrayList<>(); lod2Polygons = new ArrayList<>(); @@ -143,24 +88,31 @@ public class FeatureMapper extends ObjectWalker { lod4Polygons = new ArrayList<>(); } - private Color parseColor(String colorString) { - if (colorString == null) { - return null; + @Override + public void visit(org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly) { + if (currentPolygons == null) { + return; } - try { - String[] split = colorString.split(" "); - float r = Float.parseFloat(split[0]); - float g = Float.parseFloat(split[1]); - float b = Float.parseFloat(split[2]); - return new Color(r, g, b); - } catch (Exception e) { - e.printStackTrace(); - return null; + Polygon viewerPoly = new Polygon(currentColor); + // parse rings + Ring extRing = new Ring(); + viewerPoly.setExteriorRing(extRing); + mapRing(gmlPoly.getExterior(), extRing); + + if (gmlPoly.getInterior() != null) { + for (AbstractRingProperty arp : gmlPoly.getInterior()) { + if (arp.getObject() != null) { + Ring innerRing = new Ring(); + viewerPoly.addInteriorRing(innerRing); + mapRing(arp, innerRing); + } + } } + currentPolygons.add(viewerPoly); } @Override - public void visit(org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly) { + public void visit(org.xmlobjects.gml.model.geometry.primitives.PolygonPatch gmlPoly) { if (currentPolygons == null) { return; } @@ -182,6 +134,48 @@ public class FeatureMapper extends ObjectWalker { currentPolygons.add(viewerPoly); } + @Override + public void visit(OtherConstruction otherConstruction) { + currentColor = ColorHandler.getWallColor(); + super.visit(otherConstruction); + } + + @Override + public void visit(CityFurniture cityFurniture) { + currentColor = ColorHandler.getWallColor(); + super.visit(cityFurniture); + } + + @Override + public void visit(CityObjectGroup cityObjectGroup) { + currentColor = ColorHandler.getWallColor(); + super.visit(cityObjectGroup); + } + + @Override + public void visit(GenericLogicalSpace genericLogicalSpace) { + currentColor = ColorHandler.getWallColor(); + super.visit(genericLogicalSpace); + } + + @Override + public void visit(GenericOccupiedSpace genericOccupiedSpace) { + currentColor = ColorHandler.getWallColor(); + super.visit(genericOccupiedSpace); + } + + @Override + public void visit(GenericThematicSurface genericThematicSurface) { + currentColor = ColorHandler.getWallColor(); + super.visit(genericThematicSurface); + } + + @Override + public void visit(GenericUnoccupiedSpace genericUnoccupiedSpace) { + currentColor = ColorHandler.getWallColor(); + super.visit(genericUnoccupiedSpace); + } + @Override public void visit(Triangle triangle) { if (currentPolygons == null) { @@ -196,7 +190,7 @@ public class FeatureMapper extends ObjectWalker { mapRing(triangle.getExterior(), extRing); currentPolygons.add(viewerPoly); } - + private void mapRing(AbstractRingProperty gmlRing, Ring viewerRing) { if (gmlRing == null || gmlRing.getObject() == null) { return; @@ -259,198 +253,201 @@ public class FeatureMapper extends ObjectWalker { currentRing.addPoint(v); } + @Override + public void visit(AbstractSpace ab) { + super.visit(ab); + parseAbstractGeometry(ab.getLod0MultiSurface(), lod1Polygons); + parseAbstractGeometry(ab.getLod2MultiSurface(), lod2Polygons); + parseAbstractGeometry(ab.getLod3MultiSurface(), lod3Polygons); + parseAbstractGeometry(ab.getLod1Solid(), lod1Polygons); + parseAbstractGeometry(ab.getLod2Solid(), lod2Polygons); + parseAbstractGeometry(ab.getLod3Solid(), lod3Polygons); + } + @Override public void visit(AbstractBuilding ab) { + currentColor = ColorHandler.getWallColor(); super.visit(ab); DeprecatedPropertiesOfAbstractBuilding deprecatedProperties = ab.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, wallColor); - parseAbstractGeometry(ab.getLod2MultiSurface(), lod2Polygons, wallColor); - parseAbstractGeometry(ab.getLod3MultiSurface(), lod3Polygons, wallColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, wallColor); - parseAbstractGeometry(ab.getLod1Solid(), lod1Polygons, wallColor); - parseAbstractGeometry(ab.getLod2Solid(), lod2Polygons, wallColor); - parseAbstractGeometry(ab.getLod3Solid(), lod3Polygons, wallColor); - parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons, wallColor); + parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons); + parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons); + parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons); } - + @Override public void visit(TINRelief tinRelief) { - super.visit(tinRelief); if (tinRelief.getTin() == null || tinRelief.getTin().getObject() == null) { return; } - TriangulatedSurface object = tinRelief.getTin().getObject(); - currentPolygons = lod1Polygons; - currentColor = landColor; - object.accept(this); - currentPolygons = null; - currentColor = null; + switch (tinRelief.getLod()) { + case 0, 1: + currentPolygons = lod1Polygons; + break; + case 2: + currentPolygons = lod2Polygons; + break; + case 3: + currentPolygons = lod3Polygons; + break; + case 4: + currentPolygons = lod4Polygons; + break; + default: + currentPolygons = lod1Polygons; + break; + } + currentColor = ColorHandler.getLandColor(); + super.visit(tinRelief); } @Override public void visit(WaterBody wb) { + currentColor = ColorHandler.getWaterColor(); super.visit(wb); - DeprecatedPropertiesOfWaterBody deprecatedProperties = wb.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, waterColor); - parseAbstractGeometry(wb.getLod1Solid(), lod1Polygons, waterColor); - parseAbstractGeometry(wb.getLod2Solid(), lod2Polygons, waterColor); - parseAbstractGeometry(wb.getLod3Solid(), lod3Polygons, waterColor); - parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons, waterColor); + parseAbstractGeometry(wb.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons); + parseAbstractGeometry(wb.getDeprecatedProperties().getLod4Solid(), lod4Polygons); } @Override public void visit(PlantCover pc) { + currentColor = ColorHandler.getVegetationColor(); super.visit(pc); - DeprecatedPropertiesOfPlantCover deprecatedProperties = pc.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, vegetationColor); - parseAbstractGeometry(pc.getLod2MultiSurface(), lod2Polygons, vegetationColor); - parseAbstractGeometry(pc.getLod3MultiSurface(), lod3Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSolid(), lod1Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod2MultiSolid(), lod2Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod3MultiSolid(), lod3Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSolid(), lod4Polygons, vegetationColor); + parseAbstractGeometry(pc.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons); + parseMultiSolid(pc.getDeprecatedProperties().getLod1MultiSolid(), lod1Polygons); + parseMultiSolid(pc.getDeprecatedProperties().getLod2MultiSolid(), lod2Polygons); + parseMultiSolid(pc.getDeprecatedProperties().getLod3MultiSolid(), lod3Polygons); + parseMultiSolid(pc.getDeprecatedProperties().getLod4MultiSolid(), lod4Polygons); + } + + + private void parseMultiSolid(MultiSolidProperty ms, List polygons) { + if (ms == null || ms.getObject() == null) { + return; + } + for (SolidProperty sp : ms.getObject().getSolidMember()) { + parseAbstractGeometry(sp, polygons); + } } @Override public void visit(SolitaryVegetationObject svo) { + currentColor = ColorHandler.getVegetationColor(); super.visit(svo); - DeprecatedPropertiesOfSolitaryVegetationObject deprecatedProperties = svo.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1Geometry(), lod1Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod2Geometry(), lod2Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod3Geometry(), lod3Polygons, vegetationColor); - parseAbstractGeometry(deprecatedProperties.getLod4Geometry(), lod4Polygons, vegetationColor); - parseImplicitGeometry(svo.getLod1ImplicitRepresentation(), lod1Polygons, vegetationColor); - parseImplicitGeometry(svo.getLod2ImplicitRepresentation(), lod2Polygons, vegetationColor); - parseImplicitGeometry(svo.getLod3ImplicitRepresentation(), lod3Polygons, vegetationColor); - parseImplicitGeometry(deprecatedProperties.getLod4ImplicitRepresentation(), lod4Polygons, vegetationColor); + parseAbstractGeometry(svo.getDeprecatedProperties().getLod1Geometry(), lod1Polygons); + parseAbstractGeometry(svo.getDeprecatedProperties().getLod2Geometry(), lod2Polygons); + parseAbstractGeometry(svo.getDeprecatedProperties().getLod3Geometry(), lod3Polygons); + parseAbstractGeometry(svo.getDeprecatedProperties().getLod4Geometry(), lod4Polygons); + } + + @Override + public void visit(GroundSurface groundSurface) { + Color oldColor = currentColor; + currentColor = ColorHandler.getGroundColor(); + // process window + super.visit(groundSurface); + currentColor = oldColor; + } + + @Override + public void visit(RoofSurface roofSurface) { + Color oldColor = currentColor; + currentColor = ColorHandler.getRoofColor(); + // process window + super.visit(roofSurface); + currentColor = oldColor; } @Override public void visit(AbstractThematicSurface abs) { super.visit(abs); - Color color = getBuildingSurfaceColor(abs); DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = abs.getDeprecatedProperties(); - parseAbstractGeometry(abs.getLod2MultiSurface(), lod2Polygons, color); - parseAbstractGeometry(abs.getLod3MultiSurface(), lod3Polygons, color); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, color); + parseAbstractGeometry(abs.getLod0MultiSurface(), lod1Polygons); + parseAbstractGeometry(abs.getLod1MultiSurface(), lod1Polygons); + parseAbstractGeometry(abs.getLod2MultiSurface(), lod2Polygons); + parseAbstractGeometry(abs.getLod3MultiSurface(), lod3Polygons); + parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons); } @Override public void visit(LandUse landUse) { + currentColor = ColorHandler.getLandColor(); super.visit(landUse); - DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = landUse.getDeprecatedProperties(); - parseAbstractGeometry(landUse.getLod1MultiSurface(), lod1Polygons, landColor); - parseAbstractGeometry(landUse.getLod2MultiSurface(), lod2Polygons, landColor); - parseAbstractGeometry(landUse.getLod3MultiSurface(), lod3Polygons, landColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, landColor); } - + @Override - public void visit(AuxiliaryTrafficArea ata) { - super.visit(ata); - DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = ata.getDeprecatedProperties(); - parseAbstractGeometry(ata.getLod2MultiSurface(), lod2Polygons, transportationColor); - parseAbstractGeometry(ata.getLod3MultiSurface(), lod3Polygons, transportationColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, transportationColor); + public void visit(AbstractTransportationSpace ats) { + currentColor = ColorHandler.getTransportationColor(); + DeprecatedPropertiesOfAbstractTransportationSpace deprecatedProperties = ats.getDeprecatedProperties(); + parseAbstractGeometry(ats.getLod1Solid(), lod1Polygons); + parseAbstractGeometry(ats.getLod2Solid(), lod1Polygons); + parseAbstractGeometry(ats.getLod3Solid(), lod1Polygons); + parseAbstractGeometry(ats.getLod0MultiSurface(), lod1Polygons); + parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons); + parseAbstractGeometry(ats.getLod2MultiSurface(), lod2Polygons); + parseAbstractGeometry(ats.getLod3MultiSurface(), lod3Polygons); + parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons); } - + @Override - public void visit(TrafficArea ta) { - super.visit(ta); - DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = ta.getDeprecatedProperties(); - parseAbstractGeometry(ta.getLod2MultiSurface(), lod2Polygons, transportationColor); - parseAbstractGeometry(ta.getLod3MultiSurface(), lod3Polygons, transportationColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, transportationColor); + public void visit(Window window) { + Color oldColor = currentColor; + currentColor = ColorHandler.getWindowColor(); + // process window + super.visit(window); + currentColor = oldColor; } - + @Override - public void visit(TransportationComplex tc) { - super.visit(tc); - DeprecatedPropertiesOfAbstractTransportationSpace deprecatedProperties = tc.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, transportationColor); - parseAbstractGeometry(tc.getLod2MultiSurface(), lod2Polygons, transportationColor); - parseAbstractGeometry(tc.getLod3MultiSurface(), lod3Polygons, transportationColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, transportationColor); - } - - private Color getBuildingSurfaceColor(AbstractThematicSurface abs) { - if (abs instanceof RoofSurface) { - return roofColor; - } - if (abs instanceof GroundSurface) { - return groundColor; - } - return wallColor; + public void visit(Door door) { + Color oldColor = currentColor; + currentColor = ColorHandler.getDoorColor(); + super.visit(door); + currentColor = oldColor; } - + + @Override public void visit(AbstractFillingElement ao) { super.visit(ao); - Color color = getOpeningColor(ao); - parseAbstractGeometry(ao.getLod1Solid(), lod1Polygons, color); - parseAbstractGeometry(ao.getLod2Solid(), lod2Polygons, color); - parseAbstractGeometry(ao.getLod3Solid(), lod3Polygons, color); - parseAbstractGeometry(ao.getLod2MultiSurface(), lod2Polygons, color); - parseAbstractGeometry(ao.getLod3MultiSurface(), lod3Polygons, color); - parseImplicitGeometry(ao.getLod1ImplicitRepresentation(), lod1Polygons, color); - parseImplicitGeometry(ao.getLod2ImplicitRepresentation(), lod2Polygons, color); - parseImplicitGeometry(ao.getLod3ImplicitRepresentation(), lod3Polygons, color); - } - - private Color getOpeningColor(AbstractFillingElement ao) { - if (ao instanceof Door) { - return doorColor; - } - if (ao instanceof Window) { - return windowColor; - } - return wallColor; + parseAbstractGeometry(ao.getLod1Solid(), lod1Polygons); + parseAbstractGeometry(ao.getLod2Solid(), lod2Polygons); + parseAbstractGeometry(ao.getLod3Solid(), lod3Polygons); + parseAbstractGeometry(ao.getLod2MultiSurface(), lod2Polygons); + parseAbstractGeometry(ao.getLod3MultiSurface(), lod3Polygons); + parseImplicitGeometry(ao.getLod1ImplicitRepresentation(), lod1Polygons); + parseImplicitGeometry(ao.getLod2ImplicitRepresentation(), lod2Polygons); + parseImplicitGeometry(ao.getLod3ImplicitRepresentation(), lod3Polygons); } @Override public void visit(AbstractBridge ab) { + currentColor = ColorHandler.getBridgeColor(); super.visit(ab); - DeprecatedPropertiesOfAbstractBridge deprecatedProperties = ab.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, bridgeColor); - parseAbstractGeometry(ab.getLod2MultiSurface(), lod2Polygons, bridgeColor); - parseAbstractGeometry(ab.getLod3MultiSurface(), lod3Polygons, bridgeColor); - parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, bridgeColor); - parseAbstractGeometry(ab.getLod1Solid(), lod1Polygons, bridgeColor); - parseAbstractGeometry(ab.getLod2Solid(), lod2Polygons, bridgeColor); - parseAbstractGeometry(ab.getLod3Solid(), lod3Polygons, bridgeColor); - parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons, bridgeColor); + parseAbstractGeometry(ab.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons); + parseAbstractGeometry(ab.getDeprecatedProperties().getLod4MultiSurface(), lod4Polygons); + parseAbstractGeometry(ab.getDeprecatedProperties().getLod4Solid(), lod4Polygons); } - + @Override public void visit(BuildingInstallation bi) { + currentColor = ColorHandler.getWallColor(); super.visit(bi); - DeprecatedPropertiesOfBuildingInstallation deprecatedProperties = bi.getDeprecatedProperties(); - parseAbstractGeometry(deprecatedProperties.getLod2Geometry(), lod2Polygons, wallColor); - parseAbstractGeometry(deprecatedProperties.getLod3Geometry(), lod3Polygons, wallColor); - parseAbstractGeometry(deprecatedProperties.getLod4Geometry(), lod4Polygons, wallColor); - parseImplicitGeometry(bi.getLod2ImplicitRepresentation(), lod2Polygons, wallColor); - parseImplicitGeometry(bi.getLod3ImplicitRepresentation(), lod3Polygons, wallColor); - parseImplicitGeometry(deprecatedProperties.getLod4ImplicitRepresentation(), lod4Polygons, wallColor); } - private void parseImplicitGeometry(ImplicitGeometryProperty irp, List polygons, Color color) { + private void parseImplicitGeometry(ImplicitGeometryProperty irp, List polygons) { if (irp == null || irp.getObject() == null) { return; } ImplicitGeometry implicitGeometry = irp.getObject(); - parseAbstractGeometry(implicitGeometry.getRelativeGeometry(), polygons, color); + parseAbstractGeometry(implicitGeometry.getRelativeGeometry(), polygons); } - private void parseAbstractGeometry(GeometryProperty geom, List polygons, - Color color) { + private void parseAbstractGeometry(GeometryProperty geom, List polygons) { if (geom == null || geom.getObject() == null) { return; } - currentColor = color; currentPolygons = polygons; geom.getObject().accept(this); - currentColor = null; currentPolygons = null; }