Examples with Area de.fhg.igd.mapviewer.marker.area.Area used on opensource projects

Example 6 with Area

use of de.fhg.igd.mapviewer.marker.area.Area in project hale by halestudio.

the class AbstractMarker method paint.

/**
 * @see Marker#paint(Graphics2D, PixelConverter, int, Object, Rectangle)
 */
@Override
public void paint(Graphics2D g, PixelConverter converter, int zoom, T context, Rectangle gBounds) {
    synchronized (areas) {
        if (!areas.containsKey(zoom)) {
            Area area = paintMarker(g, context, converter, zoom, gBounds, true);
            areas.put(zoom, area);
            return;
        }
    }
    paintMarker(g, context, converter, zoom, gBounds, false);
}

Example 7 with Area

use of de.fhg.igd.mapviewer.marker.area.Area in project hale by halestudio.

the class CustomWaypointPainter method findWaypoint.

/**
 * Find a way-point at a given position
 *
 * @param point the position
 * @return the way-point
 */
public W findWaypoint(Point point) {
    Rectangle viewPort = getMapKit().getMainMap().getViewportBounds();
    // the overlap is the reason why
    final int overlap = getMaxOverlap();
    // the point is used instead of
    // a GeoPosition
    final int x = viewPort.x + point.x;
    final int y = viewPort.y + point.y;
    final int zoom = getMapKit().getMainMap().getZoom();
    final PixelConverter converter = getMapKit().getMainMap().getTileFactory().getTileProvider().getConverter();
    final Dimension mapSize = TileProviderUtils.getMapSize(getMapKit().getMainMap().getTileFactory().getTileProvider(), zoom);
    final int width = mapSize.width * getMapKit().getMainMap().getTileFactory().getTileProvider().getTileWidth(zoom);
    final int height = mapSize.height * getMapKit().getMainMap().getTileFactory().getTileProvider().getTileHeight(zoom);
    final GeoPosition topLeft = converter.pixelToGeo(new Point(Math.max(x - overlap, 0), Math.max(y - overlap, 0)), zoom);
    final GeoPosition bottomRight = converter.pixelToGeo(new Point(Math.min(x + overlap, width), Math.min(y + overlap, height)), zoom);
    BoundingBox searchBox;
    try {
        searchBox = createSearchBB(topLeft, bottomRight);
        Set<W> wps = waypoints.query(searchBox, new Verifier<W, BoundingBox>() {

            @Override
            public boolean verify(W wp, BoundingBox box) {
                try {
                    Point2D wpPixel = converter.geoToPixel(wp.getPosition(), zoom);
                    int relX = x - (int) wpPixel.getX();
                    int relY = y - (int) wpPixel.getY();
                    Area area = wp.getMarker().getArea(zoom);
                    if (area != null && area.contains(relX, relY)) {
                        // match
                        return true;
                    }
                } catch (IllegalGeoPositionException e) {
                    // $NON-NLS-1$
                    log.debug("Error converting waypoint position", e);
                }
                return false;
            }
        });
        if (wps == null || wps.isEmpty()) {
            return null;
        } else {
            if (wps.size() == 1) {
                return wps.iterator().next();
            } else {
                List<W> sorted = new ArrayList<W>(wps);
                Collections.sort(sorted, new Comparator<W>() {

                    @Override
                    public int compare(W o1, W o2) {
                        double a1 = o1.getMarker().getArea(zoom).getArea();
                        double a2 = o2.getMarker().getArea(zoom).getArea();
                        // compare size
                        if (a1 < a2) {
                            return -1;
                        } else if (a2 < a1) {
                            return 1;
                        } else {
                            return 0;
                        }
                    }
                });
                return sorted.get(0);
            }
        }
    } catch (IllegalGeoPositionException e) {
        return null;
    }
}

Example 8 with Area

use of de.fhg.igd.mapviewer.marker.area.Area in project hale by halestudio.

the class CustomWaypointPainter method findWaypoints.

/**
 * Find way-points in a rectangular area defined by the given
 * {@link GeoPosition}s
 *
 * @param topLeft the top left position
 * @param bottomRight the bottom right position
 * @param worldRect the bounding box in world pixel coordinates
 * @param converter the pixel converter
 * @param zoom the zoom level
 *
 * @return the way-points in the area
 */
public Set<W> findWaypoints(GeoPosition topLeft, GeoPosition bottomRight, final Rectangle worldRect, final PixelConverter converter, final int zoom) {
    BoundingBox searchBox;
    try {
        searchBox = createSearchBB(topLeft, bottomRight);
        final BoundingBox verifyBox = searchBox;
        Set<W> wps = waypoints.query(searchBox, new Verifier<W, BoundingBox>() {

            @Override
            public boolean verify(W wp, BoundingBox second) {
                try {
                    Point2D wpPixel = converter.geoToPixel(wp.getPosition(), zoom);
                    int dx = (int) wpPixel.getX();
                    int dy = (int) wpPixel.getY();
                    worldRect.translate(-dx, -dy);
                    try {
                        Area area = wp.getMarker().getArea(zoom);
                        if (area != null) {
                            return area.containedIn(worldRect);
                        } else {
                            // not be selected
                            return false;
                        }
                    } finally {
                        worldRect.translate(dx, dy);
                    }
                } catch (IllegalGeoPositionException e) {
                    log.warn("Could not convert waypoint position to pixel", e);
                    // fall back to simple method
                    return verifyBox.covers(wp.getBoundingBox());
                }
            }
        });
        if (wps == null) {
            return new HashSet<W>();
        } else {
            return wps;
        }
    } catch (IllegalGeoPositionException e) {
        return new HashSet<W>();
    }
}

