CityGMLViewer.java

/*-
 * Copyright 2021 Hochschule für Technik Stuttgart
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package de.hft.stuttgart.citygml.viewer;

import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
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.swing.JOptionPane;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;

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;
import org.lwjgl.PointerBuffer;
import org.lwjgl.glfw.Callbacks;
import org.lwjgl.glfw.GLFW;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.glfw.GLFWMouseButtonCallback;
import org.lwjgl.glfw.GLFWScrollCallback;
import org.lwjgl.glfw.GLFWWindowSizeCallbackI;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;
import org.lwjgl.opengl.GL30;
import org.lwjgl.opengl.GLUtil;
import org.lwjgl.system.Callback;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.MemoryUtil;
import org.lwjgl.util.nfd.NativeFileDialog;
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;
import de.hft.stuttgart.citygml.viewer.parser.ObservedInputStream;
import de.hft.stuttgart.citygml.viewer.parser.ParserConfiguration;

public class CityGMLViewer {

	private static final Logger log = Logger.getLogger(CityGMLViewer.class.getName());

	private static Camera camera;

	private static boolean mouse1Down = false;
	private static boolean mouse2Down = false;

	private static double x;
	private static double y;

	private static int width = 1024;
	private static int height = 768;

	private static List<PolygonViewInformation> viewing = new ArrayList<>();
	private static float cameraViewDistance = 10000f;

	private static long windowId;

	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) {
		boolean useDebug = false;
		for (String arg : args) {
			if (arg.equals("-debug")) {
				useDebug = true;
			}
		}
		File f = null;
		if (args != null && args.length == 1) {
			f = new File(args[0]);
			if (!f.exists() || f.isDirectory()) {
				// no file given
				f = null;
			}
		}
		if (f == null) {
			f = showFileChooserDialog();
		}
		try {
			setupWindow(f, useDebug);
		} catch (Exception e) {
			String message = e.getClass().getSimpleName() + ": " + e.getMessage();
			if (e.getCause() != null) {
				message += "\nCause: " + e.getCause().getClass().getSimpleName() + ": " + e.getCause().getMessage();
			}
			JOptionPane.showMessageDialog(null, message, "Error", JOptionPane.ERROR_MESSAGE);
		} finally {
			for (PolygonViewInformation view : viewing) {
				view.destroy();
			}
		}
	}

	private static File showFileChooserDialog() {
		File f = null;
		try (MemoryStack stack = MemoryStack.stackPush()) {
			File defaultPath = new File("bla");
			PointerBuffer pathPointer = stack.mallocPointer(1);
			int success = NativeFileDialog.NFD_OpenDialog("gml,xml", defaultPath.getAbsolutePath(), pathPointer);
			if (success == NativeFileDialog.NFD_OKAY) {
				String filePath = pathPointer.getStringUTF8(0);
				f = new File(filePath);
			} else {
				System.exit(0);
			}
		}
		return f;
	}

	private static void screenShot() {
		// Creating an rbg array of total pixels
		int[] pixels = new int[width * height];
		int bindex;
		// allocate space for RBG pixels
		ByteBuffer fb = ByteBuffer.allocateDirect(width * height * 3);

		// grab a copy of the current frame contents as RGB
		GL11.glReadPixels(0, 0, width, height, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, fb);

		BufferedImage imageIn = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		// convert RGB data in ByteBuffer to integer array
		for (int i = 0; i < pixels.length; i++) {
			bindex = i * 3;
			pixels[i] = (fb.get(bindex) << 16) + (fb.get(bindex + 1) << 8) + (fb.get(bindex + 2));
		}
		// Allocate colored pixel to buffered Image
		imageIn.setRGB(0, 0, width, height, pixels, 0, width);

		// Creating the transformation direction (horizontal)
		AffineTransform at = AffineTransform.getScaleInstance(1, -1);
		at.translate(0, -imageIn.getHeight(null));

		// Applying transformation
		AffineTransformOp opRotated = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
		BufferedImage imageOut = opRotated.filter(imageIn, null);

		try {
			int nr = 0;
			File f = new File("screen_" + nr + ".png");
			while (f.exists()) {
				nr++;
				f = new File("screen_" + nr + ".png");
			}
			ImageIO.write(imageOut, "png", f);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void setupWindow(File f, boolean useDebug) {
		GLFW.glfwSetErrorCallback(GLFWErrorCallback.create((code, desc) -> {
			log.severe("Encountered OpenGL error with code: " + code);
		}));
		if (!GLFW.glfwInit()) {
			throw new IllegalStateException("Unable to initialize GLFW");
		}
		String title = "CityGMLViewer";

		GLFW.glfwDefaultWindowHints(); // Loads GLFW's default window settings
		if (useDebug) {
			GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_DEBUG_CONTEXT, GLFW.GLFW_TRUE);
		}
		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_CONTEXT_VERSION_MAJOR, 3);
		GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 0);
		GLFW.glfwWindowHint(GLFW.GLFW_SAMPLES, 2);

		windowId = GLFW.glfwCreateWindow(width, height, title, 0, 0);
		if (windowId == 0) {
			GLFW.glfwTerminate();
			throw new IllegalStateException("Failed to create window");
		}

		GLFW.glfwSetWindowSizeCallback(windowId, new GLFWWindowSizeCallbackI() {

			@Override
			public void invoke(long window, int width, int height) {
				CityGMLViewer.width = width;
				CityGMLViewer.height = height;
				if (camera != null) {
					camera.reshape(width, height, cameraViewDistance);
				}
				if (bar != null) {
					bar.updateWindowSize(width, height);
				}
				GL11.glViewport(0, 0, width, height);
			}
		});

		GLFW.glfwSetKeyCallback(windowId, (window, key, scancode, action, mods) -> {
			if (key == GLFW.GLFW_KEY_ESCAPE && action == GLFW.GLFW_PRESS) {
				GLFW.glfwSetWindowShouldClose(window, true);
			} else if (key == GLFW.GLFW_KEY_F9 && action == GLFW.GLFW_PRESS) {
				screenShot();
			}
		});

		GLFW.glfwSetMouseButtonCallback(windowId, new GLFWMouseButtonCallback() {

			@Override
			public void invoke(long window, int button, int action, int mods) {
				if (button == GLFW.GLFW_MOUSE_BUTTON_1 && action == GLFW.GLFW_PRESS) {
					mouse1Down = true;
					try (MemoryStack stack = MemoryStack.stackPush()) {
						DoubleBuffer xBuffer = stack.mallocDouble(1);
						DoubleBuffer yBuffer = stack.mallocDouble(1);
						GLFW.glfwGetCursorPos(windowId, xBuffer, yBuffer);
						x = xBuffer.get(0);
						y = yBuffer.get(0);
					}
				} else if (button == GLFW.GLFW_MOUSE_BUTTON_1 && action == GLFW.GLFW_RELEASE) {
					mouse1Down = false;
				} else if (button == GLFW.GLFW_MOUSE_BUTTON_2 && action == GLFW.GLFW_PRESS) {
					mouse2Down = true;
					try (MemoryStack stack = MemoryStack.stackPush()) {
						DoubleBuffer xBuffer = stack.mallocDouble(1);
						DoubleBuffer yBuffer = stack.mallocDouble(1);
						GLFW.glfwGetCursorPos(windowId, xBuffer, yBuffer);
						x = xBuffer.get(0);
						y = yBuffer.get(0);
					}
				} else if (button == GLFW.GLFW_MOUSE_BUTTON_2 && action == GLFW.GLFW_RELEASE) {
					mouse2Down = false;
				}
			}
		});

		GLFW.glfwSetScrollCallback(windowId, new GLFWScrollCallback() {

			@Override
			public void invoke(long window, double xoffset, double yoffset) {
				camera.scroll((int) (-yoffset));
			}
		});

		GLFW.glfwSetCursorPosCallback(windowId, (window, xPos, yPos) -> {
			if (mouse1Down) {
				try (MemoryStack stack = MemoryStack.stackPush()) {
					double dragDiffX = xPos - x;
					double dragDiffY = yPos - y;
					camera.drag(dragDiffX, dragDiffY);
					x = xPos;
					y = yPos;
				}
			} else if (mouse2Down) {
				try (MemoryStack stack = MemoryStack.stackPush()) {
					double dragDiffX = xPos - x;
					double dragDiffY = yPos - y;
					camera.move(dragDiffX, dragDiffY);
					x = xPos;
					y = yPos;
				}
			}
		});

		GLFW.glfwMakeContextCurrent(windowId); // glfwSwapInterval needs a context on the calling thread, otherwise will
												// cause
		// 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
		Callback cb = null;
		if (useDebug) {
			cb = GLUtil.setupDebugMessageCallback();
		}

		if (!caps.OpenGL30) {
			log.warning("OpenGL 3.0 is not supported");
		}
		GLFW.glfwSwapInterval(1); // How many draws to swap the buffer

		GL11.glEnable(GL11.GL_DEPTH_TEST);
		GL11.glEnable(GL13.GL_MULTISAMPLE);
		GL11.glDisable(GL11.GL_CULL_FACE);

		GL11.glViewport(0, 0, width, height);
		GLFW.glfwShowWindow(windowId); // Shows the window

		if (log.isLoggable(Level.INFO)) {
			log.fine("OpenGL error code after displaying the window: " + GL11.glGetError());
		}

		FloatBuffer clearColor = null;
		FloatBuffer clearDepth = null;

		try {
			Shader program = new Shader("vertex.vert", "fragment.frag", useDebug);
			program.use();
			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);
			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;

			camera.setOrtho(false);
			camera.reshape(width, height, cameraViewDistance);

			clearColor = MemoryUtil.memAllocFloat(4);
			clearColor.put(0, 0.9411765f).put(1, 1f).put(2, 1f).put(3, 1f);
			clearDepth = MemoryUtil.memAllocFloat(1);
			clearDepth.put(0, 1f);

			log.fine(() -> "OpenGL error code before loop: " + GL11.glGetError());
			while (!GLFW.glfwWindowShouldClose(windowId)) {
				/* Do something */
				GL30.glClearBufferfv(GL11.GL_COLOR, 0, clearColor);
				GL30.glClearBufferfv(GL11.GL_DEPTH, 0, clearDepth);

				for (PolygonViewInformation view : viewing) {
					view.draw();
				}

				Thread.sleep(15);

				GLFW.glfwSwapBuffers(windowId);
				GLFW.glfwPollEvents();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		} finally {
			MemoryUtil.memFree(clearColor);
			MemoryUtil.memFree(clearDepth);
			if (camera != null) {
				camera.free();
			}
		}

		if (cb != null) {
			cb.free();
		}
		GLFW.glfwDestroyWindow(windowId);
		Callbacks.glfwFreeCallbacks(windowId);
		GLFW.glfwTerminate();
	}

	private static void loadGmlFile(File f) {
		try {
			File file = f;
			ParserConfiguration config = new ParserConfiguration();
			CityGMLParser.parseEpsgCodeFromFile(file, config);
			CityGMLContext context = CityGMLContext.newInstance();
			CityGMLInputFactory in = context.createCityGMLInputFactory()
					.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)));

				int threads = Runtime.getRuntime().availableProcessors();
				ExecutorService service = Executors.newFixedThreadPool(threads);
				List<Future<FeatureMapper>> mappers = new ArrayList<>();
				while (reader.hasNext()) {
					CityGMLChunk nextChunk = reader.nextChunk();
					mappers.add(service.submit(() -> {
						FeatureMapper mapper = new FeatureMapper(config);
						AbstractFeature feature = nextChunk.build();
						feature.accept(mapper);
						return 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);
				Vector3d center = bbox.getCenter();
				fMappers.forEach(m -> m.movePolygonsBy(center));
				bar.drawProgress(82);
				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 (!lod1Polygons.isEmpty()) {
					PolygonViewInformation lod1ViewInfo = new PolygonViewInformation(lod1Polygons, l);
					viewing.add(lod1ViewInfo);
				}
				if (!lod2Polygons.isEmpty()) {
					PolygonViewInformation lod2ViewInfo = new PolygonViewInformation(lod2Polygons, l);
					viewing.add(lod2ViewInfo);
				}
				if (!lod3Polygons.isEmpty()) {
					PolygonViewInformation lod3ViewInfo = new PolygonViewInformation(lod3Polygons, l);
					viewing.add(lod3ViewInfo);
				}
				if (!lod4Polygons.isEmpty()) {
					PolygonViewInformation lod4ViewInfo = new PolygonViewInformation(lod4Polygons, l);
					viewing.add(lod4ViewInfo);
				}

				double longestSide = bbox.getDiagonalLength() * 0.2;
				double d = longestSide / Math.tan(Math.toRadians(30) / 2);
				double translateZ = -d;
				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) {
			e.printStackTrace();
		}
	}
}