Java Code Examples for java.awt.geom.Path2D#Double

private void drawAreas(Graphics2D g) {
	areas.clear();
	for (TrafficArea area : manager.getAreas()) {
		Path2D shape = new Path2D.Double();
		List<Edge> edges = area.getArea().getEdges();
		Edge e = edges.get(0);
		shape.moveTo(transform.xToScreen(e.getStartX()), transform.yToScreen(e.getStartY()));
		for (Edge edge : edges) {
			shape.lineTo(transform.xToScreen(edge.getEndX()), transform.yToScreen(edge.getEndY()));
		}
		if (area == selectedArea) {
			g.setColor(SELECTED_AREA_COLOUR);
			g.fill(shape);
			g.setColor(AREA_OUTLINE_COLOUR);
			paintEdges(edges, g);
			int[][] graph = area.getGraph();
			List<Line2D> oLines = area.getOpenLines();
			g.setColor(Color.green);
			paintLines(oLines, g);
			g.setColor(Color.yellow);
			for (int i = 0; i < graph.length; i++) {
				for (int j = 0; j < graph.length; j++) {
					if (graph[i][j] > 10000)
						continue;
					Line2D line = new Line2D(TrafficSimulator.getMidPoint(oLines.get(i).getOrigin(), oLines.get(i).getEndPoint()),
							TrafficSimulator.getMidPoint(oLines.get(j).getOrigin(), oLines.get(j).getEndPoint()));
					paintLine(line, g);
				}
			}
		} else {
			g.setColor(AREA_OUTLINE_COLOUR);
			paintEdges(edges, g);
		}
		areas.put(shape, area);
	}
}
 

private static Path2D.Double nearestNeighbour(ScaledData scaledData) {
    double[] scaledX = scaledData.scaledX;
    double[] scaledY = scaledData.scaledY;
    int start = scaledData.start;
    int end = scaledData.end;
    Path2D.Double line = new Path2D.Double();
    line.moveTo(scaledX[start], scaledY[start]);
    for (int i = 1; i < end; i++) {
        double halfX = scaledX[i - 1] + (scaledX[i] - scaledX[i - 1]) / 2;
        if (!java.lang.Double.isNaN(scaledY[i-1])) {
            line.lineTo(halfX, scaledY[i - 1]);
            if (!java.lang.Double.isNaN(scaledY[i]))
                line.lineTo(halfX, scaledY[i]);
        } else {
            line.moveTo(halfX, scaledY[i]);
        }
    }
    line.lineTo(scaledX[end - 1], scaledY[end - 1]);
    return line;
}
 

@Override
public Shape getShape() {
    Path2D shape = new Path2D.Double();
    QueueComponent ref = getReferencedComponent();
    if (ref != null) {
        int capacity = ref.getCapacity();
        double contactOffset = 0.5 * capacity * SLOT_WIDTH;

        shape.moveTo(+contactOffset, 0.0);
        shape.lineTo(+contactOffset + CONTACT_LENGTH, 0.0);

        shape.moveTo(-contactOffset, 0.0);
        shape.lineTo(-contactOffset - CONTACT_LENGTH, 0.0);

        for (int i = 0; i < capacity; i++) {
            shape.append(getSlotShape(i), false);
        }
    }
    return shape;
}
 

private void paint(Graphics2D g, int width) {
  GraphicsUtil.setupAntialiasing(g);


  if (!myApplied) {
    Shape upperCurve = makeCurve(width, myStart1, myStart2, true);
    Shape lowerCurve = makeCurve(width, myEnd1, myEnd2, false);

    Path2D path = new Path2D.Double();
    path.append(upperCurve, true);
    path.append(lowerCurve, true);
    g.setColor(myColor);
    g.fill(path);

    g.setColor(DiffUtil.getFramingColor(myColor));
    g.draw(upperCurve);
    g.draw(lowerCurve);
  }
  else {
    g.setColor(myColor);
    g.draw(makeCurve(width, myStart1 + 1, myStart2 + 1, true));
    g.draw(makeCurve(width, myStart1 + 2, myStart2 + 2, true));
    g.draw(makeCurve(width, myEnd1 + 1, myEnd2 + 1, false));
    g.draw(makeCurve(width, myEnd1 + 2, myEnd2 + 2, false));
  }
}
 

