Example usage for java.awt.geom Point2D getX

List of usage examples for java.awt.geom Point2D getX

  1. HOME
  2. Java
  3. java
  4. java.awt.geom.*
  5. Point2D
  6. getX

Introduction

In this page you can find the example usage for java.awt.geom Point2D getX.

Prototype

public abstract double getX();

Source Link

Document

Returns the X coordinate of this Point2D in double precision.

Usage

From source file:org.squidy.designer.model.PipeShape.java

private PBounds computeBounds() {

    // TODO: [RR] Hack!!! Do not compute bounds if ports are invisible.
    // if (source.getOutputPort().getScale() < 1.0 ||
    // target.getOutputPort().getScale() < 1.0) {
    // return getBoundsReference();
    // }/*from  w w  w. j  a va  2  s . c om*/

    PortShape sourcePortShape;
    PortShape targetPortShape;
    if (!source.getParent().equals(target.getParent())) {
        if (source instanceof PipelineShape && !(target instanceof PipelineShape)) {
            // ConnectorShape<?, ?> tmp = source;
            // source = target;
            // target = tmp;

            sourcePortShape = source.getInputPort();
            targetPortShape = target.getInputPort();
        } else if (!(source instanceof PipelineShape) && target instanceof PipelineShape) {
            sourcePortShape = source.getOutputPort();
            targetPortShape = target.getOutputPort();
        } else {
            // TODO [RR]: This may cause unexpected painting of shapes -> The visual shape drawing does not match the processing hierarchy.
            sourcePortShape = source.getInputPort();
            targetPortShape = target.getInputPort();
        }
    } else {
        sourcePortShape = source.getOutputPort();
        targetPortShape = target.getInputPort();
    }

    // System.out.println("GFB: " + source.getGlobalFullBounds());
    // System.out.println("FBR: " + source.getFullBoundsReference());
    // System.out.println("BR : " + source.getBoundsReference());
    // System.out.println("Off: " + source.getOffset());

    Point2D p1 = globalToLocal(
            sourcePortShape.getParent().localToGlobal(sourcePortShape.getFullBoundsReference().getCenter2D()));
    Point2D p2 = globalToLocal(
            targetPortShape.getParent().localToGlobal(targetPortShape.getFullBoundsReference().getCenter2D()));

    double x1 = p1.getX();
    double x2 = p2.getX();
    double y1 = p1.getY();
    double y2 = p2.getY();

    // Rectangle2D bounds1 =
    // globalToLocal(sourcePortShape.getGlobalFullBounds());
    // Rectangle2D bounds2 =
    // globalToLocal(targetPortShape.getGlobalFullBounds());
    //      
    // double x1 = bounds1.getMinX();
    // double x2 = bounds2.getMinX();
    // double y1 = bounds1.getMinY();
    // double y2 = bounds2.getMinY();

    double x = Math.min(x1, x2);
    double y = Math.min(y1, y2);
    double width = Math.max(Math.abs(x1 - x2), 1);
    double height = Math.max(Math.abs(y1 - y2), 1);

    // Rectangle2D b = localToParent(new PBounds(x, y, width, height));
    //       shape.setCurve(x1, y1, x1 + (width / 2), y1, x2 - (width / 2), y2,
    //       x2, y2);

    shape.setLine(x1, y1 - LINE_WIDTH / 2.0 - 10, x2, y2 - LINE_WIDTH / 2.0 - 10);

    return new PBounds(shape.getBounds());
}

From source file:org.jfree.experimental.chart.plot.dial.DialValueIndicator.java

/**
 * Draws the background to the specified graphics device.  If the dial
 * frame specifies a window, the clipping region will already have been 
 * set to this window before this method is called.
 *
 * @param g2  the graphics device (<code>null</code> not permitted).
 * @param plot  the plot (ignored here).
 * @param frame  the dial frame (ignored here).
 * @param view  the view rectangle (<code>null</code> not permitted). 
 *///ww w. ja  v a2s . co  m
