## com.esri.sde.sdk.pe Class PeLineType

```java.lang.Object
com.esri.sde.sdk.pe.PeLineType
```

`public final class PeLineTypeextends java.lang.Object`

This class defines various linetype functions.

Constructor Summary
`PeLineType()`

Method Summary
`static void` ```geodesic_coordinate(double a, double e2, double lam1, double phi1, double distance, double az12, PeDouble lam2, PeDouble phi2)```
Find 2nd point on geodesic at a given distance and azimuth from 1st point - "Direct solution" Rapp(1993) - Geometric Geodesy (Part II) - p.
`static double[]` ```geodesic_densify_segment(double a, double e2, double lam1, double phi1, double lam2, double phi2, double interval, int numpts)```
----------------------------------------------------------------- Function for creating geodesic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array.
`static void` ```geodesic_distance(double a, double e2, double lam1, double phi1, double lam2, double phi2, PeDouble distance, PeDouble az12, PeDouble az21)```
Find distance along geodesic from point 1 to point2 and forward and back azimuths - "Inverse solution" Rapp(1993) - Geometric Geodesy (Part II) - p.
`static void` ```geodetic_coordinate(double a, double e2, double lam1, double phi1, double distance, double az12, PeDouble lam2, PeDouble phi2, int geographic_linetype)```
Find 2nd point at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)
`static double[]` ```geodetic_densify_segment(double a, double e2, double lam1, double phi1, double lam2, double phi2, double interval, int numpts, int geographic_linetype)```
----------------------------------------------------------------- Function for creating a generic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array.
`static void` ```geodetic_distance(double a, double e2, double lam1, double phi1, double lam2, double phi2, PeDouble distance, PeDouble az12, PeDouble az21, int geographic_linetype)```
Find distance from point 1 to point2 and forward and back azimuths - "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 "
`static void` ```great_elliptic_coordinate(double a, double e2, double lam1, double phi1, double distance, double az12, PeDouble lam2, PeDouble phi2)```
Find 2nd point on great elliptic at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)
`static double[]` ```great_elliptic_densify_segment(double a, double e2, double lam1, double phi1, double lam2, double phi2, double interval, int numpts)```
----------------------------------------------------------------- Function for creating great elliptic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array.
`static void` ```great_elliptic_distance(double a, double e2, double lam1, double phi1, double lam2, double phi2, PeDouble distance, PeDouble az12, PeDouble az21)```
Find distance along great elliptic from point 1 to point2 and forward and back azimuths -> "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 " Azimuths are positive clockwise from north
`static void` ```loxodrome_coordinate(double a, double e2, double lam1, double phi1, double distance, double az12, PeDouble lam2, PeDouble phi2)```
Find 2nd point on loxodrome at a given distance and azimuth from 1st point - "Direct solution" Snyder - Map Projections -- a Working Manual - pp.
`static double[]` ```loxodrome_densify_segment(double a, double e2, double lam1, double phi1, double lam2, double phi2, double interval, int numpts)```
----------------------------------------------------------------- Function for creating rhumb line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array.
`static void` ```loxodrome_distance(double a, double e2, double lam1, double phi1, double lam2, double phi2, PeDouble distance, PeDouble az12, PeDouble az21)```
Find distance along loxodrome from point 1 to point2 and forward and back azimuths - "Inverse solution" Snyder - Map Projections -- a Working Manual - pp.
`static void` ```normal_section_coordinate(double a, double e2, double lam1, double phi1, double distance, double az12, PeDouble lam2, PeDouble phi2)```
Find 2nd point on normal section at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)
`static double[]` ```normal_section_densify_segment(double a, double e2, double lam1, double phi1, double lam2, double phi2, double interval, int numpts)```
----------------------------------------------------------------- Function for creating normal section line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array.
`static void` ```normal_section_distance(double a, double e2, double lam1, double phi1, double lam2, double phi2, PeDouble distance, PeDouble az12, PeDouble az21)```
Find distance along normal section from point 1 to point2 and forward and back azimuths -> "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 " Azimuths are positive clockwise from north

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