@Override
public void drawInUserSpace(GraphEditor editor, Graphics2D g) {
    if ((firstNode != null) && (currentPoint != null)) {
        g.setStroke(new BasicStroke((float) editor.getViewport().pixelSizeInUserSpace().getX()));
        Path2D path = new Path2D.Double();
        path.moveTo(firstPoint.getX(), firstPoint.getY());
        for (Point2D point : controlPoints) {
            path.lineTo(point.getX(), point.getY());
        }
        path.lineTo(currentPoint.getX(), currentPoint.getY());
        if (currentNode == null) {
            g.setColor(incompleteConnectionColor);
            g.draw(path);
        } else {
            try {
                VisualModel model = editor.getModel();
                if (directedArcs) {
                    model.validateConnection(firstNode, currentNode);
                } else {
                    model.validateUndirectedConnection(firstNode, currentNode);
                }
                g.setColor(validConnectionColor);
                g.draw(path);
            } catch (InvalidConnectionException e) {
                showIssue(editor, e.getMessage());
                g.setColor(invalidConnectionColor);
                g.draw(path);
            }
        }
    }
}
 

private static Area getOuterShape(Shape shape) {
  Area area = new Area();
  Path2D path = new Path2D.Double();
  PathIterator pi = shape.getPathIterator(null);
  double[] coords = new double[6];
  while (!pi.isDone()) {
    int pathSegmentType = pi.currentSegment(coords);
    switch (pathSegmentType) {
      case PathIterator.SEG_MOVETO:
        path.moveTo(coords[0], coords[1]);
        break;
      case PathIterator.SEG_LINETO:
        path.lineTo(coords[0], coords[1]);
        break;
      case PathIterator.SEG_QUADTO:
        path.quadTo(coords[0], coords[1], coords[2], coords[3]);
        break;
      case PathIterator.SEG_CUBICTO:
        path.curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
        break;
      case PathIterator.SEG_CLOSE:
        path.closePath();
        area.add(createArea(path));
        path.reset();
        break;
      default:
        System.err.println("Unexpected value! " + pathSegmentType);
        break;
    }
    pi.next();
  }
  return area;
}
 

public static void main(final String[] args) {
    final Path2D path1 = new Path2D.Double(Path2D.WIND_EVEN_ODD, 0);
    path1.moveTo(10, 10);
    path1.lineTo(20, 20);
    final Path2D path2 = new Path2D.Float(Path2D.WIND_EVEN_ODD, 0);
    path2.moveTo(10, 10);
    path2.lineTo(20, 20);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void moveTo(final double x, final double y) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("[" + id_ + "] moveTo(" + x + ", " + y + ")");
    }

    final Path2D subPath = new Path2D.Double();
    final Point2D p = transformation_.transform(new Point2D.Double(x, y), null);
    subPath.moveTo(p.getX(), p.getY());
    subPaths_.add(subPath);
}
 

void fillPolygon(KPolygon polygon,Color c){
Path2D path=new Path2D.Double();
int s=polygon.size();
DPoint p=polygon.get(0).getBasicPoint2D();
path.moveTo(p.x,p.y);
for(int i=1;i<s;i++){
  p=polygon.get(i).getBasicPoint2D();
  path.lineTo(p.x,p.y);}
path.closePath();
graphics.setPaint(c);
graphics.fill(path); }
 

private void strokeGraphEdges_EditGeometry(Graphics2D graphics){
graphics.setStroke(UI.GRID_DRAWINGSTROKE);
graphics.setPaint(UI.EDITJIG_EDITGEOMETRY_STROKECOLOR);
Iterator<GEdge> i=GE.ge.editor_metagon.editedmetagon.getGraph().edges.iterator();
GEdge e;
double[] p0,p1;
Path2D path=new Path2D.Double();
while(i.hasNext()){
  e=i.next();
  p0=GE.ge.editor_metagon.editedmetagon.getMetagonEditorGeometryCache().getPoint(e.v0.kvertex);
  p1=GE.ge.editor_metagon.editedmetagon.getMetagonEditorGeometryCache().getPoint(e.v1.kvertex);
  path.reset();
  path.moveTo(p0[0],p0[1]);
  path.lineTo(p1[0],p1[1]);
  graphics.draw(path);}}
 