public void draw(Graphics2D g2, DialPlot plot, Rectangle2D frame, Rectangle2D view) {

    // work out the anchor point
    Rectangle2D f = DialPlot.rectangleByRadius(frame, this.radius, this.radius);
    Arc2D arc = new Arc2D.Double(f, this.angle, 0.0, Arc2D.OPEN);
    Point2D pt = arc.getStartPoint();

    // calculate the bounds of the template value
    FontMetrics fm = g2.getFontMetrics(this.font);
    String s = this.formatter.format(this.templateValue);
    Rectangle2D tb = TextUtilities.getTextBounds(s, g2, fm);

    // align this rectangle to the frameAnchor
    Rectangle2D bounds = RectangleAnchor.createRectangle(new Size2D(tb.getWidth(), tb.getHeight()), pt.getX(),
            pt.getY(), this.frameAnchor);

    // add the insets
    Rectangle2D fb = this.insets.createOutsetRectangle(bounds);

    // draw the background
    g2.setPaint(this.backgroundPaint);
    g2.fill(fb);

    // draw the border
    g2.setStroke(this.outlineStroke);
    g2.setPaint(this.outlinePaint);
    g2.draw(fb);

    // now find the text anchor point
    double value = plot.getValue(this.datasetIndex);
    String valueStr = this.formatter.format(value);
    Point2D pt2 = RectangleAnchor.coordinates(bounds, this.valueAnchor);
    g2.setPaint(this.paint);
    g2.setFont(this.font);
    TextUtilities.drawAlignedString(valueStr, g2, (float) pt2.getX(), (float) pt2.getY(), this.textAnchor);

}

From source file:org.apache.fop.svg.AbstractFOPTextPainter.java

private void updateLocationFromACI(AttributedCharacterIterator aci, Point2D loc) {
    //Adjust position of span
    Float xpos = (Float) aci.getAttribute(GVTAttributedCharacterIterator.TextAttribute.X);
    Float ypos = (Float) aci.getAttribute(GVTAttributedCharacterIterator.TextAttribute.Y);
    Float dxpos = (Float) aci.getAttribute(GVTAttributedCharacterIterator.TextAttribute.DX);
    Float dypos = (Float) aci.getAttribute(GVTAttributedCharacterIterator.TextAttribute.DY);
    if (xpos != null) {
        loc.setLocation(xpos.doubleValue(), loc.getY());
    }/* w  w w.  ja v  a2  s .co  m*/
    if (ypos != null) {
        loc.setLocation(loc.getX(), ypos.doubleValue());
    }
    if (dxpos != null) {
        loc.setLocation(loc.getX() + dxpos.doubleValue(), loc.getY());
    }
    if (dypos != null) {
        loc.setLocation(loc.getX(), loc.getY() + dypos.doubleValue());
    }
}

From source file:Hexagon.java

public void align(Rectangle2D bounds, Direction direction) {
    // these are defined here INSTEAD of in the switch, or it won't compile
    Point2D newTopRight, newTopLeft, newBottomRight, newBottomLeft;
    Point2D oldTopRight, oldTopLeft, oldBottomRight, oldBottomLeft;

    switch (direction) {
    case NorthEast:
        newTopRight = new Point2D.Double(bounds.getMaxX(), bounds.getMinY());
        oldTopRight = boundingCorners.get(BoundingCorner.TopRight);
        translate(newTopRight.getX() - oldTopRight.getX(), // deltaX
                newTopRight.getY() - oldTopRight.getY() // deltaY
        );//  ww  w. j a v a 2s.  c om
        break;
    case East:
        newTopRight = new Point2D.Double(bounds.getMaxX(), bounds.getMinY());
        oldTopRight = boundingCorners.get(BoundingCorner.TopRight);
        translate(newTopRight.getX() - oldTopRight.getX(), // deltaX
                0 // deltaY
        );
        break;
    case SouthEast:
        newBottomRight = new Point2D.Double(bounds.getMaxX(), bounds.getMaxY());
        oldBottomRight = boundingCorners.get(BoundingCorner.BottomRight);
        translate(newBottomRight.getX() - oldBottomRight.getX(), // deltaX
                newBottomRight.getY() - oldBottomRight.getY() // deltaY
        );
        break;
    case SouthWest:
        newBottomLeft = new Point2D.Double(bounds.getMinX(), bounds.getMaxY());
        oldBottomLeft = boundingCorners.get(BoundingCorner.BottomLeft);
        translate(newBottomLeft.getX() - oldBottomLeft.getX(), // deltaX
                newBottomLeft.getY() - oldBottomLeft.getY() // deltaY
        );
        break;
    case West:
        newTopLeft = new Point2D.Double(bounds.getMinX(), bounds.getMinY());
        oldTopLeft = boundingCorners.get(BoundingCorner.TopLeft);
        translate(newTopLeft.getX() - oldTopLeft.getX(), // deltaX
                0 // deltaY
        );
        break;
    case NorthWest:
        newTopLeft = new Point2D.Double(bounds.getMinX(), bounds.getMinY());
        oldTopLeft = boundingCorners.get(BoundingCorner.TopLeft);
        translate(newTopLeft.getX() - oldTopLeft.getX(), // deltaX
                newTopLeft.getY() - oldTopLeft.getY() // deltaY
        );
        break;
    }
}