Example 9 with Area

use of de.fhg.igd.mapviewer.marker.area.Area in project hale by halestudio.

the class InstanceMarker method paintLine.

/**
 * Paint a line string geometry.
 *
 * @param geometry the line string
 * @param g the graphics object to paint on
 * @param crsDefinition the CRS definition associated to the geometry
 * @param context the context
 * @param converter the pixel converter
 * @param zoom the zoom level
 * @param mapCRS the map coordinate reference system
 * @param calculateArea if the area representing the marker should be
 *            calculated, if <code>false</code> is given here the return
 *            value is ignored and should be <code>null</code>
 * @return the polygon area or <code>null</code> if painting failed
 */
protected Area paintLine(LineString geometry, Graphics2D g, CRSDefinition crsDefinition, InstanceWaypoint context, PixelConverter converter, int zoom, CoordinateReferenceSystem mapCRS, boolean calculateArea) {
    Coordinate[] coordinates = geometry.getCoordinates();
    if (coordinates.length <= 0) {
        return null;
    }
    if (coordinates.length == 1) {
        // fall back to point drawing
        Point point = getGeometryFactory().createPoint(coordinates[0]);
        return paintPoint(point, g, crsDefinition, context, converter, zoom, mapCRS, calculateArea);
    }
    try {
        // get CRS converter
        CRSConverter conv = CRSConverter.getConverter(crsDefinition.getCRS(), mapCRS);
        List<Point2D> mapPoints = new ArrayList<Point2D>(coordinates.length);
        for (Coordinate coord : coordinates) {
            // manually convert to map CRS
            Point3D mapPoint = conv.convert(coord.x, coord.y, 0);
            GeoPosition pos = new GeoPosition(mapPoint.getX(), mapPoint.getY(), converter.getMapEpsg());
            Point2D point = converter.geoToPixel(pos, zoom);
            mapPoints.add(point);
        }
        if (applyStroke(g, context)) {
            for (int i = 0; i < mapPoints.size() - 1; i++) {
                // draw each connecting line
                Point2D p1 = mapPoints.get(i);
                Point2D p2 = mapPoints.get(i + 1);
                g.drawLine((int) p1.getX(), (int) p1.getY(), (int) p2.getX(), (int) p2.getY());
            }
        } else {
            log.warn("Stroke disabled in style, LineString is not rendered");
        }
        if (!calculateArea) {
            return null;
        }
        // use a buffer around the line as area
        // XXX
        java.awt.Polygon[] buffer = createBufferPolygon(mapPoints, 3);
        // ok?
        if (buffer.length == 0) {
            return null;
        } else if (buffer.length == 1) {
            return new PolygonArea(buffer[0]);
        } else {
            Collection<Area> areas = new ArrayList<Area>();
            for (java.awt.Polygon bufferPoly : buffer) {
                areas.add(new PolygonArea(bufferPoly));
            }
            return new MultiArea(areas);
        }
    } catch (Exception e) {
        log.error("Error painting instance polygon geometry", e);
        return null;
    }
}

Example 10 with Area

use of de.fhg.igd.mapviewer.marker.area.Area in project hale by halestudio.

the class InstanceMarker method doPaintMarker.

/**
 * @see BoundingBoxMarker#doPaintMarker(Graphics2D, SelectableWaypoint,
 *      PixelConverter, int, int, int, int, int, Rectangle, boolean)
 */
@Override
protected Area doPaintMarker(Graphics2D g, InstanceWaypoint context, PixelConverter converter, int zoom, int minX, int minY, int maxX, int maxY, Rectangle gBounds, boolean calulateArea) {
    List<Area> areas = (!calulateArea) ? (null) : (new ArrayList<Area>());
    List<GeometryProperty<?>> geometries = context.getGeometries();
    // map CRS
    CoordinateReferenceSystem mapCRS;
    try {
        mapCRS = CRSDecode.getLonLatCRS(converter.getMapEpsg());
    // map (GeoPosition) assumes lon/lat order
    } catch (Throwable e) {
        log.error("Could not decode map CRS", e);
        return null;
    }
    // paint each geometry
    for (GeometryProperty<?> geometry : geometries) {
        Area geometryArea = paintGeometry(g, geometry.getCRSDefinition(), geometry.getGeometry(), context, converter, zoom, geometries.size() == 1, gBounds, mapCRS, calulateArea);
        if (areas != null && geometryArea != null) {
            areas.add(geometryArea);
        }
    }
    if (areas == null) {
        return null;
    }
    if (areas.size() == 1) {
        return areas.get(0);
    } else if (!areas.isEmpty()) {
        return new MultiArea(areas);
    }
    return null;
}