void fillPolygon(DPolygon polygon,Color c){
Path2D path=new Path2D.Double();
int s=polygon.size();
DPoint p=polygon.get(0);
path.moveTo(p.x,p.y);
for(int i=1;i<s;i++){
  p=polygon.get(i);
  path.lineTo(p.x,p.y);}
path.closePath();
graphics.setPaint(c);
graphics.fill(path); }
 

public Shape getSlotShape(int index) {
    Path2D shape = new Path2D.Double();
    if (isInitialised()) {
        double w2 = 0.5 * SLOT_WIDTH;
        double h2 = 0.5 * SLOT_HEIGHT;
        double slotOffset = getSlotOffset(index);
        shape.moveTo(slotOffset - w2, -h2);
        shape.lineTo(slotOffset - w2, +h2);
        shape.lineTo(slotOffset + w2, +h2);
        shape.lineTo(slotOffset + w2, -h2);
        shape.closePath();
    }
    return shape;
}
 

public static void main(final String[] args) {
    final Path2D path1 = new Path2D.Double(Path2D.WIND_EVEN_ODD, 0);
    path1.moveTo(10, 10);
    path1.lineTo(20, 20);
    final Path2D path2 = new Path2D.Float(Path2D.WIND_EVEN_ODD, 0);
    path2.moveTo(10, 10);
    path2.lineTo(20, 20);
}
 

/**
 * Define the lookup area on given corner, knowing the reference point of the
 * entity (head).
 * Global slope is used (plus and minus slopeMargin).
 *
 * @return the lookup area
 */
private Area getLuArea ()
{
    final double slope = skew.getSlope();
    final double dSlope = -xDir * yDir * params.slopeMargin;

    final Point2D outPt = getOutPoint();
    final Point2D inPt = getInPoint();

    // Look Up path, start by head horizontal segment
    final Path2D lu = new Path2D.Double();
    lu.moveTo(outPt.getX(), outPt.getY());
    lu.lineTo(inPt.getX(), inPt.getY());

    // Then segment away from head (system limit)
    final Rectangle systemBox = system.getBounds();
    final double yLimit = (yDir > 0) ? systemBox.getMaxY() : systemBox.getMinY();
    final double dy = yLimit - outPt.getY();
    lu.lineTo(inPt.getX() + ((slope + dSlope) * dy), yLimit);
    lu.lineTo(outPt.getX() + ((slope - dSlope) * dy), yLimit);
    lu.closePath();

    // Attachment
    StringBuilder sb = new StringBuilder();
    sb.append((corner.vSide == TOP) ? "T" : "B");
    sb.append((corner.hSide == LEFT) ? "L" : "R");
    head.addAttachment(sb.toString(), lu);

    return new Area(lu);
}
 

/**
 *
 * @param g2d
 */