From source file:edu.snu.leader.discrete.simulator.Agent.java

/**
 * Initializes Agent//w  ww .  ja  va 2  s.  c o m
 * 
 * @param simState The simulation state
 */
public void initialize(SimulationState simState, Point2D initialLocation) {
    _simState = simState;

    _initialLocation = new Vector2D(initialLocation.getX(), initialLocation.getY());

    String nearestNeighborCount = _simState.getProperties().getProperty("nearest-neighbor-count");
    Validate.notEmpty(nearestNeighborCount, "Nearest neighbor count may not be empty");
    _nearestNeighborCount = Integer.parseInt(nearestNeighborCount);

    String maxLocationRadius = _simState.getProperties().getProperty("max-location-radius");
    Validate.notEmpty(maxLocationRadius, "Max location raidus may not be empty");
    _maxLocationRadius = Double.parseDouble(maxLocationRadius);

    String canMultipleInitiate = _simState.getProperties().getProperty("can-multiple-initiate");
    Validate.notEmpty(canMultipleInitiate, "Can multiple initiate may not be empty");
    _canMultipleInitiate = Boolean.parseBoolean(canMultipleInitiate);

    String cancellationThreshold = _simState.getProperties().getProperty("cancellation-threshold");
    Validate.notEmpty(cancellationThreshold, "Use cancellation threshold may not be empty");
    _cancellationThreshold = Double.parseDouble(cancellationThreshold);

    String lambda = _simState.getProperties().getProperty("lambda");
    Validate.notEmpty(lambda, "Lambda may not be empty");
    _lambda = Float.parseFloat(lambda);

    String preCalcProbs = _simState.getProperties().getProperty("pre-calculate-probabilities");
    Validate.notEmpty(preCalcProbs, "pre-calculate-probabilities may not be empty");
    _preCalcProbs = Boolean.parseBoolean(preCalcProbs);

    _communicationType = _simState.getCommunicationType();

    _positionHistory = new Reporter(_id.toString() + ".dat", "", false);

    reset();

    _personalityTrait.initialize(this);
}

From source file:net.sf.mzmine.modules.visualization.metamsecorrelate.visual.pseudospectra.PseudoSpectraRenderer.java

@Override
protected void drawItemLabel(Graphics2D g2, XYDataset dataset, int series, int item, XYPlot plot,
        XYItemLabelGenerator generator, Rectangle2D bar, boolean negative) {
    //super.drawItemLabel(g2, dataset, series, item, plot, generator, bar, negative);  

    if (generator != null) {
        String label = generator.generateLabel(dataset, series, item);

        if (label != null) {
            Font labelFont = getItemLabelFont(series, item);
            Paint paint = getItemLabelPaint(series, item);
            g2.setFont(labelFont);//from   w  ww . j av a 2  s  . co  m
            g2.setPaint(paint);

            // get the label position..
            ItemLabelPosition position;
            if (!negative) {
                position = getPositiveItemLabelPosition(series, item);
            } else {
                position = getNegativeItemLabelPosition(series, item);
            }

            // work out the label anchor point...
            Point2D anchorPoint = calculateLabelAnchorPoint(position.getItemLabelAnchor(), bar,
                    plot.getOrientation());

            // split by \n
            String symbol = "\n";
            String[] splitted = label.split(symbol);

            if (splitted.length > 1) {
                FontRenderContext frc = g2.getFontRenderContext();
                GlyphVector gv = g2.getFont().createGlyphVector(frc, "Fg,");
                int height = 4 + (int) gv.getPixelBounds(null, 0, 0).getHeight();
                // draw more than one row
                for (int i = 0; i < splitted.length; i++) {
                    int offset = -height * (splitted.length - i - 1);
                    TextUtilities.drawRotatedString(splitted[i], g2, (float) anchorPoint.getX(),
                            (float) anchorPoint.getY() + offset, position.getTextAnchor(), position.getAngle(),
                            position.getRotationAnchor());
                }
            } else {
                // one row 
                TextUtilities.drawRotatedString(label, g2, (float) anchorPoint.getX(),
                        (float) anchorPoint.getY(), position.getTextAnchor(), position.getAngle(),
                        position.getRotationAnchor());
            }
        }
    }

}

