com.github.davidmoten.grumpy.wms.RendererUtil Maven / Gradle / Ivy

Go to download
package com.github.davidmoten.grumpy.wms;

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;

import com.github.davidmoten.grumpy.core.Position;
import com.github.davidmoten.grumpy.projection.Projector;

public class RendererUtil {

    public static void useAntialiasing(Graphics2D g) {
        RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        renderHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        renderHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g.addRenderingHints(renderHints);
    }

    public static List toPathGreatCircle(Projector projector, List positions) {
        return toPath(projector, Position.interpolateLongitude(positions));
    }

    public static List toPath(Projector projector, List positions) {
        List list = new ArrayList();

        if (positions.size() < 2)
            throw new RuntimeException("must provide at least two positions");

        list.add(createPath(projector, positions, 0));
        list.add(createPath(projector, positions, -projector.periodAtLat(0)));
        list.add(createPath(projector, positions, projector.periodAtLat(0)));

        return list;
    }

    private static List getPathPoints(Projector projector,
            List positions, double deltaX) {
        List list = new ArrayList();
        Double firstPointLat = null;
        Double firstPointLon = null;
        org.locationtech.jts.geom.Point firstPoint = null;
        for (Position pos : positions) {
            Position p = pos.normalizeLongitude();
            if (firstPoint == null) {
                firstPoint = projector.getFirstXAfter(projector, p.getLat(), p.getLon(), projector
                        .getBounds().getMinX() + deltaX);
                firstPointLat = p.getLat();
                firstPointLon = p.getLon();
                list.add(firstPoint);
            } else {
                org.locationtech.jts.geom.Point point = projector
                        .getGeometryPointInSrsRelativeTo(p.getLat(), p.getLon(), firstPointLat,
                                firstPointLon, firstPoint.getX(), firstPoint.getY());
                list.add(point);
            }
        }
        return list;
    }

    private static GeneralPath createPath(Projector projector, List positions,
            double deltaX) {
        List points = getPathPoints(projector, positions, deltaX);
        GeneralPath path = new GeneralPath();
        boolean first = true;
        for (org.locationtech.jts.geom.Point point : points) {
            Point2D.Double pt = projector.getTargetPoint(point);
            if (first) {
                path.moveTo(pt.x, pt.y);
                first = false;
            } else
                path.lineTo(pt.x, pt.y);
        }
        return path;
    }

    public static Point2D[] getPoints(Projector projector, List positions) {
        List points = new ArrayList();
        for (Position position : positions)
            points.add(projector.toPoint2D(position.getLat(), position.getLon()));
        return points.toArray(new Point2D[] {});
    }

    public static List getCircle(Position position, double radiusKm, double numPoints) {

        List positions = new ArrayList();
        for (int i = 0; i < numPoints; i++) {
            double bearing = 360.0 * i / numPoints;
            Position p = position.predict(radiusKm, bearing).normalizeLongitude();
            positions.add(p);
        }
        positions.add(positions.get(0));
        return positions;
    }

    public static void draw(Graphics2D g, List shapes) {
        for (Shape shape : shapes)
            g.draw(shape);
    }

    public static void fill(Graphics2D g, List shapes) {
        for (Shape shape : shapes)
            g.fill(shape);
    }

}