Examples with PathIterator java.awt.geom.PathIterator used on opensource projects

Example 16 with PathIterator

use of java.awt.geom.PathIterator in project poi by apache.

the class XSLFFreeformShape method setPath.

@Override
public int setPath(Path2D.Double path) {
    CTPath2D ctPath = CTPath2D.Factory.newInstance();
    Rectangle2D bounds = path.getBounds2D();
    int x0 = Units.toEMU(bounds.getX());
    int y0 = Units.toEMU(bounds.getY());
    PathIterator it = path.getPathIterator(new AffineTransform());
    int numPoints = 0;
    ctPath.setH(Units.toEMU(bounds.getHeight()));
    ctPath.setW(Units.toEMU(bounds.getWidth()));
    while (!it.isDone()) {
        double[] vals = new double[6];
        int type = it.currentSegment(vals);
        switch(type) {
            case PathIterator.SEG_MOVETO:
                CTAdjPoint2D mv = ctPath.addNewMoveTo().addNewPt();
                mv.setX(Units.toEMU(vals[0]) - x0);
                mv.setY(Units.toEMU(vals[1]) - y0);
                numPoints++;
                break;
            case PathIterator.SEG_LINETO:
                CTAdjPoint2D ln = ctPath.addNewLnTo().addNewPt();
                ln.setX(Units.toEMU(vals[0]) - x0);
                ln.setY(Units.toEMU(vals[1]) - y0);
                numPoints++;
                break;
            case PathIterator.SEG_QUADTO:
                CTPath2DQuadBezierTo qbez = ctPath.addNewQuadBezTo();
                CTAdjPoint2D qp1 = qbez.addNewPt();
                qp1.setX(Units.toEMU(vals[0]) - x0);
                qp1.setY(Units.toEMU(vals[1]) - y0);
                CTAdjPoint2D qp2 = qbez.addNewPt();
                qp2.setX(Units.toEMU(vals[2]) - x0);
                qp2.setY(Units.toEMU(vals[3]) - y0);
                numPoints += 2;
                break;
            case PathIterator.SEG_CUBICTO:
                CTPath2DCubicBezierTo bez = ctPath.addNewCubicBezTo();
                CTAdjPoint2D p1 = bez.addNewPt();
                p1.setX(Units.toEMU(vals[0]) - x0);
                p1.setY(Units.toEMU(vals[1]) - y0);
                CTAdjPoint2D p2 = bez.addNewPt();
                p2.setX(Units.toEMU(vals[2]) - x0);
                p2.setY(Units.toEMU(vals[3]) - y0);
                CTAdjPoint2D p3 = bez.addNewPt();
                p3.setX(Units.toEMU(vals[4]) - x0);
                p3.setY(Units.toEMU(vals[5]) - y0);
                numPoints += 3;
                break;
            case PathIterator.SEG_CLOSE:
                numPoints++;
                ctPath.addNewClose();
                break;
            default:
                throw new IllegalStateException("Unrecognized path segment type: " + type);
        }
        it.next();
    }
    XmlObject xo = getShapeProperties();
    if (!(xo instanceof CTShapeProperties)) {
        return -1;
    }
    ((CTShapeProperties) xo).getCustGeom().getPathLst().setPathArray(new CTPath2D[] { ctPath });
    setAnchor(bounds);
    return numPoints;
}

Example 17 with PathIterator

use of java.awt.geom.PathIterator in project scriptographer by scriptographer.

the class Raster method getAverageColor.

/**
	 * @jshide
	 */