From source file:lu.lippmann.cdb.graph.GraphViewImpl.java

public void rescaleSatelliteView() {
    //MutableTransformer masterViewTransformer   =  vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
    //MutableTransformer masterLayoutTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT);
    MutableTransformer slaveViewTransformer = vv2.getRenderContext().getMultiLayerTransformer()
            .getTransformer(Layer.VIEW);
    MutableTransformer slaveLayoutTransformer = vv2.getRenderContext().getMultiLayerTransformer()
            .getTransformer(Layer.LAYOUT);

    final Layout<CNode, CEdge> layout = vv.getGraphLayout();
    double minX = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, minY = Integer.MAX_VALUE,
            maxY = Integer.MIN_VALUE;
    final Graph<CNode, CEdge> graph = layout.getGraph();

    double w = 0, h = 0;
    for (final CNode n : graph.getVertices()) {
        final Point2D point = layout.transform(n); //center of the node
        if (point.getX() < minX) {
            minX = point.getX();//w w  w.j a va  2  s .  c  o m
            w = ShapeFactory.createShape(n.getShape()).getBounds().getWidth() / 2;
        }
        if (point.getX() > maxX) {
            maxX = point.getX();
        }
        if (point.getY() < minY) {
            minY = point.getY();
            h = ShapeFactory.createShape(n.getShape()).getBounds().getHeight() / 2;
        }
        if (point.getY() > maxY) {
            maxY = point.getY();
        }
    }

    final double graphWidth = (maxX - minX) + 2 * w;///slaveViewTransformer.getScale(); 
    final double graphHeight = (maxY - minY) + 2 * h;///slaveViewTransformer.getScale();
    final double slaveWidth = vv2.getBounds().getWidth() / slaveViewTransformer.getScale();
    final double slaveHeight = vv2.getBounds().getHeight() / slaveViewTransformer.getScale();

    final double scale1 = (slaveWidth / graphWidth);
    final double scale2 = (slaveHeight / graphHeight);
    final float scale = (float) (Math.min(scale1, scale2)); //to avoid round error 
    if (scale < slaveLayoutTransformer.getScale()) {
        slaveLayoutTransformer.setToIdentity();
        final Point2D graphCenter = GraphUtil.getCenter(
                new HashSet<CNode>(vv.getGraphLayout().getGraph().getVertices()),
                vv.getModel().getGraphLayout());
        //System.out.println("Scaling from center : " + graphCenter +"->" + slaveViewTransformer.transform(graphCenter));
        slaveLayoutTransformer.scale(scale, scale, slaveViewTransformer.transform(graphCenter));
        //System.out.println("Graph center : " + graphCenter);
        //slaveLayoutTransformer.setTranslate(slaveWidth/2-graphCenter.getX()/2,slaveHeight/2-graphCenter.getY()/2);
    } else {
        final double tx = slaveLayoutTransformer.getTranslateX();
        final double ty = slaveLayoutTransformer.getTranslateY();
        if (minX < tx) {
            slaveLayoutTransformer.translate(-minX - tx + w, 0);
        } else if (slaveWidth < maxX) {
            slaveLayoutTransformer.translate(slaveWidth - maxX - tx - w, 0);
        }
        if (minY < ty) {
            slaveLayoutTransformer.translate(0, -minY - ty + h);
        } else if (slaveHeight < maxY) {
            slaveLayoutTransformer.translate(0, slaveHeight - maxY - ty - h);
        }
    }

}

