JTS Topology Suite version 1.12

## com.vividsolutions.jts.algorithm Class Angle

```java.lang.Object com.vividsolutions.jts.algorithm.Angle
```

`public class Angleextends java.lang.Object`

Utility functions for working with angles. Unless otherwise noted, methods in this class express angles in radians.

Field Summary
`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
`Angle()`

Method Summary
`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 rotation from v1 to v2; a negative result corresponds to a clockwise 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] )

JTS Topology Suite version 1.12