final double getMindist(Point2D.Double pt) { double result = Double.MAX_VALUE; for (Point2D p : points.keySet()) { if (pt.equals(p)) { continue; } final double v = p.distance(pt); if (v < 1E-4) { throw new IllegalStateException(); } result = Math.min(result, v); } for (Line2D line : lines) { if (line.getP1().equals(pt) || line.getP2().equals(pt)) { continue; } final double v = line.ptSegDist(pt); if (result < 1E-4) { throw new IllegalStateException("pt=" + pt + " line=" + GeomUtils.toString(line)); } result = Math.min(result, v); } if (result == 0) { throw new IllegalStateException(); } // Log.println("getMindist=" + result); return result; }
public Point2D getClosestIntersectionToStart(Shape withThisShape) { // first, get the sides of the shape List<LineSegment> shapeSides = Utilities.getSides(withThisShape); // go through all the sides, and see if there are any intersections // there may be more than 1 List<Point2D> shapeIntersectionPoints = new ArrayList<Point2D>(); for (Line2D curSide : shapeSides) { if (curSide.intersectsLine(this)) { Point2D intersectionPoint = Utilities.getIntersectionPoint(this, curSide); shapeIntersectionPoints.add(intersectionPoint); } } if (shapeIntersectionPoints.size() <= 0) { return null; } else if (shapeIntersectionPoints.size() == 1) { return shapeIntersectionPoints.get(0); } else { // get the point closest to P1 Point2D closestIntersectionPoint = null; double closestIntersectionPointDistSq = java.lang.Double.MAX_VALUE; for (Point2D curPoint : shapeIntersectionPoints) { double curDistSq = curPoint.distanceSq(this.getP1()); if (curDistSq < closestIntersectionPointDistSq) { closestIntersectionPointDistSq = curDistSq; closestIntersectionPoint = curPoint; } } return closestIntersectionPoint; } }
/** * Creates a region surrounding a line segment by 'widening' the line segment. A typical use for * this method is the creation of a 'clickable' region for a line that is displayed on-screen. * * @param line the line (<code>null</code> not permitted). * @param width the width of the region. * @return A region that surrounds the line. */ public static Shape createLineRegion(final Line2D line, final float width) { final GeneralPath result = new GeneralPath(); final float x1 = (float) line.getX1(); final float x2 = (float) line.getX2(); final float y1 = (float) line.getY1(); final float y2 = (float) line.getY2(); if ((x2 - x1) != 0.0) { final double theta = Math.atan((y2 - y1) / (x2 - x1)); final float dx = (float) Math.sin(theta) * width; final float dy = (float) Math.cos(theta) * width; result.moveTo(x1 - dx, y1 + dy); result.lineTo(x1 + dx, y1 - dy); result.lineTo(x2 + dx, y2 - dy); result.lineTo(x2 - dx, y2 + dy); result.closePath(); } else { // special case, vertical line result.moveTo(x1 - width / 2.0f, y1); result.lineTo(x1 + width / 2.0f, y1); result.lineTo(x2 + width / 2.0f, y2); result.lineTo(x2 - width / 2.0f, y2); result.closePath(); } return result; }
/** @see Graphics#drawPolyline(int[], int[], int) */ public void drawPolyline(int[] x, int[] y, int nPoints) { Line2D line = new Line2D.Double(x[0], y[0], x[0], y[0]); for (int i = 1; i < nPoints; i++) { line.setLine(line.getX2(), line.getY2(), x[i], y[i]); draw(line); } }
/** @see prefuse.render.AbstractShapeRenderer#getRawShape(prefuse.visual.VisualItem) */ @Override protected Shape getRawShape(VisualItem item) { double x1 = item.getDouble(VisualItem.X); double y1 = item.getDouble(VisualItem.Y); double x2 = item.getDouble(VisualItem.X2); double y2 = item.getDouble(VisualItem.Y2); boolean isX = item.getBoolean(DocumentGridAxisLayout.IS_X); double midPoint = item.getDouble(DocumentGridAxisLayout.MID_POINT); // horizontal or vertical coords should be manually held constant so that fisheye works // properly if (isX) { // vertical line m_line.setLine(x1, y1, x1, y2); } else { // horizontal line m_line.setLine(x1, y1, x2, y1); } if (!item.canGetString(VisualItem.LABEL)) { return m_line; } String label = item.getString(VisualItem.LABEL); if (label == null) { return m_line; } FontMetrics fm = DEFAULT_GRAPHICS.getFontMetrics(item.getFont()); m_ascent = fm.getAscent(); int h = fm.getHeight(); int w = fm.stringWidth(label); double tx, ty; int labelOffset = 10; if (isX) { // vertical axis // get text x-coord, center at midPoint // tx = x1 + (x2-x1)/2 - w/2; // tx = midPoint + (x1+midPoint)/2 - w/2; // tx = x1 + midPoint/2 - w/2; // simpler approach: just add a fixed distance tx = x1 + labelOffset; // get text y-coord ty = y2 - h; } else { // horiz axis // get text x-coord tx = x1 - w - 2; // get text y-coord, center at midPoint // ty = y1 + (y2-y1)/2 - h/2; // ty = y1 + midPoint/2 - h/2; // simpler approach: just add a fixed distance ty = y1 + labelOffset; } m_box.setFrame(tx, ty, w, h); return m_box; }
public void pruneArray() { for (Shape shape : toDraw) { Line2D line = (Line2D) shape; if (line.getY1() < 0) { toDraw.remove(shape); } } }
public Shape getShape() { Line2D line = getConnectionPoints(); Point2D control = getControlPoint(); GeneralPath p = new GeneralPath(); p.moveTo((float) line.getX1(), (float) line.getY1()); p.quadTo( (float) control.getX(), (float) control.getY(), (float) line.getX2(), (float) line.getY2()); return p; }
/** * Creates an object based on this description. * * @return The object. */ public Object createObject() { final Line2D line = new Line2D.Float(); final float x1 = getFloatParameter("x1"); final float x2 = getFloatParameter("x2"); final float y1 = getFloatParameter("y1"); final float y2 = getFloatParameter("y2"); line.setLine(x1, y1, x2, y2); return line; }
/** * Translate the terminal. This is implemented since it is the most efficient way for figures that * contain terminals to translate themselves. However, this method does not call repaint(), on the * assumption that the parent figure will do so anyway. */ @Override public void translate(double x, double y) { //// repaint(); _line.setLine(_line.getX1() + x, _line.getY1() + y, _line.getX2() + x, _line.getY2() + y); if (_end != null) { _end.translate(x, y); } //// repaint(); }
/** * Creates and returns a line that is perpendicular to the specified line. * * @param line the reference line ({@code null} not permitted). * @param pt1 a point on the reference line ({@code null} not permitted). * @param size the length of the new line. * @param opposingPoint an opposing point, to define which side of the reference line the * perpendicular line will extend ({@code null} not permitted). * @return The perpendicular line. */ public static Line2D createPerpendicularLine( Line2D line, Point2D pt1, double size, Point2D opposingPoint) { double dx = line.getX2() - line.getX1(); double dy = line.getY2() - line.getY1(); double length = Math.sqrt(dx * dx + dy * dy); double pdx = dy / length; double pdy = -dx / length; int ccw = line.relativeCCW(opposingPoint); Point2D pt2 = new Point2D.Double(pt1.getX() - ccw * size * pdx, pt1.getY() - ccw * size * pdy); return new Line2D.Double(pt1, pt2); }
/** * Tests if the shape contains a point. * * @param p coord point * @return true if shape contains p */ public boolean contains(Point2D p) { double x = startPoint.getX(); double y = startPoint.getY(); double xEnd = endPoint.getX(); double yEnd = endPoint.getY(); Line2D line = new Line2D.Double(x, y, xEnd, yEnd); return line.intersects(p.getX(), p.getY(), 10, 10); }
/** * Gets the control point for the quadratic spline. * * @return the control point */ private Point2D getControlPoint() { Line2D line = getConnectionPoints(); double t = Math.tan(Math.toRadians(angle)); double dx = (line.getX2() - line.getX1()) / 2; double dy = (line.getY2() - line.getY1()) / 2; return new Point2D.Double( (line.getX1() + line.getX2()) / 2 + t * dy, (line.getY1() + line.getY2()) / 2 - t * dx); }
public boolean isZaznaczono(int x, int y) { for (Line2D l : this.linia) { if (l.intersects( x - SASIEDZTWO_BADANIA_PRZECIECIA, y - SASIEDZTWO_BADANIA_PRZECIECIA, SASIEDZTWO_BADANIA_PRZECIECIA * 2, SASIEDZTWO_BADANIA_PRZECIECIA * 2)) { return true; } } return false; }
private Edge getSelectedEdge(MouseEvent mouse) { for (int i = 0; i < listOfNodes.size(); i++) { Node node = listOfNodes.get(i); for (Edge edge : node.adjacent) { Line2D line = edge.getRepLine(); double ptToLine = line.ptSegDist(mouse.getX(), mouse.getY()); if (ptToLine <= Constants.eps) { return edge; } } } return null; }
public LineSegmentIntersection(Line2D segment, Line2D lineB) { final double x1 = segment.getX1(); final double y1 = segment.getY1(); final double x2 = segment.getX2(); final double y2 = segment.getY2(); final double x3 = lineB.getX1(); final double y3 = lineB.getY1(); final double x4 = lineB.getX2(); final double y4 = lineB.getY2(); final double den = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); if (den == 0) { inter = null; } else { final double uA1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3); final double uA = uA1 / den; final double x = x1 + uA * (x2 - x1); final double y = y1 + uA * (y2 - y1); if (uA >= 0 && uA <= 1) { inter = new Point2D.Double(x, y); } else { inter = null; } } }
public Polyline2D(Line2D line) { super(); npoints = 2; xpoints = new double[2]; ypoints = new double[2]; xpoints[0] = line.getX1(); xpoints[1] = line.getX2(); ypoints[0] = line.getY1(); ypoints[1] = line.getY2(); calculatePath(); }
public boolean nearby(Node n, double dist) { if (w == null) { Main.debug("way null"); return false; } if (w.containsNode(n)) return false; if (n.isKeyTrue("noexit")) return false; EastNorth coord = n.getEastNorth(); if (coord == null) return false; Point2D p = new Point2D.Double(coord.east(), coord.north()); if (line.getP1().distance(p) > len + dist) return false; if (line.getP2().distance(p) > len + dist) return false; return line.ptSegDist(p) < dist; }
/** * Creates a new line by extending an existing line. * * @param line the line (<code>null</code> not permitted). * @param startPercent the amount to extend the line at the start point end. * @param endPercent the amount to extend the line at the end point end. * @return A new line. */ private Line2D extendLine(Line2D line, double startPercent, double endPercent) { ParamChecks.nullNotPermitted(line, "line"); double x1 = line.getX1(); double x2 = line.getX2(); double deltaX = x2 - x1; double y1 = line.getY1(); double y2 = line.getY2(); double deltaY = y2 - y1; x1 = x1 - (startPercent * deltaX); y1 = y1 - (startPercent * deltaY); x2 = x2 + (endPercent * deltaX); y2 = y2 + (endPercent * deltaY); return new Line2D.Double(x1, y1, x2, y2); }
/** * Compares two lines are returns <code>true</code> if they are equal or both <code>null</code>. * * @param l1 the first line (<code>null</code> permitted). * @param l2 the second line (<code>null</code> permitted). * @return A boolean. */ public static boolean equal(final Line2D l1, final Line2D l2) { if (l1 == null) { return (l2 == null); } if (l2 == null) { return false; } if (!l1.getP1().equals(l2.getP1())) { return false; } if (!l1.getP2().equals(l2.getP2())) { return false; } return true; }
/** * Sets the parameters of this description object to match the supplied object. * * @param o the object (should be an instance of <code>Line2D</code>). * @throws ObjectFactoryException if the object is not an instance of <code>Line2D</code>. */ public void setParameterFromObject(final Object o) throws ObjectFactoryException { if (!(o instanceof Line2D)) { throw new ObjectFactoryException("The given object is no java.awt.geom.Line2D."); } final Line2D line = (Line2D) o; final float x1 = (float) line.getX1(); final float x2 = (float) line.getX2(); final float y1 = (float) line.getY1(); final float y2 = (float) line.getY2(); setParameter("x1", new Float(x1)); setParameter("x2", new Float(x2)); setParameter("y1", new Float(y1)); setParameter("y2", new Float(y2)); }
/** * A utility method that draws a line but only if none of the coordinates are NaN values. * * @param g2 the graphics target. * @param line the line object. * @param x0 the x-coordinate for the starting point of the line. * @param y0 the y-coordinate for the starting point of the line. * @param x1 the x-coordinate for the ending point of the line. * @param y1 the y-coordinate for the ending point of the line. */ private void drawLine(Graphics2D g2, Line2D line, double x0, double y0, double x1, double y1) { if (Double.isNaN(x0) || Double.isNaN(x1) || Double.isNaN(y0) || Double.isNaN(y1)) { return; } line.setLine(x0, y0, x1, y1); g2.draw(line); }
private double calculateDistance(Node node1, Node node2) { double totalDistance = 0; double node1x = node1.getX(); double node1y = node1.getX(); double node2x = node2.getX(); double node2y = node2.getX(); for (double[][][] RADAR_LINE : RADARS) { for (double[][] LINE : RADAR_LINE) { if (Line2D.linesIntersect( LINE[POINT_1][X], LINE[POINT_1][Y], LINE[POINT_2][X], LINE[POINT_2][Y], node1x, node1y, node2x, node2y)) { totalDistance += FEE_IN_RADAR_RANGE; } } } double distanceX = (node1.getX() - node2.getX()); double distanceY = (node1.getY() - node2.getY()); double distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY) * FEE_DISTANCE_FACTOR; return distance + totalDistance; }
/** * Finds the intersection of two line segments * * @return EastNorth null if no intersection was found, the EastNorth coordinates of the * intersection otherwise */ public static EastNorth getSegmentSegmentIntersection( EastNorth p1, EastNorth p2, EastNorth p3, EastNorth p4) { double x1 = p1.getX(); double y1 = p1.getY(); double x2 = p2.getX(); double y2 = p2.getY(); double x3 = p3.getX(); double y3 = p3.getY(); double x4 = p4.getX(); double y4 = p4.getY(); // TODO: do this locally. if (!Line2D.linesIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return null; // Convert line from (point, point) form to ax+by=c double a1 = y2 - y1; double b1 = x1 - x2; double c1 = x2 * y1 - x1 * y2; double a2 = y4 - y3; double b2 = x3 - x4; double c2 = x4 * y3 - x3 * y4; // Solve the equations double det = a1 * b2 - a2 * b1; if (det == 0) return null; // Lines are parallel double x = (b1 * c2 - b2 * c1) / det; double y = (a2 * c1 - a1 * c2) / det; return new EastNorth(x, y); }
/** @see prefuse.render.Renderer#setBounds(prefuse.visual.VisualItem) */ @Override public void setBounds(VisualItem item) { if (!m_manageBounds) { return; } Shape shape = getShape(item); if (shape == null) { item.setBounds(item.getX(), item.getY(), 0, 0); } else if (shape == m_line) { GraphicsLib.setBounds(item, shape, getStroke(item)); } else { m_box.add(m_line.getX1(), m_line.getY1()); m_box.add(m_line.getX2(), m_line.getY2()); item.setBounds(m_box.getMinX(), m_box.getMinY(), m_box.getWidth(), m_box.getHeight()); } }
private static Map<SgroupBracket, IBond> bracketBondPairs( Collection<SgroupBracket> brackets, Collection<IBond> bonds) { Map<SgroupBracket, IBond> pairs = new HashMap<>(); for (SgroupBracket bracket : brackets) { IBond crossingBond = null; for (IBond bond : bonds) { IAtom a1 = bond.getAtom(0); IAtom a2 = bond.getAtom(1); if (Line2D.linesIntersect( bracket.getFirstPoint().x, bracket.getFirstPoint().y, bracket.getSecondPoint().x, bracket.getSecondPoint().y, a1.getPoint2d().x, a1.getPoint2d().y, a2.getPoint2d().x, a2.getPoint2d().y)) { // more than one... not good if (crossingBond != null) return new HashMap<>(); crossingBond = bond; } } if (crossingBond == null) return new HashMap<>(); pairs.put(bracket, crossingBond); } return pairs; }
/** * Creates a new line by extending an existing line. * * @param line the line (<code>null</code> not permitted). * @param startPercent the amount to extend the line at the start point end. * @param endPercent the amount to extend the line at the end point end. * @return A new line. */ private Line2D extendLine(Line2D line, double startPercent, double endPercent) { if (line == null) { throw new IllegalArgumentException("Null 'line' argument."); } double x1 = line.getX1(); double x2 = line.getX2(); double deltaX = x2 - x1; double y1 = line.getY1(); double y2 = line.getY2(); double deltaY = y2 - y1; x1 = x1 - (startPercent * deltaX); y1 = y1 - (startPercent * deltaY); x2 = x2 + (endPercent * deltaX); y2 = y2 + (endPercent * deltaY); return new Line2D.Double(x1, y1, x2, y2); }
/** * Draws the tick marks. This method is called during chart rendering, you normally would not call * this method yourself. * * @param g2 the graphics target ({@code null} not permitted) * @param cursor the current offset from the edge of the dataArea * @param dataArea the area used for plotting data ({@code null} not permitted) * @param edge the location of the axis ({@code null} not permitted) * @param state axis state information ({@code null} not permitted) * @since 1.0.13 */ public void drawTickMarks( Graphics2D g2, double cursor, Rectangle2D dataArea, RectangleEdge edge, AxisState state) { Plot p = getPlot(); if (p == null) { return; } CategoryPlot plot = (CategoryPlot) p; double il = getTickMarkInsideLength(); double ol = getTickMarkOutsideLength(); Line2D line = new Line2D.Double(); List<Comparable> categories = plot.getCategoriesForAxis(this); g2.setPaint(getTickMarkPaint()); g2.setStroke(getTickMarkStroke()); if (edge.equals(RectangleEdge.TOP)) { for (Comparable key : categories) { double x = getCategoryMiddle(key, categories, dataArea, edge); line.setLine(x, cursor, x, cursor + il); g2.draw(line); line.setLine(x, cursor, x, cursor - ol); g2.draw(line); } state.cursorUp(ol); } else if (edge.equals(RectangleEdge.BOTTOM)) { for (Comparable key : categories) { double x = getCategoryMiddle(key, categories, dataArea, edge); line.setLine(x, cursor, x, cursor - il); g2.draw(line); line.setLine(x, cursor, x, cursor + ol); g2.draw(line); } state.cursorDown(ol); } else if (edge.equals(RectangleEdge.LEFT)) { for (Comparable key : categories) { double y = getCategoryMiddle(key, categories, dataArea, edge); line.setLine(cursor, y, cursor + il, y); g2.draw(line); line.setLine(cursor, y, cursor - ol, y); g2.draw(line); } state.cursorLeft(ol); } else if (edge.equals(RectangleEdge.RIGHT)) { for (Comparable key : categories) { double y = getCategoryMiddle(key, categories, dataArea, edge); line.setLine(cursor, y, cursor - il, y); g2.draw(line); line.setLine(cursor, y, cursor + ol, y); g2.draw(line); } state.cursorRight(ol); } }
MyWaySegment(Way w, Node n1, Node n2) { this.w = w; String railway = w.get("railway"); String highway = w.get("highway"); this.isAbandoned = "abandoned".equals(railway) || w.isKeyTrue("disused"); this.highway = (highway != null || railway != null) && !isAbandoned; this.isBoundary = !this.highway && "administrative".equals(w.get("boundary")); line = new Line2D.Double( n1.getEastNorth().east(), n1.getEastNorth().north(), n2.getEastNorth().east(), n2.getEastNorth().north()); len = line.getP1().distance(line.getP2()); this.n1 = n1; this.n2 = n2; }
public LinkedList<LineWorldObject> getLineWorldObjectsOnLine(Line2D line, double radius) { LinkedList<LineWorldObject> objectsInSelection = new LinkedList<LineWorldObject>(); for (LineWorldObject o : lineObjects) { if (o.getXInCM() == o.getX2InCM()) { if (line.intersectsLine( o.getXInCM(), o.getYInCM() - radius, o.getX2InCM(), o.getY2InCM() + radius)) { objectsInSelection.add(o); } } else { if (line.intersectsLine( o.getXInCM() - radius, o.getYInCM(), o.getX2InCM() + radius, o.getY2InCM())) { objectsInSelection.add(o); } } } return objectsInSelection; }
@Override public void mouseMoved(MouseEvent e) { Point p = e.getPoint(); if (line.ptSegDist(p) <= 1.0) { tipLabel.setText(tooltip); } parent.repaint(); }