Angle (RS Core TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.math.Angle

```
public class Angle
extends Object
```
Utility functions for working with angles. Unless otherwise noted, methods in this class express angles in radians.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CLOCKWISE` Constant representing clockwise orientation
`static int`	`COUNTERCLOCKWISE` Constant representing counterclockwise orientation
`static int`	`NONE` Constant representing no orientation
`static double`	`PI_OVER_2`
`static double`	`PI_OVER_4`
`static double`	`PI_TIMES_2`

Constructor Summary

Constructors
Constructor and Description

Angle()

Constructors
Constructor and Description
`Angle()`

Method Summary

Methods
Modifier and Type	Method and Description
`static double`	`angle(double x, double y)` Calculate the angle of a coordinates
`static double`	`angle(double x1, double y1, double x2, double y2, double x3, double y3)` Calculate the angle between three coordinates.
`static double`	`angle(Point p)` Returns the angle that the vector from (0,0) to p, relative to the positive X-axis.
`static double`	`angle(Point p1, Point p2, Point p3)`
`static double`	`angle2d(double x1, double x2, double y1, double y2)`
`static double`	`angleBetween(Point tip1, Point tail, Point tip2)` Returns the unoriented smallest angle between two vectors.
`static double`	`angleBetweenOriented(Point tip1, Point tail, Point tip2)` Returns the oriented smallest angle between two vectors.
`static double`	`angleDegrees(double x1, double y1, double x2, double y2)`
`static double`	`angleDiff(double ang1, double ang2)`
`static double`	`angleDiff(double angle1, double angle2, boolean clockwise)`
`static double`	`angleDiffDegrees(double a, double b)`
`static double`	`angleNorthDegrees(double x1, double y1, double x2, double y2)`
`static double`	`diff(double ang1, double ang2)` Computes the unoriented smallest difference between two angles.
`static int`	`getTurn(double ang1, double ang2)` Returns whether an angle must turn clockwise or counterclockwise to overlap another angle.
`static double`	`interiorAngle(Point p0, Point p1, Point p2)` Computes the interior angle between two segments of a ring.
`static boolean`	`isAcute(Point p0, Point p1, Point p2)` Tests whether the angle between p0-p1-p2 is acute.
`static boolean`	`isObtuse(Point p0, Point p1, Point p2)` Tests whether the angle between p0-p1-p2 is obtuse.
`static double`	`normalize(double angle)` Computes the normalized value of an angle, which is the equivalent angle in the range ( -Pi, Pi ].
`static double`	`normalizePositive(double angle)` Computes the normalized positive value of an angle, which is the equivalent angle in the range [ 0, 2*Pi ).
`static double`	`toDegrees(double radians)` Converts from radians to degrees.
`static double`	`toRadians(double angleDegrees)` Converts from degrees to radians.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PI_TIMES_2
```
public static final double PI_TIMES_2
```
    See Also:
    Constant Field Values
  - PI_OVER_2
```
public static final double PI_OVER_2
```
    See Also:
    Constant Field Values
  - PI_OVER_4
```
public static final double PI_OVER_4
```
    See Also:
    Constant Field Values
  - COUNTERCLOCKWISE
```
public static final int COUNTERCLOCKWISE
```
    Constant representing counterclockwise orientation
    
    See Also:
    Constant Field Values
  - CLOCKWISE
```
public static final int CLOCKWISE
```
    Constant representing clockwise orientation
    
    See Also:
    Constant Field Values
  - NONE
```
public static final int NONE
```
    Constant representing no orientation
    
    See Also:
    Constant Field Values
- Constructor Detail
  - Angle
```
public Angle()
```
- Method Detail
  - angle
```
public static double angle(double x,
           double y)
```
    Calculate the angle of a coordinates
    
    Parameters:
    x - The x coordinate.
    y - The y coordinate.
    
    Returns:
    The distance.
  - angle
```
public static double angle(double x1,
           double y1,
           double x2,
           double y2,
           double x3,
           double y3)
```
    Calculate the angle between three coordinates.
    
    Parameters:
    x1 - The first x coordinate.
    y1 - The first y coordinate.
    x2 - The second x coordinate.
    y2 - The second y coordinate.
    x3 - The third x coordinate.
    y3 - The third y coordinate.
    
    Returns:
    The distance.
  - angle
```
public static double angle(Point p)
```
    Returns the angle that the vector from (0,0) to p, relative to the positive X-axis. The angle is normalized to be in the range ( -Pi, Pi ].
    
    Returns:
    the normalized angle (in radians) that p makes with the positive x-axis.
  - angle
```
public static double angle(Point p1,
           Point p2,
           Point p3)
```
  - angle2d
```
public static double angle2d(double x1,
             double x2,
             double y1,
             double y2)
```
  - angleBetween
```
public static double angleBetween(Point tip1,
                  Point tail,
                  Point tip2)
```
    Returns the unoriented smallest angle between two vectors. The computed angle will be in the range [0, Pi).
    
    Parameters:
    tip1 - the tip of one vector
    tail - the tail of each vector
    tip2 - the tip of the other vector
    
    Returns:
    the angle between tail-tip1 and tail-tip2
  - angleBetweenOriented
```
public static double angleBetweenOriented(Point tip1,
                          Point tail,
                          Point tip2)
```
    Returns the oriented smallest angle between two vectors. The computed angle will be in the range (-Pi, Pi]. A positive result corresponds to a counterclockwise (CCW) rotation from v1 to v2; a negative result corresponds to a clockwise (CW) rotation; a zero result corresponds to no rotation.
    
    Parameters:
    tip1 - the tip of v1
    tail - the tail of each vector
    tip2 - the tip of v2
    
    Returns:
    the angle between v1 and v2, relative to v1
  - angleDegrees
```
public static double angleDegrees(double x1,
                  double y1,
                  double x2,
                  double y2)
```
  - angleDiff
```
public static double angleDiff(double ang1,
               double ang2)
```
  - angleDiff
```
public static double angleDiff(double angle1,
               double angle2,
               boolean clockwise)
```
  - angleDiffDegrees
```
public static double angleDiffDegrees(double a,
                      double b)
```
  - angleNorthDegrees
```
public static double angleNorthDegrees(double x1,
                       double y1,
                       double x2,
                       double y2)
```
  - diff
```
public static double diff(double ang1,
          double ang2)
```
    Computes the unoriented smallest difference between two angles. The angles are assumed to be normalized to the range [-Pi, Pi]. The result will be in the range [0, Pi].
    
    Parameters:
    ang1 - the angle of one vector (in [-Pi, Pi] )
    ang2 - the angle of the other vector (in range [-Pi, Pi] )
    
    Returns:
    the angle (in radians) between the two vectors (in range [0, Pi] )
  - getTurn
```
public static int getTurn(double ang1,
          double ang2)
```
    Returns whether an angle must turn clockwise or counterclockwise to overlap another angle.
    
    Parameters:
    ang1 - an angle (in radians)
    ang2 - an angle (in radians)
    
    Returns:
    whether a1 must turn CLOCKWISE, COUNTERCLOCKWISE or NONE to overlap a2.
  - interiorAngle
```
public static double interiorAngle(Point p0,
                   Point p1,
                   Point p2)
```
    Computes the interior angle between two segments of a ring. The ring is assumed to be oriented in a clockwise direction. The computed angle will be in the range [0, 2Pi]
    
    Parameters:
    p0 - a point of the ring
    p1 - the next point of the ring
    p2 - the next point of the ring
    
    Returns:
    the interior angle based at p1
  - isAcute
```
public static boolean isAcute(Point p0,
              Point p1,
              Point p2)
```
    Tests whether the angle between p0-p1-p2 is acute. An angle is acute if it is less than 90 degrees.
    Note: this implementation is not precise (determistic) for angles very close to 90 degrees.
    
    Parameters:
    p0 - an endpoint of the angle
    p1 - the base of the angle
    p2 - the other endpoint of the angle
  - isObtuse
```
public static boolean isObtuse(Point p0,
               Point p1,
               Point p2)
```
    Tests whether the angle between p0-p1-p2 is obtuse. An angle is obtuse if it is greater than 90 degrees.
    Note: this implementation is not precise (determistic) for angles very close to 90 degrees.
    
    Parameters:
    p0 - an endpoint of the angle
    p1 - the base of the angle
    p2 - the other endpoint of the angle
  - normalize
```
public static double normalize(double angle)
```
    Computes the normalized value of an angle, which is the equivalent angle in the range ( -Pi, Pi ].
    
    Parameters:
    angle - the angle to normalize
    
    Returns:
    an equivalent angle in the range (-Pi, Pi]
  - normalizePositive
```
public static double normalizePositive(double angle)
```
    Computes the normalized positive value of an angle, which is the equivalent angle in the range [ 0, 2*Pi ). E.g.:
    - normalizePositive(0.0) = 0.0
    - normalizePositive(-PI) = PI
    - normalizePositive(-2PI) = 0.0
    - normalizePositive(-3PI) = PI
    - normalizePositive(-4PI) = 0
    - normalizePositive(PI) = PI
    - normalizePositive(2PI) = 0.0
    - normalizePositive(3PI) = PI
    - normalizePositive(4PI) = 0.0
    Parameters:
    angle - the angle to normalize, in radians
    
    Returns:
    an equivalent positive angle
  - toDegrees
```
public static double toDegrees(double radians)
```
    Converts from radians to degrees.
    
    Parameters:
    radians - an angle in radians
    
    Returns:
    the angle in degrees
  - toRadians
```
public static double toRadians(double angleDegrees)
```
    Converts from degrees to radians.
    
    Parameters:
    angleDegrees - an angle in degrees
    
    Returns:
    the angle in radians

Class Angle

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI_TIMES_2

PI_OVER_2

PI_OVER_4

COUNTERCLOCKWISE

CLOCKWISE

NONE

Constructor Detail

Angle

Method Detail

angle

angle

angle

angle

angle2d

angleBetween

angleBetweenOriented

angleDegrees

angleDiff

angleDiff

angleDiffDegrees

angleNorthDegrees

diff

getTurn

interiorAngle

isAcute

isObtuse

normalize

normalizePositive

toDegrees

toRadians