@Override
public void paint(Graphics2D g2d) {
    super.paint(g2d);

    Path2D pointTrace = new Path2D.Double(Path2D.WIND_NON_ZERO);
    pointTrace.moveTo(mapX(myOnPeakNormalizedAquireTimes[0]), mapY(myOnPeakData[0]));
    for (int i = 0; i < myOnPeakData.length; i++) {
        // line tracing through points
        pointTrace.lineTo(mapX(myOnPeakNormalizedAquireTimes[i]), mapY(myOnPeakData[i]));
        g2d.setStroke(new BasicStroke(0.5f));
        g2d.setPaint(determineDataColor(i, Color.GRAY));
        g2d.draw(pointTrace);

        Shape intensity = new java.awt.geom.Ellipse2D.Double( //
                mapX(myOnPeakNormalizedAquireTimes[i]) - 1, mapY(myOnPeakData[i]) - 1, 2, 2);
        g2d.setStroke(new BasicStroke(1.5f));
        g2d.setPaint(determineDataColor(i, Color.black));
        g2d.draw(intensity);

        // uncertainty
        Shape plusMinusOneSigma = new Line2D.Double(//
                mapX(myOnPeakNormalizedAquireTimes[i]),// 
                mapY(myOnPeakData[i] - myOnPeakOneSigmas[i]),//
                mapX(myOnPeakNormalizedAquireTimes[i]),// 
                mapY(myOnPeakData[i] + myOnPeakOneSigmas[i]));
        g2d.setStroke(new BasicStroke(1.0f));
        g2d.draw(plusMinusOneSigma);

        // tips of uncertainty
        Shape plusOneSigmaTip = new Line2D.Double(//
                mapX(myOnPeakNormalizedAquireTimes[i]) - 1,// 
                mapY(myOnPeakData[i] + myOnPeakOneSigmas[i]),//
                mapX(myOnPeakNormalizedAquireTimes[i]) + 1,// 
                mapY(myOnPeakData[i] + myOnPeakOneSigmas[i]));

        Shape minusOneSigmaTip = new Line2D.Double(//
                mapX(myOnPeakNormalizedAquireTimes[i]) - 1,// 
                mapY(myOnPeakData[i] - myOnPeakOneSigmas[i]),//
                mapX(myOnPeakNormalizedAquireTimes[i]) + 1,// 
                mapY(myOnPeakData[i] - myOnPeakOneSigmas[i]));

        g2d.setStroke(new BasicStroke(1.0f));
        g2d.draw(plusOneSigmaTip);
        g2d.draw(minusOneSigmaTip);

    }
}
 

public void highlightPolygons(Path2D.Double[] polygonPaths) {
    this.polygonsLayerModel.highlightPolygons(polygonPaths);
    if (this.currentWorldMap != null) {
        this.currentWorldMap.refresh();
    }
}
 

private void leftMouseButtonClicked(List<Path2D.Double> polygonPaths) {
    this.repositoryOutputProductListPanel.getProductListPanel().selectProductsByPolygonPath(polygonPaths);
}
 

/**
     * Merges a sequence of points or paths if the first instance is an implementation of this library.
     *
     * @throws ClassCastException if an element in the iterator is not a {@link Shape} or a {@link Point2D}.
     */
    @Override
    final Shape tryMergePolylines(Object next, final Iterator<?> polylines) {
        if (!(next instanceof Shape || next instanceof Point2D)) {
            return null;
        }
        boolean isFloat = ShapeUtilities.isFloat(next);
        Path2D path = isFloat ? new Path2D.Float() : new Path2D.Double();
        boolean lineTo = false;
add:    for (;;) {
            if (next instanceof Point2D) {
                final double x = ((Point2D) next).getX();
                final double y = ((Point2D) next).getY();
                if (Double.isNaN(x) || Double.isNaN(y)) {
                    lineTo = false;
                } else if (lineTo) {
                    path.lineTo(x, y);
                } else {
                    path.moveTo(x, y);
                    lineTo = true;
                }
            } else {
                path.append((Shape) next, false);
                lineTo = false;
            }
            /*
             * 'polylines.hasNext()' check is conceptually part of 'for' instruction,
             * except that we need to skip this condition during the first iteration.
             */
            do if (!polylines.hasNext()) break add;
            while ((next = polylines.next()) == null);
            /*
             * Convert the path from single-precision to double-precision if needed.
             */
            if (isFloat && !ShapeUtilities.isFloat(next)) {
                path = new Path2D.Double(path);
                isFloat = false;
            }
        }
        return ShapeUtilities.toPrimitive(path);
    }
 

/**
 * 
 * @param aspectRatio
 * @param minX
 * @param minY
 * @param maxX
 * @param maxY
 */