Constructor Detail

### PeLineType

`public PeLineType()`
Method Detail

### geodesic_distance

```public static void geodesic_distance(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
PeDouble distance,
PeDouble az12,
PeDouble az21)```
Find distance along geodesic from point 1 to point2 and forward and back azimuths - "Inverse solution" Rapp(1993) - Geometric Geodesy (Part II) - p. 20-22. Vincenty(1975) formulations a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 "

### geodesic_coordinate

```public static void geodesic_coordinate(double a,
double e2,
double lam1,
double phi1,
double distance,
double az12,
PeDouble lam2,
PeDouble phi2)```
Find 2nd point on geodesic at a given distance and azimuth from 1st point - "Direct solution" Rapp(1993) - Geometric Geodesy (Part II) - p. 20-22. Vincenty(1975) formulations

### loxodrome_distance

```public static void loxodrome_distance(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
PeDouble distance,
PeDouble az12,
PeDouble az21)```
Find distance along loxodrome from point 1 to point2 and forward and back azimuths - "Inverse solution" Snyder - Map Projections -- a Working Manual - pp. 46-47. a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - output rhumb line distance between points (same units as a) az12 - output azimuth from coord 1 to coord 2 (0 North - PI South) az21 - output azimuth from coord 2 to coord 1 " Azimuths are positive clockwise from north

### loxodrome_coordinate

```public static void loxodrome_coordinate(double a,
double e2,
double lam1,
double phi1,
double distance,
double az12,
PeDouble lam2,
PeDouble phi2)```
Find 2nd point on loxodrome at a given distance and azimuth from 1st point - "Direct solution" Snyder - Map Projections -- a Working Manual - pp. 46-47. a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - rhumb line distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)

### great_elliptic_distance

```public static void great_elliptic_distance(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
PeDouble distance,
PeDouble az12,
PeDouble az21)```
Find distance along great elliptic from point 1 to point2 and forward and back azimuths -> "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 " Azimuths are positive clockwise from north

### great_elliptic_coordinate

```public static void great_elliptic_coordinate(double a,
double e2,
double lam1,
double phi1,
double distance,
double az12,
PeDouble lam2,
PeDouble phi2)```
Find 2nd point on great elliptic at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)

### normal_section_distance

```public static void normal_section_distance(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
PeDouble distance,
PeDouble az12,
PeDouble az21)```
Find distance along normal section from point 1 to point2 and forward and back azimuths -> "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 " Azimuths are positive clockwise from north

### normal_section_coordinate

```public static void normal_section_coordinate(double a,
double e2,
double lam1,
double phi1,
double distance,
double az12,
PeDouble lam2,
PeDouble phi2)```
Find 2nd point on normal section at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)

### geodetic_densify_segment

```public static double[] geodetic_densify_segment(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
double interval,
int numpts,
int geographic_linetype)```
----------------------------------------------------------------- Function for creating a generic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array. If the "interval" is less than or equal to zero, then the array will be filled in with "numpts" lon-lat pairs evenly spaced. If the "interval" value is greater than zero, then the array will be filled with points that are separated by the "interval" distance. However, the last point at lam2,phi2 may be closer than the "interval" distance from the point immediately preceding it. Also, when "interval" is positive, the "numpts" value is understood to be the maximum possible number of points in the array. If the specified "interval" distance would create more than this number of points, the array will not be filled and the return value of the function will be the negative of the number of points you actually need to use the "interval" distance.

### geodesic_densify_segment

```public static double[] geodesic_densify_segment(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
double interval,
int numpts)```
----------------------------------------------------------------- Function for creating geodesic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array. If the "interval" is less than or equal to zero, then the array will be filled in with "numpts" lon-lat pairs evenly spaced. If the "interval" value is greater than zero, then the array will be filled with points that are separated by the "interval" distance. However, the last point at lam2,phi2 may be closer than the "interval" distance from the point immediately preceding it. Also, when "interval" is positive, the "numpts" value is understood to be the maximum possible number of points in the array. If the specified "interval" distance would create more than this number of points, the array will not be filled and the return value of the function will be the negative of the number of points you actually need to use the "interval" distance.

