com.esri.sde.sdk.pe
Class PeLineType

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

public final class PeLineType
extends 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)