public void calcLowerUnctEnvelopeC(double aspectRatio, double minX, double minY, double maxX, double maxY) {

    // parameters represent viewport
    constructLowerEnvelopeAtRightEnd(endSeg, aspectRatio, minX, minY, maxX, maxY);
    constructLowerEnvelopeAtLeftEnd(startSeg, aspectRatio, minX, minY, maxX, maxY);

    lowerUnctEnvelope = new Path2D.Double (Path2D.WIND_NON_ZERO);

    // start at top right of concordia
    lowerUnctEnvelope.moveTo(
            (float) mapX(endSeg.maxX()),
            (float) mapY(endSeg.maxY()));

    ParametricCurveSegmentI myWorkingSeg = startLowerUncertSeg;

    // decide whether to include upper right corner of viewport
    if (myWorkingSeg != null) {
        if (myWorkingSeg.maxPlusSigmaY(aspectRatio) < endSeg.maxY()) {
            lowerUnctEnvelope.lineTo(
                    (float) mapX(maxX),
                    (float) mapY(maxY));
        }
    } else {
        // paint the lower right corner
        lowerUnctEnvelope.lineTo(
                (float) mapX(maxX),
                (float) mapY(minY));
    }

    while (myWorkingSeg != null) {
        // check for out of bounds
        double tempX = myWorkingSeg.maxPlusSigmaX(aspectRatio);
        double tempY = myWorkingSeg.maxPlusSigmaY(aspectRatio);
        double tempXc = myWorkingSeg.controlLowerX(aspectRatio);
        double tempYc = myWorkingSeg.controlLowerY(aspectRatio);
        double tempXl = myWorkingSeg.minPlusSigmaX(aspectRatio);
        double tempYl = myWorkingSeg.minPlusSigmaY(aspectRatio);

        lowerUnctEnvelope.lineTo(
                (float) mapX(tempX),
                (float) mapY(tempY));

        if (pointInViewPort(tempX, tempY, minX, minY, maxX, maxY) //
                ||//
                ((determineAxisIntersectedByLowerEnvelopeRight(maxX, maxY, tempXl, tempYl, tempX, tempY) == 1) //
                && pointInViewPort(tempXl, tempYl, minX, minY, maxX, maxY))) {

            lowerUnctEnvelope.curveTo(//
                    (float) mapX(tempX),
                    (float) mapY(tempY),
                    (float) mapX(tempXc),
                    (float) mapY(tempYc),
                    (float) mapX(tempXl),
                    (float) mapY(tempYl));
        } else if ((tempX < maxX) && (tempY < maxY) && !pointInViewPort(tempX, tempY, minX, minY, maxX, maxY)//
                && (!pointInViewPort(tempXl, tempYl, minX, minY, maxX, maxY))) { //
            if (determineAxisIntersectedByConcordiaLeft(minX, minY) == -1) {
                lowerUnctEnvelope.lineTo(
                        (float) mapX(tempXl),
                        (float) mapY(tempYl));
            }
            lowerUnctEnvelope.lineTo(
                    (float) mapX(minX),
                    (float) mapY(minY));
            // get rid of the rest
            while (myWorkingSeg.getLeftSeg() != null) {
                myWorkingSeg = myWorkingSeg.getLeftSeg();
            }
        }
        myWorkingSeg = myWorkingSeg.getLeftSeg();
    }
}
 

/**
 * Fills the interior of a <code>Shape</code> using the settings of the
 * <code>Graphics2D</code> context. The rendering attributes applied
 * include the <code>Clip</code>, <code>Transform</code>,
 * <code>Paint</code>, and <code>Composite</code>.
 * @param shape the <code>Shape</code> to be filled
 * @see #setPaint
 * @see java.awt.Graphics#setColor
 * @see #_transform
 * @see #setTransform
 * @see #setComposite
 * @see #clip
 * @see #setClip
 */
public void fill(Shape shape){
    Path2D.Double path = new Path2D.Double(_transform.createTransformedShape(shape));
    FreeformShape<?,?> p = _group.createFreeform();
    p.setPath(path);
    applyPaint(p);
    p.setStrokeStyle();   //Fills must be "No Line"
}