Package com.inductiveautomation.ignition.client.util.gui

Class DrawingUtilities

java.lang.Object
com.inductiveautomation.ignition.client.util.gui.DrawingUtilities
public class DrawingUtilities extends Object

  • Field Details

    • THIN_LINE

      public static final Stroke THIN_LINE

    • THICK_LINE

      public static final Stroke THICK_LINE

    • TWOPI

      public static final double TWOPI
      See Also:

  • Constructor Details

    • DrawingUtilities

      public DrawingUtilities()

  • Method Details

    • getScaledInstance

      public static BufferedImage getScaledInstance(BufferedImage img, int targetWidth, int targetHeight, Object hint, boolean higherQuality)
      Convenience method that returns a scaled instance of the provided BufferedImage. Implementation thanks to http://today.java.net/pub/a/today/2007/04/03/perils-of-image-getscaledinstance.html
      Parameters:
      img - the original image to be scaled
      targetWidth - the desired width of the scaled instance, in pixels
      targetHeight - the desired height of the scaled instance, in pixels
      hint - one of the rendering hints that corresponds to RenderingHints.KEY_INTERPOLATION (e.g. RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR, RenderingHints.VALUE_INTERPOLATION_BILINEAR, RenderingHints.VALUE_INTERPOLATION_BICUBIC)
      higherQuality - if true, this method will use a multi-step scaling technique that provides higher quality than the usual one-step technique (only useful in downscaling cases, where targetWidth or targetHeight is smaller than the original dimensions, and generally only when the BILINEAR hint is specified)
      Returns:
      a scaled version of the original BufferedImage

    • toBufferedImage

      public static BufferedImage toBufferedImage(Image img)

    • dist

      public static double dist(Point2D a, Point2D b)
      Returns the distance between two points

    • fade

      public static Color fade(Color color, float alpha)

    • dist

      public static double dist(double x1, double y1, double x2, double y2)
      Returns the distance between two points

    • dist

      public static float dist(float x1, float y1, float x2, float y2)
      Returns the distance between two points

    • distSquared

      public static double distSquared(Point2D a, Point2D b)

    • distSquared

      public static double distSquared(double x1, double y1, double x2, double y2)

    • nearestPointOnLine

      public static Point2D nearestPointOnLine(Point2D a, Point2D b, Point2D p)

    • nearestPointOnLine

      public static Point2D nearestPointOnLine(Point2D a, Point2D b, Point2D p, boolean clampToSegment)

    • nearestPointOnLine

      public static Point2D nearestPointOnLine(Point2D a, Point2D b, Point2D p, Point2D dest)

    • nearestPointOnLine

      public static Point2D nearestPointOnLine(Point2D a, Point2D b, Point2D p, Point2D dest, boolean clampToSegment)

    • nearestPointInShape

      public static Point2D nearestPointInShape(Shape shape, Point2D pt)
      Finds the nearest point on or inside the given shape. If the point is already in the shape, this simply sets dest to pt. If not, then it uses a flattening path iterator to find the line segment with with the closest point.

    • nearestPointOnLine

      public static Point2D nearestPointOnLine(double ax, double ay, double bx, double by, double px, double py, boolean clampToSegment, Point2D dest)
      Finds a point on the line that passes through A (ax,ay) and B(bx,by) that is nearest to the point P (px,py).
      Parameters:
      clampToSegment - true if you want the point to be on the segment between points A and B

    • sq

      public static double sq(double d)
      Square (d^2)

    • inset

      public static Rectangle2D inset(Rectangle2D rect, double d)
      Insets a rectangle by the given amount. Alters the given rectangle in-place

    • outset

      public static Rectangle2D outset(Rectangle2D rect, double d)

    • right

      public static double right(Rectangle2D rect)

    • right

      public static double right(Rectangle2D rect, double dX)
      Returns the x-position of the right-hand side of the rectangle after translating it by dX

    • bottom

      public static double bottom(Rectangle2D rect)

    • bottom

      public static double bottom(Rectangle2D rect, double dY)
      Returns the y-position of the bottom side of the rectangle after translating it by dY

    • centerPoint

      public static Point centerPoint(Rectangle rect)

    • centerPoint

      public static Point2D centerPoint(Rectangle2D rect)

    • centerPoint

      public static Point2D centerPoint(Point2D p1, Point2D p2)
      Find the center point on the line segment connecting the two points

    • angle

      public static double angle(Point2D p1, Point2D p2)
      Returns the angle off horizontal created by the line connecting p1 and p2

    • angle

      public static double angle(Point2D p1, Point2D p2, Point2D p3)
      Uses the Math.atan2 to calculate the angle created by the three points, where p1 is the vertex near the angle to be determined.

    • angle

      public static double angle(double p1x, double p1y, double p2x, double p2y, double p3x, double p3y)
      Uses the Math.atan2 to calculate the angle created by the three points, where p1 is the vertex near the angle to be determined.

    • subtract

      public static Point2D subtract(Point2D p1, Point2D p2)

    • dot

      public static double dot(Point2D p1, Point2D p2)
      The dot-product of two vectors.

    • scale

      public static void scale(Point2D p, double d)
      Scales a point by a value. simply multiplies the x and y location by the multiplier.

    • scaleOnLine

      public static Point2D scaleOnLine(Point2D p1, Point2D p2, double value)
      Returns a point on the line that joins p1 and p2. If value is 0.0, this will return p1, if value is 1.0, this will return p2.

    • insets

      public static Insets insets(Rectangle rect, Insets insets)
      Converts a rectangle (x,y,w,h) into an insets that represents the coordinates of the rectangles edges (top=y, bottom=y+h, left=x, right=x+h)
      Parameters:
      rect - Must not be null.
      insets - May be null, in which case a new Insets wil be instantiated and returned.

    • insets2D

      public static Insets2D insets2D(Rectangle2D rect, Insets2D insets)

    • rectangle

      public static Rectangle rectangle(Insets insets, Rectangle r)
      Performs the inverse operation of insets(Rectangle, Insets). Converts an insets representing rectangle edges into a Rectangle. If the insets has been turned "inside out" (e.g. top > bottom) it will be corrected automatically.

    • rectangle

      public static Rectangle2D rectangle(Insets2D insets, Rectangle2D r)

    • copy

      public static Rectangle2D copy(Rectangle2D rect)

    • makeRelative

      public static void makeRelative(Rectangle2D child, Rectangle2D parent)
      For two rectangles in the same coordinate space, make the child relative to the parent. Like: 

       child.x -= parent.x;
 child.y -= parent.y;

    • setX

      public static void setX(Rectangle2D rect, double newX)

    • setY

      public static void setY(Rectangle2D rect, double newY)

    • setWidth

      public static void setWidth(Rectangle2D rect, double newWidth)

    • setHeight

      public static void setHeight(Rectangle2D rect, double newHeight)

    • toString

      public static String toString(Rectangle2D rect)

    • moveRect

      public static void moveRect(Rectangle2D rect, double dx, double dy)
      Moves a rectangle by an offset, like rect.x += dx; rect.y += dy;

    • location

      public static Point2D.Double location(Rectangle2D rect)
      The location of the rectangle's x,y coords.

    • setLocation

      public static void setLocation(Rectangle2D rect, double x, double y)

    • pathsIntersect

      public static boolean pathsIntersect(Shape path1, Shape path2)
      Detects if the outlines of two shapes intersect or not.

    • rectangleContains

      public static boolean rectangleContains(Rectangle2D rectangle, Shape shape)

    • rectangleIntersects

      public static boolean rectangleIntersects(Rectangle2D rectangle, Shape shape)

    • union

      public static void union(Rectangle r1, Rectangle r2, Rectangle rv)
      Unions two rectangles, storing the result in rv, rather than creating a new rectangle

    • snapPointToAngle

      public static Point2D snapPointToAngle(Point2D center, double angle, Point2D desired)
      Snaps a point to a nearby point that is on a line aligned to a multiple of the given angle from the centerpoint.

    • snapPointToAngle

      public static Point2D snapPointToAngle(Point2D center, Point2D horizontalReference, double angle, Point2D desired)
      Snaps a point to a nearby point that is on a line aligned to a multiple of the given angle from the centerpoint.

    • near

      public static boolean near(double value, double nearTo)
      Detects double proximity within 1 millionth, since double equality is not reliable. Implementation is: 

       Math.abs(nearTo - value) < 0.000001d

    • near

      public static boolean near(double value, double nearTo, double tolerance)
      Just like the other implementation of near, but with a custom specified tolerance.

    • near

      public static boolean near(float value, float nearTo)
      Detects double proximity within 1 millionth, since float equality is not reliable. Implementation is: 

       Math.abs(nearTo - value) < 0.000001f

    • near

      public static boolean near(float value, float nearTo, float tolerance)
      Just like the other implementation of near, but with a custom specified tolerance.

    • near

      public static boolean near(Point2D p1, Point2D p2, double tolerance)
      Returns whether or not the two points' x and y coords are near each other within the specified tolerance.

    • near

      public static boolean near(Rectangle2D r1, Rectangle2D r2, double tolerance)
      Returns whether or not the rectangle's are near each other within the specified tolerance.

    • round

      public static Rectangle round(Rectangle2D rect)

    • round

      public static Rectangle round(Rectangle2D rect, Rectangle rv)

    • round

      public static int round(double d)
      Shortcut for (int)Math.round(d);

    • roundSize

      public static Dimension roundSize(Rectangle2D rect)

    • round

      public static Point round(Point2D pt)

    • asPercentage

      public static Rectangle2D asPercentage(Rectangle2D rect, Rectangle2D container, Rectangle2D rv)
      Calculates the position of rect inside container, returning the result as a rectangle where each value is a percentage of the container's size. You can re-create rect by calling project(Rectangle2D, Rectangle2D, Rectangle) with the return value of this function.
      Parameters:
      rect - The rectangle in question
      container - The reference rectangle containing rect
      rv - The return value in which to store the result. May be null.

    • asPercentage

      public static Point2D asPercentage(Point2D pt, Rectangle2D container, Point2D rv)

    • project

      public static Rectangle2D project(Rectangle2D pcts, Rectangle2D container, Rectangle2D rv)
      Projects the rectangle of percentages into the container rectangle, storing the results in the rv

    • project

      public static Point2D project(Point2D pcts, Rectangle2D container, Point2D rv)

    • rotate

      public static void rotate(double angle, double anchorX, double anchorY, Point2D point)

    • rotate

      public static void rotate(double angle, Point2D anchor, Point2D point)
      Rotates the point around the anchor, storing the results by altering the point

    • rotate

      public static void rotate(double angle, Point2D anchor, Point2D point, Point2D dest)

    • rotate

      public static void rotate(double angle, double anchorX, double anchorY, Point2D point, Point2D dest)

    • simplifyPath

      public static List<Point2D> simplifyPath(List<Point2D> points, float tolerance)
      Simplifies a basic poly-line to use fewer points
      Parameters:
      points - The list of points that make up the line
      tolerance - The tolerance of how "simple" to make the line. Zero means no simplification. A value in the high tens will simplify quite a bit.

    • reflect

      public static Point2D reflect(Point2D p1, Point2D p2, double mult)
      Consider the line segment p1,p2. This will return a homothetical point on the reflected segment. A multiplier of 1.0 will return the symmetrical point.

    • smoothPath

      public static GeneralPath smoothPath(List<Point2D> points, double smoothness)
      Turns a list of points representing a poly-line into a GeneralPath consisting of bezier curves. Thanks to http://www.efg2.com/Lab/Graphics/Jean-YvesQueinecBezierCurves.htm
      Parameters:
      smoothness - A double from zero to 1.5. Zero will make straight segments, higher numbers will make a curvier path.

    • smoothPath

      public static GeneralPath smoothPath(List<Point2D> points, double smoothness, boolean close)