Example usage for java.awt.geom Path2D.Double moveTo

List of usage examples for java.awt.geom Path2D.Double moveTo

  1. HOME
  2. Java
  3. java
  4. java.awt.geom.*
  5. Path2D.Double
  6. moveTo

Introduction

In this page you can find the example usage for java.awt.geom Path2D.Double moveTo.

Prototype

public abstract void moveTo(double x, double y);

Source Link

Document

Adds a point to the path by moving to the specified coordinates specified in double precision.

Usage

From source file:com.hp.autonomy.frontend.reports.powerpoint.PowerPointServiceImpl.java

/**
 * Internal implementation to add an image (a world map, though other image data is also fine) to a slide.
 *   Preserves the original image's aspect ratio, leaving blank space below and to the sides of the image.
 * @param slide the slide to add to./*  ww  w.j  a  v a 2 s. c  o  m*/
 * @param anchor bounding rectangle to draw onto, in PowerPoint coordinates.
 * @param picture the picture data.
 * @param markers an array of markers to draw over the map.
 * @param polygons
 * @return the picture shape object added to the slide.
 */
private static XSLFPictureShape addMap(final XSLFSlide slide, final Rectangle2D.Double anchor,
        final XSLFPictureData picture, final Marker[] markers, final MapData.Polygon[] polygons) {
    double tgtW = anchor.getWidth(), tgtH = anchor.getHeight();

    final Dimension size = picture.getImageDimension();
    final double ratio = size.getWidth() / size.getHeight();

    if (ratio > tgtW / tgtH) {
        // source image is wider than target, clip fixed width variable height
        tgtH = tgtW / ratio;
    } else {
        tgtW = tgtH * ratio;
    }

    final XSLFPictureShape canvas = slide.createPicture(picture);
    // Vertically align top, horizontally-align center
    final double offsetX = anchor.getMinX() + 0.5 * (anchor.getWidth() - tgtW), offsetY = anchor.getMinY();
    canvas.setAnchor(new Rectangle2D.Double(offsetX, offsetY, tgtW, tgtH));

    if (polygons != null) {
        for (MapData.Polygon polygon : polygons) {
            final Color color = Color.decode(polygon.getColor());
            final double[][] shapes = polygon.getPoints();
            // The ESRI spec version 1.2.1 from http://www.opengeospatial.org/standards/sfa has section 6.1.11.1,
            //    which defines polygons as follows:
            /// A Polygon is a planar Surface defined by 1 exterior boundary and 0 or more interior boundaries.
            //    Each interior boundary defines a hole in the Polygon. A Triangle is a polygon with 3 distinct,
            //    non-collinear vertices and no interior boundary.
            /// The exterior boundary LinearRing defines the top? of the surface which is the side of the surface
            //    from which the exterior boundary appears to traverse the boundary in a counter clockwise direction.
            //    The interior LinearRings will have the opposite orientation, and appear as clockwise
            //    when viewed from the top?
            // so it's even-odd winding (whereas the Path2D default is non-zero-winding).
            final Path2D.Double path = new Path2D.Double(Path2D.WIND_EVEN_ODD);

            for (final double[] points : shapes) {
                for (int ii = 0; ii < points.length; ii += 2) {
                    final double x1 = offsetX + points[ii] * tgtW;
                    final double y1 = offsetY + points[ii + 1] * tgtH;
                    if (ii == 0) {
                        path.moveTo(x1, y1);
                    } else {
                        path.lineTo(x1, y1);
                    }
                }
                path.closePath();
            }

            final XSLFFreeformShape freeform = slide.createFreeform();
            freeform.setPath(path);
            freeform.setStrokeStyle(0.5);
            // There's a 0.5 alpha transparency on the stroke, and a 0.2 alpha transparency on the polygon fill.
            freeform.setLineColor(transparentColor(color, 128));
            freeform.setFillColor(transparentColor(color, 51));

            if (StringUtils.isNotEmpty(polygon.getText())) {
                final PackageRelationship rel = freeform.getSheet().getPackagePart().addRelationship(
                        slide.getPackagePart().getPartName(), TargetMode.INTERNAL,
                        XSLFRelation.SLIDE.getRelation());
                // We create a hyperlink which links back to this slide; so we get hover-over-detail-text on the polygon
                final CTHyperlink link = ((CTShape) freeform.getXmlObject()).getNvSpPr().getCNvPr()
                        .addNewHlinkClick();
                link.setTooltip(polygon.getText());
                link.setId(rel.getId());
                link.setAction("ppaction://hlinksldjump");
            }
        }
    }

    for (Marker marker : markers) {
        final Color color = Color.decode(marker.getColor());
        final double centerX = offsetX + marker.getX() * tgtW;
        final double centerY = offsetY + marker.getY() * tgtH;

        if (marker.isCluster()) {
            final XSLFGroupShape group = slide.createGroup();
            double halfMark = 10;
            double mark = halfMark * 2;
            double innerHalfMark = 7;
            double innerMark = innerHalfMark * 2;
            // align these so the middle is the latlng position
            final Rectangle2D.Double groupAnchor = new Rectangle2D.Double(centerX - halfMark,
                    centerY - halfMark, mark, mark);

            group.setAnchor(groupAnchor);
            group.setInteriorAnchor(groupAnchor);

            final XSLFAutoShape shape = group.createAutoShape();
            shape.setShapeType(ShapeType.ELLIPSE);
            final boolean fade = marker.isFade();
            // There's a 0.3 alpha transparency (255 * 0.3 is 76) when a marker is faded out
            final int FADE_ALPHA = 76;
            shape.setFillColor(transparentColor(color, fade ? 47 : 154));
            shape.setAnchor(groupAnchor);

            final XSLFAutoShape inner = group.createAutoShape();
            inner.setFillColor(fade ? transparentColor(color, FADE_ALPHA) : color);
            inner.setLineWidth(0.1);
            inner.setLineColor(new Color((int) (color.getRed() * 0.9), (int) (color.getGreen() * 0.9),
                    (int) (color.getBlue() * 0.9), fade ? FADE_ALPHA : 255));
            inner.setShapeType(ShapeType.ELLIPSE);
            inner.setHorizontalCentered(true);
            inner.setWordWrap(false);
            inner.setVerticalAlignment(VerticalAlignment.MIDDLE);
            inner.clearText();
            final XSLFTextParagraph para = inner.addNewTextParagraph();
            para.setTextAlign(TextParagraph.TextAlign.CENTER);
            final XSLFTextRun text = para.addNewTextRun();
            text.setFontSize(6.0);
            final Color fontColor = Color.decode(StringUtils.defaultString(marker.getFontColor(), "#000000"));
            text.setFontColor(fade ? transparentColor(fontColor, FADE_ALPHA) : fontColor);
            text.setText(marker.getText());
            inner.setAnchor(new Rectangle2D.Double(centerX - innerHalfMark, centerY - innerHalfMark, innerMark,
                    innerMark));
        } else {
            final XSLFGroupShape group = slide.createGroup();

            final XSLFFreeformShape shape = group.createFreeform();
            shape.setHorizontalCentered(true);
            shape.setWordWrap(false);

            shape.setVerticalAlignment(VerticalAlignment.BOTTOM);
            shape.setLineWidth(0.5);
            shape.setLineColor(color.darker());
            shape.setFillColor(transparentColor(color, 210));

            final double halfMark = 8, mark = halfMark * 2, extension = 0.85,
                    markerHeight = (0.5 + extension) * mark, angle = Math.asin(0.5 / extension) * 180 / Math.PI;

            // Set group position
            group.setAnchor(
                    new Rectangle2D.Double(centerX - halfMark, centerY - markerHeight, mark, markerHeight));
            group.setInteriorAnchor(new Rectangle2D.Double(0, 0, mark, markerHeight));

            // Draw a semicircle and a triangle to represent the marker, pointing at the precise x,y location
            final Path2D.Double path = new Path2D.Double();
            path.moveTo(halfMark, markerHeight);
            path.append(new Arc2D.Double(0, 0, mark, mark, -angle, 180 + angle + angle, Arc2D.OPEN), true);
            path.lineTo(halfMark, markerHeight);
            shape.setPath(path);
            shape.setAnchor(new Rectangle2D.Double(0, 0, mark, markerHeight));

            final XSLFAutoShape disc = group.createAutoShape();
            disc.setShapeType(ShapeType.DONUT);
            final double discRadius = 0.25 * mark;
            final double discDiameter = 2 * discRadius;
            disc.setAnchor(new Rectangle2D.Double(halfMark - discRadius, halfMark - discRadius, discDiameter,
                    discDiameter));
            disc.setFillColor(Color.WHITE);
            disc.setLineColor(Color.WHITE);

            if (StringUtils.isNotEmpty(marker.getText())) {
                final PackageRelationship rel = shape.getSheet().getPackagePart().addRelationship(
                        slide.getPackagePart().getPartName(), TargetMode.INTERNAL,
                        XSLFRelation.SLIDE.getRelation());
                // We create a hyperlink which links back to this slide; so we get hover-over-detail-text on the marker
                // Annoyingly, you can't put a link on the group, just on the individual shapes.
                for (XSLFShape clickable : group.getShapes()) {
                    final CTHyperlink link = ((CTShape) clickable.getXmlObject()).getNvSpPr().getCNvPr()
                            .addNewHlinkClick();
                    link.setTooltip(marker.getText());
                    link.setId(rel.getId());
                    link.setAction("ppaction://hlinksldjump");
                }
            }
        }
    }

    return canvas;
}

