FeatureMapper.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.parser;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

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 de.hft.stuttgart.citygml.viewer.datastructure.Polygon;
import de.hft.stuttgart.citygml.viewer.datastructure.Ring;
import de.hft.stuttgart.citygml.viewer.math.Vector3d;

public class FeatureMapper extends ObjectWalker {

	private ParserConfiguration config;
	private List<Polygon> lod1Polygons;
	private List<Polygon> lod2Polygons;
	private List<Polygon> lod3Polygons;
	private List<Polygon> lod4Polygons;

	private List<Polygon> currentPolygons = null;
	private Ring currentRing;
	private Color currentColor;

	private ProjCoordinate p1 = new ProjCoordinate();
	private ProjCoordinate p2 = new ProjCoordinate();

	private PolygonColorMapper colorMapper;
	private ColorHandler colorHandler;

	public FeatureMapper(ParserConfiguration config, PolygonColorMapper colorMapper, ColorHandler colorHandler) {
		this.colorMapper = colorMapper;
		this.colorHandler = colorHandler;
		this.config = config;
		currentColor = colorHandler.getWallColor();
		lod1Polygons = new ArrayList<>();
		lod2Polygons = new ArrayList<>();
		lod3Polygons = new ArrayList<>();
		lod4Polygons = new ArrayList<>();
	}

	@Override
	public void visit(org.xmlobjects.gml.model.geometry.primitives.Polygon gmlPoly) {
		if (currentPolygons == null) {
			return;
		}
		Color setColor = currentColor;
		if (gmlPoly.getId() != null) {
			Color mappedColor = colorMapper.getColorForPolygon(gmlPoly.getId());
			if (mappedColor != null) {
				setColor = mappedColor;
			}
		}
		Polygon viewerPoly = new Polygon(setColor);
		// 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.PolygonPatch gmlPoly) {
		if (currentPolygons == null) {
			return;
		}
		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(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) {
			return;
		}
		// triangle is only a special case of a polygon
		// so use a polygon
		Polygon viewerPoly = new Polygon(currentColor);
		// parse rings
		Ring extRing = new Ring();
		viewerPoly.setExteriorRing(extRing);
		mapRing(triangle.getExterior(), extRing);
		currentPolygons.add(viewerPoly);
	}

	private void mapRing(AbstractRingProperty gmlRing, Ring viewerRing) {
		if (gmlRing == null || gmlRing.getObject() == null) {
			return;
		}
		AbstractRing ringGeometry = gmlRing.getObject();
		currentRing = viewerRing;
		// jump to LinearRing or Ring visit
		ringGeometry.accept(this);
	}

	@Override
	public void visit(LinearRing linearRing) {
		if (linearRing.getControlPoints() != null) {
			int dimension = getDimension(linearRing);
			parseControlPoints(linearRing.getControlPoints(), dimension);
		}
	}

	private int getDimension(LinearRing linearRing) {
		int dimension = 3;
		if (linearRing.getSrsDimension() != null) {
			dimension = linearRing.getSrsDimension();
		}
		return dimension;
	}

	private void parseControlPoints(GeometricPositionList controlPoints, int dimension) {
		List<Double> coords = controlPoints.toCoordinateList3D();
		switch (dimension) {
		case 1:
			for (int i = 0; i < coords.size(); i++) {
				createVertex(coords.get(i), 0, 0);
			}
			break;
		case 2:
			for (int i = 0; i < coords.size(); i = i + 2) {
				createVertex(coords.get(i + 0), coords.get(i + 1), 0);
			}
			break;
		case 3:
			for (int i = 0; i < coords.size(); i = i + 3) {
				createVertex(coords.get(i + 0), coords.get(i + 1), coords.get(i + 2));
			}
			break;
		default:
			throw new UnsupportedOperationException("Cannot parse Coordinates with dimension:" + dimension);
		}
	}

	private void createVertex(double x, double y, double z) {
		// transform into utm, if available
		BasicCoordinateTransform trans = config.getTargetTransform();
		if (trans != null) {
			p1.setValue(x, y);
			trans.transform(p1, p2);
			x = p2.x;
			y = p2.y;
		}
		Vector3d v = new Vector3d(x, y, z);
		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);
		parseAbstractGeometry(deprecatedProperties.getLod4MultiSurface(), lod4Polygons);
		parseAbstractGeometry(deprecatedProperties.getLod4Solid(), lod4Polygons);
	}

	@Override
	public void visit(TINRelief tinRelief) {
		if (tinRelief.getTin() == null || tinRelief.getTin().getObject() == null) {
			return;
		}
		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);
		parseAbstractGeometry(wb.getDeprecatedProperties().getLod1MultiSurface(), lod1Polygons);
		parseAbstractGeometry(wb.getDeprecatedProperties().getLod4Solid(), lod4Polygons);
	}

	@Override
	public void visit(PlantCover pc) {
		currentColor = colorHandler.getVegetationColor();
		super.visit(pc);
		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<Polygon> 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);
		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);
		DeprecatedPropertiesOfAbstractThematicSurface deprecatedProperties = abs.getDeprecatedProperties();
		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);
	}

	@Override
	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(Window window) {
		Color oldColor = currentColor;
		currentColor = colorHandler.getWindowColor();
		// process window
		super.visit(window);
		currentColor = oldColor;
	}

	@Override
	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);
		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);
		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);
	}

	private void parseImplicitGeometry(ImplicitGeometryProperty irp, List<Polygon> polygons) {
		if (irp == null || irp.getObject() == null) {
			return;
		}
		ImplicitGeometry implicitGeometry = irp.getObject();
		parseAbstractGeometry(implicitGeometry.getRelativeGeometry(), polygons);
	}

	private void parseAbstractGeometry(GeometryProperty<? extends AbstractGeometry> geom, List<Polygon> polygons) {
		if (geom == null || geom.getObject() == null) {
			return;
		}
		currentPolygons = polygons;
		geom.getObject().accept(this);
		currentPolygons = null;
	}

	public List<Polygon> getLod1Polygons() {
		return lod1Polygons;
	}

	public List<Polygon> getLod2Polygons() {
		return lod2Polygons;
	}

	public List<Polygon> getLod3Polygons() {
		return lod3Polygons;
	}

	public List<Polygon> getLod4Polygons() {
		return lod4Polygons;
	}

	public void movePolygonsBy(Vector3d center) {
		movePolygonsBy(lod1Polygons, center);
		movePolygonsBy(lod2Polygons, center);
		movePolygonsBy(lod3Polygons, center);
		movePolygonsBy(lod4Polygons, center);
	}

	private void movePolygonsBy(List<Polygon> polygons, Vector3d center) {
		for (Polygon p : polygons) {
			for (Vector3d v : p.getExteriorRing().getVertices()) {
				movePointBy(v, center);
			}
			for (Ring r : p.getInteriorRings()) {
				for (Vector3d v : r.getVertices()) {
					movePointBy(v, center);
				}
			}
		}
	}

	private void movePointBy(Vector3d v, Vector3d center) {
		v.setX(v.getX() - center.getX());
		v.setY(v.getY() - center.getY());
		v.setZ(v.getZ() - center.getZ());
	}
}