From source file:org.apache.pdfbox.rendering.PageDrawer.java

@Override
public void appendRectangle(Point2D p0, Point2D p1, Point2D p2, Point2D p3) {
    // to ensure that the path is created in the right direction, we have to create
    // it by combining single lines instead of creating a simple rectangle
    linePath.moveTo((float) p0.getX(), (float) p0.getY());
    linePath.lineTo((float) p1.getX(), (float) p1.getY());
    linePath.lineTo((float) p2.getX(), (float) p2.getY());
    linePath.lineTo((float) p3.getX(), (float) p3.getY());

    // close the subpath instead of adding the last line so that a possible set line
    // cap style isn't taken into account at the "beginning" of the rectangle
    linePath.closePath();/*from w w w  .j  av  a  2 s . co m*/
}

From source file:org.yccheok.jstock.gui.charting.ChartLayerUI.java

@Override
protected void paintLayer(Graphics2D g2, JXLayer<? extends V> layer) {
    super.paintLayer(g2, layer);

    if (this.mainTraceInfo.getPoint() == null) {
        return;//from   ww  w.  ja v a  2  s  .  co  m
    }

    final Object oldValueAntiAlias = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
    final Color oldColor = g2.getColor();

    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setColor(COLOR_BLUE);
    final int BALL_RADIUS = 8;
    g2.fillOval((int) (this.mainTraceInfo.getPoint().getX() - (BALL_RADIUS >> 1) + 0.5),
            (int) (this.mainTraceInfo.getPoint().getY() - (BALL_RADIUS >> 1) + 0.5), BALL_RADIUS, BALL_RADIUS);

    for (TraceInfo indicatorTraceInfo : this.indicatorTraceInfos) {
        final Point2D point = indicatorTraceInfo.getPoint();
        if (null == point) {
            continue;
        }
        g2.fillOval((int) (point.getX() - (BALL_RADIUS >> 1) + 0.5),
                (int) (point.getY() - (BALL_RADIUS >> 1) + 0.5), BALL_RADIUS, BALL_RADIUS);
    }

    g2.setColor(oldColor);

    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, oldValueAntiAlias);
    this.drawInformationBox(g2, layer);
}

From source file:org.jcurl.core.swing.RockEditDisplay.java

protected void paintSpeed(final Graphics2D g2, final int idx) {
    if (idx < 0)
        return;//  ww w .  j  a  va  2 s. co m
    final Point2D cwc = getPos().getRock(idx);
    final Point2D cdc = wc2dc(cwc, null);
    // prepare a direction beam (line) 5 Meters long from cwc
    final Point2D dir_dc;
    final Point2D normwc;
    final double vwc_abs;
    {
        Point2D norm = speed.getRock(idx);
        vwc_abs = MathVec.abs2D(norm);
        if (vwc_abs == 0.0)
            normwc = new Point2D.Double(0, -1);
        else
            normwc = MathVec.mult(1.0 / vwc_abs, norm, null);
        norm = MathVec.mult(5, normwc, null);
        MathVec.add(cwc, norm, norm);
        wc2dc(norm, norm);
        dir_dc = norm;
    }
    // prepare a perpendicular line for the "strength"
    final Point2D abs1_dc;
    final Point2D abs2_dc;
    final Point2D spotWc;
    {
        final double len = 0.5;
        spotWc = getSpeedSpotWC(idx, null);
        // get a perpendicular
        abs2_dc = new Point2D.Double(-normwc.getY(), normwc.getX());
        MathVec.mult(len, abs2_dc, abs2_dc);
        abs1_dc = MathVec.add(spotWc, abs2_dc, null);
        MathVec.mult(-1, abs2_dc, abs2_dc);
        MathVec.add(spotWc, abs2_dc, abs2_dc);
        wc2dc(abs1_dc, abs1_dc);
        wc2dc(abs2_dc, abs2_dc);
    }

    lineDC(g2, cdc, dir_dc);
    lineDC(g2, abs1_dc, abs2_dc);
    // circle at the hot "spot" for changing speed
    circleDC(g2, wc2dc(spotWc, null), hotRadiusDC);
}