public Color getAverageColor(Shape shape) {
    //		Rectangle2D rect = shape.getBounds2D();
    GeneralPath path;
    int width = getWidth();
    int height = getHeight();
    int startX = 0;
    int startY = 0;
    if (shape != null) {
        Matrix inverse = getInverseMatrix();
        if (inverse == null)
            return null;
        // Create a transformed path. This is faster than
        // path.clone() / path.transform(at);
        PathIterator pi = shape.getPathIterator(inverse.toAffineTransform());
        path = new GeneralPath();
        path.setWindingRule(pi.getWindingRule());
        path.append(pi, false);
        Rectangle2D bounds = path.getBounds2D();
        // Fetch the sub image to iterate over and calculate average colors
        // from
        // Crop to the maximum size.
        Rectangle2D.intersect(bounds, new Rectangle2D.Double(startX, startY, width, height), bounds);
        width = (int) Math.ceil(bounds.getWidth());
        height = (int) Math.ceil(bounds.getHeight());
        // Are we completely outside the raster? If so, return null
        if (width <= 0 || height <= 0)
            return null;
        startX = (int) Math.floor(bounds.getX());
        startY = (int) Math.floor(bounds.getY());
    } else {
        path = null;
    }
    BufferedImage img = getSubImage(startX, startY, width, height);
    //	Raster check = new Raster(img);
    //	check.setPosition(rect.getCenterX(), rect.getCenterY());
    WritableRaster raster = img.getRaster();
    byte[] data = (byte[]) raster.getDataElements(0, 0, null);
    float[] components = new float[data.length];
    for (int i = 0; i < data.length; i++) components[i] = data[i] & 0xff;
    long total = 1;
    for (int y = 0; y < height; y++) {
        for (int x = (y == 0) ? 1 : 0; x < width; x++) {
            if (path == null || path.contains(x + startX, y + startY)) {
                data = (byte[]) raster.getDataElements(x, height - 1 - y, data);
                for (int i = 0; i < data.length; i++) components[i] += data[i] & 0xff;
                total++;
            }
        }
    }
    total *= 255;
    for (int i = 0; i < components.length; i++) components[i] = components[i] / total;
    // Return colors
    if (components.length == 4)
        return new CMYKColor(components);
    else if (components.length == 3)
        return new RGBColor(components);
    else
        return new GrayColor(components);
}

Example 18 with PathIterator

use of java.awt.geom.PathIterator in project JMRI by JMRI.

the class PositionablePolygonXml method storePath.

protected Element storePath(PositionablePolygon p) {
    Element elem = new Element("path");
    PathIterator iter = p.getPathIterator(null);
    float[] coord = new float[6];
    while (!iter.isDone()) {
        int type = iter.currentSegment(coord);
        elem.addContent(storeVertex(type, coord));
        iter.next();
    }
    return elem;
}

Example 19 with PathIterator

use of java.awt.geom.PathIterator in project jdk8u_jdk by JetBrains.

the class SunGraphics2D method validateCompClip.

protected void validateCompClip() {
    int origClipState = clipState;
    if (usrClip == null) {
        clipState = CLIP_DEVICE;
        clipRegion = devClip;
    } else if (usrClip instanceof Rectangle2D) {
        clipState = CLIP_RECTANGULAR;
        if (usrClip instanceof Rectangle) {
            clipRegion = devClip.getIntersection((Rectangle) usrClip);
        } else {
            clipRegion = devClip.getIntersection(usrClip.getBounds());
        }
    } else {
        PathIterator cpi = usrClip.getPathIterator(null);
        int[] box = new int[4];
        ShapeSpanIterator sr = LoopPipe.getFillSSI(this);
        try {
            sr.setOutputArea(devClip);
            sr.appendPath(cpi);
            sr.getPathBox(box);
            Region r = Region.getInstance(box);
            r.appendSpans(sr);
            clipRegion = r;
            clipState = r.isRectangular() ? CLIP_RECTANGULAR : CLIP_SHAPE;
        } finally {
            sr.dispose();
        }
    }
    if (origClipState != clipState && (clipState == CLIP_SHAPE || origClipState == CLIP_SHAPE)) {
        validFontInfo = false;
        invalidatePipe();
    }
}

Example 20 with PathIterator

use of java.awt.geom.PathIterator in project jdk8u_jdk by JetBrains.

