projects.h: remove deprecated XY, XYZ, LP, LPZ, UV, UVW, projUV and projUVW structures

7 files changed, 47 insertions, 46 deletions

diff --git a/src/transformations/affine.cpp b/src/transformations/affine.cpp
index e2b668d3..002bb2dd 100644
--- a/src/transformations/affine.cpp
+++ b/src/transformations/affine.cpp
@@ -70,14 +70,14 @@ static PJ_COORD forward_4d(PJ_COORD obs, PJ *P) {
     return newObs;
 }
 
-static XYZ forward_3d(LPZ lpz, PJ *P) {
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.lpz = lpz;
     return forward_4d(point, P).xyz;
 }
 
 
-static XY forward_2d(LP lp, PJ *P) {
+static PJ_XY forward_2d(PJ_LP lp, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.lp = lp;
     return forward_4d(point, P).xy;
@@ -98,13 +98,13 @@ static PJ_COORD reverse_4d(PJ_COORD obs, PJ *P) {
     return newObs;
 }
 
-static LPZ reverse_3d(XYZ xyz, PJ *P) {
+static PJ_LPZ reverse_3d(PJ_XYZ xyz, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.xyz = xyz;
     return reverse_4d(point, P).lpz;
 }
 
-static LP reverse_2d(XY xy, PJ *P) {
+static PJ_LP reverse_2d(PJ_XY xy, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.xy = xy;
     return reverse_4d(point, P).lp;
diff --git a/src/transformations/deformation.cpp b/src/transformations/deformation.cpp
index 0197cf5c..7efe8a8c 100644
--- a/src/transformations/deformation.cpp
+++ b/src/transformations/deformation.cpp
@@ -19,7 +19,7 @@ returns cartesian coordinates as well.
 Corrections in the gridded model are in east, north, up (ENU) space.
 Hence the input coordinates needs to be converted to ENU-space when
 searching for corrections in the grid. The corrections are then converted
-to cartesian XYZ-space and applied to the input coordinates (also in
+to cartesian PJ_XYZ-space and applied to the input coordinates (also in
 cartesian space).
 
 A full deformation model is described by two grids, one for the horizontal
@@ -72,12 +72,12 @@ struct pj_opaque {
 } // anonymous namespace
 
 /********************************************************************************/
-static XYZ get_grid_shift(PJ* P, XYZ cartesian) {
+static PJ_XYZ get_grid_shift(PJ* P, PJ_XYZ cartesian) {
 /********************************************************************************
     Read correction values from grid. The cartesian input coordinates are
     converted to geodetic coordinates in order look up the correction values
     in the grid. Once the grid corrections are read we need to convert them
-    from ENU-space to cartesian XYZ-space. ENU -> XYZ formula described in:
+    from ENU-space to cartesian PJ_XYZ-space. ENU -> PJ_XYZ formula described in:
 
     Nørbech, T., et al, 2003(?), "Transformation from a Common Nordic Reference
     Frame to ETRS89 in Denmark, Finland, Norway, and Sweden – status report"
@@ -109,7 +109,7 @@ static XYZ get_grid_shift(PJ* P, XYZ cartesian) {
     sl = sin(geodetic.lp.lam);
     cl = cos(geodetic.lp.lam);
 
-    /* ENU -> XYZ */
+    /* ENU -> PJ_XYZ */
     temp.xyz.x = -sp*cl*shift.enu.n - sl*shift.enu.e + cp*cl*shift.enu.u;
     temp.xyz.y = -sp*sl*shift.enu.n + cl*shift.enu.e + cp*sl*shift.enu.u;
     temp.xyz.z =     cp*shift.enu.n +                     sp*shift.enu.u;
@@ -122,11 +122,11 @@ static XYZ get_grid_shift(PJ* P, XYZ cartesian) {
 }
 
 /********************************************************************************/
-static XYZ reverse_shift(PJ *P, XYZ input, double dt) {
+static PJ_XYZ reverse_shift(PJ *P, PJ_XYZ input, double dt) {
 /********************************************************************************
     Iteratively determine the reverse grid shift correction values.
 *********************************************************************************/
-    XYZ out, delta, dif;
+    PJ_XYZ out, delta, dif;
     double z0;
     int i = MAX_ITERATIONS;
 
@@ -163,10 +163,10 @@ static XYZ reverse_shift(PJ *P, XYZ input, double dt) {
     return out;
 }
 
-static XYZ forward_3d(LPZ lpz, PJ *P) {
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P) {
     struct pj_opaque *Q = (struct pj_opaque *) P->opaque;
     PJ_COORD out, in;
-    XYZ shift;
+    PJ_XYZ shift;
     double dt = 0.0;
     in.lpz = lpz;
     out = in;
@@ -192,7 +192,7 @@ static XYZ forward_3d(LPZ lpz, PJ *P) {
 static PJ_COORD forward_4d(PJ_COORD in, PJ *P) {
     struct pj_opaque *Q = (struct pj_opaque *) P->opaque;
     double dt;
-    XYZ shift;
+    PJ_XYZ shift;
     PJ_COORD out = in;
 
     if (Q->t_obs != HUGE_VAL) {
@@ -212,7 +212,7 @@ static PJ_COORD forward_4d(PJ_COORD in, PJ *P) {
 }
 
 
-static LPZ reverse_3d(XYZ in, PJ *P) {
+static PJ_LPZ reverse_3d(PJ_XYZ in, PJ *P) {
     struct pj_opaque *Q = (struct pj_opaque *) P->opaque;
     PJ_COORD out;
     double dt = 0.0;
diff --git a/src/transformations/helmert.cpp b/src/transformations/helmert.cpp
index 4a3abf4e..55112aaa 100644
--- a/src/transformations/helmert.cpp
+++ b/src/transformations/helmert.cpp
@@ -59,8 +59,8 @@ Last update: 2018-10-26
 PROJ_HEAD(helmert, "3(6)-, 4(8)- and 7(14)-parameter Helmert shift");
 PROJ_HEAD(molobadekas, "Molodensky-Badekas transformation");
 
-static XYZ helmert_forward_3d (LPZ lpz, PJ *P);
-static LPZ helmert_reverse_3d (XYZ xyz, PJ *P);
+static PJ_XYZ helmert_forward_3d (PJ_LPZ lpz, PJ *P);
+static PJ_LPZ helmert_reverse_3d (PJ_XYZ xyz, PJ *P);
 
 
 
@@ -70,10 +70,10 @@ struct pj_opaque_helmert {
 /************************************************************************
     Projection specific elements for the "helmert" PJ object
 ************************************************************************/
-    XYZ xyz;
-    XYZ xyz_0;
-    XYZ dxyz;
-    XYZ refp;
+    PJ_XYZ xyz;
+    PJ_XYZ xyz_0;
+    PJ_XYZ dxyz;
+    PJ_XYZ refp;
     PJ_OPK opk;
     PJ_OPK opk_0;
     PJ_OPK dopk;
@@ -322,7 +322,7 @@ static void build_rot_matrix(PJ *P) {
 
 
 /***********************************************************************/
-static XY helmert_forward (LP lp, PJ *P) {
+static PJ_XY helmert_forward (PJ_LP lp, PJ *P) {
 /***********************************************************************/
     struct pj_opaque_helmert *Q = (struct pj_opaque_helmert *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
@@ -342,7 +342,7 @@ static XY helmert_forward (LP lp, PJ *P) {
 
 
 /***********************************************************************/
-static LP helmert_reverse (XY xy, PJ *P) {
+static PJ_LP helmert_reverse (PJ_XY xy, PJ *P) {
 /***********************************************************************/
     struct pj_opaque_helmert *Q = (struct pj_opaque_helmert *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
@@ -362,7 +362,7 @@ static LP helmert_reverse (XY xy, PJ *P) {
 
 
 /***********************************************************************/
-static XYZ helmert_forward_3d (LPZ lpz, PJ *P) {
+static PJ_XYZ helmert_forward_3d (PJ_LPZ lpz, PJ *P) {
 /***********************************************************************/
     struct pj_opaque_helmert *Q = (struct pj_opaque_helmert *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
@@ -402,7 +402,7 @@ static XYZ helmert_forward_3d (LPZ lpz, PJ *P) {
 
 
 /***********************************************************************/
-static LPZ helmert_reverse_3d (XYZ xyz, PJ *P) {
+static PJ_LPZ helmert_reverse_3d (PJ_XYZ xyz, PJ *P) {
 /***********************************************************************/
     struct pj_opaque_helmert *Q = (struct pj_opaque_helmert *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
diff --git a/src/transformations/hgridshift.cpp b/src/transformations/hgridshift.cpp
index f0e57251..c8dfea15 100644
--- a/src/transformations/hgridshift.cpp
+++ b/src/transformations/hgridshift.cpp
@@ -17,7 +17,7 @@ struct pj_opaque_hgridshift {
 };
 } // anonymous namespace
 
-static XYZ forward_3d(LPZ lpz, PJ *P) {
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.lpz = lpz;
 
@@ -31,7 +31,7 @@ static XYZ forward_3d(LPZ lpz, PJ *P) {
 }
 
 
-static LPZ reverse_3d(XYZ xyz, PJ *P) {
+static PJ_LPZ reverse_3d(PJ_XYZ xyz, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
     point.xyz = xyz;
 
diff --git a/src/transformations/horner.cpp b/src/transformations/horner.cpp
index 73977de6..271d1187 100644
--- a/src/transformations/horner.cpp
+++ b/src/transformations/horner.cpp
@@ -83,6 +83,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "proj.h"
 #include "proj_internal.h"
 #include "projects.h"
 
@@ -109,13 +110,13 @@ struct horner {
     double *fwd_c;   /* coefficients for the complex forward transformations */
     double *inv_c;   /* coefficients for the complex inverse transformations */
 
-    UV *fwd_origin;  /* False longitude/latitude */
-    UV *inv_origin;  /* False easting/northing   */
+    PJ_UV *fwd_origin;  /* False longitude/latitude */
+    PJ_UV *inv_origin;  /* False easting/northing   */
 };
 } // anonymous namespace
 
 typedef struct horner HORNER;
-static UV      horner_func (const HORNER *transformation, PJ_DIRECTION direction, UV position);
+static PJ_UV   horner_func (const HORNER *transformation, PJ_DIRECTION direction, PJ_UV position);
 static HORNER *horner_alloc (size_t order, int complex_polynomia);
 static void    horner_free (HORNER *h);
 
@@ -166,8 +167,8 @@ static HORNER *horner_alloc (size_t order, int complex_polynomia) {
             polynomia_ok = 1;
     }
 
-    h->fwd_origin = static_cast<UV*>(horner_calloc (1, sizeof(UV)));
-    h->inv_origin = static_cast<UV*>(horner_calloc (1, sizeof(UV)));
+    h->fwd_origin = static_cast<PJ_UV*>(horner_calloc (1, sizeof(PJ_UV)));
+    h->inv_origin = static_cast<PJ_UV*>(horner_calloc (1, sizeof(PJ_UV)));
 
     if (polynomia_ok && h->fwd_origin && h->inv_origin)
         return h;
@@ -181,7 +182,7 @@ static HORNER *horner_alloc (size_t order, int complex_polynomia) {
 
 
 /**********************************************************************/
-static UV horner_func (const HORNER *transformation, PJ_DIRECTION direction, UV position) {
+static PJ_UV horner_func (const HORNER *transformation, PJ_DIRECTION direction, PJ_UV position) {
 /***********************************************************************
 
 A reimplementation of the classic Engsager/Poder 2D Horner polynomial
@@ -223,7 +224,7 @@ summing the tiny high order elements first.
     double *tcx, *tcy;                        /* Coefficient pointers */
     double  range; /* Equivalent to the gen_pol's FLOATLIMIT constant */
     double  n, e;
-    UV uv_error;
+    PJ_UV uv_error;
     uv_error.u = uv_error.v = HUGE_VAL;
 
     if (nullptr==transformation)
@@ -310,7 +311,7 @@ static PJ_COORD horner_reverse_4d (PJ_COORD point, PJ *P) {
 
 
 /**********************************************************************/
-static UV complex_horner (const HORNER *transformation, PJ_DIRECTION direction, UV position) {
+static PJ_UV complex_horner (const HORNER *transformation, PJ_DIRECTION direction, PJ_UV position) {
 /***********************************************************************
 
 A reimplementation of a classic Engsager/Poder Horner complex
@@ -323,7 +324,7 @@ polynomial evaluation engine.
     double *c, *cb;                           /* Coefficient pointers */
     double  range; /* Equivalent to the gen_pol's FLOATLIMIT constant */
     double  n, e, w, N, E;
-    UV uv_error;
+    PJ_UV uv_error;
     uv_error.u = uv_error.v = HUGE_VAL;
 
     if (nullptr==transformation)
diff --git a/src/transformations/molodensky.cpp b/src/transformations/molodensky.cpp
index 91743fda..843da5c9 100644
--- a/src/transformations/molodensky.cpp
+++ b/src/transformations/molodensky.cpp
@@ -53,8 +53,8 @@
 
 PROJ_HEAD(molodensky, "Molodensky transform");
 
-static XYZ forward_3d(LPZ lpz, PJ *P);
-static LPZ reverse_3d(XYZ xyz, PJ *P);
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P);
+static PJ_LPZ reverse_3d(PJ_XYZ xyz, PJ *P);
 
 namespace { // anonymous namespace
 struct pj_opaque_molodensky {
@@ -123,7 +123,7 @@ static double RM (double a, double es, double phi) {
 }
 
 
-static LPZ calc_standard_params(LPZ lpz, PJ *P) {
+static PJ_LPZ calc_standard_params(PJ_LPZ lpz, PJ *P) {
     struct pj_opaque_molodensky *Q = (struct pj_opaque_molodensky *) P->opaque;
     double dphi, dlam, dh;
 
@@ -162,7 +162,7 @@ static LPZ calc_standard_params(LPZ lpz, PJ *P) {
 }
 
 
-static LPZ calc_abridged_params(LPZ lpz, PJ *P) {
+static PJ_LPZ calc_abridged_params(PJ_LPZ lpz, PJ *P) {
     struct pj_opaque_molodensky *Q = (struct pj_opaque_molodensky *) P->opaque;
     double dphi, dlam, dh;
 
@@ -197,7 +197,7 @@ static LPZ calc_abridged_params(LPZ lpz, PJ *P) {
 }
 
 
-static XY forward_2d(LP lp, PJ *P) {
+static PJ_XY forward_2d(PJ_LP lp, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
 
     point.lp = lp;
@@ -207,7 +207,7 @@ static XY forward_2d(LP lp, PJ *P) {
 }
 
 
-static LP reverse_2d(XY xy, PJ *P) {
+static PJ_LP reverse_2d(PJ_XY xy, PJ *P) {
     PJ_COORD point = {{0,0,0,0}};
 
     point.xy = xy;
@@ -218,7 +218,7 @@ static LP reverse_2d(XY xy, PJ *P) {
 }
 
 
-static XYZ forward_3d(LPZ lpz, PJ *P) {
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P) {
     struct pj_opaque_molodensky *Q = (struct pj_opaque_molodensky *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
 
@@ -246,10 +246,10 @@ static PJ_COORD forward_4d(PJ_COORD obs, PJ *P) {
 }
 
 
-static LPZ reverse_3d(XYZ xyz, PJ *P) {
+static PJ_LPZ reverse_3d(PJ_XYZ xyz, PJ *P) {
     struct pj_opaque_molodensky *Q = (struct pj_opaque_molodensky *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
-    LPZ lpz;
+    PJ_LPZ lpz;
 
     /* calculate parameters depending on the mode we are in */
     point.xyz = xyz;
diff --git a/src/transformations/vgridshift.cpp b/src/transformations/vgridshift.cpp
index b3da906d..fe2bc3e5 100644
--- a/src/transformations/vgridshift.cpp
+++ b/src/transformations/vgridshift.cpp
@@ -18,7 +18,7 @@ struct pj_opaque_vgridshift {
 };
 } // anonymous namespace
 
-static XYZ forward_3d(LPZ lpz, PJ *P) {
+static PJ_XYZ forward_3d(PJ_LPZ lpz, PJ *P) {
     struct pj_opaque_vgridshift *Q = (struct pj_opaque_vgridshift *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
     point.lpz = lpz;
@@ -33,7 +33,7 @@ static XYZ forward_3d(LPZ lpz, PJ *P) {
 }
 
 
-static LPZ reverse_3d(XYZ xyz, PJ *P) {
+static PJ_LPZ reverse_3d(PJ_XYZ xyz, PJ *P) {
     struct pj_opaque_vgridshift *Q = (struct pj_opaque_vgridshift *) P->opaque;
     PJ_COORD point = {{0,0,0,0}};
     point.xyz = xyz;