Go to the source code of this file.
Data Structures | |
| struct | geo_pos3_t |
| struct | geo_pos2_t |
| struct | geo_pos3_32_t |
| struct | geo_pos2_32_t |
| struct | vect3_t |
| struct | vect3l_t |
| struct | vect2_t |
| struct | ellip_t |
| struct | bezier_t |
| struct | sph_xlate_t |
| struct | fpp_t |
| struct | lcc_t |
| struct | mat4_t |
| struct | mat3_t |
Macros | |
| #define | RAD2DEG_RATIO (M_PI / 180.0) |
| #define | DEG2RAD_RATIO (180.0 / M_PI) |
| #define | DEG2RAD(d) ((d) * RAD2DEG_RATIO) |
| #define | RAD2DEG(r) ((r) * DEG2RAD_RATIO) |
| #define | GEO_POS2(lat, lon) ((geo_pos2_t){(lat), (lon)}) |
| #define | GEO_POS3(lat, lon, elev) ((geo_pos3_t){(lat), (lon), (elev)}) |
| #define | GEO_POS3_F32(lat, lon, elev) ((geo_pos3_f32_t){(lat), (lon), (elev)}) |
| #define | GEO_POS2_F32(lat, lon) ((geo_pos2_f32_t){(lat), (lon)}) |
| #define | TO_GEO3(geo3) ((geo_pos3_t){(geo3).lat, (geo3).lon, (geo3).elev}) |
| #define | TO_GEO2(geo2) ((geo_pos2_t){(geo2).lat, (geo2).lon}) |
| #define | TO_GEO3_32(geo3) ((geo_pos3_32_t){(geo3).lat, (geo3).lon, (geo3).elev}) |
| #define | TO_GEO2_32(geo2) ((geo_pos3_32_t){(geo3).lat, (geo3).lon}) |
| #define | VECT2(x, y) ((vect2_t){(x), (y)}) |
| #define | VECT3(x, y, z) ((vect3_t){(x), (y), (z)}) |
| #define | VECT3L(x, y, z) ((vect3l_t){(x), (y), (z)}) |
| #define | VECT2_EQ(a, b) ((a).x == (b).x && (a).y == (b).y) |
| #define | VECT3_EQ(a, b) ((a).x == (b).x && (a).y == (b).y && (a).z == (b).z) |
| #define | VECT2_PARALLEL(a, b) (((a).y == 0 && (b).y == 0) || (((a).x / (a).y) == ((b).x / (b).y))) |
| #define | ZERO_VECT2 ((vect2_t){0.0, 0.0}) |
| #define | ZERO_VECT3 ((vect3_t){0.0, 0.0, 0.0}) |
| #define | ZERO_VECT3L ((vect3l_t){0.0, 0.0, 0.0}) |
| #define | NULL_VECT2 ((vect2_t){NAN, NAN}) |
| #define | NULL_VECT3 ((vect3_t){NAN, NAN, NAN}) |
| #define | NULL_VECT3L ((vect3l_t){NAN, NAN, NAN}) |
| #define | NULL_GEO_POS3 ((geo_pos3_t){NAN, NAN, NAN}) |
| #define | NULL_GEO_POS3_32 ((geo_pos3_32_t){NAN, NAN, NAN}) |
| #define | NULL_GEO_POS2 ((geo_pos2_t){NAN, NAN}) |
| #define | NULL_GEO_POS2_32 ((geo_pos2_32_t){NAN, NAN}) |
| #define | IS_NULL_VECT(a) (isnan((a).x)) |
| #define | IS_NULL_VECT2(a) (isnan((a).x) || isnan((a).y)) |
| #define | IS_NULL_VECT3(a) (isnan((a).x) || isnan((a).y) || isnan((a).z)) |
| #define | IS_FINITE_VECT2(a) (isfinite((a).x) && isfinite((a).y)) |
| #define | IS_FINITE_VECT3(a) (isfinite((a).x) && isfinite((a).y) && isfinite((a).z)) |
| #define | IS_NULL_GEO_POS(a) (isnan((a).lat)) |
| #define | IS_NULL_GEO_POS2(a) (isnan((a).lat) || isnan((a).lon)) |
| #define | IS_NULL_GEO_POS3(a) (isnan((a).lat) || isnan((a).lon) || isnan((a).elev)) |
| #define | IS_ZERO_VECT2(a) ((a).x == 0.0 && (a).y == 0.0) |
| #define | IS_ZERO_VECT3(a) ((a).x == 0.0 && (a).y == 0.0 && (a).z == 0.0) |
| #define | VECT2_TO_VECT3(v, z) ((vect3_t){(v).x, (v).y, (z)}) |
| #define | VECT3_TO_VECT2(v) ((vect2_t){(v).x, (v).y}) |
| #define | VECT3L_TO_VECT3(v) ((vect3_t){(v).x, (v).y, (v).z}) |
| #define | VECT3_TO_VECT3L(v) ((vect3l_t){(v).x, (v).y, (v).z}) |
| #define | GEO2_TO_GEO3(v, a) ((geo_pos3_t){(v).lat, (v).lon, (a)}) |
| #define | GEO3_TO_GEO2(v) ((geo_pos2_t){(v).lat, (v).lon}) |
| #define | GEO3_FT2M(g) GEO_POS3((g).lat, (g).lon, FEET2MET((g).elev)) |
| #define | GEO3_M2FT(g) GEO_POS3((g).lat, (g).lon, MET2FEET((g).elev)) |
| #define | GEO3_EQ(p1, p2) |
| #define | GEO2_EQ(p1, p2) ((p1).lat == (p2).lat && (p1).lon == (p2).lon) |
| #define | EARTH_MSL 6371200 |
| #define | PRINT_VECT2(v) printf(#v "(%f, %f)\n", v.x, v.y) |
| #define | PRINT_VECT3(v) printf(#v "(%f, %f, %f)\n", v.x, v.y, v.z) |
| #define | PRINT_VECT3L(v) printf(#v "(%Lf, %Lf, %Lf)\n", v.x, v.y, v.z) |
| #define | PRINT_GEO2(p) printf(#p "(%f, %f)\n", p.lat, p.lon) |
| #define | PRINT_GEO3(p) printf(#p "(%f, %f, %f)\n", p.lat, p.lon, p.elev) |
| #define | MAT4(mat, col, row) ((mat)->_mat4_data[(col) * 4 + (row)]) |
| #define | MAT3(mat, col, row) ((mat)->_mat3_data[(col) * 3 + (row)]) |
| #define | MAT4_DATA(mat) ((mat)->_mat4_data) |
| #define | MAT3_DATA(mat) ((mat)->_mat3_data) |
Variables | |
| const ellip_t | wgs84 |
Detailed Description
This file contains LOTS of utility functions and types to handle various geometric operations.
Definition in file geom.h.
Macro Definition Documentation
◆ DEG2RAD
| #define DEG2RAD | ( | d | ) | ((d) * RAD2DEG_RATIO) |
◆ DEG2RAD_RATIO
| #define DEG2RAD_RATIO (180.0 / M_PI) |
◆ EARTH_MSL
| #define EARTH_MSL 6371200 |
◆ GEO2_EQ
| #define GEO2_EQ | ( | p1, | |
| p2 | |||
| ) | ((p1).lat == (p2).lat && (p1).lon == (p2).lon) |
◆ GEO2_TO_GEO3
| #define GEO2_TO_GEO3 | ( | v, | |
| a | |||
| ) | ((geo_pos3_t){(v).lat, (v).lon, (a)}) |
Extends a 2-space geo_pos2_t v into a geo_pos3_t by appending the elevation coordinate a.
◆ GEO3_EQ
| #define GEO3_EQ | ( | p1, | |
| p2 | |||
| ) |
◆ GEO3_FT2M
| #define GEO3_FT2M | ( | g | ) | GEO_POS3((g).lat, (g).lon, FEET2MET((g).elev)) |
Converts a geo_pos3_t using feet for elevation into meters.
◆ GEO3_M2FT
| #define GEO3_M2FT | ( | g | ) | GEO_POS3((g).lat, (g).lon, MET2FEET((g).elev)) |
Converts a geo_pos3_t using meters for elevation into feet.
◆ GEO3_TO_GEO2
| #define GEO3_TO_GEO2 | ( | v | ) | ((geo_pos2_t){(v).lat, (v).lon}) |
◆ GEO_POS2
| #define GEO_POS2 | ( | lat, | |
| lon | |||
| ) | ((geo_pos2_t){(lat), (lon)}) |
- Returns
- A geo_pos2_t with
latandlon.
◆ GEO_POS2_F32
| #define GEO_POS2_F32 | ( | lat, | |
| lon | |||
| ) | ((geo_pos2_f32_t){(lat), (lon)}) |
- Returns
- A geo_pos2_32_t with
latandlon.
◆ GEO_POS3
| #define GEO_POS3 | ( | lat, | |
| lon, | |||
| elev | |||
| ) | ((geo_pos3_t){(lat), (lon), (elev)}) |
- Returns
- A geo_pos3_t with
lat,lonandelev.
◆ GEO_POS3_F32
| #define GEO_POS3_F32 | ( | lat, | |
| lon, | |||
| elev | |||
| ) | ((geo_pos3_f32_t){(lat), (lon), (elev)}) |
- Returns
- A geo_pos3_32_t with
lat,lonandelev.
◆ IS_FINITE_VECT2
| #define IS_FINITE_VECT2 | ( | a | ) | (isfinite((a).x) && isfinite((a).y)) |
◆ IS_FINITE_VECT3
| #define IS_FINITE_VECT3 | ( | a | ) | (isfinite((a).x) && isfinite((a).y) && isfinite((a).z)) |
◆ IS_NULL_GEO_POS
| #define IS_NULL_GEO_POS | ( | a | ) | (isnan((a).lat)) |
◆ IS_NULL_GEO_POS2
| #define IS_NULL_GEO_POS2 | ( | a | ) | (isnan((a).lat) || isnan((a).lon)) |
◆ IS_NULL_GEO_POS3
| #define IS_NULL_GEO_POS3 | ( | a | ) | (isnan((a).lat) || isnan((a).lon) || isnan((a).elev)) |
◆ IS_NULL_VECT
| #define IS_NULL_VECT | ( | a | ) | (isnan((a).x)) |
◆ IS_NULL_VECT2
| #define IS_NULL_VECT2 | ( | a | ) | (isnan((a).x) || isnan((a).y)) |
◆ IS_NULL_VECT3
| #define IS_NULL_VECT3 | ( | a | ) | (isnan((a).x) || isnan((a).y) || isnan((a).z)) |
◆ IS_ZERO_VECT2
| #define IS_ZERO_VECT2 | ( | a | ) | ((a).x == 0.0 && (a).y == 0.0) |
◆ IS_ZERO_VECT3
| #define IS_ZERO_VECT3 | ( | a | ) | ((a).x == 0.0 && (a).y == 0.0 && (a).z == 0.0) |
◆ MAT3
| #define MAT3 | ( | mat, | |
| col, | |||
| row | |||
| ) | ((mat)->_mat3_data[(col) * 3 + (row)]) |
◆ MAT3_DATA
◆ MAT4
| #define MAT4 | ( | mat, | |
| col, | |||
| row | |||
| ) | ((mat)->_mat4_data[(col) * 4 + (row)]) |
◆ MAT4_DATA
◆ NULL_GEO_POS2
| #define NULL_GEO_POS2 ((geo_pos2_t){NAN, NAN}) |
- Returns
- A geo_pos2_t with all coordinates set to
NAN.
◆ NULL_GEO_POS2_32
| #define NULL_GEO_POS2_32 ((geo_pos2_32_t){NAN, NAN}) |
- Returns
- A geo_pos2_32_t with all coordinates set to
NAN.
◆ NULL_GEO_POS3
| #define NULL_GEO_POS3 ((geo_pos3_t){NAN, NAN, NAN}) |
- Returns
- A geo_pos3_t with all coordinates set to
NAN.
◆ NULL_GEO_POS3_32
| #define NULL_GEO_POS3_32 ((geo_pos3_32_t){NAN, NAN, NAN}) |
- Returns
- A geo_pos3_32_t with all coordinates set to
NAN.
◆ NULL_VECT2
| #define NULL_VECT2 ((vect2_t){NAN, NAN}) |
◆ NULL_VECT3
| #define NULL_VECT3 ((vect3_t){NAN, NAN, NAN}) |
◆ NULL_VECT3L
| #define NULL_VECT3L ((vect3l_t){NAN, NAN, NAN}) |
◆ PRINT_GEO2
| #define PRINT_GEO2 | ( | p | ) | printf(#p "(%f, %f)\n", p.lat, p.lon) |
◆ PRINT_GEO3
| #define PRINT_GEO3 | ( | p | ) | printf(#p "(%f, %f, %f)\n", p.lat, p.lon, p.elev) |
◆ PRINT_VECT2
◆ PRINT_VECT3
| #define PRINT_VECT3 | ( | v | ) | printf(#v "(%f, %f, %f)\n", v.x, v.y, v.z) |
◆ PRINT_VECT3L
| #define PRINT_VECT3L | ( | v | ) | printf(#v "(%Lf, %Lf, %Lf)\n", v.x, v.y, v.z) |
◆ RAD2DEG
| #define RAD2DEG | ( | r | ) | ((r) * DEG2RAD_RATIO) |
◆ RAD2DEG_RATIO
| #define RAD2DEG_RATIO (M_PI / 180.0) |
◆ TO_GEO2
| #define TO_GEO2 | ( | geo2 | ) | ((geo_pos2_t){(geo2).lat, (geo2).lon}) |
Converts any object in geo2 with the fields lat and lon into a geo_pos2_t.
◆ TO_GEO2_32
| #define TO_GEO2_32 | ( | geo2 | ) | ((geo_pos3_32_t){(geo3).lat, (geo3).lon}) |
Same as TO_GEO2() but returns a geo_pos2_32_t instead.
◆ TO_GEO3
| #define TO_GEO3 | ( | geo3 | ) | ((geo_pos3_t){(geo3).lat, (geo3).lon, (geo3).elev}) |
Converts any object in geo3 with the fields lat, lon and elev into a geo_pos3_t.
◆ TO_GEO3_32
| #define TO_GEO3_32 | ( | geo3 | ) | ((geo_pos3_32_t){(geo3).lat, (geo3).lon, (geo3).elev}) |
Same as TO_GEO3() but returns a geo_pos3_32_t instead.
◆ VECT2
| #define VECT2 | ( | x, | |
| y | |||
| ) | ((vect2_t){(x), (y)}) |
◆ VECT2_EQ
| #define VECT2_EQ | ( | a, | |
| b | |||
| ) | ((a).x == (b).x && (a).y == (b).y) |
◆ VECT2_PARALLEL
| #define VECT2_PARALLEL | ( | a, | |
| b | |||
| ) | (((a).y == 0 && (b).y == 0) || (((a).x / (a).y) == ((b).x / (b).y))) |
◆ VECT2_TO_VECT3
| #define VECT2_TO_VECT3 | ( | v, | |
| z | |||
| ) | ((vect3_t){(v).x, (v).y, (z)}) |
◆ VECT3
| #define VECT3 | ( | x, | |
| y, | |||
| z | |||
| ) | ((vect3_t){(x), (y), (z)}) |
◆ VECT3_EQ
| #define VECT3_EQ | ( | a, | |
| b | |||
| ) | ((a).x == (b).x && (a).y == (b).y && (a).z == (b).z) |
◆ VECT3_TO_VECT2
| #define VECT3_TO_VECT2 | ( | v | ) | ((vect2_t){(v).x, (v).y}) |
◆ VECT3_TO_VECT3L
| #define VECT3_TO_VECT3L | ( | v | ) | ((vect3l_t){(v).x, (v).y, (v).z}) |
◆ VECT3L
| #define VECT3L | ( | x, | |
| y, | |||
| z | |||
| ) | ((vect3l_t){(x), (y), (z)}) |
◆ VECT3L_TO_VECT3
| #define VECT3L_TO_VECT3 | ( | v | ) | ((vect3_t){(v).x, (v).y, (v).z}) |
◆ ZERO_VECT2
| #define ZERO_VECT2 ((vect2_t){0.0, 0.0}) |
◆ ZERO_VECT3
| #define ZERO_VECT3 ((vect3_t){0.0, 0.0, 0.0}) |
◆ ZERO_VECT3L
| #define ZERO_VECT3L ((vect3l_t){0.0, 0.0, 0.0}) |
Function Documentation
◆ bezier_alloc()
| bezier_t * bezier_alloc | ( | size_t | n_pts | ) |
◆ bezier_free()
| void bezier_free | ( | bezier_t * | curve | ) |
◆ circ2circ_isect()
Computes the intersection of two circles. The circles are centered at ‘ca’ and ‘cb’ and have radii ‘ra’ and ‘rb’ respectively. The ‘i’ argument must point to an array capable of holding at least two points, which will be filled with the intersection points. The function returns the number of intersections (and appropriate slots filled in ‘i’). Possible values are:
- 0: the circles do not intersect.
- 1: the circles touch in one point.
- 2: the circles intersection at two points.
- UINT_MAX: the circles are identical (‘i’ is NOT populated).
◆ dir2hdg()
| double dir2hdg | ( | vect2_t | dir | ) |
◆ ecef2ecmi()
◆ ecef2geo()
| geo_pos3_t ecef2geo | ( | vect3_t | pos, |
| const ellip_t * | ellip | ||
| ) |
Does the reverse transform of geo2ecef_mtr(), by translating ECEF coordinates into geographic coordinates on an ellipsoid.
- Parameters
-
pos Input ECEF coordinates to be translated. ellip Definition of the ellipsoid to which posis to be translated.
- Returns
- Geographic coordinates on ellipsoid
ellipmatching the position of ECEF coordinatespos. Elevation is encoded as meters.
◆ ecef2gl()
◆ ecef2gl_l()
◆ ecef2sph()
| geo_pos3_t ecef2sph | ( | vect3_t | v | ) |
◆ ecmi2ecef()
◆ ecmi2geo()
| geo_pos3_t ecmi2geo | ( | vect3_t | pos, |
| double | delta_t, | ||
| const ellip_t * | ellip | ||
| ) |
Converts ECmI coordinates into geographic coordinates.
- Parameters
-
pos Input ECmI coordinates. delta_t Delta-time (in seconds) from the ECmI reference time. ellip Earth ellipsoid to use. You'll probably want &wgs84 in here.
- Returns
- Geographic coordinates corresponding to the specified ECmI coordinates at reference time + delta_t.
◆ ecmi2sph()
| geo_pos3_t ecmi2sph | ( | vect3_t | pos, |
| double | delta_t | ||
| ) |
◆ ellip_init()
| ellip_t ellip_init | ( | double | semi_major, |
| double | semi_minor, | ||
| double | flattening | ||
| ) |
◆ fpp2geo()
| geo_pos2_t fpp2geo | ( | vect2_t | pos, |
| const fpp_t * | fpp | ||
| ) |
Back-projects a point from a projection surface into spherical coordinate space. N.B. since projection loses some information about the original input point, back-projection is incomplete for projections where either:
- the projection origin was non-negative, or
- the projection origin was less than -EARTH_MSL
This means back-projection is only uniquely possible possible for gnomonic, stereographic and other projections where the projection origin lies "inside" the projected sphere. In case back-projection is not unique, the point closer to the projection origin is returned.
◆ fpp_get_gc_distance()
◆ fpp_get_scale()
- Returns
- The scaling previously set using fpp_set_scale(). If no scaling is set, the default is
VECT2(1, 1).
◆ fpp_init()
| fpp_t fpp_init | ( | geo_pos2_t | center, |
| double | rot, | ||
| double | dist, | ||
| const ellip_t * | ellip, | ||
| bool_t | allow_inv | ||
| ) |
Prepares a set of projection parameters for projections from a fixed origin along the projection axis onto a flat projection plane. The plane is centered at ‘center’ and is rotated ‘rot’ degrees relative to the sphere's native coordinate system. The projection plane touches the sphere at the center point and is parallel to its surface there. Points on the sphere are projected from a fixed origin along a projection axis that is perpendicular to the projection plane and passes through its center. The distance of this point along the projection axis from the projection plane is ‘dist’ with positive offsets increasing away from the sphere's center.
You can pass INFINITY for ‘dist’, in which case the projection origin will be centered at +INFINITY, constructing an orthographic projection. N.B. ATM there is no way to position the projection point at -INFINITY. If you wish to construct an inverted orthographic projection, simply flip the ‘x’ coordinate of the projected points. Also, it is illegal to pass dist == 0.0.
◆ fpp_set_scale()
Sets a final output scaling vector for a flat plane projection previously created using one of the *fpp_init functions. This scaling vector is used to simply multiply the X and Y coordinates of the project's output. In essence, it is no different than doing:
- See also
- fpp_init()
◆ gc_distance()
| double gc_distance | ( | geo_pos2_t | start, |
| geo_pos2_t | end | ||
| ) |
◆ gc_point_hdg()
| double gc_point_hdg | ( | geo_pos2_t | start, |
| geo_pos2_t | end | ||
| ) |
Computes the great-circle point heading from start to end. The heading is calculated at the position of the first argument. In essence, it asks the question "what heading to I need to be facing
at `start` to move towards `end` along a great circle path." The underlying projection assumes a WGS-84 ellipsoid.
◆ geo2ecef_ft()
| vect3_t geo2ecef_ft | ( | geo_pos3_t | pos, |
| const ellip_t * | ellip | ||
| ) |
◆ geo2ecef_mtr()
| vect3_t geo2ecef_mtr | ( | geo_pos3_t | pos, |
| const ellip_t * | ellip | ||
| ) |
Converts a series of geographic coordinates on an ellipsoid into Euclidian coordinates in the ECEF coordinate system.
- Parameters
-
pos Geographic coordinates on the ellipsoid described in ellip. The elevation component of the coordinates is assumed to be in meters.ellip Definition of the ellipsoid on which posexists.
- Returns
- A 3-space vector, corresponding to the position of
posin the ECEF coordinate system.
◆ geo2ecmi()
| vect3_t geo2ecmi | ( | geo_pos3_t | pos, |
| double | delta_t, | ||
| const ellip_t * | ellip | ||
| ) |
Converts geographic coordinates into ECmI coordinates.
- Parameters
-
pos Input geographic coordinates. delta_t Delta-time (in seconds) from the ECmI reference time. ellip Earth ellipsoid to use. You'll probably want &wgs84 in here.
- Returns
- ECmI coordinates corresponding to the specified geographic coordinates at reference time + delta_t.
◆ geo2fpp()
| vect2_t geo2fpp | ( | geo_pos2_t | pos, |
| const fpp_t * | fpp | ||
| ) |
Projects a point at ‘pos’ according to the projection ‘proj’ and returns a 2D vector to the projected point's location on the projection plane. If the specified point cannot be projected (because its projection falls outside of the projection plane), NULL_VECT2 is returned instead.
◆ geo2lcc()
| vect2_t geo2lcc | ( | geo_pos2_t | pos, |
| const lcc_t * | lcc | ||
| ) |
◆ geo2sph()
| geo_pos3_t geo2sph | ( | geo_pos3_t | pos, |
| const ellip_t * | ellip | ||
| ) |
Converts between geographic coordinates on an ellipsoid into equivalent geographic coordinates on a perfect sphere.
- Parameters
-
pos Geographic coordinates on the ellipsoid described in ellip.ellip Definition of the ellipsoid on which posexists.
- Returns
- Coordinates
posexpressed on a perfect sphere, as-if it was co-located with the ellipsoid.
◆ geo_displace()
| geo_pos2_t geo_displace | ( | const ellip_t * | ellip, |
| geo_pos2_t | pos, | ||
| double | truehdg, | ||
| double | dist | ||
| ) |
Given a starting coordinate and displacement direction + distance, displaces the starting coordinates in the desired direction and distance along a great circle.
- Parameters
-
ellip An optional ellipsoid pointer, describing the Earth ellipsoid to use. If NULL, then the projection uses a spherical Earth model.pos The starting position of the displacement. truehdg The direction of the displacement in degrees from true north. dist The distance of the displacement in meters.
- Returns
- The displaced coordinates along a great circle, in the direction of
truehdgand fordistmeters.
◆ geo_displace_dir()
| geo_pos2_t geo_displace_dir | ( | const ellip_t * | ellip, |
| geo_pos2_t | pos, | ||
| vect2_t | dir, | ||
| double | dist | ||
| ) |
◆ geo_pos2_from_str()
| bool_t geo_pos2_from_str | ( | const char * | lat, |
| const char * | lon, | ||
| geo_pos2_t * | pos | ||
| ) |
Parses a series of strings for latitude and longitude and uses them to construct a geo_pos2_t, with checking for correctness.
- Parameters
-
lat The latitude in fractional degrees (positive north). lon The longitude in fractional degrees (positive east). pos A mandatory return argument that will be filled the resulting geographic coordinates.
- Returns
B_TRUEif the input coordinates were a valid latitude & longitude. If the input contained invalid data, returnsB_FALSEinstead and you shouldn't use the returnedpos.
◆ geo_pos3_from_str()
| bool_t geo_pos3_from_str | ( | const char * | lat, |
| const char * | lon, | ||
| const char * | elev, | ||
| geo_pos3_t * | pos | ||
| ) |
Same as geo_pos2_from_str(), but includes an elevation argument and returns a geo_pos3_t.
◆ gl2ecef()
◆ gl2ecef_l()
◆ gnomo_fpp_init()
| fpp_t gnomo_fpp_init | ( | geo_pos2_t | center, |
| double | rot, | ||
| const ellip_t * | ellip, | ||
| bool_t | allow_inv | ||
| ) |
◆ hdg2dir()
| vect2_t hdg2dir | ( | double | truehdg | ) |
◆ is_on_arc()
| bool_t is_on_arc | ( | double | angle_x, |
| double | angle1, | ||
| double | angle2, | ||
| bool_t | cw | ||
| ) |
Determines whether an angle is part of an arc.
- Parameters
-
angle_x Angle who's membership of the arc to examine (in degrees). angle1 Start angle of the arc (in degrees). angle2 End angle of the arc (in degrees). cw Flag indicating whether the arc progresses clockwise or counter clockwise from angle1 to angle2.
- Returns
B_TRUEif angle_x is on the arc,B_FALSEif it is not.
◆ lcc_init()
| lcc_t lcc_init | ( | double | reflat, |
| double | reflon, | ||
| double | stdpar1, | ||
| double | stdpar2 | ||
| ) |
Prepares a set of Lambert conformal conic projection parameters.
- Parameters
-
reflat Reference latitude in degrees. reflon Reference longitude in degrees. stdpar1 First standard parallel in degrees. stdpar2 Second standard parallel in degrees.
- Returns
- The set of lcc parameters to pass to geo2lcc.
◆ mat3_ident()
| void mat3_ident | ( | mat3_t * | mat | ) |
◆ mat4_ident()
| void mat4_ident | ( | mat4_t * | mat | ) |
◆ ortho_fpp_init()
| fpp_t ortho_fpp_init | ( | geo_pos2_t | center, |
| double | rot, | ||
| const ellip_t * | ellip, | ||
| bool_t | allow_inv | ||
| ) |
◆ point_in_poly()
Checks if a point lies inside of a polygon.
- Parameters
-
pt A vector pointing to the position of the point to examine. poly An array of 2-space vectors specifying the points of the polygon. Must contain at least 3 points and must be terminated by a final NULL_VECT2point.
- Returns
B_TRUEif the point lies inside ofpoly,B_FALSEotherwise.
◆ quad_bezier_func()
| double quad_bezier_func | ( | double | x, |
| const bezier_t * | func | ||
| ) |
Calculates the value of a function defined by a set of quadratic bezier curve segments.
- Parameters
-
x Function input value. func The set of quadratic bezier curves defining the function. Please note that since this is a function, curve segments may not overlap. This is to guarantee that at any point xthe function resolves to one value.
- Returns
- The function value at point
x. If the point is beyond the edges of the bezier curve segments describing the function, theyvalue of the first or last curve point is returned, i.e. beyond the curve boundaries, the function is assumed to be flat.
◆ quad_bezier_func_inv()
| double * quad_bezier_func_inv | ( | double | y, |
| const bezier_t * | func, | ||
| size_t * | n_xs | ||
| ) |
Calculates the value of a function ‘g’ defined as the inverse of a function ‘f’ which is defined by a set of quadratic bezier curve segments:
IOW, this function is the inverse of quad_bezier_func(), i.e. it looks for an unknown ‘x’ input to quad_bezier_func() that produces a known ‘y’ output. Please note that the ‘func’ argument of quad_bezier_func need not be a bijective function definition, so quad_bezier_func_inv() can return multiple ‘x’ values that all map to the given ‘y’ value. As a special case, if the ‘func’ definition includes a constant portion (i.e. a potentially infinite number of ‘x’ values corresponds to a given ‘y’ value), quad_bezier_func_inv() returns NULL and sets n_xs to SIZE_MAX. You should treat this case as "infinite solutions."
- Parameters
-
y Output value of the function funcfor which to look for a suitable ‘x’ input value.func The set of quadratic bezier curve defining the function with the same constraints as in quad_bezier_func. n_xs Output parameter which will be filled with the number of ‘x’ input points returned.
- Returns
- An array of ‘x’ values corresponding to the ‘y’ argument. The number of elements in this array is filled in ‘n_xs’. Caller is responsible for freeing this array using lacf_free().
◆ rel_angle()
| double rel_angle | ( | double | a1, |
| double | a2 | ||
| ) |
◆ sph2ecef()
| vect3_t sph2ecef | ( | geo_pos3_t | pos | ) |
Converts surface coordinates on an Earth-sized sphere into 3-space coordinate vector in ECEF space. Please note that this considers the Earth to be a perfect sphere and hence cannot be used for very precise calculations. For more accurate conversions, use geo2ecef_mtr().
- Parameters
-
pos The input position to convert.
In 3-space, axes have their origins at the globe center point, are perpendicular to each other and are designated as follows:
- x: positive & passing through lat=0, lon=0
- y: positive & passing through lat=0, lon=+90
- z: positive & passing through lat=90
- See also
- geo2ecef_mtr()
◆ sph2ecmi()
| vect3_t sph2ecmi | ( | geo_pos3_t | pos, |
| double | delta_t | ||
| ) |
◆ sph_xlate()
| geo_pos2_t sph_xlate | ( | geo_pos2_t | pos, |
| const sph_xlate_t * | xlate | ||
| ) |
◆ sph_xlate_init()
| sph_xlate_t sph_xlate_init | ( | geo_pos2_t | displac, |
| double | rot, | ||
| bool_t | inv | ||
| ) |
Prepares a set of geographical coordinate translation parameters.
- Parameters
-
displac The relative latitude & longitude (in degrees) between the origins of the two respective coordinate systems. For example, a displacement of +10 degrees of latitude (north) and +20 degrees of longitude (east) will result in an input coordinate of +5,+5 translating into -5,-15 in the target system (assuming ‘rotation’ below is zero). Please note that these coordinates as well as all transformations are assumed to be in geocentric coordinates on the an EARTH_MSL radius spheroid. rot The relative rotation of the axes of the target coordinate system to the source coordinate system in degrees counter-clockwise. For example, a rotation of +90 degrees and no translation applied to an input coordinate of +5 degrees of latitude (north) and +5 degrees of longitude (east) will translate into -5,+5.
◆ sph_xlate_vect()
| vect3_t sph_xlate_vect | ( | vect3_t | p, |
| const sph_xlate_t * | xlate | ||
| ) |
◆ stereo_fpp_init()
| fpp_t stereo_fpp_init | ( | geo_pos2_t | center, |
| double | rot, | ||
| const ellip_t * | ellip, | ||
| bool_t | allow_inv | ||
| ) |
◆ vect2_abs()
| double vect2_abs | ( | vect2_t | a | ) |
◆ vect2_add()
◆ vect2_dist()
◆ vect2_dotprod()
◆ vect2_mean()
◆ vect2_mul()
◆ vect2_neg()
◆ vect2_norm()
◆ vect2_rot()
◆ vect2_rot_inv_y()
◆ vect2_scmul()
◆ vect2_set_abs()
◆ vect2_sub()
◆ vect2_unit()
◆ vect2circ_isect()
◆ vect2poly_isect()
◆ vect2poly_isect_get()
| unsigned vect2poly_isect_get | ( | vect2_t | a, |
| vect2_t | oa, | ||
| const vect2_t * | poly, | ||
| vect2_t * | isects, | ||
| unsigned | cap | ||
| ) |
Checks if a vector and a polygon intersect.
- Parameters
-
a Direction & magnitude of first vector. oa Vector pointing to the origin of the first vector. poly An array of 2-space vectors specifying the points of the polygon. Must contain at least 3 points and must be terminated by a final NULL_VECT2point.isects An optional return array that will be populated with the intersection points. At most ‘cap’ elements will be written to the array. The return value is the total number of intersections. Can be NULLif you do not wish to receive the intersections.cap Number of elements in ‘isects’ that can be populated with intersections. No more than ‘cap’ elements will be written to isects.
- Returns
- The number of the polygon's sides that the vector intersects. Please note that this only checks intersection with the sides, not if the vector is contained completely inside the polygon. Use point_in_poly() with the vector's origin to test for that scenario.
◆ vect2sph_isect()
| unsigned vect2sph_isect | ( | vect3_t | v, |
| vect3_t | o, | ||
| vect3_t | c, | ||
| double | r, | ||
| bool_t | confined, | ||
| vect3_t | i[2] | ||
| ) |
Determines whether and where a vector intersects the surface of a sphere. Returns the number of intersection points (zero, one or two).
- Parameters
-
v Vector for which to determine the intersection. o Vector pointing from the coordinate origin to the origin of vector v (i.e. displacement of ‘v’ from the origin). c Displacement of sphere center point from the coordinate origin. r Radius of sphere. confined If B_TRUE, only intersects which lie between the vector's start & ending point (inclusive) are returned. Otherwise any intersect along an infinite linear extension of the vector is returned. i If not NULL, this function stores vectors pointing to the intersection points from the coordinate origin in this array: - if 0 is returned, two null vectors are stored in the array.
- if 1 is returned, one null vector and one non-null vector pointing to the intersection point are stored in the array (ordering in the array is not guarantted as described here).
- if 2 is returned, two non-null vectors pointing to the intersection points are stored in the array.
◆ vect2vect_isect()
Calculates a 2D vector-to-vector intersection point and returns it.
- Parameters
-
a First vector. oa Vector to origin of first vector from the coordinate origin. b Second vector. oa Vector to origin of second vector from the coordinate origin. confined If B_TRUE, only intersects which lie between the vectors' start & ending points (inclusive) are considered. Otherwise any intersect along an infinite linear extension of the vectors is returned.
- Returns
- A vector from the coordinate origin to the intersection point or NULL_VECT2 if the vectors are parallel (no intersection or inf many intersections if they're directly on top of each other).
◆ vect3_abs()
| double vect3_abs | ( | vect3_t | a | ) |
◆ vect3_acf2local()
◆ vect3_add()
◆ vect3_dist()
◆ vect3_dotprod()
◆ vect3_local2acf()
Converts a vector from X-Plane local OpenGL coordinates to aircraft coordinates, given aircraft local roll, pitch and heading. This can also be used to convert from aircraft coordinates to the true reference frame, by using true_phi, true_theta and true_psi intead of their local equivalents.
◆ vect3_mean()
◆ vect3_mul()
Performs a simple per-component multiplication of two vectors.
◆ vect3_neg()
◆ vect3_rot()
◆ vect3_scmul()
◆ vect3_set_abs()
◆ vect3_sub()
◆ vect3_unit()
◆ vect3_xprod()
◆ vect3l_abs()
| long double vect3l_abs | ( | vect3l_t | a | ) |
