Angle

java.lang.Object
- com.vividsolutions.jts.algorithm.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()`

Method Summary

Methods

Modifier and Type	Method and Description
`static double`	`angle(Coordinate p)` Returns the angle that the vector from (0,0) to p, relative to the positive X-axis.
`static double`	`angle(Coordinate p0, Coordinate p1)` Returns the angle of the vector from p0 to p1, relative to the positive X-axis.
`static double`	`angleBetween(Coordinate tip1, Coordinate tail, Coordinate tip2)` Returns the unoriented smallest angle between two vectors.
`static double`	`angleBetweenOriented(Coordinate tip1, Coordinate tail, Coordinate tip2)` Returns the oriented smallest angle between two vectors.
`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(Coordinate p0, Coordinate p1, Coordinate p2)` Computes the interior angle between two segments of a ring.
`static boolean`	`isAcute(Coordinate p0, Coordinate p1, Coordinate p2)` Tests whether the angle between p0-p1-p2 is acute.
`static boolean`	`isObtuse(Coordinate p0, Coordinate p1, Coordinate 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
  - 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
  - angle
```
public static double angle(Coordinate p0,
                           Coordinate p1)
```
    Returns the angle of the vector from p0 to p1, relative to the positive X-axis. The angle is normalized to be in the range [ -Pi, Pi ].
    
    Returns:
    
    the normalized angle (in radians) that p0-p1 makes with the positive x-axis.
  - angle
```
public static double angle(Coordinate 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.
  - isAcute
```
public static boolean isAcute(Coordinate p0,
                              Coordinate p1,
                              Coordinate 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(Coordinate p0,
                               Coordinate p1,
                               Coordinate 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
  - angleBetween
```
public static double angleBetween(Coordinate tip1,
                                  Coordinate tail,
                                  Coordinate 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(Coordinate tip1,
                                          Coordinate tail,
                                          Coordinate 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
  - interiorAngle
```
public static double interiorAngle(Coordinate p0,
                                   Coordinate p1,
                                   Coordinate 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
  - 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.
  - 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
  - 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] )

Class Angle

Field Summary

Fields

Constructor Summary

Constructors

Method Summary

Methods

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

toDegrees

toRadians

angle

angle

isAcute

isObtuse

angleBetween

angleBetweenOriented

interiorAngle

getTurn

normalize

normalizePositive

diff