the class MarlinRenderingEngine method getAATileGenerator.

/**
     * Construct an antialiased tile generator for the given shape with
     * the given rendering attributes and store the bounds of the tile
     * iteration in the bbox parameter.
     * The {@code at} parameter specifies a transform that should affect
     * both the shape and the {@code BasicStroke} attributes.
     * The {@code clip} parameter specifies the current clip in effect
     * in device coordinates and can be used to prune the data for the
     * operation, but the renderer is not required to perform any
     * clipping.
     * If the {@code BasicStroke} parameter is null then the shape
     * should be filled as is, otherwise the attributes of the
     * {@code BasicStroke} should be used to specify a draw operation.
     * The {@code thin} parameter indicates whether or not the
     * transformed {@code BasicStroke} represents coordinates smaller
     * than the minimum resolution of the antialiasing rasterizer as
     * specified by the {@code getMinimumAAPenWidth()} method.
     * <p>
     * Upon returning, this method will fill the {@code bbox} parameter
     * with 4 values indicating the bounds of the iteration of the
     * tile generator.
     * The iteration order of the tiles will be as specified by the
     * pseudo-code:
     * <pre>
     *     for (y = bbox[1]; y < bbox[3]; y += tileheight) {
     *         for (x = bbox[0]; x < bbox[2]; x += tilewidth) {
     *         }
     *     }
     * </pre>
     * If there is no output to be rendered, this method may return
     * null.
     *
     * @param s the shape to be rendered (fill or draw)
     * @param at the transform to be applied to the shape and the
     *           stroke attributes
     * @param clip the current clip in effect in device coordinates
     * @param bs if non-null, a {@code BasicStroke} whose attributes
     *           should be applied to this operation
     * @param thin true if the transformed stroke attributes are smaller
     *             than the minimum dropout pen width
     * @param normalize true if the {@code VALUE_STROKE_NORMALIZE}
     *                  {@code RenderingHint} is in effect
     * @param bbox returns the bounds of the iteration
     * @return the {@code AATileGenerator} instance to be consulted
     *         for tile coverages, or null if there is no output to render
     * @since 1.7
     */
@Override
public AATileGenerator getAATileGenerator(Shape s, AffineTransform at, Region clip, BasicStroke bs, boolean thin, boolean normalize, int[] bbox) {
    MarlinTileGenerator ptg = null;
    Renderer r = null;
    final RendererContext rdrCtx = getRendererContext();
    try {
        // Test if at is identity:
        final AffineTransform _at = (at != null && !at.isIdentity()) ? at : null;
        final NormMode norm = (normalize) ? NormMode.ON_WITH_AA : NormMode.OFF;
        if (bs == null) {
            // fill shape:
            final PathIterator pi = getNormalizingPathIterator(rdrCtx, norm, s.getPathIterator(_at));
            // note: Winding rule may be EvenOdd ONLY for fill operations !
            r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(), clip.getWidth(), clip.getHeight(), pi.getWindingRule());
            // TODO: subdivide quad/cubic curves into monotonic curves ?
            pathTo(rdrCtx, pi, r);
        } else {
            // draw shape with given stroke:
            r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(), clip.getWidth(), clip.getHeight(), PathIterator.WIND_NON_ZERO);
            strokeTo(rdrCtx, s, _at, bs, thin, norm, true, r);
        }
        if (r.endRendering()) {
            ptg = rdrCtx.ptg.init();
            ptg.getBbox(bbox);
            // note: do not returnRendererContext(rdrCtx)
            // as it will be called later by MarlinTileGenerator.dispose()
            r = null;
        }
    } finally {
        if (r != null) {
            // dispose renderer:
            r.dispose();
            // recycle the RendererContext instance
            MarlinRenderingEngine.returnRendererContext(rdrCtx);
        }
    }
    // Return null to cancel AA tile generation (nothing to render)
    return ptg;
}