From source file:openlr.map.sqlite.impl.LineImpl.java

/**
 * Delivers the shape in form of a {@link Path2D}. This method is marked
 * deprecated in the OpenLR interface. It is implemented in an inefficient
 * way here to keep it working but clients should switch to the successor
 * method {@link #getShapeCoordinates()}!
 * /*from  w ww. ja v a 2  s .c o  m*/
 * @deprecated This method is kept but inefficient, please use  {@link #getShapeCoordinates()} instead! 
 */
@Override
@Deprecated
public Path2D.Double getShape() {

    Path2D.Double path = new Path2D.Double();

    boolean first = true;

    for (GeoCoordinates coord : shape) {

        if (first) {
            path.moveTo(coord.getLongitudeDeg(), coord.getLatitudeDeg());
            first = false;
        } else {
            path.lineTo(coord.getLongitudeDeg(), coord.getLatitudeDeg());
        }

    }
    return path;
}

From source file:org.mabb.fontverter.opentype.TtfGlyph.java

/**
 * Debug only method at the moment, will not return an entireley accurate path in many cases.
 *///from  w  w  w .j a v  a2s .com
List<Path2D.Double> getPaths() {
    LinkedList<Path2D.Double> paths = new LinkedList<Path2D.Double>();

    int startPtOn = 0;
    Point2D.Double lastPoint = new Point2D.Double();

    for (Integer endPtOn : countourEndPoints) {
        Path2D.Double pathOn = new Path2D.Double();

        if (startPtOn == 0)
            pathOn.moveTo(0, 0);

        Point2D.Double firstPoint = new Point2D.Double();

        for (int i = startPtOn; i < endPtOn + 1; i++) {

            Point2D.Double relativePoint = points.get(i);
            Point2D.Double point = new Point2D.Double();
            point.x = relativePoint.x + lastPoint.x;
            point.y = relativePoint.y + lastPoint.y;

            if (startPtOn != 0 && i == startPtOn)
                pathOn.moveTo(point.x, point.y);
            else
                pathOn.lineTo(point.x, point.y);

            if (i == startPtOn)
                firstPoint = point;

            lastPoint = point;
        }
        startPtOn = endPtOn + 1;

        pathOn.lineTo(firstPoint.x, firstPoint.y);
        paths.add(pathOn);
    }

    return paths;
}

From source file:org.ut.biolab.medsavant.shared.util.MiscUtils.java

/**
 * Utility method to create a polygonal path from a list of coordinates
 *
 * @param coords a sequence of x,y coordinates (should be an even number and
 * at least 4)//from   w  w w . j  a v  a 2  s .co  m
 */
public static Path2D.Double createPolygon(double... coords) {
    if (coords.length < 4 || (coords.length & 1) != 0) {
        throw new IllegalArgumentException("Invalid coordinates for createPolygon");
    }

    Path2D.Double result = new Path2D.Double(Path2D.WIND_NON_ZERO, coords.length / 2);
    result.moveTo(coords[0], coords[1]);
    for (int i = 2; i < coords.length; i += 2) {
        result.moveTo(coords[i], coords[i + 1]);
    }
    result.closePath();
    return result;
}

From source file:savant.util.MiscUtils.java

/**
 * Utility method to create a polygonal path from a list of coordinates
 * @param coords a sequence of x,y coordinates (should be an even number and at least 4)
 *///from  ww w.  j  av a2  s.c  o m
public static Path2D.Double createPolygon(double... coords) {
    if (coords.length < 4 || (coords.length & 1) != 0)
        throw new IllegalArgumentException("Invalid coordinates for createPolygon");

    Path2D.Double result = new Path2D.Double(Path2D.WIND_NON_ZERO, coords.length / 2);
    result.moveTo(coords[0], coords[1]);
    for (int i = 2; i < coords.length; i += 2) {
        result.lineTo(coords[i], coords[i + 1]);
    }
    result.closePath();
    return result;
}

From source file:savant.view.tracks.TrackRenderer.java

/**
 * Shared by BAMTrackRenderer and RichIntervalTrackRenderer to draw the white diamond
 * which indicates an insertion.//w  ww.  ja  v  a  2 s.  co  m
 */
public Shape drawInsertion(Graphics2D g2, double x, double y, double unitWidth, double unitHeight) {

    ColourScheme cs = (ColourScheme) instructions.get(DrawingInstruction.COLOUR_SCHEME);
    g2.setColor(cs.getColor(ColourKey.INSERTED_BASE));
    double w = unitWidth * 0.5;

    Path2D.Double rhombus = new Path2D.Double();
    rhombus.moveTo(x, y);
    rhombus.lineTo(x + w, y + unitHeight * 0.5);
    rhombus.lineTo(x, y + unitHeight);
    rhombus.lineTo(x - w, y + unitHeight * 0.5);
    rhombus.closePath();
    g2.fill(rhombus);

    return rhombus;
}