### loxodrome_densify_segment

```public static double[] loxodrome_densify_segment(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
double interval,
int numpts)```
----------------------------------------------------------------- Function for creating rhumb line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array. If the "interval" is less than or equal to zero, then the array will be filled in with "numpts" lon-lat pairs evenly spaced. If the "interval" value is greater than zero, then the array will be filled with points that are separated by the "interval" distance. However, the last point at lam2,phi2 may be closer than the "interval" distance from the point immediately preceding it. Also, when "interval" is positive, the "numpts" value is understood to be the maximum possible number of points in the array. If the specified "interval" distance would create more than this number of points, the array will not be filled and the return value of the function will be the negative of the number of points you actually need to use the "interval" distance.

### great_elliptic_densify_segment

```public static double[] great_elliptic_densify_segment(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
double interval,
int numpts)```
----------------------------------------------------------------- Function for creating great elliptic line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[][2] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array. If the "interval" is less than or equal to zero, then the array will be filled in with "numpts" lon-lat pairs evenly spaced. If the "interval" value is greater than zero, then the array will be filled with points that are separated by the "interval" distance. However, the last point at lam2,phi2 may be closer than the "interval" distance from the point immediately preceding it. Also, when "interval" is positive, the "numpts" value is understood to be the maximum possible number of points in the array. If the specified "interval" distance would create more than this number of points, the array will not be filled and the return value of the function will be the negative of the number of points you actually need to use the "interval" distance.

### normal_section_densify_segment

```public static double[] normal_section_densify_segment(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
double interval,
int numpts)```
----------------------------------------------------------------- Function for creating normal section line from point 1 to point 2 ----------------------------------------------------------------- a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) coord[] - array of coordinate pairs to fill in interval - distance between vertices in coordinate array (in same units as a) numpts - if interval is zero or non-positive, number of evenly spaced vertices in coordinate array or if interval is positive, max number of vertices to not exceed in coordinate array. If the "interval" is less than or equal to zero, then the array will be filled in with "numpts" lon-lat pairs evenly spaced. If the "interval" value is greater than zero, then the array will be filled with points that are separated by the "interval" distance. However, the last point at lam2,phi2 may be closer than the "interval" distance from the point immediately preceding it. Also, when "interval" is positive, the "numpts" value is understood to be the maximum possible number of points in the array. If the specified "interval" distance would create more than this number of points, the array will not be filled and the return value of the function will be the negative of the number of points you actually need to use the "interval" distance. If the return value is non-negative, it is the number of points created in the array.

### geodetic_distance

```public static void geodetic_distance(double a,
double e2,
double lam1,
double phi1,
double lam2,
double phi2,
PeDouble distance,
PeDouble az12,
PeDouble az21,
int geographic_linetype)```
Find distance from point 1 to point2 and forward and back azimuths - "Inverse solution" a - semi-major axis length e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) lam2, phi2 - coordinate of 'to' point (coord 2) distance - distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) az21 - azimuth from coord 2 to coord 1 "

### geodetic_coordinate

```public static void geodetic_coordinate(double a,
double e2,
double lam1,
double phi1,
double distance,
double az12,
PeDouble lam2,
PeDouble phi2,
int geographic_linetype)```
Find 2nd point at a given distance and azimuth from 1st point -> "Direct solution" a - semi-major axis length of spheroid e2 - eccentricity squared of spheroid lam1, phi1 - coordinate of 'from' point (coord 1) distance - great elliptic distance between points (same units as a) az12 - azimuth from coord 1 to coord 2 (0 North - PI South) Azimuths are positive clockwise from north lam2, phi2 - output coordinate of 'to' point (coord 2)