GEOS: geos::algorithm::Angle Class Reference

Static Public Member Functions | Static Public Attributes

# geos::algorithm::Angle Class Reference

Utility functions for working with angles. More...

`#include <Angle.h>`

List of all members.

## Static Public Member Functions
static double | toDegrees (double radians)
| Converts from radians to degrees.
static double | toRadians (double angleDegrees)
| Converts from degrees to radians.
static double | angle (const geom::Coordinate &p0, const geom::Coordinate &p1)
| Returns the angle of the vector from p0 to p1, relative to the positive X-axis.
static double | angle (const geom::Coordinate &p)
| Returns the angle that the vector from (0,0) to p, relative to the positive X-axis.
static bool | isAcute (const geom::Coordinate &p0, const geom::Coordinate &p1, const geom::Coordinate &p2)
| Tests whether the angle between p0-p1-p2 is acute.
static bool | isObtuse (const geom::Coordinate &p0, const geom::Coordinate &p1, const geom::Coordinate &p2)
| Tests whether the angle between p0-p1-p2 is obtuse.
static double | angleBetween (const geom::Coordinate &tip1, const geom::Coordinate &tail, const geom::Coordinate &tip2)
| Returns the unoriented smallest angle between two vectors.
static double | angleBetweenOriented (const geom::Coordinate &tip1, const geom::Coordinate &tail, const geom::Coordinate &tip2)
| Returns the oriented smallest angle between two vectors.
static double | interiorAngle (const geom::Coordinate &p0, const geom::Coordinate &p1, const geom::Coordinate &p2)
| Computes the interior angle between two segments of a ring.
static int | getTurn (double ang1, double ang2)
| Returns whether an angle must turn clockwise or counterclockwise to overlap another angle.
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 | diff (double ang1, double ang2)
| Computes the unoriented smallest difference between two angles.
## Static Public Attributes
static const double | PI_TIMES_2
static const double | PI_OVER_2
static const double | PI_OVER_4
static const int | COUNTERCLOCKWISE = CGAlgorithms::COUNTERCLOCKWISE
| Constant representing counterclockwise orientation.
static const int | CLOCKWISE = CGAlgorithms::CLOCKWISE
| Constant representing clockwise orientation.
static const int | NONE = CGAlgorithms::COLLINEAR
| Constant representing no orientation.

## Detailed Description

Utility functions for working with angles.

Unless otherwise noted, methods in this class express angles in radians.

## Member Function Documentation

static double geos::algorithm::Angle::angle | ( | const geom::Coordinate & | p0,
|  | const geom::Coordinate & | p1
| ) |  | `[static]`

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.

static double geos::algorithm::Angle::angle | ( | const geom::Coordinate & | p ) | `[static]`

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.

static double geos::algorithm::Angle::angleBetween | ( | const geom::Coordinate & | tip1,
|  | const geom::Coordinate & | tail,
|  | const geom::Coordinate & | tip2
| ) |  | `[static]`

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

static double geos::algorithm::Angle::angleBetweenOriented | ( | const geom::Coordinate & | tip1,
|  | const geom::Coordinate & | tail,
|  | const geom::Coordinate & | tip2
| ) |  | `[static]`

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

static double geos::algorithm::Angle::diff | ( | double | ang1,
|  | double | ang2
| ) |  | `[static]`

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] )

static int geos::algorithm::Angle::getTurn | ( | double | ang1,
|  | double | ang2
| ) |  | `[static]`

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.

static double geos::algorithm::Angle::interiorAngle | ( | const geom::Coordinate & | p0,
|  | const geom::Coordinate & | p1,
|  | const geom::Coordinate & | p2
| ) |  | `[static]`

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`

static bool geos::algorithm::Angle::isAcute | ( | const geom::Coordinate & | p0,
|  | const geom::Coordinate & | p1,
|  | const geom::Coordinate & | p2
| ) |  | `[static]`

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

static bool geos::algorithm::Angle::isObtuse | ( | const geom::Coordinate & | p0,
|  | const geom::Coordinate & | p1,
|  | const geom::Coordinate & | p2
| ) |  | `[static]`

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

static double geos::algorithm::Angle::normalize | ( | double | angle ) | `[static]`

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]

static double geos::algorithm::Angle::normalizePositive | ( | double | angle ) | `[static]`

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

static double geos::algorithm::Angle::toDegrees | ( | double | radians ) | `[static]`

Converts from radians to degrees.

Parameters:

  radians | an angle in radians

Returns:
  the angle in degrees

static double geos::algorithm::Angle::toRadians | ( | double | angleDegrees ) | `[static]`

Converts from degrees to radians.

Parameters:

  angleDegrees | an angle in degrees

Returns:
  the angle in radians

The documentation for this class was generated from the following file:

- Angle.h