EDIT

cdmlib-ext/KmlJaxbMarshallerTest.kml

import de.micromata.opengis.kml.v_2_2_0.Kml;

import eu.etaxonomy.cdm.ext.geo.kml.KMLDocumentBuilder;

    public OccurrenceServiceRequestParameterDto getOccurrenceServiceRequestParameters(

            List<SpecimenOrObservationBase> specimensOrObservations,

        for (SpecimenOrObservationBase<?> specimenOrObservationBase : specimensOrObservations) {

            SpecimenOrObservationBase<?> specimensOrObservation = occurrenceDao

            if (specimensOrObservation instanceof FieldUnit) {

                GatheringEvent gatherEvent = ((FieldUnit) specimensOrObservation).getGatheringEvent();

            if (specimensOrObservation instanceof DerivedUnit) {

                registerDerivedUnitLocations((DerivedUnit) specimensOrObservation, derivedUnitPoints);

    @Override

    public Kml occurrencesToKML(

            List<SpecimenOrObservationBase> specimensOrObservations,

            Map<SpecimenOrObservationType, Color> specimenOrObservationTypeColors) {

    		KMLDocumentBuilder builder = new KMLDocumentBuilder();

    		for (SpecimenOrObservationBase<?> specimenOrObservationBase : specimensOrObservations) {

    			builder.addSpecimenOrObservationBase(occurrenceDao.load(specimenOrObservationBase.getUuid())); 			 

    		}

    		Kml kml = builder.build();

    		return kml;

    }

import de.micromata.opengis.kml.v_2_2_0.Kml;

    public OccurrenceServiceRequestParameterDto getOccurrenceServiceRequestParameters(

	public Kml occurrencesToKML(List<SpecimenOrObservationBase> specimensOrObersvations,

			Map<SpecimenOrObservationType, Color> specimenOrObservationTypeColors);

/**

 * Copyright (C) 2020 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.ext.geo.kml;

import java.awt.geom.Point2D;

import javax.measure.Quantity;

import javax.measure.Unit;

import javax.measure.UnitConverter;

import javax.measure.quantity.Length;

import org.apache.log4j.Logger;

import org.geotools.data.DataUtilities;

import org.geotools.feature.SchemaException;

import org.geotools.feature.simple.SimpleFeatureBuilder;

import org.geotools.geometry.jts.JTS;

import org.geotools.geometry.jts.JTSFactoryFinder;

import org.geotools.referencing.CRS;

import org.geotools.referencing.GeodeticCalculator;

import org.geotools.referencing.crs.DefaultGeographicCRS;

import org.locationtech.jts.geom.Coordinate;

import org.locationtech.jts.geom.CoordinateSequence;

import org.locationtech.jts.geom.Geometry;

import org.locationtech.jts.geom.GeometryFactory;

import org.locationtech.jts.geom.Point;

import org.locationtech.jts.geom.Polygon;

import org.locationtech.jts.util.GeometricShapeFactory;

import org.opengis.feature.GeometryAttribute;

import org.opengis.feature.simple.SimpleFeature;

import org.opengis.feature.simple.SimpleFeatureType;

import org.opengis.geometry.MismatchedDimensionException;

import org.opengis.referencing.FactoryException;

import org.opengis.referencing.NoSuchAuthorityCodeException;

import org.opengis.referencing.crs.CoordinateReferenceSystem;

import org.opengis.referencing.crs.ProjectedCRS;

import org.opengis.referencing.operation.MathTransform;

import org.opengis.referencing.operation.TransformException;

import si.uom.SI;

import tec.uom.se.quantity.Quantities;

/**

 * See :

 * 

 * https://gis.stackexchange.com/questions/311272/create-dynamic-circle-polygon-from-specific-lat-long-using-geotools

 * https://gis.stackexchange.com/questions/283183/using-geometricshapefactory-to-create-circle-with-radius-in-miles

 * 

 * https://stackoverflow.com/questions/36481651/how-do-i-create-a-circle-with-latitude-longitude-and-radius-with-geotools#36528805

 * 

 * 

 * Another great library for creating shapes is https://github.com/locationtech/spatial4j

 * 

 * @author Andreas Kohlbecker

 * @since Apr 21, 2020

 */

public class GeometryBuilder {

	private final static Logger logger = Logger.getLogger(GeometryBuilder.class);

	public enum CircleMethod {

		circle, simpleCircleSmall, simpleCircle, reprojectedCircle;

	}

	/**

	 * Fails with javax.measure.IncommensurableException: m is not compatible with

	 * deg

	 * 

	 * see

	 * https://gis.stackexchange.com/questions/283183/using-geometricshapefactory-to-create-circle-with-radius-in-miles

	 * 

	 * @param radius

	 * @param latitude

	 * @param longitude

	 * @return

	 * @throws NoSuchAuthorityCodeException

	 * @throws FactoryException

	 */

	public Polygon circle(Double radius, Double latitude, Double longitude)

			throws NoSuchAuthorityCodeException, FactoryException {

		Quantity<Length> radiusMeter = Quantities.getQuantity(radius, SI.METRE);

		Unit<Length> origUnit = (Unit<Length>) DefaultGeographicCRS.WGS84.getCoordinateSystem().getAxis(0).getUnit(); //// (Unit<Length>)

																														//// ////

																														//// origCRS.getCoordinateSystem().getAxis(0).getUnit();

		GeometricShapeFactory shapeFactory = new GeometricShapeFactory();

		shapeFactory.setNumPoints(32);

		shapeFactory.setCentre(new Coordinate(latitude, longitude));

		shapeFactory.setSize(radiusMeter.to(origUnit).getValue().doubleValue() * 2);

		Polygon circlePolygon = shapeFactory.createCircle();

		circlePolygon.setSRID(4326);

		return circlePolygon;

	}

	/**

	 * Only suitable for small radius (> 1000 m) as the circles are heavily

	 * distorted otherwise.

	 * 

	 * @param radius

	 * @param latitude

	 * @param longitude

	 * @return

	 */

	public Geometry simpleCircleSmall(Double radius, Double latitude, Double longitude) {

		double diameterInMeters = radius * 2.0d;

		GeometricShapeFactory shapeFactory = new GeometricShapeFactory();

		shapeFactory.setNumPoints(64); // adjustable

		shapeFactory.setCentre(new Coordinate(longitude, latitude));

		// Length in meters of 1° of latitude = always 111.32 km

		shapeFactory.setWidth(diameterInMeters / 111320d);

		// Length in meters of 1° of longitude = 40075 km * cos( latitude ) / 360

		shapeFactory.setHeight(diameterInMeters / (40075000 * Math.cos(Math.toRadians(latitude)) / 360));

		Polygon circle = shapeFactory.createEllipse();

		return circle;

	}

	/**

	 * Creates perfect circles which are looking good but might be projected

	 * incorrectly for the resulting map

	 * 

	 * @param distance

	 * @param latitude

	 * @param longitude

	 * @return

	 */

	public Geometry simpleCircle(Quantity<Length> distance, Double latitude, Double longitude) {

		GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory(null);

		CoordinateSequence coordinateSequence = geometryFactory.getCoordinateSequenceFactory()

				.create(new Coordinate[] { new Coordinate(longitude, latitude) });

		Point point = new Point(coordinateSequence, geometryFactory);

		GeodeticCalculator calc = new GeodeticCalculator(DefaultGeographicCRS.WGS84);

		calc.setStartingGeographicPoint(longitude, latitude);

		UnitConverter converter = distance.getUnit().getConverterTo(SI.METRE);

		double d = converter.convert(distance.getValue()).doubleValue();

		calc.setDirection(0.0, d);

		Point2D p2 = calc.getDestinationGeographicPoint();

		calc.setDirection(90.0, d);

		Point2D p3 = calc.getDestinationGeographicPoint();

		double dy = p2.getY() - latitude;

		double dx = p3.getX() - longitude;

		double dist = (dy + dx) / 2.0;

		Polygon p1 = (Polygon) point.buffer(dist);

		return p1;

	}

	/**

	 * This Method should produces the best circles.

	 * 

	 * The code is based on an example published by Ian Turton on stackoverflow:

	 * 

	 * https://stackoverflow.com/questions/36481651/how-do-i-create-a-circle-with-latitude-longitude-and-radius-with-geotools#36528805

	 * 

	 * see https://gist.github.com/ianturton/973563fe5004985ba35a6e2247f7d823 and

	 * https://gitlab.com/snippets/17558

	 * 

	 * @param feature

	 * @param distance

	 * @return

	 */

	public Geometry bufferFeature(SimpleFeature feature, Double radius) {

		// replacment for Measure<Double, Length> distance:

		Quantity<Length> radiusMeter = Quantities.getQuantity(radius, SI.METRE);

		// extract the geometry

		GeometryAttribute gProp = feature.getDefaultGeometryProperty();

		CoordinateReferenceSystem origCRS = gProp.getDescriptor().getCoordinateReferenceSystem();

		Geometry geom = (Geometry) feature.getDefaultGeometry();

		Geometry pGeom = geom;

		MathTransform toTransform, fromTransform = null;

		// reproject the geometry to a local projection

		if (!(origCRS instanceof ProjectedCRS)) {

			double x = geom.getCoordinate().x;

			double y = geom.getCoordinate().y;

			String code = "AUTO:42001," + x + "," + y;

			// System.out.println(code);

			CoordinateReferenceSystem auto;

			try {

				auto = CRS.decode(code);

				toTransform = CRS.findMathTransform(DefaultGeographicCRS.WGS84, auto);

				fromTransform = CRS.findMathTransform(auto, DefaultGeographicCRS.WGS84);

				pGeom = JTS.transform(geom, toTransform);

			} catch (MismatchedDimensionException | TransformException | FactoryException e) {

				logger.error(e);

			}

		}

		// create a buffer around the geometry, assumes the geometry is in the same

		// units as the distance variable.

		Geometry out = pGeom.buffer(radiusMeter.getValue().doubleValue());

		Geometry retGeom = out;

		// reproject the geometry to the original projection

		if (!(origCRS instanceof ProjectedCRS)) {

			try {

				retGeom = JTS.transform(out, fromTransform);

			} catch (MismatchedDimensionException | TransformException e) {

				logger.error(e);

			}

		}

		return retGeom;

	}

	public static SimpleFeature createSimplePointFeature(Double longitude, Double latitude) throws SchemaException {

		SimpleFeatureType schema = DataUtilities.createType("", "Location", "locations:Point:srid=4326,id:Integer" // a

																													// number

																													// attribute

		);

		SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(schema);

		GeometryFactory geometryFactory = new GeometryFactory();

		/* Longitude (= x coord) first ! */

		Point point = geometryFactory.createPoint(new Coordinate(longitude, latitude));

		featureBuilder.add(point);

		SimpleFeature feature = featureBuilder.buildFeature(null);

		return feature;

	}

}

/**

 * Copyright (C) 2020 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.ext.geo.kml;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import org.apache.log4j.Logger;

import org.geotools.feature.SchemaException;

import org.locationtech.jts.geom.Coordinate;

import org.opengis.feature.simple.SimpleFeature;

import org.opengis.referencing.FactoryException;

import de.micromata.opengis.kml.v_2_2_0.AltitudeMode;

import de.micromata.opengis.kml.v_2_2_0.Document;

import de.micromata.opengis.kml.v_2_2_0.ExtendedData;

import de.micromata.opengis.kml.v_2_2_0.Feature;

import de.micromata.opengis.kml.v_2_2_0.Kml;

import de.micromata.opengis.kml.v_2_2_0.KmlFactory;

import de.micromata.opengis.kml.v_2_2_0.LineStyle;

import de.micromata.opengis.kml.v_2_2_0.LinearRing;

import de.micromata.opengis.kml.v_2_2_0.Placemark;

import de.micromata.opengis.kml.v_2_2_0.PolyStyle;

import de.micromata.opengis.kml.v_2_2_0.Polygon;

import de.micromata.opengis.kml.v_2_2_0.Style;

import eu.etaxonomy.cdm.model.location.Point;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;

import eu.etaxonomy.cdm.model.term.DefinedTerm;

import eu.etaxonomy.cdm.model.term.TermType;

import si.uom.SI;

import tec.uom.se.quantity.Quantities;

/**

 * 

 * @author Andreas Kohlbecker

 * @since Apr 21, 2020

 */

public class KMLDocumentBuilder {

	private final static Logger logger = Logger.getLogger(KMLDocumentBuilder.class);

	private Set<SpecimenOrObservationBase> occSet = new HashSet<>();

	private Map<String, Style> styles = new HashMap<>();

	private static final DefinedTerm KIND_OF_UNIT_UNSET = DefinedTerm.NewInstance(TermType.KindOfUnit);

	public KMLDocumentBuilder addSpecimenOrObservationBase(SpecimenOrObservationBase occurrence) {

		occSet.add(occurrence);

		return this;

	}

	public Kml build() {

		Kml kml = KmlFactory.createKml();

		List<Feature> documentFeatures = new ArrayList<>();

		for (SpecimenOrObservationBase sob : occSet) {

			if (sob instanceof FieldUnit) {

				GatheringEvent gatherEvent = ((FieldUnit) sob).getGatheringEvent();

				if (gatherEvent != null && isValidPoint(gatherEvent.getExactLocation())) {

					createFieldUnitPlacemarks(documentFeatures, sob, gatherEvent, LocationType.FIELD_UNIT, sob.getKindOfUnit());

				}

			}

			if (sob instanceof DerivedUnit) {

				walkDerivationPath((DerivedUnit) sob, (DerivedUnit) sob, documentFeatures, null);

			}

		}

		Document doc = kml.createAndSetDocument();

		doc.getFeature().addAll(documentFeatures);

		doc.getStyleSelector().addAll(styles.values());

		return kml;

	}

	/**

	 * @param derivedUnit

	 * @param documentFeatures

	 * @param kindOfUnit

	 */

	private void walkDerivationPath(DerivedUnit derivedUnit, DerivedUnit unitOfInterest, List<Feature> documentFeatures,

			DefinedTerm kindOfUnit) {

		if (kindOfUnit == null) {

			if (derivedUnit.getKindOfUnit() != null) {

				kindOfUnit = derivedUnit.getKindOfUnit();

			} else {

				kindOfUnit = KIND_OF_UNIT_UNSET;

			}

		}

		Set<SpecimenOrObservationBase> originals = derivedUnit.getOriginals();

		if (originals != null) {

			for (SpecimenOrObservationBase<?> original : originals) {

				if (original instanceof FieldUnit) {

					GatheringEvent gatherEvent = ((FieldUnit) original).getGatheringEvent();

					if (gatherEvent != null && isValidPoint(gatherEvent.getExactLocation())) {

						createFieldUnitPlacemarks(documentFeatures, unitOfInterest, gatherEvent, LocationType.DERIVED_UNIT, kindOfUnit);

					}

				} else {

					walkDerivationPath((DerivedUnit) original, unitOfInterest, documentFeatures, kindOfUnit);

				}

			}

		}

	}

	/**

	 * @param documentFeatures

	 * @param sob

	 * @param gatherEvent

	 */

	private void createFieldUnitPlacemarks(List<Feature> documentFeatures, SpecimenOrObservationBase sob,

			GatheringEvent gatherEvent, LocationType locationType, DefinedTerm kindOfUnit) {

		Placemark mapMarker = fieldUnitLocationMarker(gatherEvent.getExactLocation(),

				gatherEvent.getAbsoluteElevation(), locationType, kindOfUnit);

		documentFeatures.add(mapMarker);

		addExtendedData(mapMarker, sob, gatherEvent);

		errorRadiusPlacemark(gatherEvent.getExactLocation()).ifPresent(pm -> documentFeatures.add(pm));

	}

	/**

	 * @param exactLocation

	 * @param altitude

	 * @param locationType

	 * @param kindOfUnit

	 * @return

	 */

	private Placemark fieldUnitLocationMarker(Point exactLocation, Integer altitude, LocationType locationType,

			DefinedTerm kindOfUnit) {

		Placemark mapMarker = KmlFactory.createPlacemark();

		de.micromata.opengis.kml.v_2_2_0.Point point = KmlFactory.createPoint();

		point.setAltitudeMode(AltitudeMode.ABSOLUTE);

		if (altitude != null) {

			point.setCoordinates(Arrays.asList(KmlFactory.createCoordinate(exactLocation.getLongitude(),

					exactLocation.getLatitude(), altitude.doubleValue())));

		} else {

			point.setCoordinates(Arrays

					.asList(KmlFactory.createCoordinate(exactLocation.getLongitude(), exactLocation.getLatitude())));

		}

		mapMarker.setGeometry(point);

		mapMarker.setStyleUrl(styleURL(locationType, kindOfUnit));

		return mapMarker;

	}

	private Optional<Placemark> errorRadiusPlacemark(Point exactLocation) {

		// exactLocation.setErrorRadius(25 * 1000); // METER // uncomment for debugging

		Placemark errorRadiusCicle = null;

		if (exactLocation.getErrorRadius() != null && exactLocation.getErrorRadius() > 0) {

			errorRadiusCicle = KmlFactory.createPlacemark();

			LinearRing cirle = createKMLCircle(exactLocation.getLongitude(), exactLocation.getLatitude(),

					exactLocation.getErrorRadius());

			Polygon polygon = errorRadiusCicle.createAndSetPolygon();

			polygon.createAndSetOuterBoundaryIs().setLinearRing(cirle);

			polygon.setExtrude(true);

			errorRadiusCicle.setStyleUrl(errorRadiusStyleURL());

		}

		return Optional.ofNullable(errorRadiusCicle);

	}

	/**

	 * @param longitude

	 * @param latitude

	 * @param errorRadiusMeter

	 * @return

	 */

	private LinearRing createKMLCircle(Double longitude, Double latitude, Integer errorRadiusMeter) {

		GeometryBuilder.CircleMethod method = GeometryBuilder.CircleMethod.reprojectedCircle;

		LinearRing lineString = KmlFactory.createLinearRing();

		lineString.setAltitudeMode(AltitudeMode.RELATIVE_TO_GROUND);

		org.locationtech.jts.geom.Geometry polygonGeom = null;

		GeometryBuilder gb = new GeometryBuilder();

		try {

			switch (method) {

			case simpleCircle:

				// this is the best method so far !!!!

				polygonGeom = gb.simpleCircle(Quantities.getQuantity(errorRadiusMeter.doubleValue(), SI.METRE),

						latitude, longitude);

				break;

			case simpleCircleSmall:

				// Only suitable for small radius (> 1000 m) as the circles are heavily distorted

				// otherwise.

				polygonGeom = gb.simpleCircleSmall(errorRadiusMeter.doubleValue(), latitude, longitude);

				break;

			case circle:

				// fails

				polygonGeom = gb.circle(errorRadiusMeter.doubleValue(), latitude, longitude);

				break;

			case reprojectedCircle:

				// incomplete

				SimpleFeature pointFeature = gb.createSimplePointFeature(longitude, latitude);

				polygonGeom = gb.bufferFeature(pointFeature, errorRadiusMeter.doubleValue());

				break;

			}

			for (Coordinate coordinate : polygonGeom.getCoordinates()) {

				lineString.addToCoordinates(coordinate.getX(), coordinate.getY());

			}

		} catch (FactoryException e) {

			logger.error("Polygon creation for error radius failed", e);

		} catch (SchemaException e) {

			logger.error("SimplePointFeature creation failed", e);

		}

		return lineString;

	}

	private void addExtendedData(Placemark mapMarker, SpecimenOrObservationBase sob, GatheringEvent gatherEvent) {

		String name = "";

		if(sob.getRecordBasis() != null) {

			name = sob.getRecordBasis().name();

		} else {

			name = SpecimenOrObservationType.Unknown.name();

		}

		String titleCache = sob.getTitleCache();

		String locationString = null;

		if(gatherEvent.getExactLocation() != null) {

			locationString = gatherEvent.getExactLocation().toSexagesimalString(false,  true);

			titleCache = titleCache.replace(locationString + ", ", "");

		}

		String description = "<p class=\"title-cache\">" + titleCache 

				+ " <a class=\"specimen-link\" href=\"${specimen-link-base-url}/" + sob.getUuid() + "\">${specimen-link-text}</a>"

				+ "</p>";

		if(locationString != null) {

			// see https://www.mediawiki.org/wiki/GeoHack

			description += "<p class=\"exact-location\"><a target=\"geohack\" href=\"https://tools.wmflabs.org/geohack/en/" + 

		gatherEvent.getExactLocation().getLatitude() + ";" + gatherEvent.getExactLocation().getLongitude() +"?pagename=" + name + "\">" + locationString + "</a></p>";

		}

		// mapMarker.setName(name);

		mapMarker.setDescription(description);

		ExtendedData extendedData = mapMarker.createAndSetExtendedData();

		extendedData.createAndAddData(sob.getTitleCache()).setName("titleCache");

		if(mapMarker.getGeometry() != null && mapMarker.getGeometry() instanceof de.micromata.opengis.kml.v_2_2_0.Point) {

			extendedData.createAndAddData(((de.micromata.opengis.kml.v_2_2_0.Point)mapMarker.getGeometry()).getCoordinates().toString()).setName("Location");

		}

	}

	private String styleURL(LocationType locationType, DefinedTerm kindOfUnit) {

		String key = "";

		if (locationType != null) {

			key += locationType.name();

		}

		if (kindOfUnit != null) {

			key += kindOfUnit.getUuid();

		}

		if (!styles.containsKey(key)) {

			Style style = KmlFactory.createStyle().withIconStyle(MapMarkerIcons.red_blank.asIconStyle());

			style.setId(key);

			styles.put(key, style);

		}

		return "#" + key;

	}

	private String errorRadiusStyleURL() {

		String key = "ERROR_RADIUS";

		if (!styles.containsKey(key)) {

			Style style = KmlFactory.createStyle();

			PolyStyle polyStyle = style.createAndSetPolyStyle();

			polyStyle.setColor("100000ee"); // aabbggrr, where aa=alpha (00 to ff); bb=blue (00 to ff); gg=green (00 to ff); rr=red (00 to ff).

			polyStyle.setFill(true);

			polyStyle.setOutline(true);

			style.setId(key);

			LineStyle lineStyle = style.createAndSetLineStyle();

			// lineStyle.setColor("ff880088"); // aabbggrr, where aa=alpha (00 to ff);

			// bb=blue (00 to ff); gg=green (00 to ff); rr=red (00 to ff).

			lineStyle.setWidth(1);

			styles.put(key, style);

		}

		return "#" + key;

	}

	// TODO use also for .EditGeoService.registerDerivedUnitLocations(DerivedUnit

	// derivedUnit, List<Point> derivedUnitPoints) !!!!!!!!!

	public boolean isValidPoint(Point point) {

		if (point == null) {

			return false;

		}

		// points with no longitude or latitude should not exist

		// see #4173 ([Rule] Longitude and Latitude in Point must not be null)

		if (point.getLatitude() == null || point.getLongitude() == null) {

			return false;

		}

		// FIXME: remove next statement after

		// DerivedUnitFacade or ABCD import is fixed

		//

		if (point.getLatitude() == 0.0 || point.getLongitude() == 0.0) {

			return false;

		}

		return true;

	}

	public enum LocationType {

		FIELD_UNIT, DERIVED_UNIT;

	}

}

/**

 * Copyright (C) 2020 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.ext.geo.kml;

import java.net.MalformedURLException;

import java.net.URL;

import de.micromata.opengis.kml.v_2_2_0.ColorMode;

import de.micromata.opengis.kml.v_2_2_0.IconStyle;

import de.micromata.opengis.kml.v_2_2_0.KmlFactory;

import de.micromata.opengis.kml.v_2_2_0.Units;

import de.micromata.opengis.kml.v_2_2_0.Vec2;

/**

 * 

 * MOre icons at http://kml4earth.appspot.com/icons.html

 * 

 * @author Andreas Kohlbecker

 * @since Apr 21, 2020

 */

public enum MapMarkerIcons {

	blu_blank("http://maps.google.com/mapfiles/kml/paddle/blu-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	blu_circle("http://maps.google.com/mapfiles/kml/paddle/blu-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	blu_diamond("http://maps.google.com/mapfiles/kml/paddle/blu-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	blu_square("http://maps.google.com/mapfiles/kml/paddle/blu-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	blu_stars("http://maps.google.com/mapfiles/kml/paddle/blu-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	grn_blank("http://maps.google.com/mapfiles/kml/paddle/grn-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	grn_circle("http://maps.google.com/mapfiles/kml/paddle/grn-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	grn_diamond("http://maps.google.com/mapfiles/kml/paddle/grn-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	grn_square("http://maps.google.com/mapfiles/kml/paddle/grn-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	grn_stars("http://maps.google.com/mapfiles/kml/paddle/grn-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ltblu_blank("http://maps.google.com/mapfiles/kml/paddle/ltblu-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ltblu_circle("http://maps.google.com/mapfiles/kml/paddle/ltblu-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ltblu_diamond("http://maps.google.com/mapfiles/kml/paddle/ltblu-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ltblu_square("http://maps.google.com/mapfiles/kml/paddle/ltblu-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ltblu_stars("http://maps.google.com/mapfiles/kml/paddle/ltblu-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	pink_blank("http://maps.google.com/mapfiles/kml/paddle/pink-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	pink_circle("http://maps.google.com/mapfiles/kml/paddle/pink-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	pink_diamond("http://maps.google.com/mapfiles/kml/paddle/pink-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	pink_square("http://maps.google.com/mapfiles/kml/paddle/pink-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	pink_stars("http://maps.google.com/mapfiles/kml/paddle/pink-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	purple_blank("http://maps.google.com/mapfiles/kml/paddle/purple-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	purple_circle("http://maps.google.com/mapfiles/kml/paddle/purple-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	purple_diamond("http://maps.google.com/mapfiles/kml/paddle/purple-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	purple_square("http://maps.google.com/mapfiles/kml/paddle/purple-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	purple_stars("http://maps.google.com/mapfiles/kml/paddle/purple-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	red_blank("http://maps.google.com/mapfiles/kml/paddle/red-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	red_circle("http://maps.google.com/mapfiles/kml/paddle/red-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	red_diamond("http://maps.google.com/mapfiles/kml/paddle/red-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	red_square("http://maps.google.com/mapfiles/kml/paddle/red-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	red_stars("http://maps.google.com/mapfiles/kml/paddle/red-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ylw_blank("http://maps.google.com/mapfiles/kml/paddle/ylw-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ylw_circle("http://maps.google.com/mapfiles/kml/paddle/ylw-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ylw_diamond("http://maps.google.com/mapfiles/kml/paddle/ylw-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ylw_square("http://maps.google.com/mapfiles/kml/paddle/ylw-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	ylw_stars("http://maps.google.com/mapfiles/kml/paddle/ylw-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	orange_blank("http://maps.google.com/mapfiles/kml/paddle/orange-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	orange_circle("http://maps.google.com/mapfiles/kml/paddle/orange-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	orange_diamond("http://maps.google.com/mapfiles/kml/paddle/orange-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	orange_square("http://maps.google.com/mapfiles/kml/paddle/orange-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	orange_stars("http://maps.google.com/mapfiles/kml/paddle/orange-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	wht_blank("http://maps.google.com/mapfiles/kml/paddle/wht-blank.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	wht_circle("http://maps.google.com/mapfiles/kml/paddle/wht-circle.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	wht_diamond("http://maps.google.com/mapfiles/kml/paddle/wht-diamond.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	wht_square("http://maps.google.com/mapfiles/kml/paddle/wht-sqare.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	wht_stars("http://maps.google.com/mapfiles/kml/paddle/wht-stars.png", KmlFactory.createVec2().withX(0.5).withY(0).withXunits(Units.FRACTION).withYunits(Units.FRACTION)),

	sunny("http://maps.google.com/mapfiles/kml/shapes/sunny.png", null);

	URL url;

	Vec2 hotspot;

	MapMarkerIcons(String ulr, Vec2 hotspot) {

		try {

			this.url = new URL(ulr);

			if(hotspot != null) {

				this.hotspot = hotspot;

			}

		} catch (MalformedURLException e) {

			throw new RuntimeException(e);

		}

	}

	@Override

	public String toString() {

		return url.toString();

	}

	public Vec2 hotSpot() {

		return hotspot;

	}

	public IconStyle asIconStyle() {

		IconStyle iconStyle = KmlFactory.createIconStyle().withIcon(

				KmlFactory.createIcon().withHref(this.toString())

				);

		iconStyle.setScale(1);

		iconStyle.setHotSpot(hotspot);

		return iconStyle;

	}

}

package eu.etaxonomy.cdm.ext.kml;

import static org.junit.Assert.assertTrue;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.StringWriter;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;

import org.apache.commons.io.FileUtils;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.junit.Before;

import org.junit.Test;

import de.micromata.opengis.kml.v_2_2_0.Kml;

import eu.etaxonomy.cdm.ext.geo.kml.KMLDocumentBuilder;

import eu.etaxonomy.cdm.model.location.Point;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;

public class KmlJaxbMarshallerTest {

	Kml kml;

	Logger logger;

	@Before

	public void makeKML() {

		FieldUnit fu = FieldUnit.NewInstance();

		fu.setGatheringEvent(GatheringEvent.NewInstance());

		fu.getGatheringEvent().setExactLocation(Point.NewInstance(-112.292238941097, 36.09520916122063, null, null));

		KMLDocumentBuilder builder = new KMLDocumentBuilder();

		builder.addSpecimenOrObservationBase(fu);

		kml = builder.build();

		logger = Logger.getLogger(this.getClass());

		logger.setLevel(Level.DEBUG);

	}

	@Test

	public void marshallTest() throws JAXBException, IOException {

		JAXBContext jaxbContext = JAXBContext.newInstance(Kml.class);

		Marshaller marshaller = jaxbContext.createMarshaller();

		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

		StringWriter sw = new StringWriter();

		marshaller.marshal(kml, sw);

		String kml = sw.toString();

		if(logger.isDebugEnabled()) {

			logger.debug("kml:\n" + kml);

			FileUtils.write(new File("KmlJaxbMarshallerTest.kml"), kml);

		}

		assertTrue(kml.contains("<kml:Document>"));

		assertTrue(kml.contains("<kml:Point>"));

		assertTrue(kml.contains("<kml:coordinates>-112.292238941097,36.09520916122063</kml:coordinates>"));

		assertTrue(kml.contains("<kml:altitudeMode>absolute</kml:altitudeMode>"));

	}

}

	@Bean

	@DependsOn({ "requestMappingHandlerAdapter" })

	public XmlViewResolver getOaiXmlViewResolver() {

		XmlViewResolver resolver = new XmlViewResolver();

		resolver.setOrder(1);

		resolver.setLocation(new ServletContextResource(servletContext, "/WEB-INF/oai-views.xml"));

		resolver.setCache(XML_VIEW_CACHING);

		return resolver;

	}

	@Bean

	@DependsOn({ "requestMappingHandlerAdapter" })

	public XmlViewResolver kmlXmlViewResolver() {

		XmlViewResolver resolver = new PatternViewResolver();

		resolver.setOrder(1);

		resolver.setLocation(new ServletContextResource(servletContext, "/WEB-INF/kml-views.xml"));

		resolver.setCache(XML_VIEW_CACHING);

		return resolver;

	}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <!--

        ===============================================================

        This is the configuration file for a

        eu.etaxonomy.cdm.remote.view.XMLViewResolver

        ===============================================================

    -->

    <bean name="**/kml/** **/kml/*" class="org.springframework.web.servlet.view.xml.MarshallingView">

        <property name="contentType" value="text/xml; charset=UTF-8"/>

        <property name="marshaller" ref="kmlMarshaller"/><!-- see /cdmlib-remote/src/main/resources/eu/etaxonomy/cdm/remote.xml -->

    </bean>

</beans>

package eu.etaxonomy.cdm.remote.controller;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.CrossOrigin;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

@CrossOrigin(origins = "*", maxAge = 3600)

@Controller

public class OptionsController {

	@RequestMapping(

            value = "/**",

            method = RequestMethod.OPTIONS

    )

    public ResponseEntity handle() {

        return new ResponseEntity(HttpStatus.OK);

    }

}

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.CrossOrigin;

import org.springframework.web.bind.annotation.RestController;

    public OccurrenceServiceRequestParameterDto doGetOccurrenceMapUriParams(

        Map<SpecimenOrObservationType, Color> specimenOrObservationTypeColors = null;

        List<SpecimenOrObservationBase> specimensOrObersvations = occurencesForTaxon(uuid, relationshipUuids,

				relationshipInversUuids, maxDepth, response);

        OccurrenceServiceRequestParameterDto dto = geoservice.getOccurrenceServiceRequestParameters(specimensOrObersvations,

                specimenOrObservationTypeColors );

        return dto;

    }

	private List<SpecimenOrObservationBase> occurencesForTaxon(UUID taxonUuid, UuidList relationshipUuids,

			UuidList relationshipInversUuids, Integer maxDepth, HttpServletResponse response) throws IOException {

		Set<TaxonRelationshipEdge> includeRelationships = ControllerUtils.loadIncludeRelationships(

        Taxon taxon = getCdmBaseInstance(Taxon.class, taxonUuid, response, (List<String>)null);

		return specimensOrObersvations;

	}

/**

 * Copyright (C) 2009 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.remote.controller.ext;

import java.awt.Color;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.WebDataBinder;

import org.springframework.web.bind.annotation.CrossOrigin;

import org.springframework.web.bind.annotation.InitBinder;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import de.micromata.opengis.kml.v_2_2_0.Kml;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge;

import eu.etaxonomy.cdm.database.UpdatableRoutingDataSource;

import eu.etaxonomy.cdm.ext.geo.IEditGeoService;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;

import eu.etaxonomy.cdm.remote.controller.BaseController;

import eu.etaxonomy.cdm.remote.controller.util.ControllerUtils;

import eu.etaxonomy.cdm.remote.editor.DefinedTermBaseList;

import eu.etaxonomy.cdm.remote.editor.TermBaseListPropertyEditor;

import eu.etaxonomy.cdm.remote.editor.UUIDListPropertyEditor;

import eu.etaxonomy.cdm.remote.editor.UuidList;

import io.swagger.annotations.Api;

/**

 * The ExternalGeoController class is a Spring MVC Controller.

 * <p>

 * The syntax of the mapped service URIs contains the the {datasource-name} path element.

 * The available {datasource-name}s are defined in a configuration file which

 * is loaded by the {@link UpdatableRoutingDataSource}. If the

 * UpdatableRoutingDataSource is not being used in the actual application

 * context any arbitrary {datasource-name} may be used.

 * <p>

 * @author a.kohlbecker

 * @since 18.06.2009

 *

 */

@CrossOrigin(origins = "*")

@Controller

@Api(value="mapServiceParameters")

@RequestMapping(value = { "kml" })

public class KmlController extends BaseController<TaxonBase, ITaxonService> {

    public static final Logger logger = Logger.getLogger(KmlController.class);

    @Autowired

    private IEditGeoService geoservice;

    @Autowired

    private IOccurrenceService occurrenceService;

    @Autowired

    private ITermService termService;

    @InitBinder

    @Override

    public void initBinder(WebDataBinder binder) {

        super.initBinder(binder);

        binder.registerCustomEditor(UuidList.class, new UUIDListPropertyEditor());

        binder.registerCustomEditor(DefinedTermBaseList.class, new TermBaseListPropertyEditor<MarkerType>(termService));

    }

    @Autowired

    @Override

    public void setService(ITaxonService service) {

        this.service = service;

    }

    /**

     * Assembles and returns URI parameter Strings for the EDIT Map Service. The distribution areas for the

     * {@link Taxon} instance identified by the <code>{taxon-uuid}</code> are found and are translated into

     * an valid URI parameter String. Higher level distribution areas are expanded in order to include all

     * nested sub-areas.

     * <p>

     * URI: <b>&#x002F;{datasource-name}&#x002F;geo&#x002F;map&#x002F;distribution&#x002F;{taxon-uuid}</b>

     *

     * @param request

     * @param response

     * @return URI parameter Strings for the EDIT Map Service

     * @throws IOException TODO write controller method documentation

     */

    @RequestMapping(value = { "taxonOccurrencesFor/{uuid}" }, method = RequestMethod.GET)

    public Kml doGetOccurrenceKml(

            @PathVariable("uuid") UUID uuid,

            @RequestParam(value = "relationships", required = false) UuidList relationshipUuids,

            @RequestParam(value = "relationshipsInvers", required = false) UuidList relationshipInversUuids,

            @RequestParam(value = "maxDepth", required = false) Integer maxDepth,

            HttpServletRequest request,

            HttpServletResponse response)

            throws IOException {

        logger.info("doGetOccurrenceKml() " + requestPathAndQuery(request));

        Map<SpecimenOrObservationType, Color> specimenOrObservationTypeColors = null;

        List<SpecimenOrObservationBase> specimensOrObersvations = occurencesForTaxon(uuid, relationshipUuids,

				relationshipInversUuids, maxDepth, response);

        Kml kml = geoservice.occurrencesToKML(specimensOrObersvations, specimenOrObservationTypeColors);

        return kml;

    }

	private List<SpecimenOrObservationBase> occurencesForTaxon(UUID taxonUuid, UuidList relationshipUuids,

			UuidList relationshipInversUuids, Integer maxDepth, HttpServletResponse response) throws IOException {

		Set<TaxonRelationshipEdge> includeRelationships = ControllerUtils.loadIncludeRelationships(

                relationshipUuids, relationshipInversUuids, termService);

        Taxon taxon = getCdmBaseInstance(Taxon.class, taxonUuid, response, (List<String>)null);

        List<OrderHint> orderHints = new ArrayList<OrderHint>();

        orderHints.add(new OrderHint("titleCache", SortOrder.DESCENDING));

        List<SpecimenOrObservationBase> specimensOrObersvations = occurrenceService.listByAssociatedTaxon(

                null, includeRelationships, taxon, maxDepth, null, null, orderHints, null);

		return specimensOrObersvations;

	}

}

 * View class which serializes objects as xml

 * 

 * @deprecated use {@link org.springframework.web.servlet.view.xml.MarshallingView} instead

@Deprecated

   <bean id="kmlMarshaller" name="kmlMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">

    <property name="classesToBeBound">

      <list>

        <value>de.micromata.opengis.kml.v_2_2_0.Kml</value>

      </list>

    </property>

   	<property name="checkForXmlRootElement" value="false" />

   	<property name="marshallerProperties">

      <map>

        <entry key="jaxb.formatted.output"><value type="java.lang.Boolean">true</value></entry>

      </map>

    </property>

   </bean>