Skip to content
GitLab
Commit 19a9b8c6 authored by Matthias Betz's avatar Matthias Betz
Browse files

only using opengl 3.0 

added more geometry parsing
added parallel parsing
parent 0f66af82
Show whitespace changes
Inline Side-by-side
pom.xml
View file @ 19a9b8c6
...@@ -7,8 +7,8 @@ ...@@ -7,8 +7,8 @@
<properties> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target> <maven.compiler.target>17</maven.compiler.target>
<lwjgl.version>3.2.3</lwjgl.version> <lwjgl.version>3.2.3</lwjgl.version>
<joml.version>1.10.1</joml.version> <joml.version>1.10.1</joml.version>
</properties> </properties>
...@@ -65,17 +65,24 @@ ...@@ -65,17 +65,24 @@
</dependencyManagement> </dependencyManagement>
<dependencies> <dependencies>
<!-- https://mvnrepository.com/artifact/org.citygml4j/citygml4j --> <!-- https://mvnrepository.com/artifact/org.citygml4j/citygml4j-core -->
<dependency> <dependency>
<groupId>org.citygml4j</groupId> <groupId>org.citygml4j</groupId>
<artifactId>citygml4j</artifactId> <artifactId>citygml4j-core</artifactId>
<version>3.0.0-rc.2</version> <version>3.0.0-rc.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.citygml4j/citygml4j-xml -->
<dependency>
<groupId>org.citygml4j</groupId>
<artifactId>citygml4j-xml</artifactId>
<version>3.0.0-rc.4</version>
</dependency> </dependency>
<!-- https://mvnrepository.com/artifact/org.locationtech.proj4j/proj4j --> <!-- https://mvnrepository.com/artifact/org.locationtech.proj4j/proj4j -->
<dependency> <dependency>
<groupId>org.locationtech.proj4j</groupId> <groupId>org.locationtech.proj4j</groupId>
<artifactId>proj4j</artifactId> <artifactId>proj4j</artifactId>
<version>1.1.3</version> <version>1.1.5</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.lwjgl</groupId> <groupId>org.lwjgl</groupId>
......
src/main/java/de/hft/stuttgart/citygml/viewer/CityGMLViewer.java
View file @ 19a9b8c6
...@@ -25,17 +25,24 @@ import java.nio.DoubleBuffer; ...@@ -25,17 +25,24 @@ import java.nio.DoubleBuffer;
import java.nio.FloatBuffer; import java.nio.FloatBuffer;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; 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.Level;
import java.util.logging.Logger; import java.util.logging.Logger;
import javax.imageio.ImageIO; import javax.imageio.ImageIO;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.ParserConfigurationException;
import org.citygml4j.CityGMLContext; import org.citygml4j.core.model.core.AbstractFeature;
import org.citygml4j.CityGMLContextException; import org.citygml4j.core.util.CityGMLConstants;
import org.citygml4j.model.core.AbstractCityObject; import org.citygml4j.xml.CityGMLContext;
import org.citygml4j.model.core.AbstractFeature; import org.citygml4j.xml.CityGMLContextException;
import org.citygml4j.xml.reader.ChunkingOptions; import org.citygml4j.xml.reader.ChunkOptions;
import org.citygml4j.xml.reader.CityGMLChunk;
import org.citygml4j.xml.reader.CityGMLInputFactory; import org.citygml4j.xml.reader.CityGMLInputFactory;
import org.citygml4j.xml.reader.CityGMLReadException; import org.citygml4j.xml.reader.CityGMLReadException;
import org.citygml4j.xml.reader.CityGMLReader; import org.citygml4j.xml.reader.CityGMLReader;
...@@ -58,6 +65,7 @@ import org.xml.sax.SAXException; ...@@ -58,6 +65,7 @@ import org.xml.sax.SAXException;
import com.jogamp.opengl.GLException; import com.jogamp.opengl.GLException;
import de.hft.stuttgart.citygml.viewer.datastructure.BoundingBox; 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.math.Vector3d;
import de.hft.stuttgart.citygml.viewer.parser.CityGMLParser; import de.hft.stuttgart.citygml.viewer.parser.CityGMLParser;
import de.hft.stuttgart.citygml.viewer.parser.FeatureMapper; import de.hft.stuttgart.citygml.viewer.parser.FeatureMapper;
...@@ -86,6 +94,15 @@ public class CityGMLViewer { ...@@ -86,6 +94,15 @@ public class CityGMLViewer {
private static ProgressBar bar; private static ProgressBar bar;
private static final String CITY_OBJECT_MEMBER = "cityObjectMember";
private static List<QName> 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) { public static void main(String[] args) {
File f = null; File f = null;
if (args != null && args.length == 1) { if (args != null && args.length == 1) {
...@@ -173,9 +190,8 @@ public class CityGMLViewer { ...@@ -173,9 +190,8 @@ public class CityGMLViewer {
GLFW.glfwDefaultWindowHints(); // Loads GLFW's default window settings 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_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_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_MAJOR, 3);
GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 3); GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 0);
GLFW.glfwWindowHint(GLFW.GLFW_SAMPLES, 2); GLFW.glfwWindowHint(GLFW.GLFW_SAMPLES, 2);
windowId = GLFW.glfwCreateWindow(width, height, title, 0, 0); windowId = GLFW.glfwCreateWindow(width, height, title, 0, 0);
...@@ -271,8 +287,8 @@ public class CityGMLViewer { ...@@ -271,8 +287,8 @@ public class CityGMLViewer {
// NO_CURRENT_CONTEXT error // NO_CURRENT_CONTEXT error
org.lwjgl.opengl.GLCapabilities caps = GL.createCapabilities(); // Will let lwjgl know we want to use this org.lwjgl.opengl.GLCapabilities caps = GL.createCapabilities(); // Will let lwjgl know we want to use this
// context as the context to draw with // context as the context to draw with
if (!caps.OpenGL33) { if (!caps.OpenGL30) {
log.warning("OpenGL 33 is not supported"); log.warning("OpenGL 3.0 is not supported");
} }
GLFW.glfwSwapInterval(1); // How many draws to swap the buffer GLFW.glfwSwapInterval(1); // How many draws to swap the buffer
...@@ -284,7 +300,7 @@ public class CityGMLViewer { ...@@ -284,7 +300,7 @@ public class CityGMLViewer {
GLFW.glfwShowWindow(windowId); // Shows the window GLFW.glfwShowWindow(windowId); // Shows the window
if (log.isLoggable(Level.INFO)) { 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; FloatBuffer clearColor = null;
...@@ -293,24 +309,19 @@ public class CityGMLViewer { ...@@ -293,24 +309,19 @@ public class CityGMLViewer {
try { try {
Shader program = new Shader("vertex.vert", "fragment.frag"); Shader program = new Shader("vertex.vert", "fragment.frag");
program.use(); program.use();
if (log.isLoggable(Level.INFO)) { log.fine(() -> "OpenGL error code after shader loading: " + GL11.glGetError());
log.info("OpenGL error code after shader loading: " + GL11.glGetError());
}
camera = new Camera(program); camera = new Camera(program);
camera.setOrtho(true); camera.setOrtho(true);
camera.reshape(width, height, cameraViewDistance); camera.reshape(width, height, cameraViewDistance);
bar = new ProgressBar(windowId, width, height); bar = new ProgressBar(windowId, width, height);
bar.drawProgress(0); bar.drawProgress(0);
if (log.isLoggable(Level.INFO)) { log.fine(() -> "OpenGL error code after drawing initial progress bar: " + GL11.glGetError());
log.info("OpenGL error code after drawing initial progress bar: " + GL11.glGetError());
}
loadGmlFile(f); loadGmlFile(f);
log.fine(() -> "OpenGL error code after loading GML file: " + GL11.glGetError());
bar.free(); bar.free();
bar = null; bar = null;
if (log.isLoggable(Level.INFO)) {
log.info("OpenGL error code after loading GML file: " + GL11.glGetError());
}
camera.setOrtho(false); camera.setOrtho(false);
camera.reshape(width, height, cameraViewDistance); camera.reshape(width, height, cameraViewDistance);
...@@ -319,9 +330,7 @@ public class CityGMLViewer { ...@@ -319,9 +330,7 @@ public class CityGMLViewer {
clearDepth = MemoryUtil.memAllocFloat(1); clearDepth = MemoryUtil.memAllocFloat(1);
clearDepth.put(0, 1f); clearDepth.put(0, 1f);
if (log.isLoggable(Level.INFO)) { log.fine(() -> "OpenGL error code before loop: " + GL11.glGetError());
log.info("OpenGL error code before loop: " + GL11.glGetError());
}
while (!GLFW.glfwWindowShouldClose(windowId)) { while (!GLFW.glfwWindowShouldClose(windowId)) {
/* Do something */ /* Do something */
GL30.glClearBufferfv(GL11.GL_COLOR, 0, clearColor); GL30.glClearBufferfv(GL11.GL_COLOR, 0, clearColor);
...@@ -359,44 +368,74 @@ public class CityGMLViewer { ...@@ -359,44 +368,74 @@ public class CityGMLViewer {
CityGMLParser.parseEpsgCodeFromFile(file, config); CityGMLParser.parseEpsgCodeFromFile(file, config);
CityGMLContext context = CityGMLContext.newInstance(); CityGMLContext context = CityGMLContext.newInstance();
CityGMLInputFactory in = context.createCityGMLInputFactory() CityGMLInputFactory in = context.createCityGMLInputFactory()
.withChunking(ChunkingOptions.chunkByCityModelMembers()); .withChunking(ChunkOptions.chunkByProperties(chunkProperties).skipCityModel(true));
try (ObservedInputStream ois = new ObservedInputStream(file); try (ObservedInputStream ois = new ObservedInputStream(file);
CityGMLReader reader = in.createCityGMLReader(file.getAbsolutePath(), ois)) { CityGMLReader reader = in.createCityGMLReader(file.getAbsolutePath(), ois)) {
ois.addListener(p -> bar.drawProgress((int) (p * 82))); ois.addListener(p -> bar.drawProgress((int) (p * 82)));
FeatureMapper mapper = new FeatureMapper(config);
int threads = Runtime.getRuntime().availableProcessors();
ExecutorService service = Executors.newFixedThreadPool(threads);
List<Future<FeatureMapper>> mappers = new ArrayList<>();
while (reader.hasNext()) { while (reader.hasNext()) {
AbstractFeature chunk = reader.next(); CityGMLChunk nextChunk = reader.nextChunk();
if (chunk instanceof AbstractCityObject) { mappers.add(service.submit(() -> {
AbstractCityObject aco = (AbstractCityObject) chunk; FeatureMapper mapper = new FeatureMapper(config);
aco.accept(mapper); AbstractFeature feature = nextChunk.build();
} feature.accept(mapper);
} return mapper;
BoundingBox bbox = BoundingBox.of(mapper); }));
}
service.shutdown();
service.awaitTermination(20, TimeUnit.MINUTES);
List<Polygon> lod1Polygons = new ArrayList<>();
List<Polygon> lod2Polygons = new ArrayList<>();
List<Polygon> lod3Polygons = new ArrayList<>();
List<Polygon> lod4Polygons = new ArrayList<>();
List<FeatureMapper> 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); bar.drawProgress(81);
Vector3d center = bbox.getCenter(); Vector3d center = bbox.getCenter();
mapper.movePolygonsBy(center); fMappers.forEach(m -> m.movePolygonsBy(center));
bar.drawProgress(82); bar.drawProgress(82);
long nrOfPolygons = (long) mapper.getLod1Polygons().size() + mapper.getLod2Polygons().size() long nrOfPolygons = (long) lod1Polygons.size() + lod2Polygons.size()
+ mapper.getLod3Polygons().size() + mapper.getLod4Polygons().size(); + lod3Polygons.size() + lod4Polygons.size();
long[] count = new long[1]; long[] count = new long[1];
log.info(() -> "Found " + nrOfPolygons + " polygons");
PolygonListener l = () -> { PolygonListener l = () -> {
count[0]++; count[0]++;
bar.drawProgress(82 + (int) (count[0] * 9 / nrOfPolygons)); bar.drawProgress(82 + (int) (count[0] * 9 / nrOfPolygons));
}; };
if (!mapper.getLod1Polygons().isEmpty()) { if (!lod1Polygons.isEmpty()) {
PolygonViewInformation lod1ViewInfo = new PolygonViewInformation(mapper.getLod1Polygons(), l); PolygonViewInformation lod1ViewInfo = new PolygonViewInformation(lod1Polygons, l);
viewing.add(lod1ViewInfo); viewing.add(lod1ViewInfo);
} }
if (!mapper.getLod2Polygons().isEmpty()) { if (!lod2Polygons.isEmpty()) {
PolygonViewInformation lod2ViewInfo = new PolygonViewInformation(mapper.getLod2Polygons(), l); PolygonViewInformation lod2ViewInfo = new PolygonViewInformation(lod2Polygons, l);
viewing.add(lod2ViewInfo); viewing.add(lod2ViewInfo);
} }
if (!mapper.getLod3Polygons().isEmpty()) { if (!lod3Polygons.isEmpty()) {
PolygonViewInformation lod3ViewInfo = new PolygonViewInformation(mapper.getLod3Polygons(), l); PolygonViewInformation lod3ViewInfo = new PolygonViewInformation(lod3Polygons, l);
viewing.add(lod3ViewInfo); viewing.add(lod3ViewInfo);
} }
if (!mapper.getLod3Polygons().isEmpty()) { if (!lod4Polygons.isEmpty()) {
PolygonViewInformation lod4ViewInfo = new PolygonViewInformation(mapper.getLod4Polygons(), l); PolygonViewInformation lod4ViewInfo = new PolygonViewInformation(lod4Polygons, l);
viewing.add(lod4ViewInfo); viewing.add(lod4ViewInfo);
} }
...@@ -406,6 +445,9 @@ public class CityGMLViewer { ...@@ -406,6 +445,9 @@ public class CityGMLViewer {
camera.setDistance((float) translateZ); camera.setDistance((float) translateZ);
cameraViewDistance = (float) longestSide * 20f; cameraViewDistance = (float) longestSide * 20f;
camera.reshape(width, height, cameraViewDistance); 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 } catch (GLException | IOException | ParserConfigurationException | SAXException | CityGMLContextException
| CityGMLReadException e) { | CityGMLReadException e) {
......
src/main/java/de/hft/stuttgart/citygml/viewer/PolygonViewInformation.java
View file @ 19a9b8c6
...@@ -26,12 +26,10 @@ import java.util.List; ...@@ -26,12 +26,10 @@ import java.util.List;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15; import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30; import org.lwjgl.opengl.GL30;
import org.lwjgl.opengl.GL44;
import org.lwjgl.opengl.GL45;
import org.lwjgl.system.MemoryUtil; 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.Polygon;
import de.hft.stuttgart.citygml.viewer.datastructure.TesselatedPolygon; import de.hft.stuttgart.citygml.viewer.datastructure.TesselatedPolygon;
import de.hft.stuttgart.citygml.viewer.datastructure.Triangle3d; import de.hft.stuttgart.citygml.viewer.datastructure.Triangle3d;
...@@ -41,34 +39,37 @@ public class PolygonViewInformation { ...@@ -41,34 +39,37 @@ public class PolygonViewInformation {
private static final Vector3d AXIS = new Vector3d(19, 0.8, 1.5).normalize(); private static final Vector3d AXIS = new Vector3d(19, 0.8, 1.5).normalize();
private int vao; private int vao;
private IntBuffer buffers;
private boolean draw = false; private boolean draw = false;
private int elements; private int elements;
private PolygonListener listener; private PolygonListener listener;
private int posVbo;
private int colorVbo;
private int indexVbo;
public PolygonViewInformation(List<Polygon> polygons, PolygonListener listener) { public PolygonViewInformation(List<Polygon> polygons, PolygonListener listener) {
this.listener = listener; this.listener = listener;
vao = GL45.glCreateVertexArrays(); vao = GL30.glGenVertexArrays();
GL45.glVertexArrayAttribBinding(vao, BufferConstants.ATTRIBUTE_POSITION, BufferConstants.BINDING_INDEX_0); GL30.glBindVertexArray(vao);
GL45.glVertexArrayAttribBinding(vao, BufferConstants.ATTRIBUTE_COLOR, BufferConstants.BINDING_INDEX_0);
GL45.glVertexArrayAttribFormat(vao, BufferConstants.ATTRIBUTE_POSITION, 3, GL_FLOAT, false, 0); posVbo = GL15.glGenBuffers();
GL45.glVertexArrayAttribFormat(vao, BufferConstants.ATTRIBUTE_COLOR, 3, GL_FLOAT, false, 3 * 4); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, posVbo);
GL20.glEnableVertexAttribArray(0);
GL20.glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
GL45.glEnableVertexArrayAttrib(vao, BufferConstants.ATTRIBUTE_POSITION); colorVbo = GL15.glGenBuffers();
GL45.glEnableVertexArrayAttrib(vao, BufferConstants.ATTRIBUTE_COLOR); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, colorVbo);
GL20.glEnableVertexAttribArray(1);
GL20.glVertexAttribPointer(1, 3, GL_FLOAT, false, 0, 0);
buffers = MemoryUtil.memAllocInt(BufferConstants.SIZE); indexVbo = GL15.glGenBuffers();
GL45.glCreateBuffers(buffers); setupBuffers(polygons, posVbo, colorVbo, indexVbo);
GL45.glVertexArrayElementBuffer(vao, buffers.get(BufferConstants.ELEMENT)); GL30.glBindVertexArray(0);
GL45.glVertexArrayVertexBuffer(vao, BufferConstants.BINDING_INDEX_0, buffers.get(BufferConstants.VERTEX), 0, (3 + 3) * 4);
setupBuffers(polygons);
} }
private void setupBuffers(List<Polygon> polys) { private void setupBuffers(List<Polygon> polys, int posVbo, int colorVbo, int indexVbo) {
List<TesselatedPolygon> tessPolys = new ArrayList<>(); List<TesselatedPolygon> tessPolys = new ArrayList<>();
for (Polygon poly : polys) { for (Polygon poly : polys) {
tessPolys.add(TesselatedPolygon.of(poly)); tessPolys.add(TesselatedPolygon.of(poly));
...@@ -81,8 +82,11 @@ public class PolygonViewInformation { ...@@ -81,8 +82,11 @@ public class PolygonViewInformation {
} }
// 6 float for 3 vertices per triangle // 6 float for 3 vertices per triangle
int moreSpace = nrOfTriangles * 3 * 3 * 2; int vertexDataSize = nrOfTriangles * 3 * 3;
FloatBuffer vertexData = MemoryUtil.memAllocFloat(moreSpace); FloatBuffer vertexData = MemoryUtil.memAllocFloat(vertexDataSize);
int colorDataSize = nrOfTriangles * 3 * 3;
FloatBuffer colorData = MemoryUtil.memAllocFloat(colorDataSize);
IntBuffer elementData = MemoryUtil.memAllocInt(nrOfTriangles * 3); IntBuffer elementData = MemoryUtil.memAllocInt(nrOfTriangles * 3);
float[] rgba = new float[4]; float[] rgba = new float[4];
for (TesselatedPolygon tessPoly : tessPolys) { for (TesselatedPolygon tessPoly : tessPolys) {
...@@ -96,9 +100,9 @@ public class PolygonViewInformation { ...@@ -96,9 +100,9 @@ public class PolygonViewInformation {
(int) (baseColor.getBlue() * acos)); (int) (baseColor.getBlue() * acos));
derivedColor.getComponents(rgba); derivedColor.getComponents(rgba);
for (Triangle3d tri : tessPoly.getTriangles()) { for (Triangle3d tri : tessPoly.getTriangles()) {
addPoint(vertexData, tri.getP1(), rgba[0], rgba[1], rgba[2]); addPoint(vertexData, colorData, tri.getP1(), rgba[0], rgba[1], rgba[2]);
addPoint(vertexData, tri.getP2(), rgba[0], rgba[1], rgba[2]); addPoint(vertexData, colorData, tri.getP2(), rgba[0], rgba[1], rgba[2]);
addPoint(vertexData, tri.getP3(), rgba[0], rgba[1], rgba[2]); addPoint(vertexData, colorData, tri.getP3(), rgba[0], rgba[1], rgba[2]);
} }
listener.finishedPolygon(); listener.finishedPolygon();
} }
...@@ -106,30 +110,35 @@ public class PolygonViewInformation { ...@@ -106,30 +110,35 @@ public class PolygonViewInformation {
elementData.put(i); elementData.put(i);
} }
((Buffer) elementData).flip(); ((Buffer) elementData).flip();
((Buffer) colorData).flip();
((Buffer) vertexData).flip(); ((Buffer) vertexData).flip();
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, buffers.get(BufferConstants.VERTEX)); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, posVbo);
GL44.glBufferStorage(GL15.GL_ARRAY_BUFFER, vertexData, 0); 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_ARRAY_BUFFER, 0);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, buffers.get(BufferConstants.ELEMENT)); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, indexVbo);
GL44.glBufferStorage(GL15.GL_ELEMENT_ARRAY_BUFFER, elementData, 0); GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, elementData, GL15.GL_STATIC_DRAW);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
MemoryUtil.memFree(elementData); MemoryUtil.memFree(elementData);
MemoryUtil.memFree(colorData);
MemoryUtil.memFree(vertexData); MemoryUtil.memFree(vertexData);
draw = true; draw = true;
elements = elementData.capacity(); elements = elementData.capacity();
} }
private static void addPoint(FloatBuffer lod1VertexData, Vector3d point, float red, float green, float blue) { private static void addPoint(FloatBuffer vertexData, FloatBuffer colorData, Vector3d point, float red, float green, float blue) {
lod1VertexData.put((float) point.getX()); vertexData.put((float) point.getX());
lod1VertexData.put((float) point.getY()); vertexData.put((float) point.getY());
lod1VertexData.put((float) point.getZ()); vertexData.put((float) point.getZ());
lod1VertexData.put(red); colorData.put(red);
lod1VertexData.put(green); colorData.put(green);
lod1VertexData.put(blue); colorData.put(blue);
} }
public boolean shouldDraw() { public boolean shouldDraw() {
...@@ -145,13 +154,16 @@ public class PolygonViewInformation { ...@@ -145,13 +154,16 @@ public class PolygonViewInformation {
} }
public void destroy() { public void destroy() {
MemoryUtil.memFree(buffers); GL15.glDeleteBuffers(colorVbo);
GL15.glDeleteBuffers(posVbo);
GL15.glDeleteBuffers(indexVbo);
GL30.glDeleteVertexArrays(vao);
} }
public void draw() { public void draw() {
if (draw) { if (draw) {
GL30.glBindVertexArray(vao); GL30.glBindVertexArray(vao);
GL11.glDrawElements(GL11.GL_TRIANGLES, elements, GL11.GL_UNSIGNED_INT, 0); GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, elements);
} }
} }
} }
src/main/java/de/hft/stuttgart/citygml/viewer/datastructure/BoundingBox.java
View file @ 19a9b8c6
...@@ -162,4 +162,10 @@ public class BoundingBox { ...@@ -162,4 +162,10 @@ public class BoundingBox {
public String toString() { public String toString() {
return Arrays.toString(bbox); return Arrays.toString(bbox);
} }
public static BoundingBox of(List<Polygon> lod1Polygons, List<Polygon> lod2Polygons, List<Polygon> lod3Polygons,
List<Polygon> lod4Polygons) {
return BoundingBoxCalculator.calculateBoundingBox(lod1Polygons, lod2Polygons, lod3Polygons, lod4Polygons);
}
} }
src/main/java/de/hft/stuttgart/citygml/viewer/math/BoundingBoxCalculator.java
View file @ 19a9b8c6
...@@ -116,11 +116,16 @@ public class BoundingBoxCalculator { ...@@ -116,11 +116,16 @@ public class BoundingBoxCalculator {
} }
public static BoundingBox calculateBoundingBox(FeatureMapper mapper) { public static BoundingBox calculateBoundingBox(FeatureMapper mapper) {
return calculateBoundingBox(mapper.getLod1Polygons(), mapper.getLod2Polygons(), mapper.getLod3Polygons(), mapper.getLod4Polygons());
}
public static BoundingBox calculateBoundingBox(List<Polygon> lod1Polygons, List<Polygon> lod2Polygons,
List<Polygon> lod3Polygons, List<Polygon> lod4Polygons) {
List<List<Polygon>> polygonList = new ArrayList<>(); List<List<Polygon>> polygonList = new ArrayList<>();
polygonList.add(mapper.getLod1Polygons()); polygonList.add(lod1Polygons);
polygonList.add(mapper.getLod2Polygons()); polygonList.add(lod2Polygons);
polygonList.add(mapper.getLod3Polygons()); polygonList.add(lod3Polygons);
polygonList.add(mapper.getLod4Polygons()); polygonList.add(lod4Polygons);
double lowX = Double.MAX_VALUE; double lowX = Double.MAX_VALUE;
double highX = Double.NEGATIVE_INFINITY; double highX = Double.NEGATIVE_INFINITY;
......
src/main/java/de/hft/stuttgart/citygml/viewer/parser/ColorHandler.java 0 → 100644
View file @ 19a9b8c6
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;
}
}
src/main/java/de/hft/stuttgart/citygml/viewer/parser/FeatureMapper.java
View file @ 19a9b8c6
...@@ -16,50 +16,49 @@ ...@@ -16,50 +16,49 @@
package de.hft.stuttgart.citygml.viewer.parser; package de.hft.stuttgart.citygml.viewer.parser;
import java.awt.Color; import java.awt.Color;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Properties;
import org.citygml4j.core.model.bridge.AbstractBridge;
import org.citygml4j.model.bridge.AbstractBridge; import org.citygml4j.core.model.building.AbstractBuilding;
import org.citygml4j.model.building.AbstractBuilding; import org.citygml4j.core.model.building.BuildingInstallation;
import org.citygml4j.model.building.BuildingInstallation; import org.citygml4j.core.model.cityfurniture.CityFurniture;
import org.citygml4j.model.construction.AbstractFillingElement; import org.citygml4j.core.model.cityobjectgroup.CityObjectGroup;
import org.citygml4j.model.construction.Door; import org.citygml4j.core.model.construction.AbstractFillingElement;
import org.citygml4j.model.construction.GroundSurface; import org.citygml4j.core.model.construction.Door;
import org.citygml4j.model.construction.RoofSurface; import org.citygml4j.core.model.construction.GroundSurface;
import org.citygml4j.model.construction.Window; import org.citygml4j.core.model.construction.OtherConstruction;
import org.citygml4j.model.core.AbstractThematicSurface; import org.citygml4j.core.model.construction.RoofSurface;
import org.citygml4j.model.core.ImplicitGeometry; import org.citygml4j.core.model.construction.Window;
import org.citygml4j.model.core.ImplicitGeometryProperty; import org.citygml4j.core.model.core.AbstractSpace;
import org.citygml4j.model.deprecated.bridge.DeprecatedPropertiesOfAbstractBridge; import org.citygml4j.core.model.core.AbstractThematicSurface;
import org.citygml4j.model.deprecated.building.DeprecatedPropertiesOfAbstractBuilding; import org.citygml4j.core.model.core.ImplicitGeometry;
import org.citygml4j.model.deprecated.building.DeprecatedPropertiesOfBuildingInstallation; import org.citygml4j.core.model.core.ImplicitGeometryProperty;
import org.citygml4j.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface; import org.citygml4j.core.model.deprecated.building.DeprecatedPropertiesOfAbstractBuilding;
import org.citygml4j.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace; import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface;
import org.citygml4j.model.deprecated.transportation.TransportationComplex; import org.citygml4j.core.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace;
import org.citygml4j.model.deprecated.vegetation.DeprecatedPropertiesOfPlantCover; import org.citygml4j.core.model.generics.GenericLogicalSpace;
import org.citygml4j.model.deprecated.vegetation.DeprecatedPropertiesOfSolitaryVegetationObject; import org.citygml4j.core.model.generics.GenericOccupiedSpace;
import org.citygml4j.model.deprecated.waterbody.DeprecatedPropertiesOfWaterBody; import org.citygml4j.core.model.generics.GenericThematicSurface;
import org.citygml4j.model.landuse.LandUse; import org.citygml4j.core.model.generics.GenericUnoccupiedSpace;
import org.citygml4j.model.relief.TINRelief; import org.citygml4j.core.model.landuse.LandUse;
import org.citygml4j.model.transportation.AuxiliaryTrafficArea; import org.citygml4j.core.model.relief.TINRelief;
import org.citygml4j.model.transportation.TrafficArea; import org.citygml4j.core.model.transportation.AbstractTransportationSpace;
import org.citygml4j.model.vegetation.PlantCover; import org.citygml4j.core.model.vegetation.PlantCover;
import org.citygml4j.model.vegetation.SolitaryVegetationObject; import org.citygml4j.core.model.vegetation.SolitaryVegetationObject;
import org.citygml4j.model.waterbody.WaterBody; import org.citygml4j.core.model.waterbody.WaterBody;
import org.citygml4j.visitor.ObjectWalker; import org.citygml4j.core.visitor.ObjectWalker;
import org.locationtech.proj4j.BasicCoordinateTransform; import org.locationtech.proj4j.BasicCoordinateTransform;
import org.locationtech.proj4j.ProjCoordinate; import org.locationtech.proj4j.ProjCoordinate;
import org.xmlobjects.gml.model.geometry.AbstractGeometry; import org.xmlobjects.gml.model.geometry.AbstractGeometry;
import org.xmlobjects.gml.model.geometry.GeometricPositionList; import org.xmlobjects.gml.model.geometry.GeometricPositionList;
import org.xmlobjects.gml.model.geometry.GeometryProperty; 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.AbstractRing;
import org.xmlobjects.gml.model.geometry.primitives.AbstractRingProperty; import org.xmlobjects.gml.model.geometry.primitives.AbstractRingProperty;
import org.xmlobjects.gml.model.geometry.primitives.LinearRing; 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.Triangle;
import org.xmlobjects.gml.model.geometry.primitives.TriangulatedSurface;
import de.hft.stuttgart.citygml.viewer.datastructure.Polygon; import de.hft.stuttgart.citygml.viewer.datastructure.Polygon;
import de.hft.stuttgart.citygml.viewer.datastructure.Ring; import de.hft.stuttgart.citygml.viewer.datastructure.Ring;
...@@ -67,17 +66,6 @@ import de.hft.stuttgart.citygml.viewer.math.Vector3d; ...@@ -67,17 +66,6 @@ import de.hft.stuttgart.citygml.viewer.math.Vector3d;
public class FeatureMapper extends ObjectWalker { 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 ParserConfiguration config;
private List<Polygon> lod1Polygons; private List<Polygon> lod1Polygons;
private List<Polygon> lod2Polygons; private List<Polygon> lod2Polygons;
...@@ -91,51 +79,8 @@ public class FeatureMapper extends ObjectWalker { ...@@ -91,51 +79,8 @@ public class FeatureMapper extends ObjectWalker {
private ProjCoordinate p1 = new ProjCoordinate(); private ProjCoordinate p1 = new ProjCoordinate();
private ProjCoordinate p2 = new ProjCoordinate(); private ProjCoordinate p2 = new ProjCoordinate();
public FeatureMapper(ParserConfiguration config) throws IOException { public FeatureMapper(ParserConfiguration config) {
try (FileReader reader = new FileReader("color.properties")) { currentColor = ColorHandler.getWallColor();
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;
}
}
this.config = config; this.config = config;
lod1Polygons = new ArrayList<>(); lod1Polygons = new ArrayList<>();
lod2Polygons = new ArrayList<>(); lod2Polygons = new ArrayList<>();
...@@ -143,24 +88,31 @@ public class FeatureMapper extends ObjectWalker { ...@@ -143,24 +88,31 @@ public class FeatureMapper extends ObjectWalker {
lod4Polygons = new ArrayList<>(); lod4Polygons = new ArrayList<>();
} }
private Color parseColor(String colorString) { @Override
if (colorString == null) { public void visit(org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly) {
return null; if (currentPolygons == null) {
return;
} }
try { Polygon viewerPoly = new Polygon(currentColor);
String[] split = colorString.split(" "); // parse rings
float r = Float.parseFloat(split[0]); Ring extRing = new Ring();
float g = Float.parseFloat(split[1]); viewerPoly.setExteriorRing(extRing);
float b = Float.parseFloat(split[2]); mapRing(gmlPoly.getExterior(), extRing);
return new Color(r, g, b);
} catch (Exception e) { if (gmlPoly.getInterior() != null) {
e.printStackTrace(); for (AbstractRingProperty arp : gmlPoly.getInterior()) {
return null; if (arp.getObject() != null) {
Ring innerRing = new Ring();
viewerPoly.addInteriorRing(innerRing);
mapRing(arp, innerRing);
} }
} }
}
currentPolygons.add(viewerPoly);
}
@Override @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) { if (currentPolygons == null) {
return; return;
} }
...@@ -182,6 +134,48 @@ public class FeatureMapper extends ObjectWalker { ...@@ -182,6 +134,48 @@ public class FeatureMapper extends ObjectWalker {
currentPolygons.add(viewerPoly); 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 @Override
public void visit(Triangle triangle) { public void visit(Triangle triangle) {
if (currentPolygons == null) { if (currentPolygons == null) {
...@@ -259,198 +253,201 @@ public class FeatureMapper extends ObjectWalker { ...@@ -259,198 +253,201 @@ public class FeatureMapper extends ObjectWalker {
currentRing.addPoint(v); 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 @Override
public void visit(AbstractBuilding ab) { public void visit(AbstractBuilding ab) {
currentColor = ColorHandler.getWallColor();
super.visit(ab); super.visit(ab);
DeprecatedPropertiesOfAbstractBuilding deprecatedProperties = ab.getDeprecatedProperties(); DeprecatedPropertiesOfAbstractBuilding deprecatedProperties = ab.getDeprecatedProperties();
parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, wallColor); parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons);
parseAbstractGeometry(ab.getLod2MultiSurface(), lod2Polygons, wallColor); parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons);
parseAbstractGeometry(ab.getLod3MultiSurface(), lod3Polygons, wallColor); parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons);
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);
} }
@Override @Override
public void visit(TINRelief tinRelief) { public void visit(TINRelief tinRelief) {
super.visit(tinRelief);
if (tinRelief.getTin() == null || tinRelief.getTin().getObject() == null) { if (tinRelief.getTin() == null || tinRelief.getTin().getObject() == null) {
return; return;
} }
TriangulatedSurface object = tinRelief.getTin().getObject(); switch (tinRelief.getLod()) {
case 0, 1:
currentPolygons = lod1Polygons; currentPolygons = lod1Polygons;
currentColor = landColor; break;
object.accept(this); case 2:
currentPolygons = null; currentPolygons = lod2Polygons;
currentColor = null; break;
case 3:
currentPolygons = lod3Polygons;
break;
case 4:
currentPolygons = lod4Polygons;
break;
default:
currentPolygons = lod1Polygons;
break;
}
currentColor = ColorHandler.getLandColor();
super.visit(tinRelief);
} }
@Override @Override
public void visit(WaterBody wb) { public void visit(WaterBody wb) {
currentColor = ColorHandler.getWaterColor();
super.visit(wb); super.visit(wb);
DeprecatedPropertiesOfWaterBody deprecatedProperties = wb.getDeprecatedProperties(); parseAbstractGeometry(wb.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, waterColor); parseAbstractGeometry(wb.getDeprecatedProperties().getLod4Solid(), lod4Polygons);
parseAbstractGeometry(wb.getLod1Solid(), lod1Polygons, waterColor);
parseAbstractGeometry(wb.getLod2Solid(), lod2Polygons, waterColor);
parseAbstractGeometry(wb.getLod3Solid(), lod3Polygons, waterColor);
parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons, waterColor);
} }
@Override @Override
public void visit(PlantCover pc) { public void visit(PlantCover pc) {
currentColor = ColorHandler.getVegetationColor();
super.visit(pc); super.visit(pc);
DeprecatedPropertiesOfPlantCover deprecatedProperties = pc.getDeprecatedProperties(); parseAbstractGeometry(pc.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, vegetationColor); parseMultiSolid(pc.getDeprecatedProperties().getLod1MultiSolid(), lod1Polygons);
parseAbstractGeometry(pc.getLod2MultiSurface(), lod2Polygons, vegetationColor); parseMultiSolid(pc.getDeprecatedProperties().getLod2MultiSolid(), lod2Polygons);
parseAbstractGeometry(pc.getLod3MultiSurface(), lod3Polygons, vegetationColor); parseMultiSolid(pc.getDeprecatedProperties().getLod3MultiSolid(), lod3Polygons);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, vegetationColor); parseMultiSolid(pc.getDeprecatedProperties().getLod4MultiSolid(), lod4Polygons);
parseAbstractGeometry(deprecatedProperties.getLod1MultiSolid(), lod1Polygons, vegetationColor); }
parseAbstractGeometry(deprecatedProperties.getLod2MultiSolid(), lod2Polygons, vegetationColor);
parseAbstractGeometry(deprecatedProperties.getLod3MultiSolid(), lod3Polygons, vegetationColor);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSolid(), lod4Polygons, vegetationColor); private void parseMultiSolid(MultiSolidProperty ms, List<Polygon> polygons) {
if (ms == null || ms.getObject() == null) {
return;
}
for (SolidProperty sp : ms.getObject().getSolidMember()) {
parseAbstractGeometry(sp, polygons);
}
} }
@Override @Override
public void visit(SolitaryVegetationObject svo) { public void visit(SolitaryVegetationObject svo) {
currentColor = ColorHandler.getVegetationColor();
super.visit(svo); super.visit(svo);
DeprecatedPropertiesOfSolitaryVegetationObject deprecatedProperties = svo.getDeprecatedProperties(); parseAbstractGeometry(svo.getDeprecatedProperties().getLod1Geometry(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod1Geometry(), lod1Polygons, vegetationColor); parseAbstractGeometry(svo.getDeprecatedProperties().getLod2Geometry(), lod2Polygons);
parseAbstractGeometry(deprecatedProperties.getLod2Geometry(), lod2Polygons, vegetationColor); parseAbstractGeometry(svo.getDeprecatedProperties().getLod3Geometry(), lod3Polygons);
parseAbstractGeometry(deprecatedProperties.getLod3Geometry(), lod3Polygons, vegetationColor); parseAbstractGeometry(svo.getDeprecatedProperties().getLod4Geometry(), lod4Polygons);
parseAbstractGeometry(deprecatedProperties.getLod4Geometry(), lod4Polygons, vegetationColor); }
parseImplicitGeometry(svo.getLod1ImplicitRepresentation(), lod1Polygons, vegetationColor);
parseImplicitGeometry(svo.getLod2ImplicitRepresentation(), lod2Polygons, vegetationColor); @Override
parseImplicitGeometry(svo.getLod3ImplicitRepresentation(), lod3Polygons, vegetationColor); public void visit(GroundSurface groundSurface) {
parseImplicitGeometry(deprecatedProperties.getLod4ImplicitRepresentation(), lod4Polygons, vegetationColor); 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 @Override
public void visit(AbstractThematicSurface abs) { public void visit(AbstractThematicSurface abs) {
super.visit(abs); super.visit(abs);
Color color = getBuildingSurfaceColor(abs);
DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = abs.getDeprecatedProperties(); DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = abs.getDeprecatedProperties();
parseAbstractGeometry(abs.getLod2MultiSurface(), lod2Polygons, color); parseAbstractGeometry(abs.getLod0MultiSurface(), lod1Polygons);
parseAbstractGeometry(abs.getLod3MultiSurface(), lod3Polygons, color); parseAbstractGeometry(abs.getLod1MultiSurface(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, color); parseAbstractGeometry(abs.getLod2MultiSurface(), lod2Polygons);
parseAbstractGeometry(abs.getLod3MultiSurface(), lod3Polygons);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons);
} }
@Override @Override
public void visit(LandUse landUse) { public void visit(LandUse landUse) {
currentColor = ColorHandler.getLandColor();
super.visit(landUse); 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 @Override
public void visit(AuxiliaryTrafficArea ata) { public void visit(AbstractTransportationSpace ats) {
super.visit(ata); currentColor = ColorHandler.getTransportationColor();
DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = ata.getDeprecatedProperties(); DeprecatedPropertiesOfAbstractTransportationSpace deprecatedProperties = ats.getDeprecatedProperties();
parseAbstractGeometry(ata.getLod2MultiSurface(), lod2Polygons, transportationColor); parseAbstractGeometry(ats.getLod1Solid(), lod1Polygons);
parseAbstractGeometry(ata.getLod3MultiSurface(), lod3Polygons, transportationColor); parseAbstractGeometry(ats.getLod2Solid(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, transportationColor); 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 @Override
public void visit(TrafficArea ta) { public void visit(Window window) {
super.visit(ta); Color oldColor = currentColor;
DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = ta.getDeprecatedProperties(); currentColor = ColorHandler.getWindowColor();
parseAbstractGeometry(ta.getLod2MultiSurface(), lod2Polygons, transportationColor); // process window
parseAbstractGeometry(ta.getLod3MultiSurface(), lod3Polygons, transportationColor); super.visit(window);
parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons, transportationColor); currentColor = oldColor;
} }
@Override @Override
public void visit(TransportationComplex tc) { public void visit(Door door) {
super.visit(tc); Color oldColor = currentColor;
DeprecatedPropertiesOfAbstractTransportationSpace deprecatedProperties = tc.getDeprecatedProperties(); currentColor = ColorHandler.getDoorColor();
parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, transportationColor); super.visit(door);
parseAbstractGeometry(tc.getLod2MultiSurface(), lod2Polygons, transportationColor); currentColor = oldColor;
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;
}
@Override @Override
public void visit(AbstractFillingElement ao) { public void visit(AbstractFillingElement ao) {
super.visit(ao); super.visit(ao);
Color color = getOpeningColor(ao); parseAbstractGeometry(ao.getLod1Solid(), lod1Polygons);
parseAbstractGeometry(ao.getLod1Solid(), lod1Polygons, color); parseAbstractGeometry(ao.getLod2Solid(), lod2Polygons);
parseAbstractGeometry(ao.getLod2Solid(), lod2Polygons, color); parseAbstractGeometry(ao.getLod3Solid(), lod3Polygons);
parseAbstractGeometry(ao.getLod3Solid(), lod3Polygons, color); parseAbstractGeometry(ao.getLod2MultiSurface(), lod2Polygons);
parseAbstractGeometry(ao.getLod2MultiSurface(), lod2Polygons, color); parseAbstractGeometry(ao.getLod3MultiSurface(), lod3Polygons);
parseAbstractGeometry(ao.getLod3MultiSurface(), lod3Polygons, color); parseImplicitGeometry(ao.getLod1ImplicitRepresentation(), lod1Polygons);
parseImplicitGeometry(ao.getLod1ImplicitRepresentation(), lod1Polygons, color); parseImplicitGeometry(ao.getLod2ImplicitRepresentation(), lod2Polygons);
parseImplicitGeometry(ao.getLod2ImplicitRepresentation(), lod2Polygons, color); parseImplicitGeometry(ao.getLod3ImplicitRepresentation(), lod3Polygons);
parseImplicitGeometry(ao.getLod3ImplicitRepresentation(), lod3Polygons, color);
}
private Color getOpeningColor(AbstractFillingElement ao) {
if (ao instanceof Door) {
return doorColor;
}
if (ao instanceof Window) {
return windowColor;
}
return wallColor;
} }
@Override @Override
public void visit(AbstractBridge ab) { public void visit(AbstractBridge ab) {
currentColor = ColorHandler.getBridgeColor();
super.visit(ab); super.visit(ab);
DeprecatedPropertiesOfAbstractBridge deprecatedProperties = ab.getDeprecatedProperties(); parseAbstractGeometry(ab.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons);
parseAbstractGeometry(deprecatedProperties.getLod1MultiSurface(), lod1Polygons, bridgeColor); parseAbstractGeometry(ab.getDeprecatedProperties().getLod4MultiSurface(), lod4Polygons);
parseAbstractGeometry(ab.getLod2MultiSurface(), lod2Polygons, bridgeColor); parseAbstractGeometry(ab.getDeprecatedProperties().getLod4Solid(), lod4Polygons);
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);
} }
@Override @Override
public void visit(BuildingInstallation bi) { public void visit(BuildingInstallation bi) {
currentColor = ColorHandler.getWallColor();
super.visit(bi); 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<Polygon> polygons, Color color) { private void parseImplicitGeometry(ImplicitGeometryProperty irp, List<Polygon> polygons) {
if (irp == null || irp.getObject() == null) { if (irp == null || irp.getObject() == null) {
return; return;
} }
ImplicitGeometry implicitGeometry = irp.getObject(); ImplicitGeometry implicitGeometry = irp.getObject();
parseAbstractGeometry(implicitGeometry.getRelativeGeometry(), polygons, color); parseAbstractGeometry(implicitGeometry.getRelativeGeometry(), polygons);
} }
private void parseAbstractGeometry(GeometryProperty<? extends AbstractGeometry> geom, List<Polygon> polygons, private void parseAbstractGeometry(GeometryProperty<? extends AbstractGeometry> geom, List<Polygon> polygons) {
Color color) {
if (geom == null || geom.getObject() == null) { if (geom == null || geom.getObject() == null) {
return; return;
} }
currentColor = color;
currentPolygons = polygons; currentPolygons = polygons;
geom.getObject().accept(this); geom.getObject().accept(this);
currentColor = null;
currentPolygons = null; currentPolygons = null;
} }
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

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