From 549268ff39d4ef614bc8a32d7bd735e87802d78b Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Thu, 22 Nov 2018 21:56:33 +0100 Subject: Make proj_create_crs_to_crs() use proj_obj_create_operations() and use area of use argument, and make createFromUserInput() recognize init=epsg: / init=IGNF: in legacy mode, that is when proj_context_get_use_proj4_init_rules() is used --- src/c_api.cpp | 126 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 75 insertions(+), 51 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index fbba0f51..ba1b9534 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -276,6 +276,18 @@ PJ_GUESSED_WKT_DIALECT proj_context_guess_wkt_dialect(PJ_CONTEXT *ctx, // --------------------------------------------------------------------------- +//! @cond Doxygen_Suppress +static const char *getOptionValue(const char *option, + const char *keyWithEqual) noexcept { + if (ci_starts_with(option, keyWithEqual)) { + return option + strlen(keyWithEqual); + } + return nullptr; +} +//! @endcond + +// --------------------------------------------------------------------------- + /** \brief Instanciate an object from a WKT string, PROJ string or object code * (like "EPSG:4326", "urn:ogc:def:crs:EPSG::4326", * "urn:ogc:def:coordinateOperation:EPSG::1671"). @@ -287,7 +299,17 @@ PJ_GUESSED_WKT_DIALECT proj_context_guess_wkt_dialect(PJ_CONTEXT *ctx, * * @param ctx PROJ context, or NULL for default context * @param text String (must not be NULL) - * @param options should be set to NULL for now + * @param options null-terminated list of options, or NULL. Currently + * supported options are: + * * @return Object that must be unreferenced with proj_obj_unref(), or NULL in * case of error. */ @@ -298,8 +320,20 @@ PJ_OBJ *proj_obj_create_from_user_input(PJ_CONTEXT *ctx, const char *text, (void)options; auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); try { + bool usePROJ4InitRules = false; + for (auto iter = options; iter && iter[0]; ++iter) { + const char *value; + if ((value = getOptionValue(*iter, "USE_PROJ4_INIT_RULES="))) { + usePROJ4InitRules = ci_equal(value, "YES"); + } else { + std::string msg("Unknown option :"); + msg += *iter; + proj_log_error(ctx, __FUNCTION__, msg.c_str()); + return nullptr; + } + } auto identifiedObject = nn_dynamic_pointer_cast( - createFromUserInput(text, dbContext)); + createFromUserInput(text, dbContext, usePROJ4InitRules)); if (identifiedObject) { return PJ_OBJ::create(ctx, NN_NO_CHECK(identifiedObject)); } @@ -809,18 +843,6 @@ const char *proj_obj_get_id_code(PJ_OBJ *obj, int index) { // --------------------------------------------------------------------------- -//! @cond Doxygen_Suppress -static const char *getOptionValue(const char *option, - const char *keyWithEqual) noexcept { - if (ci_starts_with(option, keyWithEqual)) { - return option + strlen(keyWithEqual); - } - return nullptr; -} -//! @endcond - -// --------------------------------------------------------------------------- - /** \brief Get a WKT representation of an object. * * The returned string is valid while the input obj parameter is valid, @@ -986,26 +1008,28 @@ const char *proj_obj_as_proj_string(PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, /** \brief Return the area of use of an object. * * @param obj Object (must not be NULL) - * @param p_west_lon Pointer to a double to receive the west longitude (in - * degrees). Or NULL. If the returned value is -1000, the bounding box is + * @param p_west_lon_degree Pointer to a double to receive the west longitude + * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_south_lat Pointer to a double to receive the south latitude (in - * degrees). Or NULL. If the returned value is -1000, the bounding box is + * @param p_south_lat_degree Pointer to a double to receive the south latitude + * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_east_lon Pointer to a double to receive the east longitude (in - * degrees). Or NULL. If the returned value is -1000, the bounding box is + * @param p_east_lon_degree Pointer to a double to receive the east longitude + * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_north_lat Pointer to a double to receive the north latitude (in - * degrees). Or NULL. If the returned value is -1000, the bounding box is + * @param p_north_lat_degree Pointer to a double to receive the north latitude + * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. * @param p_area_name Pointer to a string to receive the name of the area of * use. Or NULL. *p_area_name is valid while obj is valid itself. * @return TRUE in case of success, FALSE in case of error or if the area * of use is unknown. */ -int proj_obj_get_area_of_use(PJ_OBJ *obj, double *p_west_lon, - double *p_south_lat, double *p_east_lon, - double *p_north_lat, const char **p_area_name) { +int proj_obj_get_area_of_use(PJ_OBJ *obj, double *p_west_lon_degree, + double *p_south_lat_degree, + double *p_east_lon_degree, + double *p_north_lat_degree, + const char **p_area_name) { if (p_area_name) { *p_area_name = nullptr; } @@ -1031,32 +1055,32 @@ int proj_obj_get_area_of_use(PJ_OBJ *obj, double *p_west_lon, auto bbox = dynamic_cast(geogElements[0].get()); if (bbox) { - if (p_west_lon) { - *p_west_lon = bbox->westBoundLongitude(); + if (p_west_lon_degree) { + *p_west_lon_degree = bbox->westBoundLongitude(); } - if (p_south_lat) { - *p_south_lat = bbox->southBoundLatitude(); + if (p_south_lat_degree) { + *p_south_lat_degree = bbox->southBoundLatitude(); } - if (p_east_lon) { - *p_east_lon = bbox->eastBoundLongitude(); + if (p_east_lon_degree) { + *p_east_lon_degree = bbox->eastBoundLongitude(); } - if (p_north_lat) { - *p_north_lat = bbox->northBoundLatitude(); + if (p_north_lat_degree) { + *p_north_lat_degree = bbox->northBoundLatitude(); } return true; } } - if (p_west_lon) { - *p_west_lon = -1000; + if (p_west_lon_degree) { + *p_west_lon_degree = -1000; } - if (p_south_lat) { - *p_south_lat = -1000; + if (p_south_lat_degree) { + *p_south_lat_degree = -1000; } - if (p_east_lon) { - *p_east_lon = -1000; + if (p_east_lon_degree) { + *p_east_lon_degree = -1000; } - if (p_north_lat) { - *p_north_lat = -1000; + if (p_north_lat_degree) { + *p_north_lat_degree = -1000; } return true; } @@ -3743,21 +3767,21 @@ void proj_operation_factory_context_set_desired_accuracy( /** \brief Set the desired area of interest for the resulting coordinate * transformations. * - * For an area of interest crossing the anti-meridian, west_lon will be - * greater than east_lon. + * For an area of interest crossing the anti-meridian, west_lon_degree will be + * greater than east_lon_degree. * * @param ctxt Operation factory context. must not be NULL - * @param west_lon West longitude (in degrees). - * @param south_lat South latitude (in degrees). - * @param east_lon East longitude (in degrees). - * @param north_lat North latitude (in degrees). + * @param west_lon_degree West longitude (in degrees). + * @param south_lat_degree South latitude (in degrees). + * @param east_lon_degree East longitude (in degrees). + * @param north_lat_degree North latitude (in degrees). */ void proj_operation_factory_context_set_area_of_interest( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, double west_lon, double south_lat, - double east_lon, double north_lat) { + PJ_OPERATION_FACTORY_CONTEXT *ctxt, double west_lon_degree, + double south_lat_degree, double east_lon_degree, double north_lat_degree) { assert(ctxt); - ctxt->operationContext->setAreaOfInterest( - Extent::createFromBBOX(west_lon, south_lat, east_lon, north_lat)); + ctxt->operationContext->setAreaOfInterest(Extent::createFromBBOX( + west_lon_degree, south_lat_degree, east_lon_degree, north_lat_degree)); } // --------------------------------------------------------------------------- -- cgit v1.2.3 From a66c12277666489cac74535bad8d2cf565ad542d Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Fri, 23 Nov 2018 15:51:33 +0100 Subject: cs2cs: upgrade to use proj_create_crs_to_crs() --- src/c_api.cpp | 147 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 145 insertions(+), 2 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index ba1b9534..3b51d905 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -39,6 +39,7 @@ #include "proj/common.hpp" #include "proj/coordinateoperation.hpp" +#include "proj/coordinatesystem.hpp" #include "proj/crs.hpp" #include "proj/datum.hpp" #include "proj/io.hpp" @@ -56,6 +57,7 @@ using namespace NS_PROJ::common; using namespace NS_PROJ::crs; +using namespace NS_PROJ::cs; using namespace NS_PROJ::datum; using namespace NS_PROJ::io; using namespace NS_PROJ::internal; @@ -1354,8 +1356,8 @@ int proj_obj_prime_meridian_get_parameters(PJ_OBJ *prime_meridian, // --------------------------------------------------------------------------- -/** \brief Return the base CRS of a BoundCRS or the source CRS of a - * CoordinateOperation. +/** \brief Return the base CRS of a BoundCRS or a DerivedCRS/ProjectedCRS, or + * the source CRS of a CoordinateOperation. * * The returned object must be unreferenced with proj_obj_unref() after * use. @@ -1372,6 +1374,10 @@ PJ_OBJ *proj_obj_get_source_crs(PJ_OBJ *obj) { if (boundCRS) { return PJ_OBJ::create(obj->ctx, boundCRS->baseCRS()); } + auto derivedCRS = dynamic_cast(ptr); + if (derivedCRS) { + return PJ_OBJ::create(obj->ctx, derivedCRS->baseCRS()); + } auto co = dynamic_cast(ptr); if (co) { auto sourceCRS = co->sourceCRS(); @@ -4071,3 +4077,140 @@ double proj_coordoperation_get_accuracy(PJ_OBJ *coordoperation) { } return -1; } + +// --------------------------------------------------------------------------- + +/** \brief Returns the coordinate system of a SingleCRS. + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param crs Objet of type SingleCRS (must not be NULL) + * @return Object that must be unreferenced with proj_obj_unref(), or NULL + * in case of error. + */ +PJ_OBJ *proj_obj_crs_get_coordinate_system(PJ_OBJ *crs) { + assert(crs); + auto l_crs = dynamic_cast(crs->obj.get()); + if (!l_crs) { + proj_log_error(crs->ctx, __FUNCTION__, "Object is not a SingleCRS"); + return nullptr; + } + return PJ_OBJ::create(crs->ctx, l_crs->coordinateSystem()); +} + +// --------------------------------------------------------------------------- + +/** \brief Returns the type of the coordinate system. + * + * @param cs Objet of type CoordinateSystem (must not be NULL) + * @return type, or NULL in case of error. + */ +const char *proj_obj_cs_get_type(PJ_OBJ *cs) { + assert(cs); + auto l_cs = dynamic_cast(cs->obj.get()); + if (!l_cs) { + proj_log_error(cs->ctx, __FUNCTION__, + "Object is not a CoordinateSystem"); + return nullptr; + } + if (dynamic_cast(l_cs)) { + return "Cartesian"; + } + if (dynamic_cast(l_cs)) { + return "Ellipsoidal"; + } + if (dynamic_cast(l_cs)) { + return "Vertical"; + } + if (dynamic_cast(l_cs)) { + return "Spherical"; + } + if (dynamic_cast(l_cs)) { + return "Ordinal"; + } + if (dynamic_cast(l_cs)) { + return "Parametric"; + } + if (dynamic_cast(l_cs)) { + return "DateTimeTemporal"; + } + if (dynamic_cast(l_cs)) { + return "TemporalCount"; + } + if (dynamic_cast(l_cs)) { + return "TemporalMeasure"; + } + return "unknown"; +} + +// --------------------------------------------------------------------------- + +/** \brief Returns the number of axis of the coordinate system. + * + * @param cs Objet of type CoordinateSystem (must not be NULL) + * @return number of axis, or -1 in case of error. + */ +int proj_obj_cs_get_axis_count(PJ_OBJ *cs) { + assert(cs); + auto l_cs = dynamic_cast(cs->obj.get()); + if (!l_cs) { + proj_log_error(cs->ctx, __FUNCTION__, + "Object is not a CoordinateSystem"); + return -1; + } + return static_cast(l_cs->axisList().size()); +} + +// --------------------------------------------------------------------------- + +/** \brief Returns information on an axis + * + * @param cs Objet of type CoordinateSystem (must not be NULL) + * @param index Index of the coordinate system (between 0 and + * proj_obj_cs_get_axis_count() - 1) + * @param pName Pointer to a string value to store the axis name. or NULL + * @param pAbbrev Pointer to a string value to store the axis abbreviation. or + * NULL + * @param pDirection Pointer to a string value to store the axis direction. or + * NULL + * @param pUnitConvFactor Pointer to a double value to store the axis + * unit conversion factor. or NULL + * @param pUnitName Pointer to a string value to store the axis + * unit name. or NULL + * @return TRUE in case of success + */ +int proj_obj_cs_get_axis_info(PJ_OBJ *cs, int index, const char **pName, + const char **pAbbrev, const char **pDirection, + double *pUnitConvFactor, const char **pUnitName) { + assert(cs); + auto l_cs = dynamic_cast(cs->obj.get()); + if (!l_cs) { + proj_log_error(cs->ctx, __FUNCTION__, + "Object is not a CoordinateSystem"); + return false; + } + const auto &axisList = l_cs->axisList(); + if (index < 0 || static_cast(index) >= axisList.size()) { + proj_log_error(cs->ctx, __FUNCTION__, "Invalid index"); + return false; + } + const auto &axis = axisList[index]; + if (pName) { + *pName = axis->nameStr().c_str(); + } + if (pAbbrev) { + *pAbbrev = axis->abbreviation().c_str(); + } + if (pDirection) { + *pDirection = axis->direction().toString().c_str(); + } + if (pUnitConvFactor) { + *pUnitConvFactor = axis->unit().conversionToSI(); + } + if (pUnitName) { + *pUnitName = axis->unit().name().c_str(); + } + return true; +} -- cgit v1.2.3 From 67758b2c67ea329116b59818c038797667c4e1d1 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Mon, 26 Nov 2018 15:47:57 +0100 Subject: Redirect epsg:XXXX and IGNF:XXXX CRS expansions to the database, and remove the data/epsg and data/IGNF files --- src/c_api.cpp | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index 3b51d905..e74f4347 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -252,6 +252,28 @@ const char *proj_context_get_database_path(PJ_CONTEXT *ctx) { // --------------------------------------------------------------------------- +/** \brief Return a metadata from the database. + * + * The returned pointer remains valid while ctx is valid, and until + * proj_context_get_database_metadata() is called. + * + * @param ctx PROJ context, or NULL for default context + * @param key Metadata key. Must not be NULL + * @return value, or nullptr + */ +const char *proj_context_get_database_metadata(PJ_CONTEXT *ctx, + const char *key) { + SANITIZE_CTX(ctx); + try { + return getDBcontext(ctx)->getMetadata(key); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + /** \brief Guess the "dialect" of the WKT string. * * @param ctx PROJ context, or NULL for default context -- cgit v1.2.3 From cf855b24d2b901054bee90309cdc5df00dfb3085 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Wed, 28 Nov 2018 14:52:56 +0100 Subject: C API extensions and renaming - proj_obj_create_projected_XXXXX() are renamed to proj_obj_create_conversion_snake_case() and just instanciate a Conversion object - Advanced manipulation functions are moved to a dedicated section at bottom of proj.h - New C API needed for GDAL OGRSpatialReference --- src/c_api.cpp | 3318 +++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 2267 insertions(+), 1051 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index e74f4347..dc7bc3e6 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -96,10 +96,10 @@ struct PJ_OBJ { IdentifiedObjectNNPtr obj; // cached results - std::string lastWKT{}; - std::string lastPROJString{}; - bool gridsNeededAsked = false; - std::vector gridsNeeded{}; + mutable std::string lastWKT{}; + mutable std::string lastPROJString{}; + mutable bool gridsNeededAsked = false; + mutable std::vector gridsNeeded{}; explicit PJ_OBJ(PJ_CONTEXT *ctxIn, const IdentifiedObjectNNPtr &objIn) : ctx(ctxIn), obj(objIn) {} @@ -312,6 +312,29 @@ static const char *getOptionValue(const char *option, // --------------------------------------------------------------------------- +/** \brief "Clone" an object. + * + * Technically this just increases the reference counter on the object, since + * PJ_OBJ objects are immutable. + * + * The returned object must be unreferenced with proj_obj_unref() after use. + * It should be used by at most one thread at a time. + * + * @param obj Object to clone. Must not be NULL. + * @return Object that must be unreferenced with proj_obj_unref(), or NULL in + * case of error. + */ +PJ_OBJ *proj_obj_clone(const PJ_OBJ *obj) { + try { + return PJ_OBJ::create(obj->ctx, obj->obj); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + } + return nullptr; +} + +// --------------------------------------------------------------------------- + /** \brief Instanciate an object from a WKT string, PROJ string or object code * (like "EPSG:4326", "urn:ogc:def:crs:EPSG::4326", * "urn:ogc:def:coordinateOperation:EPSG::1671"). @@ -561,6 +584,10 @@ convertPJObjectTypeToObjectType(PJ_OBJ_TYPE type, bool &valid) { cppType = AuthorityFactory::ObjectType::COMPOUND_CRS; break; + case PJ_OBJ_TYPE_ENGINEERING_CRS: + valid = false; + break; + case PJ_OBJ_TYPE_TEMPORAL_CRS: valid = false; break; @@ -658,7 +685,7 @@ PJ_OBJ_LIST *proj_obj_create_from_name(PJ_CONTEXT *ctx, const char *auth_name, * @param obj Object (must not be NULL) * @return its type. */ -PJ_OBJ_TYPE proj_obj_get_type(PJ_OBJ *obj) { +PJ_OBJ_TYPE proj_obj_get_type(const PJ_OBJ *obj) { assert(obj); auto ptr = obj->obj.get(); if (dynamic_cast(ptr)) { @@ -715,6 +742,9 @@ PJ_OBJ_TYPE proj_obj_get_type(PJ_OBJ *obj) { if (dynamic_cast(ptr)) { return PJ_OBJ_TYPE_TEMPORAL_CRS; } + if (dynamic_cast(ptr)) { + return PJ_OBJ_TYPE_ENGINEERING_CRS; + } if (dynamic_cast(ptr)) { return PJ_OBJ_TYPE_BOUND_CRS; } @@ -745,7 +775,7 @@ PJ_OBJ_TYPE proj_obj_get_type(PJ_OBJ *obj) { * @param obj Object (must not be NULL) * @return TRUE if it is deprecated, FALSE otherwise */ -int proj_obj_is_deprecated(PJ_OBJ *obj) { +int proj_obj_is_deprecated(const PJ_OBJ *obj) { assert(obj); return obj->obj->isDeprecated(); } @@ -759,7 +789,7 @@ int proj_obj_is_deprecated(PJ_OBJ *obj) { * @param criterion Comparison criterion * @return TRUE if they are equivalent */ -int proj_obj_is_equivalent_to(PJ_OBJ *obj, PJ_OBJ *other, +int proj_obj_is_equivalent_to(const PJ_OBJ *obj, const PJ_OBJ *other, PJ_COMPARISON_CRITERION criterion) { assert(obj); assert(other); @@ -796,7 +826,7 @@ int proj_obj_is_equivalent_to(PJ_OBJ *obj, PJ_OBJ *other, * * @param obj Object (must not be NULL) */ -int proj_obj_is_crs(PJ_OBJ *obj) { +int proj_obj_is_crs(const PJ_OBJ *obj) { assert(obj); return dynamic_cast(obj->obj.get()) != nullptr; } @@ -810,7 +840,7 @@ int proj_obj_is_crs(PJ_OBJ *obj) { * @param obj Object (must not be NULL) * @return a string, or NULL in case of error or missing name. */ -const char *proj_obj_get_name(PJ_OBJ *obj) { +const char *proj_obj_get_name(const PJ_OBJ *obj) { assert(obj); const auto &desc = obj->obj->name()->description(); if (!desc.has_value()) { @@ -831,7 +861,7 @@ const char *proj_obj_get_name(PJ_OBJ *obj) { * @param index Index of the identifier. 0 = first identifier * @return a string, or NULL in case of error or missing name. */ -const char *proj_obj_get_id_auth_name(PJ_OBJ *obj, int index) { +const char *proj_obj_get_id_auth_name(const PJ_OBJ *obj, int index) { assert(obj); const auto &ids = obj->obj->identifiers(); if (static_cast(index) >= ids.size()) { @@ -856,7 +886,7 @@ const char *proj_obj_get_id_auth_name(PJ_OBJ *obj, int index) { * @param index Index of the identifier. 0 = first identifier * @return a string, or NULL in case of error or missing name. */ -const char *proj_obj_get_id_code(PJ_OBJ *obj, int index) { +const char *proj_obj_get_id_code(const PJ_OBJ *obj, int index) { assert(obj); const auto &ids = obj->obj->identifiers(); if (static_cast(index) >= ids.size()) { @@ -892,7 +922,7 @@ const char *proj_obj_get_id_code(PJ_OBJ *obj, int index) { * * @return a string, or NULL in case of error. */ -const char *proj_obj_as_wkt(PJ_OBJ *obj, PJ_WKT_TYPE type, +const char *proj_obj_as_wkt(const PJ_OBJ *obj, PJ_WKT_TYPE type, const char *const *options) { assert(obj); @@ -983,7 +1013,7 @@ const char *proj_obj_as_wkt(PJ_OBJ *obj, PJ_WKT_TYPE type, * use of etmerc by utm conversions) * @return a string, or NULL in case of error. */ -const char *proj_obj_as_proj_string(PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, +const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, const char *const *options) { assert(obj); auto exportable = @@ -1049,7 +1079,7 @@ const char *proj_obj_as_proj_string(PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, * @return TRUE in case of success, FALSE in case of error or if the area * of use is unknown. */ -int proj_obj_get_area_of_use(PJ_OBJ *obj, double *p_west_lon_degree, +int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *p_west_lon_degree, double *p_south_lat_degree, double *p_east_lon_degree, double *p_north_lat_degree, @@ -1111,7 +1141,8 @@ int proj_obj_get_area_of_use(PJ_OBJ *obj, double *p_west_lon_degree, // --------------------------------------------------------------------------- -static const GeodeticCRS *extractGeodeticCRS(PJ_OBJ *crs, const char *fname) { +static const GeodeticCRS *extractGeodeticCRS(const PJ_OBJ *crs, + const char *fname) { assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { @@ -1137,7 +1168,7 @@ static const GeodeticCRS *extractGeodeticCRS(PJ_OBJ *crs, const char *fname) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_geodetic_crs(PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_get_geodetic_crs(const PJ_OBJ *crs) { auto geodCRS = extractGeodeticCRS(crs, __FUNCTION__); if (!geodCRS) { return nullptr; @@ -1161,7 +1192,7 @@ PJ_OBJ *proj_obj_crs_get_geodetic_crs(PJ_OBJ *crs) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_sub_crs(PJ_OBJ *crs, int index) { +PJ_OBJ *proj_obj_crs_get_sub_crs(const PJ_OBJ *crs, int index) { assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { @@ -1177,6 +1208,54 @@ PJ_OBJ *proj_obj_crs_get_sub_crs(PJ_OBJ *crs, int index) { // --------------------------------------------------------------------------- +/** \brief Returns a BoundCRS + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param base_crs Base CRS (must not be NULL) + * @param hub_crs Hub CRS (must not be NULL) + * @param transformation Transformation (must not be NULL) + * @return Object that must be unreferenced with proj_obj_unref(), or NULL + * in case of error. + */ +PJ_OBJ *proj_obj_crs_create_bound_crs(const PJ_OBJ *base_crs, + const PJ_OBJ *hub_crs, + const PJ_OBJ *transformation) { + assert(base_crs); + assert(hub_crs); + assert(transformation); + auto l_base_crs = util::nn_dynamic_pointer_cast(base_crs->obj); + if (!l_base_crs) { + proj_log_error(base_crs->ctx, __FUNCTION__, "base_crs is not a CRS"); + return nullptr; + } + auto l_hub_crs = util::nn_dynamic_pointer_cast(hub_crs->obj); + if (!l_hub_crs) { + proj_log_error(base_crs->ctx, __FUNCTION__, "hub_crs is not a CRS"); + return nullptr; + } + auto l_transformation = + util::nn_dynamic_pointer_cast(transformation->obj); + if (!l_transformation) { + proj_log_error(base_crs->ctx, __FUNCTION__, + "transformation is not a CRS"); + return nullptr; + } + try { + return PJ_OBJ::create(base_crs->ctx, + BoundCRS::create(NN_NO_CHECK(l_base_crs), + NN_NO_CHECK(l_hub_crs), + NN_NO_CHECK(l_transformation))); + } catch (const std::exception &e) { + proj_log_error(base_crs->ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + /** \brief Returns potentially * a BoundCRS, with a transformation to EPSG:4326, wrapping this CRS * @@ -1191,7 +1270,7 @@ PJ_OBJ *proj_obj_crs_get_sub_crs(PJ_OBJ *crs, int index) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(const PJ_OBJ *crs) { assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { @@ -1199,8 +1278,13 @@ PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(PJ_OBJ *crs) { return nullptr; } auto dbContext = getDBcontextNoException(crs->ctx, __FUNCTION__); - return PJ_OBJ::create(crs->ctx, - l_crs->createBoundCRSToWGS84IfPossible(dbContext)); + try { + return PJ_OBJ::create( + crs->ctx, l_crs->createBoundCRSToWGS84IfPossible(dbContext)); + } catch (const std::exception &e) { + proj_log_error(crs->ctx, __FUNCTION__, e.what()); + return nullptr; + } } // --------------------------------------------------------------------------- @@ -1215,7 +1299,7 @@ PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(PJ_OBJ *crs) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_get_ellipsoid(PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_ellipsoid(const PJ_OBJ *obj) { auto ptr = obj->obj.get(); if (dynamic_cast(ptr)) { auto geodCRS = extractGeodeticCRS(obj, __FUNCTION__); @@ -1245,7 +1329,7 @@ PJ_OBJ *proj_obj_get_ellipsoid(PJ_OBJ *obj) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_horizontal_datum(PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_get_horizontal_datum(const PJ_OBJ *crs) { auto geodCRS = extractGeodeticCRS(crs, __FUNCTION__); if (!geodCRS) { return nullptr; @@ -1279,7 +1363,7 @@ PJ_OBJ *proj_obj_crs_get_horizontal_datum(PJ_OBJ *crs) { * flattening. or NULL * @return TRUE in case of success. */ -int proj_obj_ellipsoid_get_parameters(PJ_OBJ *ellipsoid, +int proj_obj_ellipsoid_get_parameters(const PJ_OBJ *ellipsoid, double *pSemiMajorMetre, double *pSemiMinorMetre, int *pIsSemiMinorComputed, @@ -1320,7 +1404,7 @@ int proj_obj_ellipsoid_get_parameters(PJ_OBJ *ellipsoid, * in case of error. */ -PJ_OBJ *proj_obj_get_prime_meridian(PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_prime_meridian(const PJ_OBJ *obj) { auto ptr = obj->obj.get(); if (dynamic_cast(ptr)) { auto geodCRS = extractGeodeticCRS(obj, __FUNCTION__); @@ -1351,7 +1435,7 @@ PJ_OBJ *proj_obj_get_prime_meridian(PJ_OBJ *obj) { * or NULL * @return TRUE in case of success. */ -int proj_obj_prime_meridian_get_parameters(PJ_OBJ *prime_meridian, +int proj_obj_prime_meridian_get_parameters(const PJ_OBJ *prime_meridian, double *pLongitude, double *pLongitudeUnitConvFactor, const char **pLongitudeUnitName) { @@ -1389,7 +1473,7 @@ int proj_obj_prime_meridian_get_parameters(PJ_OBJ *prime_meridian, * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error, or missing source CRS. */ -PJ_OBJ *proj_obj_get_source_crs(PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_source_crs(const PJ_OBJ *obj) { assert(obj); auto ptr = obj->obj.get(); auto boundCRS = dynamic_cast(ptr); @@ -1426,7 +1510,7 @@ PJ_OBJ *proj_obj_get_source_crs(PJ_OBJ *obj) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error, or missing target CRS. */ -PJ_OBJ *proj_obj_get_target_crs(PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_target_crs(const PJ_OBJ *obj) { assert(obj); auto ptr = obj->obj.get(); auto boundCRS = dynamic_cast(ptr); @@ -1478,7 +1562,7 @@ PJ_OBJ *proj_obj_get_target_crs(PJ_OBJ *obj) { * released with proj_free_int_list(). * @return a list of matching reference CRS, or nullptr in case of error. */ -PJ_OBJ_LIST *proj_obj_identify(PJ_OBJ *obj, const char *auth_name, +PJ_OBJ_LIST *proj_obj_identify(const PJ_OBJ *obj, const char *auth_name, const char *const *options, int **confidence) { assert(obj); (void)options; @@ -1629,7 +1713,8 @@ void proj_free_string_list(PROJ_STRING_LIST list) { * @return Object of type SingleOperation that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_get_coordoperation(PJ_OBJ *crs, const char **pMethodName, +PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, + const char **pMethodName, const char **pMethodAuthorityName, const char **pMethodCode) { assert(crs); @@ -1682,8 +1767,9 @@ static PropertyMap createPropertyMapName(const char *name) { // --------------------------------------------------------------------------- static UnitOfMeasure createLinearUnit(const char *name, double convFactor) { - return name == nullptr ? UnitOfMeasure::METRE - : UnitOfMeasure(name, convFactor); + return name == nullptr + ? UnitOfMeasure::METRE + : UnitOfMeasure(name, convFactor, UnitOfMeasure::Type::LINEAR); } // --------------------------------------------------------------------------- @@ -1693,21 +1779,55 @@ static UnitOfMeasure createAngularUnit(const char *name, double convFactor) { ? UnitOfMeasure::DEGREE : ci_equal(name, "grad") ? UnitOfMeasure::GRAD - : UnitOfMeasure(name, convFactor)) + : UnitOfMeasure(name, convFactor, + UnitOfMeasure::Type::ANGULAR)) : UnitOfMeasure::DEGREE; } + +// --------------------------------------------------------------------------- + +static GeodeticReferenceFrameNNPtr createGeodeticReferenceFrame( + PJ_CONTEXT *ctx, const char *datumName, const char *ellipsoidName, + double semiMajorMetre, double invFlattening, const char *primeMeridianName, + double primeMeridianOffset, const char *angularUnits, + double angularUnitsConv) { + const UnitOfMeasure angUnit( + createAngularUnit(angularUnits, angularUnitsConv)); + auto dbContext = getDBcontext(ctx); + auto body = Ellipsoid::guessBodyName(dbContext, semiMajorMetre); + auto ellpsName = createPropertyMapName(ellipsoidName); + auto ellps = + invFlattening != 0.0 + ? Ellipsoid::createFlattenedSphere( + ellpsName, Length(semiMajorMetre), Scale(invFlattening), body) + : Ellipsoid::createSphere(ellpsName, Length(semiMajorMetre), body); + auto pm = PrimeMeridian::create( + PropertyMap().set(common::IdentifiedObject::NAME_KEY, + primeMeridianName ? primeMeridianName + : primeMeridianOffset == 0.0 + ? (ellps->celestialBody() == + Ellipsoid::EARTH + ? "Greenwich" + : "Reference meridian") + : "unnamed"), + Angle(primeMeridianOffset, angUnit)); + return GeodeticReferenceFrame::create(createPropertyMapName(datumName), + ellps, util::optional(), + pm); +} + //! @endcond // --------------------------------------------------------------------------- -/** \brief Create a GeographicCRS 2D from its definition. +/** \brief Create a GeographicCRS. * * The returned object must be unreferenced with proj_obj_unref() after * use. * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param geogName Name of the GeographicCRS. Or NULL + * @param crsName Name of the GeographicCRS. Or NULL * @param datumName Name of the GeodeticReferenceFrame. Or NULL * @param ellipsoidName Name of the Ellipsoid. Or NULL * @param semiMajorMetre Ellipsoid semi-major axis, in metres. @@ -1715,52 +1835,34 @@ static UnitOfMeasure createAngularUnit(const char *name, double convFactor) { * @param primeMeridianName Name of the PrimeMeridian. Or NULL * @param primeMeridianOffset Offset of the prime meridian, expressed in the * specified angular units. - * @param angularUnits Name of the angular units. Or NULL for Degree - * @param angularUnitsConv Conversion factor from the angular unit to radian. Or + * @param pmAngularUnits Name of the angular units. Or NULL for Degree + * @param pmAngularUnitsConv Conversion factor from the angular unit to radian. + * Or * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL - * @param latLongOrder TRUE for Latitude Longitude axis order. + * @param ellipsoidalCS Coordinate system. Must not be NULL. * * @return Object of type GeographicCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_create_geographic_crs( - PJ_CONTEXT *ctx, const char *geogName, const char *datumName, + PJ_CONTEXT *ctx, const char *crsName, const char *datumName, const char *ellipsoidName, double semiMajorMetre, double invFlattening, const char *primeMeridianName, double primeMeridianOffset, - const char *angularUnits, double angularUnitsConv, int latLongOrder) { + const char *pmAngularUnits, double pmAngularUnitsConv, + PJ_OBJ *ellipsoidalCS) { SANITIZE_CTX(ctx); + auto cs = util::nn_dynamic_pointer_cast(ellipsoidalCS->obj); + if (!cs) { + return nullptr; + } try { - const UnitOfMeasure angUnit( - createAngularUnit(angularUnits, angularUnitsConv)); - auto dbContext = getDBcontext(ctx); - auto body = Ellipsoid::guessBodyName(dbContext, semiMajorMetre); - auto ellpsName = createPropertyMapName(ellipsoidName); - auto ellps = - invFlattening != 0.0 - ? Ellipsoid::createFlattenedSphere(ellpsName, - Length(semiMajorMetre), - Scale(invFlattening), body) - : Ellipsoid::createSphere(ellpsName, Length(semiMajorMetre), - body); - auto pm = PrimeMeridian::create( - PropertyMap().set( - common::IdentifiedObject::NAME_KEY, - primeMeridianName - ? primeMeridianName - : primeMeridianOffset == 0.0 - ? (ellps->celestialBody() == Ellipsoid::EARTH - ? "Greenwich" - : "Reference meridian") - : "unnamed"), - Angle(primeMeridianOffset, angUnit)); - auto datum = GeodeticReferenceFrame::create( - createPropertyMapName(datumName), ellps, - util::optional(), pm); - auto geogCRS = GeographicCRS::create( - createPropertyMapName(geogName), datum, - latLongOrder ? cs::EllipsoidalCS::createLatitudeLongitude(angUnit) - : cs::EllipsoidalCS::createLongitudeLatitude(angUnit)); + auto datum = createGeodeticReferenceFrame( + ctx, datumName, ellipsoidName, semiMajorMetre, invFlattening, + primeMeridianName, primeMeridianOffset, pmAngularUnits, + pmAngularUnitsConv); + auto geogCRS = GeographicCRS::create(createPropertyMapName(crsName), + datum, NN_NO_CHECK(cs)); return PJ_OBJ::create(ctx, geogCRS); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -1770,258 +1872,1054 @@ PJ_OBJ *proj_obj_create_geographic_crs( // --------------------------------------------------------------------------- -//! @cond Doxygen_Suppress - -static PJ_OBJ *proj_obj_create_projected_crs(PJ_OBJ *geodetic_crs, - const char *crs_name, - const ConversionNNPtr &conv, - const UnitOfMeasure &linearUnit) { - assert(geodetic_crs); - auto geogCRS = - util::nn_dynamic_pointer_cast(geodetic_crs->obj); - if (!geogCRS) { +/** \brief Create a GeographicCRS. + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param crsName Name of the GeographicCRS. Or NULL + * @param datum Datum. Must not be NULL. + * @param ellipsoidalCS Coordinate system. Must not be NULL. + * + * @return Object of type GeographicCRS that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ +PJ_OBJ *proj_obj_create_geographic_crs_from_datum(const char *crsName, + PJ_OBJ *datum, + PJ_OBJ *ellipsoidalCS) { + + auto l_datum = + util::nn_dynamic_pointer_cast(datum->obj); + if (!l_datum) { + proj_log_error(datum->ctx, __FUNCTION__, + "datum is not a GeodeticReferenceFrame"); return nullptr; } - auto crs = ProjectedCRS::create( - createPropertyMapName(crs_name), NN_NO_CHECK(geogCRS), conv, - cs::CartesianCS::createEastingNorthing(linearUnit)); - return PJ_OBJ::create(geodetic_crs->ctx, crs); + auto cs = util::nn_dynamic_pointer_cast(ellipsoidalCS->obj); + if (!cs) { + return nullptr; + } + try { + auto geogCRS = + GeographicCRS::create(createPropertyMapName(crsName), + NN_NO_CHECK(l_datum), NN_NO_CHECK(cs)); + return PJ_OBJ::create(datum->ctx, geogCRS); + } catch (const std::exception &e) { + proj_log_error(datum->ctx, __FUNCTION__, e.what()); + } + return nullptr; } -//! @endcond - -/* BEGIN: Generated by scripts/create_c_api_projections.py*/ - // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a Universal Transverse Mercator - * conversion. +/** \brief Create a GeodeticCRS of geocentric type. * - * See osgeo::proj::operation::Conversion::createUTM(). + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * @param ctx PROJ context, or NULL for default context + * @param crsName Name of the GeographicCRS. Or NULL + * @param datumName Name of the GeodeticReferenceFrame. Or NULL + * @param ellipsoidName Name of the Ellipsoid. Or NULL + * @param semiMajorMetre Ellipsoid semi-major axis, in metres. + * @param invFlattening Ellipsoid inverse flattening. Or 0 for a sphere. + * @param primeMeridianName Name of the PrimeMeridian. Or NULL + * @param primeMeridianOffset Offset of the prime meridian, expressed in the + * specified angular units. + * @param angularUnits Name of the angular units. Or NULL for Degree + * @param angularUnitsConv Conversion factor from the angular unit to radian. Or + * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL + * @param linearUnits Name of the linear units. Or NULL for Metre + * @param linearUnitsConv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * + * @return Object of type GeodeticCRS that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs_UTM(PJ_OBJ *geodetic_crs, - const char *crs_name, int zone, - int north) { - const auto &linearUnit = UnitOfMeasure::METRE; - auto conv = Conversion::createUTM(PropertyMap(), zone, north != 0); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_geocentric_crs( + PJ_CONTEXT *ctx, const char *crsName, const char *datumName, + const char *ellipsoidName, double semiMajorMetre, double invFlattening, + const char *primeMeridianName, double primeMeridianOffset, + const char *angularUnits, double angularUnitsConv, const char *linearUnits, + double linearUnitsConv) { + + SANITIZE_CTX(ctx); + try { + const UnitOfMeasure linearUnit( + createLinearUnit(linearUnits, linearUnitsConv)); + auto datum = createGeodeticReferenceFrame( + ctx, datumName, ellipsoidName, semiMajorMetre, invFlattening, + primeMeridianName, primeMeridianOffset, angularUnits, + angularUnitsConv); + + auto geodCRS = + GeodeticCRS::create(createPropertyMapName(crsName), datum, + cs::CartesianCS::createGeocentric(linearUnit)); + return PJ_OBJ::create(ctx, geodCRS); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } + // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a conversion based on the Transverse - * Mercator projection method. +/** \brief Create a GeodeticCRS of geocentric type. * - * See osgeo::proj::operation::Conversion::createTransverseMercator(). + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * @param crsName Name of the GeographicCRS. Or NULL + * @param datum Datum. Must not be NULL. + * @param linearUnits Name of the linear units. Or NULL for Metre + * @param linearUnitsConv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * + * @return Object of type GeodeticCRS that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs_TransverseMercator( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createTransverseMercator( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(const char *crsName, + const PJ_OBJ *datum, + const char *linearUnits, + double linearUnitsConv) { + try { + const UnitOfMeasure linearUnit( + createLinearUnit(linearUnits, linearUnitsConv)); + auto l_datum = + util::nn_dynamic_pointer_cast(datum->obj); + if (!l_datum) { + proj_log_error(datum->ctx, __FUNCTION__, + "datum is not a GeodeticReferenceFrame"); + return nullptr; + } + auto geodCRS = GeodeticCRS::create( + createPropertyMapName(crsName), NN_NO_CHECK(l_datum), + cs::CartesianCS::createGeocentric(linearUnit)); + return PJ_OBJ::create(datum->ctx, geodCRS); + } catch (const std::exception &e) { + proj_log_error(datum->ctx, __FUNCTION__, e.what()); + } + return nullptr; } + // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a conversion based on the Gauss - * Schreiber Transverse Mercator projection method. +/** \brief Return a copy of the object with its name changed * - * See - * osgeo::proj::operation::Conversion::createGaussSchreiberTransverseMercator(). + * Currently, only implemented on CRS objects. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_projected_crs_GaussSchreiberTransverseMercator( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGaussSchreiberTransverseMercator( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); -} -// --------------------------------------------------------------------------- - -/** \brief Instanciate a ProjectedCRS with a conversion based on the Transverse - * Mercator South Orientated projection method. + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. * - * See - * osgeo::proj::operation::Conversion::createTransverseMercatorSouthOriented(). + * @param obj Object of type CRS. Must not be NULL + * @param name New name. Must not be NULL * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs_TransverseMercatorSouthOriented( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createTransverseMercatorSouthOriented( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ PROJ_DLL *proj_obj_alter_name(const PJ_OBJ *obj, const char *name) { + auto crs = dynamic_cast(obj->obj.get()); + if (!crs) { + return nullptr; + } + try { + return PJ_OBJ::create(obj->ctx, crs->alterName(name)); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + } + return nullptr; } + // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a conversion based on the Two Point - * Equidistant projection method. +/** \brief Return a copy of the CRS with its geodetic CRS changed * - * See osgeo::proj::operation::Conversion::createTwoPointEquidistant(). + * Currently, when obj is a GeodeticCRS, it returns a clone of newGeodCRS + * When obj is a ProjectedCRS, it replaces its base CRS with newGeodCRS. + * When obj is a CompoundCRS, it replaces the GeodeticCRS part of the horizontal + * CRS with newGeodCRS. + * In other cases, it returns a clone of obj. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_projected_crs_TwoPointEquidistant( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstPoint, - double longitudeFirstPoint, double latitudeSecondPoint, - double longitudeSeconPoint, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createTwoPointEquidistant( - PropertyMap(), Angle(latitudeFirstPoint, angUnit), - Angle(longitudeFirstPoint, angUnit), - Angle(latitudeSecondPoint, angUnit), - Angle(longitudeSeconPoint, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); -} -// --------------------------------------------------------------------------- - -/** \brief Instanciate a ProjectedCRS with a conversion based on the Tunisia - * Mapping Grid projection method. + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. * - * See osgeo::proj::operation::Conversion::createTunisiaMappingGrid(). + * @param obj Object of type CRS. Must not be NULL + * @param newGeodCRS Object of type GeodeticCRS. Must not be NULL * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs_TunisiaMappingGrid( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createTunisiaMappingGrid( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_crs_alter_geodetic_crs(const PJ_OBJ *obj, + const PJ_OBJ *newGeodCRS) { + auto l_newGeodCRS = + util::nn_dynamic_pointer_cast(newGeodCRS->obj); + if (!l_newGeodCRS) { + proj_log_error(obj->ctx, __FUNCTION__, + "newGeodCRS is not a GeodeticCRS"); + return nullptr; + } + + auto crs = dynamic_cast(obj->obj.get()); + if (!crs) { + proj_log_error(obj->ctx, __FUNCTION__, "obj is not a CRS"); + return nullptr; + } + + try { + return PJ_OBJ::create(obj->ctx, + crs->alterGeodeticCRS(NN_NO_CHECK(l_newGeodCRS))); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + return nullptr; + } } + // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a conversion based on the Albers - * Conic Equal Area projection method. +/** \brief Return a copy of the CRS with its angular units changed * - * See osgeo::proj::operation::Conversion::createAlbersEqualArea(). + * The CRS must be or contain a GeographicCRS. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_projected_crs_AlbersEqualArea( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFalseOrigin, - double longitudeFalseOrigin, double latitudeFirstParallel, - double latitudeSecondParallel, double eastingFalseOrigin, - double northingFalseOrigin, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createAlbersEqualArea( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); -} -// --------------------------------------------------------------------------- - -/** \brief Instanciate a ProjectedCRS with a conversion based on the Lambert - * Conic Conformal 1SP projection method. + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. * - * See osgeo::proj::operation::Conversion::createLambertConicConformal_1SP(). + * @param obj Object of type CRS. Must not be NULL + * @param angularUnits Name of the angular units. Or NULL for Degree + * @param angularUnitsConv Conversion factor from the angular unit to radian. Or + * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_1SP( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertConicConformal_1SP( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(const PJ_OBJ *obj, + const char *angularUnits, + double angularUnitsConv) { + + auto geodCRS = proj_obj_crs_get_geodetic_crs(obj); + if (!geodCRS) { + return nullptr; + } + auto geogCRS = dynamic_cast(geodCRS->obj.get()); + if (!geogCRS) { + proj_obj_unref(geodCRS); + return nullptr; + } + + PJ_OBJ *geogCRSAltered = nullptr; + try { + const UnitOfMeasure angUnit( + createAngularUnit(angularUnits, angularUnitsConv)); + geogCRSAltered = PJ_OBJ::create( + obj->ctx, + GeographicCRS::create( + createPropertyMapName(proj_obj_get_name(geodCRS)), + geogCRS->datum(), geogCRS->datumEnsemble(), + geogCRS->coordinateSystem()->alterAngularUnit(angUnit))); + proj_obj_unref(geodCRS); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_obj_unref(geodCRS); + return nullptr; + } + + auto ret = proj_obj_crs_alter_geodetic_crs(obj, geogCRSAltered); + proj_obj_unref(geogCRSAltered); + return ret; } + // --------------------------------------------------------------------------- -/** \brief Instanciate a ProjectedCRS with a conversion based on the Lambert - * Conic Conformal (2SP) projection method. +/** \brief Return a copy of the CRS with the linear units of its coordinate + * system changed * - * See osgeo::proj::operation::Conversion::createLambertConicConformal_2SP(). + * The CRS must be or contain a ProjectedCRS, VerticalCRS or a GeocentricCRS. * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFalseOrigin, - double longitudeFalseOrigin, double latitudeFirstParallel, - double latitudeSecondParallel, double eastingFalseOrigin, - double northingFalseOrigin, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param obj Object of type CRS. Must not be NULL + * @param linearUnits Name of the linear units. Or NULL for Metre + * @param linearUnitsConv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ +PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(const PJ_OBJ *obj, + const char *linearUnits, + double linearUnitsConv) { + auto crs = dynamic_cast(obj->obj.get()); + if (!crs) { + return nullptr; + } + + try { + const UnitOfMeasure linearUnit( + createLinearUnit(linearUnits, linearUnitsConv)); + return PJ_OBJ::create(obj->ctx, crs->alterCSLinearUnit(linearUnit)); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + +/** \brief Return a copy of the CRS with the lineaer units of the parameters + * of its conversion modified. + * + * The CRS must be or contain a ProjectedCRS, VerticalCRS or a GeocentricCRS. + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param obj Object of type ProjectedCRS. Must not be NULL + * @param linearUnits Name of the linear units. Or NULL for Metre + * @param linearUnitsConv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * @param convertToNewUnit TRUE if exisiting values should be converted from + * their current unit to the new unit. If FALSE, their value will be left + * unchanged and the unit overriden (so the resulting CRS will not be + * equivalent to the original one for reprojection purposes). + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ +PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(const PJ_OBJ *obj, + const char *linearUnits, + double linearUnitsConv, + int convertToNewUnit) { + auto crs = dynamic_cast(obj->obj.get()); + if (!crs) { + return nullptr; + } + + try { + const UnitOfMeasure linearUnit( + createLinearUnit(linearUnits, linearUnitsConv)); + return PJ_OBJ::create( + obj->ctx, crs->alterParametersLinearUnit(linearUnit, + convertToNewUnit == TRUE)); + } catch (const std::exception &e) { + proj_log_error(obj->ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a EngineeringCRS with just a name + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param ctx PROJ context, or NULL for default context + * @param crsName CRS name. Or NULL. + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ +PJ_OBJ PROJ_DLL *proj_obj_create_engineering_crs(PJ_CONTEXT *ctx, + const char *crsName) { + try { + return PJ_OBJ::create( + ctx, EngineeringCRS::create( + createPropertyMapName(crsName), + EngineeringDatum::create(PropertyMap()), + CartesianCS::createEastingNorthing(UnitOfMeasure::METRE))); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a Conversion + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param ctx PROJ context, or NULL for default context + * @param name Conversion name. Or NULL. + * @param auth_name Conversion authority name. Or NULL. + * @param code Conversion code. Or NULL. + * @param method_name Method name. Or NULL. + * @param method_auth_name Method authority name. Or NULL. + * @param method_code Method code. Or NULL. + * @param param_count Number of parameters (size of params argument) + * @param params Parameter descriptions (array of size param_count) + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ + +PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, const char *name, + const char *auth_name, const char *code, + const char *method_name, + const char *method_auth_name, + const char *method_code, int param_count, + const PJ_PARAM_DESCRIPTION *params) { + try { + PropertyMap propConv; + propConv.set(common::IdentifiedObject::NAME_KEY, + name ? name : "unnamed"); + if (auth_name && code) { + propConv.set(metadata::Identifier::CODESPACE_KEY, auth_name) + .set(metadata::Identifier::CODE_KEY, code); + } + PropertyMap propMethod; + propMethod.set(common::IdentifiedObject::NAME_KEY, + method_name ? method_name : "unnamed"); + if (method_auth_name && method_code) { + propMethod + .set(metadata::Identifier::CODESPACE_KEY, method_auth_name) + .set(metadata::Identifier::CODE_KEY, method_code); + } + std::vector parameters; + std::vector values; + for (int i = 0; i < param_count; i++) { + PropertyMap propParam; + propParam.set(common::IdentifiedObject::NAME_KEY, + params[i].name ? params[i].name : "unnamed"); + if (params[i].auth_name && params[i].code) { + propParam + .set(metadata::Identifier::CODESPACE_KEY, + params[i].auth_name) + .set(metadata::Identifier::CODE_KEY, params[i].code); + } + parameters.emplace_back(OperationParameter::create(propParam)); + auto unit_type = UnitOfMeasure::Type::UNKNOWN; + switch (params[i].unit_type) { + case PJ_UT_ANGULAR: + unit_type = UnitOfMeasure::Type::ANGULAR; + break; + case PJ_UT_LINEAR: + unit_type = UnitOfMeasure::Type::LINEAR; + break; + case PJ_UT_SCALE: + unit_type = UnitOfMeasure::Type::SCALE; + break; + case PJ_UT_TIME: + unit_type = UnitOfMeasure::Type::TIME; + break; + case PJ_UT_PARAMETRIC: + unit_type = UnitOfMeasure::Type::PARAMETRIC; + break; + } + + Measure measure( + params[i].value, + params[i].unit_type == PJ_UT_ANGULAR + ? createAngularUnit(params[i].unit_name, + params[i].unit_conv_factor) + : params[i].unit_type == PJ_UT_LINEAR + ? createLinearUnit(params[i].unit_name, + params[i].unit_conv_factor) + : UnitOfMeasure( + params[i].unit_name ? params[i].unit_name + : "unnamed", + params[i].unit_conv_factor, unit_type)); + values.emplace_back(ParameterValue::create(measure)); + } + return PJ_OBJ::create( + ctx, Conversion::create(propConv, propMethod, parameters, values)); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + return nullptr; + } +} + +// --------------------------------------------------------------------------- + +//! @cond Doxygen_Suppress + +static CoordinateSystemAxisNNPtr createAxis(const PJ_AXIS_DESCRIPTION &axis) { + const auto dir = + axis.direction ? AxisDirection::valueOf(axis.direction) : nullptr; + if (dir == nullptr) + throw Exception("invalid value for axis direction"); + auto unit_type = UnitOfMeasure::Type::UNKNOWN; + switch (axis.unit_type) { + case PJ_UT_ANGULAR: + unit_type = UnitOfMeasure::Type::ANGULAR; + break; + case PJ_UT_LINEAR: + unit_type = UnitOfMeasure::Type::LINEAR; + break; + case PJ_UT_SCALE: + unit_type = UnitOfMeasure::Type::SCALE; + break; + case PJ_UT_TIME: + unit_type = UnitOfMeasure::Type::TIME; + break; + case PJ_UT_PARAMETRIC: + unit_type = UnitOfMeasure::Type::PARAMETRIC; + break; + } + auto unit = + axis.unit_type == PJ_UT_ANGULAR + ? createAngularUnit(axis.unit_name, axis.unit_conv_factor) + : axis.unit_type == PJ_UT_LINEAR + ? createLinearUnit(axis.unit_name, axis.unit_conv_factor) + : UnitOfMeasure(axis.unit_name ? axis.unit_name : "unnamed", + axis.unit_conv_factor, unit_type); + + return CoordinateSystemAxis::create( + createPropertyMapName(axis.name), + axis.abbreviation ? axis.abbreviation : std::string(), *dir, unit); +} + +//! @endcond + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a CoordinateSystem. + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param ctx PROJ context, or NULL for default context + * @param type Coordinate system type. + * @param axis_count Number of axis + * @param axis Axis description (array of size axis_count) + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ + +PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, + int axis_count, const PJ_AXIS_DESCRIPTION *axis) { + try { + switch (type) { + case PJ_CS_TYPE_UNKNOWN: + return nullptr; + + case PJ_CS_TYPE_CARTESIAN: { + if (axis_count == 2) { + return PJ_OBJ::create( + ctx, CartesianCS::create(PropertyMap(), createAxis(axis[0]), + createAxis(axis[1]))); + } else if (axis_count == 3) { + return PJ_OBJ::create( + ctx, CartesianCS::create(PropertyMap(), createAxis(axis[0]), + createAxis(axis[1]), + createAxis(axis[2]))); + } + break; + } + + case PJ_CS_TYPE_ELLIPSOIDAL: { + if (axis_count == 2) { + return PJ_OBJ::create( + ctx, + EllipsoidalCS::create(PropertyMap(), createAxis(axis[0]), + createAxis(axis[1]))); + } else if (axis_count == 3) { + return PJ_OBJ::create( + ctx, EllipsoidalCS::create( + PropertyMap(), createAxis(axis[0]), + createAxis(axis[1]), createAxis(axis[2]))); + } + break; + } + + case PJ_CS_TYPE_VERTICAL: { + if (axis_count == 1) { + return PJ_OBJ::create( + ctx, + VerticalCS::create(PropertyMap(), createAxis(axis[0]))); + } + break; + } + + case PJ_CS_TYPE_SPHERICAL: { + if (axis_count == 3) { + return PJ_OBJ::create( + ctx, EllipsoidalCS::create( + PropertyMap(), createAxis(axis[0]), + createAxis(axis[1]), createAxis(axis[2]))); + } + break; + } + + case PJ_CS_TYPE_PARAMETRIC: { + if (axis_count == 1) { + return PJ_OBJ::create( + ctx, + ParametricCS::create(PropertyMap(), createAxis(axis[0]))); + } + break; + } + + case PJ_CS_TYPE_ORDINAL: { + std::vector axisVector; + for (int i = 0; i < axis_count; i++) { + axisVector.emplace_back(createAxis(axis[i])); + } + + return PJ_OBJ::create(ctx, + OrdinalCS::create(PropertyMap(), axisVector)); + } + + case PJ_CS_TYPE_DATETIMETEMPORAL: { + if (axis_count == 1) { + return PJ_OBJ::create( + ctx, DateTimeTemporalCS::create(PropertyMap(), + createAxis(axis[0]))); + } + break; + } + + case PJ_CS_TYPE_TEMPORALCOUNT: { + if (axis_count == 1) { + return PJ_OBJ::create( + ctx, TemporalCountCS::create(PropertyMap(), + createAxis(axis[0]))); + } + break; + } + + case PJ_CS_TYPE_TEMPORALMEASURE: { + if (axis_count == 1) { + return PJ_OBJ::create( + ctx, TemporalMeasureCS::create(PropertyMap(), + createAxis(axis[0]))); + } + break; + } + } + + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + return nullptr; + } + proj_log_error(ctx, __FUNCTION__, "Wrong value for axis_count"); + return nullptr; +} + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a CartesiansCS 2D + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param ctx PROJ context, or NULL for default context + * @param type Coordinate system type. + * @param unit_name Unit name. + * @param unit_conv_factor Unit conversion factor to SI. + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ + +PJ_OBJ *proj_obj_create_cartesian_2D_cs(PJ_CONTEXT *ctx, + PJ_CARTESIAN_CS_2D_TYPE type, + const char *unit_name, + double unit_conv_factor) { + try { + switch (type) { + case PJ_CART2D_EASTING_NORTHING: + return PJ_OBJ::create( + ctx, CartesianCS::createEastingNorthing( + createLinearUnit(unit_name, unit_conv_factor))); + + case PJ_CART2D_NORTHING_EASTING: + return PJ_OBJ::create( + ctx, CartesianCS::createNorthingEasting( + createLinearUnit(unit_name, unit_conv_factor))); + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a Ellipsoidal 2D + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param ctx PROJ context, or NULL for default context + * @param type Coordinate system type. + * @param unit_name Unit name. + * @param unit_conv_factor Unit conversion factor to SI. + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ + +PJ_OBJ *proj_obj_create_ellipsoidal_2D_cs(PJ_CONTEXT *ctx, + PJ_ELLIPSOIDAL_CS_2D_TYPE type, + const char *unit_name, + double unit_conv_factor) { + try { + switch (type) { + case PJ_ELLPS2D_LONGITUDE_LATITUDE: + return PJ_OBJ::create( + ctx, EllipsoidalCS::createLongitudeLatitude( + createAngularUnit(unit_name, unit_conv_factor))); + + case PJ_ELLPS2D_LATITUDE_LONGITUDE: + return PJ_OBJ::create( + ctx, EllipsoidalCS::createLatitudeLongitude( + createAngularUnit(unit_name, unit_conv_factor))); + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param crs_name CRS name. Or NULL + * @param geodetic_crs Base GeodeticCRS. Must not be NULL. + * @param conversion Conversion. Must not be NULL. + * @param coordinate_system Cartesian coordinate system. Must not be NULL. + * + * @return Object that must be unreferenced with + * proj_obj_unref(), or NULL in case of error. + */ + +PJ_OBJ *proj_obj_create_projected_crs(const char *crs_name, + const PJ_OBJ *geodetic_crs, + const PJ_OBJ *conversion, + const PJ_OBJ *coordinate_system) { + auto geodCRS = + util::nn_dynamic_pointer_cast(geodetic_crs->obj); + if (!geodCRS) { + return nullptr; + } + auto conv = util::nn_dynamic_pointer_cast(conversion->obj); + if (!conv) { + return nullptr; + } + auto cs = + util::nn_dynamic_pointer_cast(coordinate_system->obj); + if (!cs) { + return nullptr; + } + try { + return PJ_OBJ::create( + geodetic_crs->ctx, + ProjectedCRS::create(createPropertyMapName(crs_name), + NN_NO_CHECK(geodCRS), NN_NO_CHECK(conv), + NN_NO_CHECK(cs))); + } catch (const std::exception &e) { + proj_log_error(geodetic_crs->ctx, __FUNCTION__, e.what()); + } + return nullptr; +} + +// --------------------------------------------------------------------------- + +//! @cond Doxygen_Suppress + +static PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, + const ConversionNNPtr &conv) { + return PJ_OBJ::create(ctx, conv); +} + +//! @endcond + +/* BEGIN: Generated by scripts/create_c_api_projections.py*/ + +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a Universal Transverse Mercator + * conversion. + * + * See osgeo::proj::operation::Conversion::createUTM(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_utm(PJ_CONTEXT *ctx, int zone, int north) { + try { + auto conv = Conversion::createUTM(PropertyMap(), zone, north != 0); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Transverse + * Mercator projection method. + * + * See osgeo::proj::operation::Conversion::createTransverseMercator(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_transverse_mercator( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createTransverseMercator( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Gauss + * Schreiber Transverse Mercator projection method. + * + * See + * osgeo::proj::operation::Conversion::createGaussSchreiberTransverseMercator(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_gauss_schreiber_transverse_mercator( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGaussSchreiberTransverseMercator( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Transverse + * Mercator South Orientated projection method. + * + * See + * osgeo::proj::operation::Conversion::createTransverseMercatorSouthOriented(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_transverse_mercator_south_oriented( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createTransverseMercatorSouthOriented( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Two Point + * Equidistant projection method. + * + * See osgeo::proj::operation::Conversion::createTwoPointEquidistant(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_two_point_equidistant( + PJ_CONTEXT *ctx, double latitudeFirstPoint, double longitudeFirstPoint, + double latitudeSecondPoint, double longitudeSeconPoint, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createTwoPointEquidistant( + PropertyMap(), Angle(latitudeFirstPoint, angUnit), + Angle(longitudeFirstPoint, angUnit), + Angle(latitudeSecondPoint, angUnit), + Angle(longitudeSeconPoint, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Tunisia + * Mapping Grid projection method. + * + * See osgeo::proj::operation::Conversion::createTunisiaMappingGrid(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_tunisia_mapping_grid( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createTunisiaMappingGrid( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Albers + * Conic Equal Area projection method. + * + * See osgeo::proj::operation::Conversion::createAlbersEqualArea(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_albers_equal_area( + PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, + double latitudeFirstParallel, double latitudeSecondParallel, + double eastingFalseOrigin, double northingFalseOrigin, + const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createAlbersEqualArea( + PropertyMap(), Angle(latitudeFalseOrigin, angUnit), + Angle(longitudeFalseOrigin, angUnit), + Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(eastingFalseOrigin, linearUnit), + Length(northingFalseOrigin, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Lambert + * Conic Conformal 1SP projection method. + * + * See osgeo::proj::operation::Conversion::createLambertConicConformal_1SP(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_1sp( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertConicConformal_2SP( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertConicConformal_1SP( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; +} +// --------------------------------------------------------------------------- + +/** \brief Instanciate a ProjectedCRS with a conversion based on the Lambert + * Conic Conformal (2SP) projection method. + * + * See osgeo::proj::operation::Conversion::createLambertConicConformal_2SP(). + * + * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + */ +PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp( + PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, + double latitudeFirstParallel, double latitudeSecondParallel, + double eastingFalseOrigin, double northingFalseOrigin, + const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertConicConformal_2SP( + PropertyMap(), Angle(latitudeFalseOrigin, angUnit), + Angle(longitudeFalseOrigin, angUnit), + Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(eastingFalseOrigin, linearUnit), + Length(northingFalseOrigin, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2034,25 +2932,31 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP_Michigan( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFalseOrigin, - double longitudeFalseOrigin, double latitudeFirstParallel, - double latitudeSecondParallel, double eastingFalseOrigin, - double northingFalseOrigin, double ellipsoidScalingFactor, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertConicConformal_2SP_Michigan( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit), Scale(ellipsoidScalingFactor)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_michigan( + PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, + double latitudeFirstParallel, double latitudeSecondParallel, + double eastingFalseOrigin, double northingFalseOrigin, + double ellipsoidScalingFactor, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertConicConformal_2SP_Michigan( + PropertyMap(), Angle(latitudeFalseOrigin, angUnit), + Angle(longitudeFalseOrigin, angUnit), + Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(eastingFalseOrigin, linearUnit), + Length(northingFalseOrigin, linearUnit), + Scale(ellipsoidScalingFactor)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2065,25 +2969,29 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP_Michigan( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP_Belgium( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFalseOrigin, - double longitudeFalseOrigin, double latitudeFirstParallel, - double latitudeSecondParallel, double eastingFalseOrigin, - double northingFalseOrigin, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertConicConformal_2SP_Belgium( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_belgium( + PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, + double latitudeFirstParallel, double latitudeSecondParallel, + double eastingFalseOrigin, double northingFalseOrigin, + const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertConicConformal_2SP_Belgium( + PropertyMap(), Angle(latitudeFalseOrigin, angUnit), + Angle(longitudeFalseOrigin, angUnit), + Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(eastingFalseOrigin, linearUnit), + Length(northingFalseOrigin, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2095,20 +3003,26 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertConicConformal_2SP_Belgium( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_AzimuthalEquidistant( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeNatOrigin, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createAzimuthalEquidistant( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_azimuthal_equidistant( + PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createAzimuthalEquidistant( + PropertyMap(), Angle(latitudeNatOrigin, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2120,20 +3034,26 @@ PJ_OBJ *proj_obj_create_projected_crs_AzimuthalEquidistant( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_GuamProjection( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeNatOrigin, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGuamProjection( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_guam_projection( + PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGuamProjection( + PropertyMap(), Angle(latitudeNatOrigin, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2145,20 +3065,26 @@ PJ_OBJ *proj_obj_create_projected_crs_GuamProjection( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Bonne( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeNatOrigin, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createBonne( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_bonne( + PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createBonne(PropertyMap(), + Angle(latitudeNatOrigin, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2171,20 +3097,26 @@ PJ_OBJ *proj_obj_create_projected_crs_Bonne( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_LambertCylindricalEqualAreaSpherical( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstParallel, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertCylindricalEqualAreaSpherical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area_spherical( + PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertCylindricalEqualAreaSpherical( + PropertyMap(), Angle(latitudeFirstParallel, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2196,20 +3128,26 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertCylindricalEqualAreaSpherical( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_LambertCylindricalEqualArea( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstParallel, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertCylindricalEqualArea( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area( + PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertCylindricalEqualArea( + PropertyMap(), Angle(latitudeFirstParallel, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2221,19 +3159,24 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertCylindricalEqualArea( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_CassiniSoldner( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_cassini_soldner( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createCassiniSoldner( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createCassiniSoldner( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2245,22 +3188,28 @@ PJ_OBJ *proj_obj_create_projected_crs_CassiniSoldner( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EquidistantConic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double latitudeFirstParallel, - double latitudeSecondParallel, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEquidistantConic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_equidistant_conic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, + double latitudeFirstParallel, double latitudeSecondParallel, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEquidistantConic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2272,19 +3221,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EquidistantConic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertI( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_i( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createEckertI(PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2296,19 +3250,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertI( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertII( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_ii( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEckertII( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2320,19 +3279,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertII( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertIII( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertIII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_iii( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEckertIII( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2344,19 +3308,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertIII( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertIV( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertIV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_iv( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEckertIV( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2368,19 +3337,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertIV( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertV( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_v( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createEckertV(PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2392,19 +3366,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertV( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EckertVI( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEckertVI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_eckert_vi( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEckertVI( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2416,20 +3395,26 @@ PJ_OBJ *proj_obj_create_projected_crs_EckertVI( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EquidistantCylindrical( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstParallel, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEquidistantCylindrical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical( + PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEquidistantCylindrical( + PropertyMap(), Angle(latitudeFirstParallel, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2442,20 +3427,26 @@ PJ_OBJ *proj_obj_create_projected_crs_EquidistantCylindrical( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EquidistantCylindricalSpherical( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstParallel, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEquidistantCylindricalSpherical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical_spherical( + PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEquidistantCylindricalSpherical( + PropertyMap(), Angle(latitudeFirstParallel, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2467,19 +3458,24 @@ PJ_OBJ *proj_obj_create_projected_crs_EquidistantCylindricalSpherical( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Gall( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGall( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_gall( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createGall(PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2491,19 +3487,24 @@ PJ_OBJ *proj_obj_create_projected_crs_Gall( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_GoodeHomolosine( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGoodeHomolosine( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_goode_homolosine( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGoodeHomolosine( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2515,19 +3516,24 @@ PJ_OBJ *proj_obj_create_projected_crs_GoodeHomolosine( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_InterruptedGoodeHomolosine( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createInterruptedGoodeHomolosine( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_interrupted_goode_homolosine( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createInterruptedGoodeHomolosine( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2540,19 +3546,24 @@ PJ_OBJ *proj_obj_create_projected_crs_InterruptedGoodeHomolosine( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_GeostationarySatelliteSweepX( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double height, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_x( + PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGeostationarySatelliteSweepX( - PropertyMap(), Angle(centerLong, angUnit), Length(height, linearUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGeostationarySatelliteSweepX( + PropertyMap(), Angle(centerLong, angUnit), + Length(height, linearUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2565,19 +3576,24 @@ PJ_OBJ *proj_obj_create_projected_crs_GeostationarySatelliteSweepX( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_GeostationarySatelliteSweepY( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double height, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_y( + PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGeostationarySatelliteSweepY( - PropertyMap(), Angle(centerLong, angUnit), Length(height, linearUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGeostationarySatelliteSweepY( + PropertyMap(), Angle(centerLong, angUnit), + Length(height, linearUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2589,19 +3605,24 @@ PJ_OBJ *proj_obj_create_projected_crs_GeostationarySatelliteSweepY( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Gnomonic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_gnomonic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createGnomonic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createGnomonic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2614,23 +3635,29 @@ PJ_OBJ *proj_obj_create_projected_crs_Gnomonic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_HotineObliqueMercatorVariantA( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeProjectionCentre, +PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_a( + PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeProjectionCentre, double azimuthInitialLine, double angleFromRectifiedToSkrewGrid, double scale, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createHotineObliqueMercatorVariantA( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeProjectionCentre, angUnit), - Angle(azimuthInitialLine, angUnit), - Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createHotineObliqueMercatorVariantA( + PropertyMap(), Angle(latitudeProjectionCentre, angUnit), + Angle(longitudeProjectionCentre, angUnit), + Angle(azimuthInitialLine, angUnit), + Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2643,25 +3670,30 @@ PJ_OBJ *proj_obj_create_projected_crs_HotineObliqueMercatorVariantA( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_HotineObliqueMercatorVariantB( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeProjectionCentre, +PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_b( + PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeProjectionCentre, double azimuthInitialLine, double angleFromRectifiedToSkrewGrid, double scale, double eastingProjectionCentre, double northingProjectionCentre, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createHotineObliqueMercatorVariantB( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeProjectionCentre, angUnit), - Angle(azimuthInitialLine, angUnit), - Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), - Length(eastingProjectionCentre, linearUnit), - Length(northingProjectionCentre, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createHotineObliqueMercatorVariantB( + PropertyMap(), Angle(latitudeProjectionCentre, angUnit), + Angle(longitudeProjectionCentre, angUnit), + Angle(azimuthInitialLine, angUnit), + Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), + Length(eastingProjectionCentre, linearUnit), + Length(northingProjectionCentre, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2675,24 +3707,30 @@ PJ_OBJ *proj_obj_create_projected_crs_HotineObliqueMercatorVariantB( * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ PJ_OBJ * -proj_obj_create_projected_crs_HotineObliqueMercatorTwoPointNaturalOrigin( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeProjectionCentre, - double latitudePoint1, double longitudePoint1, double latitudePoint2, - double longitudePoint2, double scale, double eastingProjectionCentre, +proj_obj_create_conversion_hotine_oblique_mercator_two_point_natural_origin( + PJ_CONTEXT *ctx, double latitudeProjectionCentre, double latitudePoint1, + double longitudePoint1, double latitudePoint2, double longitudePoint2, + double scale, double eastingProjectionCentre, double northingProjectionCentre, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createHotineObliqueMercatorTwoPointNaturalOrigin( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(latitudePoint1, angUnit), Angle(longitudePoint1, angUnit), - Angle(latitudePoint2, angUnit), Angle(longitudePoint2, angUnit), - Scale(scale), Length(eastingProjectionCentre, linearUnit), - Length(northingProjectionCentre, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createHotineObliqueMercatorTwoPointNaturalOrigin( + PropertyMap(), Angle(latitudeProjectionCentre, angUnit), + Angle(latitudePoint1, angUnit), Angle(longitudePoint1, angUnit), + Angle(latitudePoint2, angUnit), Angle(longitudePoint2, angUnit), + Scale(scale), Length(eastingProjectionCentre, linearUnit), + Length(northingProjectionCentre, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2705,22 +3743,27 @@ proj_obj_create_projected_crs_HotineObliqueMercatorTwoPointNaturalOrigin( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_InternationalMapWorldPolyconic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double latitudeFirstParallel, double latitudeSecondParallel, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createInternationalMapWorldPolyconic( - PropertyMap(), Angle(centerLong, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_international_map_world_polyconic( + PJ_CONTEXT *ctx, double centerLong, double latitudeFirstParallel, + double latitudeSecondParallel, double falseEasting, double falseNorthing, + const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createInternationalMapWorldPolyconic( + PropertyMap(), Angle(centerLong, angUnit), + Angle(latitudeFirstParallel, angUnit), + Angle(latitudeSecondParallel, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2732,24 +3775,30 @@ PJ_OBJ *proj_obj_create_projected_crs_InternationalMapWorldPolyconic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_KrovakNorthOriented( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeProjectionCentre, - double longitudeOfOrigin, double colatitudeConeAxis, - double latitudePseudoStandardParallel, +PJ_OBJ *proj_obj_create_conversion_krovak_north_oriented( + PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeOfOrigin, + double colatitudeConeAxis, double latitudePseudoStandardParallel, double scaleFactorPseudoStandardParallel, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createKrovakNorthOriented( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeOfOrigin, angUnit), Angle(colatitudeConeAxis, angUnit), - Angle(latitudePseudoStandardParallel, angUnit), - Scale(scaleFactorPseudoStandardParallel), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createKrovakNorthOriented( + PropertyMap(), Angle(latitudeProjectionCentre, angUnit), + Angle(longitudeOfOrigin, angUnit), + Angle(colatitudeConeAxis, angUnit), + Angle(latitudePseudoStandardParallel, angUnit), + Scale(scaleFactorPseudoStandardParallel), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2761,24 +3810,30 @@ PJ_OBJ *proj_obj_create_projected_crs_KrovakNorthOriented( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Krovak( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeProjectionCentre, - double longitudeOfOrigin, double colatitudeConeAxis, - double latitudePseudoStandardParallel, +PJ_OBJ *proj_obj_create_conversion_krovak( + PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeOfOrigin, + double colatitudeConeAxis, double latitudePseudoStandardParallel, double scaleFactorPseudoStandardParallel, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createKrovak( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeOfOrigin, angUnit), Angle(colatitudeConeAxis, angUnit), - Angle(latitudePseudoStandardParallel, angUnit), - Scale(scaleFactorPseudoStandardParallel), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createKrovak( + PropertyMap(), Angle(latitudeProjectionCentre, angUnit), + Angle(longitudeOfOrigin, angUnit), + Angle(colatitudeConeAxis, angUnit), + Angle(latitudePseudoStandardParallel, angUnit), + Scale(scaleFactorPseudoStandardParallel), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2790,20 +3845,26 @@ PJ_OBJ *proj_obj_create_projected_crs_Krovak( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_LambertAzimuthalEqualArea( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeNatOrigin, - double longitudeNatOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createLambertAzimuthalEqualArea( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_lambert_azimuthal_equal_area( + PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createLambertAzimuthalEqualArea( + PropertyMap(), Angle(latitudeNatOrigin, angUnit), + Angle(longitudeNatOrigin, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2815,19 +3876,24 @@ PJ_OBJ *proj_obj_create_projected_crs_LambertAzimuthalEqualArea( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_MillerCylindrical( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createMillerCylindrical( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_miller_cylindrical( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createMillerCylindrical( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2839,20 +3905,26 @@ PJ_OBJ *proj_obj_create_projected_crs_MillerCylindrical( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_MercatorVariantA( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createMercatorVariantA( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_mercator_variant_a( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createMercatorVariantA( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2864,20 +3936,25 @@ PJ_OBJ *proj_obj_create_projected_crs_MercatorVariantA( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_MercatorVariantB( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeFirstParallel, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createMercatorVariantB( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_mercator_variant_b( + PJ_CONTEXT *ctx, double latitudeFirstParallel, double centerLong, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createMercatorVariantB( + PropertyMap(), Angle(latitudeFirstParallel, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2890,19 +3967,24 @@ PJ_OBJ *proj_obj_create_projected_crs_MercatorVariantB( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_PopularVisualisationPseudoMercator( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_popular_visualisation_pseudo_mercator( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createPopularVisualisationPseudoMercator( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createPopularVisualisationPseudoMercator( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2914,19 +3996,24 @@ PJ_OBJ *proj_obj_create_projected_crs_PopularVisualisationPseudoMercator( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Mollweide( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createMollweide( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_mollweide( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createMollweide( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2938,19 +4025,24 @@ PJ_OBJ *proj_obj_create_projected_crs_Mollweide( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_NewZealandMappingGrid( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_new_zealand_mapping_grid( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createNewZealandMappingGrid( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createNewZealandMappingGrid( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2962,20 +4054,26 @@ PJ_OBJ *proj_obj_create_projected_crs_NewZealandMappingGrid( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_ObliqueStereographic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createObliqueStereographic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_oblique_stereographic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createObliqueStereographic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -2987,19 +4085,24 @@ PJ_OBJ *proj_obj_create_projected_crs_ObliqueStereographic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Orthographic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_orthographic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createOrthographic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createOrthographic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3011,19 +4114,24 @@ PJ_OBJ *proj_obj_create_projected_crs_Orthographic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_AmericanPolyconic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_american_polyconic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createAmericanPolyconic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createAmericanPolyconic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3035,20 +4143,26 @@ PJ_OBJ *proj_obj_create_projected_crs_AmericanPolyconic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_PolarStereographicVariantA( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createPolarStereographicVariantA( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_a( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createPolarStereographicVariantA( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3060,20 +4174,25 @@ PJ_OBJ *proj_obj_create_projected_crs_PolarStereographicVariantA( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_PolarStereographicVariantB( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeStandardParallel, - double longitudeOfOrigin, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createPolarStereographicVariantB( - PropertyMap(), Angle(latitudeStandardParallel, angUnit), - Angle(longitudeOfOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_b( + PJ_CONTEXT *ctx, double latitudeStandardParallel, double longitudeOfOrigin, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createPolarStereographicVariantB( + PropertyMap(), Angle(latitudeStandardParallel, angUnit), + Angle(longitudeOfOrigin, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3085,19 +4204,24 @@ PJ_OBJ *proj_obj_create_projected_crs_PolarStereographicVariantB( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Robinson( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createRobinson( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_robinson( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createRobinson( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3109,19 +4233,24 @@ PJ_OBJ *proj_obj_create_projected_crs_Robinson( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Sinusoidal( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createSinusoidal( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_sinusoidal( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createSinusoidal( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3133,20 +4262,26 @@ PJ_OBJ *proj_obj_create_projected_crs_Sinusoidal( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_Stereographic( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double scale, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createStereographic( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Scale(scale), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_stereographic( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createStereographic( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Scale(scale), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3158,19 +4293,24 @@ PJ_OBJ *proj_obj_create_projected_crs_Stereographic( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_VanDerGrinten( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createVanDerGrinten( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_van_der_grinten( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createVanDerGrinten( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3182,19 +4322,24 @@ PJ_OBJ *proj_obj_create_projected_crs_VanDerGrinten( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerI( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_i( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createWagnerI(PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3206,19 +4351,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerI( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerII( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_ii( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createWagnerII( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3230,20 +4380,25 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerII( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerIII( - PJ_OBJ *geodetic_crs, const char *crs_name, double latitudeTrueScale, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerIII( - PropertyMap(), Angle(latitudeTrueScale, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_iii( + PJ_CONTEXT *ctx, double latitudeTrueScale, double centerLong, + double falseEasting, double falseNorthing, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createWagnerIII( + PropertyMap(), Angle(latitudeTrueScale, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3255,19 +4410,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerIII( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerIV( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerIV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_iv( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createWagnerIV( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3279,19 +4439,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerIV( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerV( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_v( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = + Conversion::createWagnerV(PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3303,19 +4468,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerV( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerVI( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerVI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_vi( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createWagnerVI( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3327,19 +4497,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerVI( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_WagnerVII( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createWagnerVII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_wagner_vii( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createWagnerVII( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3352,19 +4527,24 @@ PJ_OBJ *proj_obj_create_projected_crs_WagnerVII( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_QuadrilateralizedSphericalCube( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLat, - double centerLong, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, +PJ_OBJ *proj_obj_create_conversion_quadrilateralized_spherical_cube( + PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createQuadrilateralizedSphericalCube( - PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createQuadrilateralizedSphericalCube( + PropertyMap(), Angle(centerLat, angUnit), + Angle(centerLong, angUnit), Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3376,20 +4556,25 @@ PJ_OBJ *proj_obj_create_projected_crs_QuadrilateralizedSphericalCube( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_SphericalCrossTrackHeight( - PJ_OBJ *geodetic_crs, const char *crs_name, double pegPointLat, - double pegPointLong, double pegPointHeading, double pegPointHeight, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createSphericalCrossTrackHeight( - PropertyMap(), Angle(pegPointLat, angUnit), - Angle(pegPointLong, angUnit), Angle(pegPointHeading, angUnit), - Length(pegPointHeight, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_spherical_cross_track_height( + PJ_CONTEXT *ctx, double pegPointLat, double pegPointLong, + double pegPointHeading, double pegPointHeight, const char *angUnitName, + double angUnitConvFactor, const char *linearUnitName, + double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createSphericalCrossTrackHeight( + PropertyMap(), Angle(pegPointLat, angUnit), + Angle(pegPointLong, angUnit), Angle(pegPointHeading, angUnit), + Length(pegPointHeight, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } // --------------------------------------------------------------------------- @@ -3401,19 +4586,24 @@ PJ_OBJ *proj_obj_create_projected_crs_SphericalCrossTrackHeight( * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). * Angular parameters are expressed in (angUnitName, angUnitConvFactor). */ -PJ_OBJ *proj_obj_create_projected_crs_EqualEarth( - PJ_OBJ *geodetic_crs, const char *crs_name, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { - UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); - UnitOfMeasure angUnit(createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createEqualEarth( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_projected_crs(geodetic_crs, crs_name, conv, - linearUnit); +PJ_OBJ *proj_obj_create_conversion_equal_earth( + PJ_CONTEXT *ctx, double centerLong, double falseEasting, + double falseNorthing, const char *angUnitName, double angUnitConvFactor, + const char *linearUnitName, double linearUnitConvFactor) { + try { + UnitOfMeasure linearUnit( + createLinearUnit(linearUnitName, linearUnitConvFactor)); + UnitOfMeasure angUnit( + createAngularUnit(angUnitName, angUnitConvFactor)); + auto conv = Conversion::createEqualEarth( + PropertyMap(), Angle(centerLong, angUnit), + Length(falseEasting, linearUnit), + Length(falseNorthing, linearUnit)); + return proj_obj_create_conversion(ctx, conv); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } + return nullptr; } /* END: Generated by scripts/create_c_api_projections.py*/ @@ -3428,7 +4618,7 @@ PJ_OBJ *proj_obj_create_projected_crs_EqualEarth( * @return TRUE or FALSE. */ -int proj_coordoperation_is_instanciable(PJ_OBJ *coordoperation) { +int proj_coordoperation_is_instanciable(const PJ_OBJ *coordoperation) { assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); @@ -3453,7 +4643,7 @@ int proj_coordoperation_is_instanciable(PJ_OBJ *coordoperation) { * (must not be NULL) */ -int proj_coordoperation_get_param_count(PJ_OBJ *coordoperation) { +int proj_coordoperation_get_param_count(const PJ_OBJ *coordoperation) { assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { @@ -3474,7 +4664,7 @@ int proj_coordoperation_get_param_count(PJ_OBJ *coordoperation) { * @return index (>=0), or -1 in case of error. */ -int proj_coordoperation_get_param_index(PJ_OBJ *coordoperation, +int proj_coordoperation_get_param_index(const PJ_OBJ *coordoperation, const char *name) { assert(coordoperation); assert(name); @@ -3517,7 +4707,7 @@ int proj_coordoperation_get_param_index(PJ_OBJ *coordoperation, * @return TRUE in case of success. */ -int proj_coordoperation_get_param(PJ_OBJ *coordoperation, int index, +int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, const char **pName, const char **pNameAuthorityName, const char **pNameCode, double *pValue, @@ -3613,7 +4803,7 @@ int proj_coordoperation_get_param(PJ_OBJ *coordoperation, int index, * (must not be NULL) */ -int proj_coordoperation_get_grid_used_count(PJ_OBJ *coordoperation) { +int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { assert(coordoperation); auto co = dynamic_cast(coordoperation->obj.get()); @@ -3662,7 +4852,7 @@ int proj_coordoperation_get_grid_used_count(PJ_OBJ *coordoperation) { * @return TRUE in case of success. */ -int proj_coordoperation_get_grid_used(PJ_OBJ *coordoperation, int index, +int proj_coordoperation_get_grid_used(const PJ_OBJ *coordoperation, int index, const char **pShortName, const char **pFullName, const char **pPackageName, @@ -3993,9 +5183,9 @@ void proj_operation_factory_context_set_allowed_intermediate_crs( * @return a result set that must be unreferenced with * proj_obj_list_unref(), or NULL in case of error. */ -PJ_OBJ_LIST * -proj_obj_create_operations(PJ_OBJ *source_crs, PJ_OBJ *target_crs, - PJ_OPERATION_FACTORY_CONTEXT *operationContext) { +PJ_OBJ_LIST *proj_obj_create_operations( + const PJ_OBJ *source_crs, const PJ_OBJ *target_crs, + const PJ_OPERATION_FACTORY_CONTEXT *operationContext) { assert(source_crs); assert(target_crs); assert(operationContext); @@ -4035,7 +5225,7 @@ proj_obj_create_operations(PJ_OBJ *source_crs, PJ_OBJ *target_crs, * * @param result Objet of type PJ_OBJ_LIST (must not be NULL) */ -int proj_obj_list_get_count(PJ_OBJ_LIST *result) { +int proj_obj_list_get_count(const PJ_OBJ_LIST *result) { assert(result); return static_cast(result->objects.size()); } @@ -4054,7 +5244,7 @@ int proj_obj_list_get_count(PJ_OBJ_LIST *result) { * or nullptr in case of error. */ -PJ_OBJ *proj_obj_list_get(PJ_OBJ_LIST *result, int index) { +PJ_OBJ *proj_obj_list_get(const PJ_OBJ_LIST *result, int index) { assert(result); if (index < 0 || index >= proj_obj_list_get_count(result)) { proj_log_error(result->ctx, __FUNCTION__, "Invalid index"); @@ -4080,7 +5270,7 @@ void proj_obj_list_unref(PJ_OBJ_LIST *result) { delete result; } * * @return the accuracy, or a negative value if unknown or in case of error. */ -double proj_coordoperation_get_accuracy(PJ_OBJ *coordoperation) { +double proj_coordoperation_get_accuracy(const PJ_OBJ *coordoperation) { assert(coordoperation); auto co = dynamic_cast(coordoperation->obj.get()); @@ -4102,6 +5292,32 @@ double proj_coordoperation_get_accuracy(PJ_OBJ *coordoperation) { // --------------------------------------------------------------------------- +/** \brief Returns the datum of a SingleCRS. + * + * The returned object must be unreferenced with proj_obj_unref() after + * use. + * It should be used by at most one thread at a time. + * + * @param crs Objet of type SingleCRS (must not be NULL) + * @return Object that must be unreferenced with proj_obj_unref(), or NULL + * in case of error (or if there is no datum) + */ +PJ_OBJ *proj_obj_crs_get_datum(const PJ_OBJ *crs) { + assert(crs); + auto l_crs = dynamic_cast(crs->obj.get()); + if (!l_crs) { + proj_log_error(crs->ctx, __FUNCTION__, "Object is not a SingleCRS"); + return nullptr; + } + const auto &datum = l_crs->datum(); + if (!datum) { + return nullptr; + } + return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(datum)); +} + +// --------------------------------------------------------------------------- + /** \brief Returns the coordinate system of a SingleCRS. * * The returned object must be unreferenced with proj_obj_unref() after @@ -4112,7 +5328,7 @@ double proj_coordoperation_get_accuracy(PJ_OBJ *coordoperation) { * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_coordinate_system(PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_get_coordinate_system(const PJ_OBJ *crs) { assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { @@ -4127,44 +5343,44 @@ PJ_OBJ *proj_obj_crs_get_coordinate_system(PJ_OBJ *crs) { /** \brief Returns the type of the coordinate system. * * @param cs Objet of type CoordinateSystem (must not be NULL) - * @return type, or NULL in case of error. + * @return type, or PJ_CS_TYPE_UNKNOWN in case of error. */ -const char *proj_obj_cs_get_type(PJ_OBJ *cs) { +PJ_COORDINATE_SYSTEM_TYPE proj_obj_cs_get_type(const PJ_OBJ *cs) { assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { proj_log_error(cs->ctx, __FUNCTION__, "Object is not a CoordinateSystem"); - return nullptr; + return PJ_CS_TYPE_UNKNOWN; } if (dynamic_cast(l_cs)) { - return "Cartesian"; + return PJ_CS_TYPE_CARTESIAN; } if (dynamic_cast(l_cs)) { - return "Ellipsoidal"; + return PJ_CS_TYPE_ELLIPSOIDAL; } if (dynamic_cast(l_cs)) { - return "Vertical"; + return PJ_CS_TYPE_VERTICAL; } if (dynamic_cast(l_cs)) { - return "Spherical"; + return PJ_CS_TYPE_SPHERICAL; } if (dynamic_cast(l_cs)) { - return "Ordinal"; + return PJ_CS_TYPE_ORDINAL; } if (dynamic_cast(l_cs)) { - return "Parametric"; + return PJ_CS_TYPE_PARAMETRIC; } if (dynamic_cast(l_cs)) { - return "DateTimeTemporal"; + return PJ_CS_TYPE_DATETIMETEMPORAL; } if (dynamic_cast(l_cs)) { - return "TemporalCount"; + return PJ_CS_TYPE_TEMPORALCOUNT; } if (dynamic_cast(l_cs)) { - return "TemporalMeasure"; + return PJ_CS_TYPE_TEMPORALMEASURE; } - return "unknown"; + return PJ_CS_TYPE_UNKNOWN; } // --------------------------------------------------------------------------- @@ -4174,7 +5390,7 @@ const char *proj_obj_cs_get_type(PJ_OBJ *cs) { * @param cs Objet of type CoordinateSystem (must not be NULL) * @return number of axis, or -1 in case of error. */ -int proj_obj_cs_get_axis_count(PJ_OBJ *cs) { +int proj_obj_cs_get_axis_count(const PJ_OBJ *cs) { assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { @@ -4203,7 +5419,7 @@ int proj_obj_cs_get_axis_count(PJ_OBJ *cs) { * unit name. or NULL * @return TRUE in case of success */ -int proj_obj_cs_get_axis_info(PJ_OBJ *cs, int index, const char **pName, +int proj_obj_cs_get_axis_info(const PJ_OBJ *cs, int index, const char **pName, const char **pAbbrev, const char **pDirection, double *pUnitConvFactor, const char **pUnitName) { assert(cs); -- cgit v1.2.3 From c42a6d88f1314bfac9f70e2e7721d12c84013892 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Thu, 29 Nov 2018 18:27:56 +0100 Subject: C API: replace ctxt by ctx --- src/c_api.cpp | 86 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 43 insertions(+), 43 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index dc7bc3e6..8d01df95 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -142,11 +142,11 @@ struct PJ_OBJ_LIST { struct projCppContext { DatabaseContextNNPtr databaseContext; - explicit projCppContext(PJ_CONTEXT *ctxt, const char *dbPath = nullptr, + explicit projCppContext(PJ_CONTEXT *ctx, const char *dbPath = nullptr, const char *const *auxDbPaths = nullptr) : databaseContext(DatabaseContext::create( dbPath ? dbPath : std::string(), toVector(auxDbPaths))) { - databaseContext->attachPJContext(ctxt); + databaseContext->attachPJContext(ctx); } static std::vector toVector(const char *const *auxDbPaths) { @@ -4962,22 +4962,22 @@ proj_create_operation_factory_context(PJ_CONTEXT *ctx, const char *authority) { * This method should be called one and exactly one for each function * returning a PJ_OPERATION_FACTORY_CONTEXT* * - * @param ctxt Object, or NULL. + * @param ctx Object, or NULL. */ -void proj_operation_factory_context_unref(PJ_OPERATION_FACTORY_CONTEXT *ctxt) { - delete ctxt; +void proj_operation_factory_context_unref(PJ_OPERATION_FACTORY_CONTEXT *ctx) { + delete ctx; } // --------------------------------------------------------------------------- /** \brief Set the desired accuracy of the resulting coordinate transformations. - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param accuracy Accuracy in meter (or 0 to disable the filter). */ void proj_operation_factory_context_set_desired_accuracy( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, double accuracy) { - assert(ctxt); - ctxt->operationContext->setDesiredAccuracy(accuracy); + PJ_OPERATION_FACTORY_CONTEXT *ctx, double accuracy) { + assert(ctx); + ctx->operationContext->setDesiredAccuracy(accuracy); } // --------------------------------------------------------------------------- @@ -4988,17 +4988,17 @@ void proj_operation_factory_context_set_desired_accuracy( * For an area of interest crossing the anti-meridian, west_lon_degree will be * greater than east_lon_degree. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param west_lon_degree West longitude (in degrees). * @param south_lat_degree South latitude (in degrees). * @param east_lon_degree East longitude (in degrees). * @param north_lat_degree North latitude (in degrees). */ void proj_operation_factory_context_set_area_of_interest( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, double west_lon_degree, + PJ_OPERATION_FACTORY_CONTEXT *ctx, double west_lon_degree, double south_lat_degree, double east_lon_degree, double north_lat_degree) { - assert(ctxt); - ctxt->operationContext->setAreaOfInterest(Extent::createFromBBOX( + assert(ctx); + ctx->operationContext->setAreaOfInterest(Extent::createFromBBOX( west_lon_degree, south_lat_degree, east_lon_degree, north_lat_degree)); } @@ -5010,30 +5010,30 @@ void proj_operation_factory_context_set_area_of_interest( * * The default is PJ_CRS_EXTENT_SMALLEST. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param use How source and target CRS extent should be used. */ void proj_operation_factory_context_set_crs_extent_use( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, PROJ_CRS_EXTENT_USE use) { - assert(ctxt); + PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_CRS_EXTENT_USE use) { + assert(ctx); switch (use) { case PJ_CRS_EXTENT_NONE: - ctxt->operationContext->setSourceAndTargetCRSExtentUse( + ctx->operationContext->setSourceAndTargetCRSExtentUse( CoordinateOperationContext::SourceTargetCRSExtentUse::NONE); break; case PJ_CRS_EXTENT_BOTH: - ctxt->operationContext->setSourceAndTargetCRSExtentUse( + ctx->operationContext->setSourceAndTargetCRSExtentUse( CoordinateOperationContext::SourceTargetCRSExtentUse::BOTH); break; case PJ_CRS_EXTENT_INTERSECTION: - ctxt->operationContext->setSourceAndTargetCRSExtentUse( + ctx->operationContext->setSourceAndTargetCRSExtentUse( CoordinateOperationContext::SourceTargetCRSExtentUse::INTERSECTION); break; case PJ_CRS_EXTENT_SMALLEST: - ctxt->operationContext->setSourceAndTargetCRSExtentUse( + ctx->operationContext->setSourceAndTargetCRSExtentUse( CoordinateOperationContext::SourceTargetCRSExtentUse::SMALLEST); break; } @@ -5048,20 +5048,20 @@ void proj_operation_factory_context_set_crs_extent_use( * * The default is PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param criterion patial criterion to use */ void PROJ_DLL proj_operation_factory_context_set_spatial_criterion( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, PROJ_SPATIAL_CRITERION criterion) { - assert(ctxt); + PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_SPATIAL_CRITERION criterion) { + assert(ctx); switch (criterion) { case PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT: - ctxt->operationContext->setSpatialCriterion( + ctx->operationContext->setSpatialCriterion( CoordinateOperationContext::SpatialCriterion::STRICT_CONTAINMENT); break; case PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION: - ctxt->operationContext->setSpatialCriterion( + ctx->operationContext->setSpatialCriterion( CoordinateOperationContext::SpatialCriterion::PARTIAL_INTERSECTION); break; } @@ -5073,26 +5073,26 @@ void PROJ_DLL proj_operation_factory_context_set_spatial_criterion( * * The default is USE_FOR_SORTING. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param use how grid availability is used. */ void PROJ_DLL proj_operation_factory_context_set_grid_availability_use( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, PROJ_GRID_AVAILABILITY_USE use) { - assert(ctxt); + PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_GRID_AVAILABILITY_USE use) { + assert(ctx); switch (use) { case PROJ_GRID_AVAILABILITY_USED_FOR_SORTING: - ctxt->operationContext->setGridAvailabilityUse( + ctx->operationContext->setGridAvailabilityUse( CoordinateOperationContext::GridAvailabilityUse::USE_FOR_SORTING); break; case PROJ_GRID_AVAILABILITY_DISCARD_OPERATION_IF_MISSING_GRID: - ctxt->operationContext->setGridAvailabilityUse( + ctx->operationContext->setGridAvailabilityUse( CoordinateOperationContext::GridAvailabilityUse:: DISCARD_OPERATION_IF_MISSING_GRID); break; case PROJ_GRID_AVAILABILITY_IGNORED: - ctxt->operationContext->setGridAvailabilityUse( + ctx->operationContext->setGridAvailabilityUse( CoordinateOperationContext::GridAvailabilityUse:: IGNORE_GRID_AVAILABILITY); break; @@ -5106,13 +5106,13 @@ void PROJ_DLL proj_operation_factory_context_set_grid_availability_use( * * The default is true. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param usePROJNames whether PROJ alternative grid names should be used */ void proj_operation_factory_context_set_use_proj_alternative_grid_names( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, int usePROJNames) { - assert(ctxt); - ctxt->operationContext->setUsePROJAlternativeGridNames(usePROJNames != 0); + PJ_OPERATION_FACTORY_CONTEXT *ctx, int usePROJNames) { + assert(ctx); + ctx->operationContext->setUsePROJAlternativeGridNames(usePROJNames != 0); } // --------------------------------------------------------------------------- @@ -5134,13 +5134,13 @@ void proj_operation_factory_context_set_use_proj_alternative_grid_names( * * The default is true. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param allow whether intermediate CRS may be used. */ void proj_operation_factory_context_set_allow_use_intermediate_crs( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, int allow) { - assert(ctxt); - ctxt->operationContext->setAllowUseIntermediateCRS(allow != 0); + PJ_OPERATION_FACTORY_CONTEXT *ctx, int allow) { + assert(ctx); + ctx->operationContext->setAllowUseIntermediateCRS(allow != 0); } // --------------------------------------------------------------------------- @@ -5148,21 +5148,21 @@ void proj_operation_factory_context_set_allow_use_intermediate_crs( /** \brief Restrict the potential pivot CRSs that can be used when trying to * build a coordinate operation between two CRS that have no direct operation. * - * @param ctxt Operation factory context. must not be NULL + * @param ctx Operation factory context. must not be NULL * @param list_of_auth_name_codes an array of strings NLL terminated, * with the format { "auth_name1", "code1", "auth_name2", "code2", ... NULL } */ void proj_operation_factory_context_set_allowed_intermediate_crs( - PJ_OPERATION_FACTORY_CONTEXT *ctxt, + PJ_OPERATION_FACTORY_CONTEXT *ctx, const char *const *list_of_auth_name_codes) { - assert(ctxt); + assert(ctx); std::vector> pivots; for (auto iter = list_of_auth_name_codes; iter && iter[0] && iter[1]; iter += 2) { pivots.emplace_back(std::pair( std::string(iter[0]), std::string(iter[1]))); } - ctxt->operationContext->setIntermediateCRS(pivots); + ctx->operationContext->setIntermediateCRS(pivots); } // --------------------------------------------------------------------------- -- cgit v1.2.3 From 28d69400b04eb683bfccb3e7d3ad8a054ad73897 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Thu, 29 Nov 2018 20:47:26 +0100 Subject: C API: rename output parameters to have a out_ prefix --- src/c_api.cpp | 320 ++++++++++++++++++++++++++++++---------------------------- 1 file changed, 164 insertions(+), 156 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index 8d01df95..35409e47 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -1062,30 +1062,30 @@ const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, /** \brief Return the area of use of an object. * * @param obj Object (must not be NULL) - * @param p_west_lon_degree Pointer to a double to receive the west longitude + * @param out_west_lon_degree Pointer to a double to receive the west longitude * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_south_lat_degree Pointer to a double to receive the south latitude + * @param out_south_lat_degree Pointer to a double to receive the south latitude * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_east_lon_degree Pointer to a double to receive the east longitude + * @param out_east_lon_degree Pointer to a double to receive the east longitude * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_north_lat_degree Pointer to a double to receive the north latitude + * @param out_north_lat_degree Pointer to a double to receive the north latitude * (in degrees). Or NULL. If the returned value is -1000, the bounding box is * unknown. - * @param p_area_name Pointer to a string to receive the name of the area of + * @param out_area_name Pointer to a string to receive the name of the area of * use. Or NULL. *p_area_name is valid while obj is valid itself. * @return TRUE in case of success, FALSE in case of error or if the area * of use is unknown. */ -int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *p_west_lon_degree, - double *p_south_lat_degree, - double *p_east_lon_degree, - double *p_north_lat_degree, - const char **p_area_name) { - if (p_area_name) { - *p_area_name = nullptr; +int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *out_west_lon_degree, + double *out_south_lat_degree, + double *out_east_lon_degree, + double *out_north_lat_degree, + const char **out_area_name) { + if (out_area_name) { + *out_area_name = nullptr; } auto objectUsage = dynamic_cast(obj->obj.get()); if (!objectUsage) { @@ -1100,8 +1100,8 @@ int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *p_west_lon_degree, return false; } const auto &desc = extent->description(); - if (desc.has_value() && p_area_name) { - *p_area_name = desc->c_str(); + if (desc.has_value() && out_area_name) { + *out_area_name = desc->c_str(); } const auto &geogElements = extent->geographicElements(); @@ -1109,32 +1109,32 @@ int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *p_west_lon_degree, auto bbox = dynamic_cast(geogElements[0].get()); if (bbox) { - if (p_west_lon_degree) { - *p_west_lon_degree = bbox->westBoundLongitude(); + if (out_west_lon_degree) { + *out_west_lon_degree = bbox->westBoundLongitude(); } - if (p_south_lat_degree) { - *p_south_lat_degree = bbox->southBoundLatitude(); + if (out_south_lat_degree) { + *out_south_lat_degree = bbox->southBoundLatitude(); } - if (p_east_lon_degree) { - *p_east_lon_degree = bbox->eastBoundLongitude(); + if (out_east_lon_degree) { + *out_east_lon_degree = bbox->eastBoundLongitude(); } - if (p_north_lat_degree) { - *p_north_lat_degree = bbox->northBoundLatitude(); + if (out_north_lat_degree) { + *out_north_lat_degree = bbox->northBoundLatitude(); } return true; } } - if (p_west_lon_degree) { - *p_west_lon_degree = -1000; + if (out_west_lon_degree) { + *out_west_lon_degree = -1000; } - if (p_south_lat_degree) { - *p_south_lat_degree = -1000; + if (out_south_lat_degree) { + *out_south_lat_degree = -1000; } - if (p_east_lon_degree) { - *p_east_lon_degree = -1000; + if (out_east_lon_degree) { + *out_east_lon_degree = -1000; } - if (p_north_lat_degree) { - *p_north_lat_degree = -1000; + if (out_north_lat_degree) { + *out_north_lat_degree = -1000; } return true; } @@ -1352,22 +1352,25 @@ PJ_OBJ *proj_obj_crs_get_horizontal_datum(const PJ_OBJ *crs) { /** \brief Return ellipsoid parameters. * * @param ellipsoid Object of type Ellipsoid (must not be NULL) - * @param pSemiMajorMetre Pointer to a value to store the semi-major axis in + * @param out_semi_major_metre Pointer to a value to store the semi-major axis + * in * metre. or NULL - * @param pSemiMinorMetre Pointer to a value to store the semi-minor axis in + * @param out_semi_minor_metre Pointer to a value to store the semi-minor axis + * in * metre. or NULL - * @param pIsSemiMinorComputed Pointer to a boolean value to indicate if the + * @param out_is_semi_minor_computed Pointer to a boolean value to indicate if + * the * semi-minor value was computed. If FALSE, its value comes from the * definition. or NULL - * @param pInverseFlattening Pointer to a value to store the inverse + * @param out_inv_flattening Pointer to a value to store the inverse * flattening. or NULL * @return TRUE in case of success. */ int proj_obj_ellipsoid_get_parameters(const PJ_OBJ *ellipsoid, - double *pSemiMajorMetre, - double *pSemiMinorMetre, - int *pIsSemiMinorComputed, - double *pInverseFlattening) { + double *out_semi_major_metre, + double *out_semi_minor_metre, + int *out_is_semi_minor_computed, + double *out_inv_flattening) { assert(ellipsoid); auto l_ellipsoid = dynamic_cast(ellipsoid->obj.get()); if (!l_ellipsoid) { @@ -1376,17 +1379,19 @@ int proj_obj_ellipsoid_get_parameters(const PJ_OBJ *ellipsoid, return FALSE; } - if (pSemiMajorMetre) { - *pSemiMajorMetre = l_ellipsoid->semiMajorAxis().getSIValue(); + if (out_semi_major_metre) { + *out_semi_major_metre = l_ellipsoid->semiMajorAxis().getSIValue(); } - if (pSemiMinorMetre) { - *pSemiMinorMetre = l_ellipsoid->computeSemiMinorAxis().getSIValue(); + if (out_semi_minor_metre) { + *out_semi_minor_metre = + l_ellipsoid->computeSemiMinorAxis().getSIValue(); } - if (pIsSemiMinorComputed) { - *pIsSemiMinorComputed = !(l_ellipsoid->semiMinorAxis().has_value()); + if (out_is_semi_minor_computed) { + *out_is_semi_minor_computed = + !(l_ellipsoid->semiMinorAxis().has_value()); } - if (pInverseFlattening) { - *pInverseFlattening = l_ellipsoid->computedInverseFlattening(); + if (out_inv_flattening) { + *out_inv_flattening = l_ellipsoid->computedInverseFlattening(); } return TRUE; } @@ -1427,18 +1432,18 @@ PJ_OBJ *proj_obj_get_prime_meridian(const PJ_OBJ *obj) { /** \brief Return prime meridian parameters. * * @param prime_meridian Object of type PrimeMeridian (must not be NULL) - * @param pLongitude Pointer to a value to store the longitude of the prime + * @param out_longitude Pointer to a value to store the longitude of the prime * meridian, in its native unit. or NULL - * @param pLongitudeUnitConvFactor Pointer to a value to store the conversion + * @param out_unit_conv_factor Pointer to a value to store the conversion * factor of the prime meridian longitude unit to radian. or NULL - * @param pLongitudeUnitName Pointer to a string value to store the unit name. + * @param out_unit_name Pointer to a string value to store the unit name. * or NULL * @return TRUE in case of success. */ int proj_obj_prime_meridian_get_parameters(const PJ_OBJ *prime_meridian, - double *pLongitude, - double *pLongitudeUnitConvFactor, - const char **pLongitudeUnitName) { + double *out_longitude, + double *out_unit_conv_factor, + const char **out_unit_name) { assert(prime_meridian); auto l_pm = dynamic_cast(prime_meridian->obj.get()); if (!l_pm) { @@ -1447,15 +1452,15 @@ int proj_obj_prime_meridian_get_parameters(const PJ_OBJ *prime_meridian, return false; } const auto &longitude = l_pm->longitude(); - if (pLongitude) { - *pLongitude = longitude.value(); + if (out_longitude) { + *out_longitude = longitude.value(); } const auto &unit = longitude.unit(); - if (pLongitudeUnitConvFactor) { - *pLongitudeUnitConvFactor = unit.conversionToSI(); + if (out_unit_conv_factor) { + *out_unit_conv_factor = unit.conversionToSI(); } - if (pLongitudeUnitName) { - *pLongitudeUnitName = unit.name().c_str(); + if (out_unit_name) { + *out_unit_name = unit.name().c_str(); } return true; } @@ -1704,19 +1709,19 @@ void proj_free_string_list(PROJ_STRING_LIST list) { * It should be used by at most one thread at a time. * * @param crs Objet of type DerivedCRS or BoundCRSs (must not be NULL) - * @param pMethodName Pointer to a string value to store the method + * @param out_method_name Pointer to a string value to store the method * (projection) name. or NULL - * @param pMethodAuthorityName Pointer to a string value to store the method + * @param out_method_auth_name Pointer to a string value to store the method * authority name. or NULL - * @param pMethodCode Pointer to a string value to store the method + * @param out_method_code Pointer to a string value to store the method * code. or NULL * @return Object of type SingleOperation that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, - const char **pMethodName, - const char **pMethodAuthorityName, - const char **pMethodCode) { + const char **out_method_name, + const char **out_method_auth_name, + const char **out_method_code) { assert(crs); SingleOperationPtr co; @@ -1736,21 +1741,21 @@ PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, const auto &method = co->method(); const auto &method_ids = method->identifiers(); - if (pMethodName) { - *pMethodName = method->name()->description()->c_str(); + if (out_method_name) { + *out_method_name = method->name()->description()->c_str(); } - if (pMethodAuthorityName) { + if (out_method_auth_name) { if (!method_ids.empty()) { - *pMethodAuthorityName = method_ids[0]->codeSpace()->c_str(); + *out_method_auth_name = method_ids[0]->codeSpace()->c_str(); } else { - *pMethodAuthorityName = nullptr; + *out_method_auth_name = nullptr; } } - if (pMethodCode) { + if (out_method_code) { if (!method_ids.empty()) { - *pMethodCode = method_ids[0]->code().c_str(); + *out_method_code = method_ids[0]->code().c_str(); } else { - *pMethodCode = nullptr; + *out_method_code = nullptr; } } return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(co)); @@ -4691,29 +4696,30 @@ int proj_coordoperation_get_param_index(const PJ_OBJ *coordoperation, * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) * @param index Parameter index. - * @param pName Pointer to a string value to store the parameter name. or NULL - * @param pNameAuthorityName Pointer to a string value to store the parameter + * @param out_name Pointer to a string value to store the parameter name. or + * NULL + * @param out_auth_name Pointer to a string value to store the parameter * authority name. or NULL - * @param pNameCode Pointer to a string value to store the parameter + * @param out_code Pointer to a string value to store the parameter * code. or NULL - * @param pValue Pointer to a double value to store the parameter + * @param out_value Pointer to a double value to store the parameter * value (if numeric). or NULL - * @param pValueString Pointer to a string value to store the parameter + * @param out_value_string Pointer to a string value to store the parameter * value (if of type string). or NULL - * @param pValueUnitConvFactor Pointer to a double value to store the parameter + * @param out_unit_conv_factor Pointer to a double value to store the parameter * unit conversion factor. or NULL - * @param pValueUnitName Pointer to a string value to store the parameter + * @param out_unit_name Pointer to a string value to store the parameter * unit name. or NULL * @return TRUE in case of success. */ int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, - const char **pName, - const char **pNameAuthorityName, - const char **pNameCode, double *pValue, - const char **pValueString, - double *pValueUnitConvFactor, - const char **pValueUnitName) { + const char **out_name, + const char **out_auth_name, + const char **out_code, double *out_value, + const char **out_value_string, + double *out_unit_conv_factor, + const char **out_unit_name) { assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { @@ -4731,21 +4737,21 @@ int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, const auto ¶m = parameters[index]; const auto ¶m_ids = param->identifiers(); - if (pName) { - *pName = param->name()->description()->c_str(); + if (out_name) { + *out_name = param->name()->description()->c_str(); } - if (pNameAuthorityName) { + if (out_auth_name) { if (!param_ids.empty()) { - *pNameAuthorityName = param_ids[0]->codeSpace()->c_str(); + *out_auth_name = param_ids[0]->codeSpace()->c_str(); } else { - *pNameAuthorityName = nullptr; + *out_auth_name = nullptr; } } - if (pNameCode) { + if (out_code) { if (!param_ids.empty()) { - *pNameCode = param_ids[0]->code().c_str(); + *out_code = param_ids[0]->code().c_str(); } else { - *pNameCode = nullptr; + *out_code = nullptr; } } @@ -4756,38 +4762,38 @@ int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, if (opParamValue) { paramValue = opParamValue->parameterValue().as_nullable(); } - if (pValue) { - *pValue = 0; + if (out_value) { + *out_value = 0; if (paramValue) { if (paramValue->type() == ParameterValue::Type::MEASURE) { - *pValue = paramValue->value().value(); + *out_value = paramValue->value().value(); } } } - if (pValueString) { - *pValueString = nullptr; + if (out_value_string) { + *out_value_string = nullptr; if (paramValue) { if (paramValue->type() == ParameterValue::Type::FILENAME) { - *pValueString = paramValue->valueFile().c_str(); + *out_value_string = paramValue->valueFile().c_str(); } else if (paramValue->type() == ParameterValue::Type::STRING) { - *pValueString = paramValue->stringValue().c_str(); + *out_value_string = paramValue->stringValue().c_str(); } } } - if (pValueUnitConvFactor) { - *pValueUnitConvFactor = 0; + if (out_unit_conv_factor) { + *out_unit_conv_factor = 0; if (paramValue) { if (paramValue->type() == ParameterValue::Type::MEASURE) { - *pValueUnitConvFactor = + *out_unit_conv_factor = paramValue->value().unit().conversionToSI(); } } } - if (pValueUnitName) { - *pValueUnitName = nullptr; + if (out_unit_name) { + *out_unit_name = nullptr; if (paramValue) { if (paramValue->type() == ParameterValue::Type::MEASURE) { - *pValueUnitName = paramValue->value().unit().name().c_str(); + *out_unit_name = paramValue->value().unit().name().c_str(); } } } @@ -4835,29 +4841,29 @@ int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) * @param index Parameter index. - * @param pShortName Pointer to a string value to store the grid short name. or - * NULL - * @param pFullName Pointer to a string value to store the grid full filename. + * @param out_short_name Pointer to a string value to store the grid short name. * or NULL - * @param pPackageName Pointer to a string value to store the package name where + * @param out_full_name Pointer to a string value to store the grid full + * filename. or NULL + * @param out_package_name Pointer to a string value to store the package name + * where * the grid might be found. or NULL - * @param pURL Pointer to a string value to store the grid URL or the + * @param out_url Pointer to a string value to store the grid URL or the * package URL where the grid might be found. or NULL - * @param pDirectDownload Pointer to a int (boolean) value to store whether - * *pURL can be downloaded directly. or NULL - * @param pOpenLicense Pointer to a int (boolean) value to store whether + * @param out_direct_download Pointer to a int (boolean) value to store whether + * *out_url can be downloaded directly. or NULL + * @param out_open_license Pointer to a int (boolean) value to store whether * the grid is released with an open license. or NULL - * @param pAvailable Pointer to a int (boolean) value to store whether the grid - * is available at runtime. or NULL + * @param out_available Pointer to a int (boolean) value to store whether the + * grid is available at runtime. or NULL * @return TRUE in case of success. */ -int proj_coordoperation_get_grid_used(const PJ_OBJ *coordoperation, int index, - const char **pShortName, - const char **pFullName, - const char **pPackageName, - const char **pURL, int *pDirectDownload, - int *pOpenLicense, int *pAvailable) { +int proj_coordoperation_get_grid_used( + const PJ_OBJ *coordoperation, int index, const char **out_short_name, + const char **out_full_name, const char **out_package_name, + const char **out_url, int *out_direct_download, int *out_open_license, + int *out_available) { const int count = proj_coordoperation_get_grid_used_count(coordoperation); if (index < 0 || index >= count) { proj_log_error(coordoperation->ctx, __FUNCTION__, "Invalid index"); @@ -4865,32 +4871,32 @@ int proj_coordoperation_get_grid_used(const PJ_OBJ *coordoperation, int index, } const auto &gridDesc = coordoperation->gridsNeeded[index]; - if (pShortName) { - *pShortName = gridDesc.shortName.c_str(); + if (out_short_name) { + *out_short_name = gridDesc.shortName.c_str(); } - if (pFullName) { - *pFullName = gridDesc.fullName.c_str(); + if (out_full_name) { + *out_full_name = gridDesc.fullName.c_str(); } - if (pPackageName) { - *pPackageName = gridDesc.packageName.c_str(); + if (out_package_name) { + *out_package_name = gridDesc.packageName.c_str(); } - if (pURL) { - *pURL = gridDesc.url.c_str(); + if (out_url) { + *out_url = gridDesc.url.c_str(); } - if (pDirectDownload) { - *pDirectDownload = gridDesc.directDownload; + if (out_direct_download) { + *out_direct_download = gridDesc.directDownload; } - if (pOpenLicense) { - *pOpenLicense = gridDesc.openLicense; + if (out_open_license) { + *out_open_license = gridDesc.openLicense; } - if (pAvailable) { - *pAvailable = gridDesc.available; + if (out_available) { + *out_available = gridDesc.available; } return true; @@ -5408,20 +5414,22 @@ int proj_obj_cs_get_axis_count(const PJ_OBJ *cs) { * @param cs Objet of type CoordinateSystem (must not be NULL) * @param index Index of the coordinate system (between 0 and * proj_obj_cs_get_axis_count() - 1) - * @param pName Pointer to a string value to store the axis name. or NULL - * @param pAbbrev Pointer to a string value to store the axis abbreviation. or - * NULL - * @param pDirection Pointer to a string value to store the axis direction. or - * NULL - * @param pUnitConvFactor Pointer to a double value to store the axis + * @param out_name Pointer to a string value to store the axis name. or NULL + * @param out_abbrev Pointer to a string value to store the axis abbreviation. + * or NULL + * @param out_direction Pointer to a string value to store the axis direction. + * or NULL + * @param out_unit_conv_factor Pointer to a double value to store the axis * unit conversion factor. or NULL - * @param pUnitName Pointer to a string value to store the axis + * @param out_unit_name Pointer to a string value to store the axis * unit name. or NULL * @return TRUE in case of success */ -int proj_obj_cs_get_axis_info(const PJ_OBJ *cs, int index, const char **pName, - const char **pAbbrev, const char **pDirection, - double *pUnitConvFactor, const char **pUnitName) { +int proj_obj_cs_get_axis_info(const PJ_OBJ *cs, int index, + const char **out_name, const char **out_abbrev, + const char **out_direction, + double *out_unit_conv_factor, + const char **out_unit_name) { assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { @@ -5435,20 +5443,20 @@ int proj_obj_cs_get_axis_info(const PJ_OBJ *cs, int index, const char **pName, return false; } const auto &axis = axisList[index]; - if (pName) { - *pName = axis->nameStr().c_str(); + if (out_name) { + *out_name = axis->nameStr().c_str(); } - if (pAbbrev) { - *pAbbrev = axis->abbreviation().c_str(); + if (out_abbrev) { + *out_abbrev = axis->abbreviation().c_str(); } - if (pDirection) { - *pDirection = axis->direction().toString().c_str(); + if (out_direction) { + *out_direction = axis->direction().toString().c_str(); } - if (pUnitConvFactor) { - *pUnitConvFactor = axis->unit().conversionToSI(); + if (out_unit_conv_factor) { + *out_unit_conv_factor = axis->unit().conversionToSI(); } - if (pUnitName) { - *pUnitName = axis->unit().name().c_str(); + if (out_unit_name) { + *out_unit_name = axis->unit().name().c_str(); } return true; } -- cgit v1.2.3 From 664bd689bf8dd3ca38a5071459902b89114e88eb Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Fri, 30 Nov 2018 02:36:00 +0100 Subject: C API: do not 'cache' PROJ context in PJ_OBJ objects We store the PJ_CONTEXT* in the PJ_OBJ objects, but this might cause issues in multi-threaded uses. For example, before this change, let's imagie: - a PJ_OBJ is created in thread A with a PJ_CONTEXT that is specific to this thread A - PJ_OBJ is transfered to another thread that operates on it. It might thus use the PJ_CONTEXT that was TLS(A) - in the meantime thread A does completely different things, but still operate on its PJ_CONTEXT. We might get a concurrent use of the PJ_CONTEXT despite working on different PJ_OBJ Another situation is when using constructor functions that take two PJ_OBJ. Up to now, we arbitrarily selected the context of one of the arguments to attach it to the new object. So better be explicit on which context is used. For reference, in those wrappers of the C++ API, the context is mostly used for two things: - reporting C++ exceptions as PROJ errors with the error handler attached to the PJ_CONTEXT - using the database handle that is associated with the PJ_CONTEXT. --- src/c_api.cpp | 952 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 564 insertions(+), 388 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index 35409e47..5f9ed5c2 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -92,7 +92,6 @@ static void PROJ_NO_INLINE proj_log_debug(PJ_CONTEXT *ctx, const char *function, * Operation. Should be used by at most one thread at a time. */ struct PJ_OBJ { //! @cond Doxygen_Suppress - PJ_CONTEXT *ctx; IdentifiedObjectNNPtr obj; // cached results @@ -101,10 +100,8 @@ struct PJ_OBJ { mutable bool gridsNeededAsked = false; mutable std::vector gridsNeeded{}; - explicit PJ_OBJ(PJ_CONTEXT *ctxIn, const IdentifiedObjectNNPtr &objIn) - : ctx(ctxIn), obj(objIn) {} - static PJ_OBJ *create(PJ_CONTEXT *ctxIn, - const IdentifiedObjectNNPtr &objIn); + explicit PJ_OBJ(const IdentifiedObjectNNPtr &objIn) : obj(objIn) {} + static PJ_OBJ *create(const IdentifiedObjectNNPtr &objIn); PJ_OBJ(const PJ_OBJ &) = delete; PJ_OBJ &operator=(const PJ_OBJ &) = delete; @@ -112,8 +109,8 @@ struct PJ_OBJ { }; //! @cond Doxygen_Suppress -PJ_OBJ *PJ_OBJ::create(PJ_CONTEXT *ctxIn, const IdentifiedObjectNNPtr &objIn) { - return new PJ_OBJ(ctxIn, objIn); +PJ_OBJ *PJ_OBJ::create(const IdentifiedObjectNNPtr &objIn) { + return new PJ_OBJ(objIn); } //! @endcond @@ -122,12 +119,10 @@ PJ_OBJ *PJ_OBJ::create(PJ_CONTEXT *ctxIn, const IdentifiedObjectNNPtr &objIn) { /** \brief Opaque object representing a set of operation results. */ struct PJ_OBJ_LIST { //! @cond Doxygen_Suppress - PJ_CONTEXT *ctx; std::vector objects; - explicit PJ_OBJ_LIST(PJ_CONTEXT *ctxIn, - std::vector &&objectsIn) - : ctx(ctxIn), objects(std::move(objectsIn)) {} + explicit PJ_OBJ_LIST(std::vector &&objectsIn) + : objects(std::move(objectsIn)) {} PJ_OBJ_LIST(const PJ_OBJ_LIST &) = delete; PJ_OBJ_LIST &operator=(const PJ_OBJ_LIST &) = delete; @@ -320,15 +315,17 @@ static const char *getOptionValue(const char *option, * The returned object must be unreferenced with proj_obj_unref() after use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object to clone. Must not be NULL. * @return Object that must be unreferenced with proj_obj_unref(), or NULL in * case of error. */ -PJ_OBJ *proj_obj_clone(const PJ_OBJ *obj) { +PJ_OBJ *proj_obj_clone(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { + SANITIZE_CTX(ctx); try { - return PJ_OBJ::create(obj->ctx, obj->obj); + return PJ_OBJ::create(obj->obj); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } return nullptr; } @@ -382,7 +379,7 @@ PJ_OBJ *proj_obj_create_from_user_input(PJ_CONTEXT *ctx, const char *text, auto identifiedObject = nn_dynamic_pointer_cast( createFromUserInput(text, dbContext, usePROJ4InitRules)); if (identifiedObject) { - return PJ_OBJ::create(ctx, NN_NO_CHECK(identifiedObject)); + return PJ_OBJ::create(NN_NO_CHECK(identifiedObject)); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -414,7 +411,7 @@ PJ_OBJ *proj_obj_create_from_wkt(PJ_CONTEXT *ctx, const char *wkt, auto identifiedObject = nn_dynamic_pointer_cast( WKTParser().createFromWKT(wkt)); if (identifiedObject) { - return PJ_OBJ::create(ctx, NN_NO_CHECK(identifiedObject)); + return PJ_OBJ::create(NN_NO_CHECK(identifiedObject)); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -447,7 +444,7 @@ PJ_OBJ *proj_obj_create_from_proj_string(PJ_CONTEXT *ctx, auto identifiedObject = nn_dynamic_pointer_cast( PROJStringParser().createFromPROJString(proj_string)); if (identifiedObject) { - return PJ_OBJ::create(ctx, NN_NO_CHECK(identifiedObject)); + return PJ_OBJ::create(NN_NO_CHECK(identifiedObject)); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -504,7 +501,7 @@ PJ_OBJ *proj_obj_create_from_database(PJ_CONTEXT *ctx, const char *auth_name, .as_nullable(); break; } - return PJ_OBJ::create(ctx, NN_NO_CHECK(obj)); + return PJ_OBJ::create(NN_NO_CHECK(obj)); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -671,7 +668,7 @@ PJ_OBJ_LIST *proj_obj_create_from_name(PJ_CONTEXT *ctx, const char *auth_name, for (const auto &obj : res) { objects.push_back(obj); } - return new PJ_OBJ_LIST(ctx, std::move(objects)); + return new PJ_OBJ_LIST(std::move(objects)); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -907,6 +904,7 @@ const char *proj_obj_get_id_code(const PJ_OBJ *obj, int index) { * This function may return NULL if the object is not compatible with an * export to the requested type. * + * @param ctx PROJ context, or NULL for default context * @param obj Object (must not be NULL) * @param type WKT version. * @param options null-terminated list of options, or NULL. Currently @@ -922,8 +920,9 @@ const char *proj_obj_get_id_code(const PJ_OBJ *obj, int index) { * * @return a string, or NULL in case of error. */ -const char *proj_obj_as_wkt(const PJ_OBJ *obj, PJ_WKT_TYPE type, - const char *const *options) { +const char *proj_obj_as_wkt(PJ_CONTEXT *ctx, const PJ_OBJ *obj, + PJ_WKT_TYPE type, const char *const *options) { + SANITIZE_CTX(ctx); assert(obj); // Make sure that the C and C++ enumerations match @@ -978,14 +977,14 @@ const char *proj_obj_as_wkt(const PJ_OBJ *obj, PJ_WKT_TYPE type, } else { std::string msg("Unknown option :"); msg += *iter; - proj_log_error(obj->ctx, __FUNCTION__, msg.c_str()); + proj_log_error(ctx, __FUNCTION__, msg.c_str()); return nullptr; } } obj->lastWKT = obj->obj->exportToWKT(formatter.get()); return obj->lastWKT.c_str(); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -1004,6 +1003,7 @@ const char *proj_obj_as_wkt(const PJ_OBJ *obj, PJ_WKT_TYPE type, * This function may return NULL if the object is not compatible with an * export to the requested type. * + * @param ctx PROJ context, or NULL for default context * @param obj Object (must not be NULL) * @param type PROJ String version. * @param options NULL-terminated list of strings with "KEY=VALUE" format. or @@ -1013,14 +1013,15 @@ const char *proj_obj_as_wkt(const PJ_OBJ *obj, PJ_WKT_TYPE type, * use of etmerc by utm conversions) * @return a string, or NULL in case of error. */ -const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, +const char *proj_obj_as_proj_string(PJ_CONTEXT *ctx, const PJ_OBJ *obj, + PJ_PROJ_STRING_TYPE type, const char *const *options) { + SANITIZE_CTX(ctx); assert(obj); auto exportable = dynamic_cast(obj->obj.get()); if (!exportable) { - proj_log_error(obj->ctx, __FUNCTION__, - "Object type not exportable to PROJ"); + proj_log_error(ctx, __FUNCTION__, "Object type not exportable to PROJ"); return nullptr; } // Make sure that the C and C++ enumeration match @@ -1039,7 +1040,7 @@ const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, } const PROJStringFormatter::Convention convention = static_cast(type); - auto dbContext = getDBcontextNoException(obj->ctx, __FUNCTION__); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); try { auto formatter = PROJStringFormatter::create(convention, dbContext); if (options != nullptr && options[0] != nullptr) { @@ -1052,7 +1053,7 @@ const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, obj->lastPROJString = exportable->exportToPROJString(formatter.get()); return obj->lastPROJString.c_str(); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -1061,6 +1062,7 @@ const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, /** \brief Return the area of use of an object. * + * @param ctx PROJ context, or NULL for default context * @param obj Object (must not be NULL) * @param out_west_lon_degree Pointer to a double to receive the west longitude * (in degrees). Or NULL. If the returned value is -1000, the bounding box is @@ -1079,11 +1081,13 @@ const char *proj_obj_as_proj_string(const PJ_OBJ *obj, PJ_PROJ_STRING_TYPE type, * @return TRUE in case of success, FALSE in case of error or if the area * of use is unknown. */ -int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *out_west_lon_degree, +int proj_obj_get_area_of_use(PJ_CONTEXT *ctx, const PJ_OBJ *obj, + double *out_west_lon_degree, double *out_south_lat_degree, double *out_east_lon_degree, double *out_north_lat_degree, const char **out_area_name) { + (void)ctx; if (out_area_name) { *out_area_name = nullptr; } @@ -1141,17 +1145,17 @@ int proj_obj_get_area_of_use(const PJ_OBJ *obj, double *out_west_lon_degree, // --------------------------------------------------------------------------- -static const GeodeticCRS *extractGeodeticCRS(const PJ_OBJ *crs, +static const GeodeticCRS *extractGeodeticCRS(PJ_CONTEXT *ctx, const PJ_OBJ *crs, const char *fname) { assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { - proj_log_error(crs->ctx, fname, "Object is not a CRS"); + proj_log_error(ctx, fname, "Object is not a CRS"); return nullptr; } auto geodCRS = l_crs->extractGeodeticCRSRaw(); if (!geodCRS) { - proj_log_error(crs->ctx, fname, "CRS has no geodetic CRS"); + proj_log_error(ctx, fname, "CRS has no geodetic CRS"); } return geodCRS; } @@ -1164,18 +1168,19 @@ static const GeodeticCRS *extractGeodeticCRS(const PJ_OBJ *crs, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type CRS (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_geodetic_crs(const PJ_OBJ *crs) { - auto geodCRS = extractGeodeticCRS(crs, __FUNCTION__); +PJ_OBJ *proj_obj_crs_get_geodetic_crs(PJ_CONTEXT *ctx, const PJ_OBJ *crs) { + SANITIZE_CTX(ctx); + auto geodCRS = extractGeodeticCRS(ctx, crs, __FUNCTION__); if (!geodCRS) { return nullptr; } - return PJ_OBJ::create(crs->ctx, - NN_NO_CHECK(nn_dynamic_pointer_cast( - geodCRS->shared_from_this()))); + return PJ_OBJ::create(NN_NO_CHECK(nn_dynamic_pointer_cast( + geodCRS->shared_from_this()))); } // --------------------------------------------------------------------------- @@ -1186,24 +1191,27 @@ PJ_OBJ *proj_obj_crs_get_geodetic_crs(const PJ_OBJ *crs) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type CRS (must not be NULL) * @param index Index of the CRS component (typically 0 = horizontal, 1 = * vertical) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_sub_crs(const PJ_OBJ *crs, int index) { +PJ_OBJ *proj_obj_crs_get_sub_crs(PJ_CONTEXT *ctx, const PJ_OBJ *crs, + int index) { + SANITIZE_CTX(ctx); assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { - proj_log_error(crs->ctx, __FUNCTION__, "Object is not a CompoundCRS"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CompoundCRS"); return nullptr; } const auto &components = l_crs->componentReferenceSystems(); if (static_cast(index) >= components.size()) { return nullptr; } - return PJ_OBJ::create(crs->ctx, components[index]); + return PJ_OBJ::create(components[index]); } // --------------------------------------------------------------------------- @@ -1214,42 +1222,42 @@ PJ_OBJ *proj_obj_crs_get_sub_crs(const PJ_OBJ *crs, int index) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param base_crs Base CRS (must not be NULL) * @param hub_crs Hub CRS (must not be NULL) * @param transformation Transformation (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_create_bound_crs(const PJ_OBJ *base_crs, +PJ_OBJ *proj_obj_crs_create_bound_crs(PJ_CONTEXT *ctx, const PJ_OBJ *base_crs, const PJ_OBJ *hub_crs, const PJ_OBJ *transformation) { + SANITIZE_CTX(ctx); assert(base_crs); assert(hub_crs); assert(transformation); auto l_base_crs = util::nn_dynamic_pointer_cast(base_crs->obj); if (!l_base_crs) { - proj_log_error(base_crs->ctx, __FUNCTION__, "base_crs is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "base_crs is not a CRS"); return nullptr; } auto l_hub_crs = util::nn_dynamic_pointer_cast(hub_crs->obj); if (!l_hub_crs) { - proj_log_error(base_crs->ctx, __FUNCTION__, "hub_crs is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "hub_crs is not a CRS"); return nullptr; } auto l_transformation = util::nn_dynamic_pointer_cast(transformation->obj); if (!l_transformation) { - proj_log_error(base_crs->ctx, __FUNCTION__, - "transformation is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "transformation is not a CRS"); return nullptr; } try { - return PJ_OBJ::create(base_crs->ctx, - BoundCRS::create(NN_NO_CHECK(l_base_crs), + return PJ_OBJ::create(BoundCRS::create(NN_NO_CHECK(l_base_crs), NN_NO_CHECK(l_hub_crs), NN_NO_CHECK(l_transformation))); } catch (const std::exception &e) { - proj_log_error(base_crs->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -1266,23 +1274,26 @@ PJ_OBJ *proj_obj_crs_create_bound_crs(const PJ_OBJ *base_crs, * This is the same as method * osgeo::proj::crs::CRS::createBoundCRSToWGS84IfPossible() * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type CRS (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(const PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(PJ_CONTEXT *ctx, + const PJ_OBJ *crs) { + SANITIZE_CTX(ctx); assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { - proj_log_error(crs->ctx, __FUNCTION__, "Object is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CRS"); return nullptr; } - auto dbContext = getDBcontextNoException(crs->ctx, __FUNCTION__); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); try { return PJ_OBJ::create( - crs->ctx, l_crs->createBoundCRSToWGS84IfPossible(dbContext)); + l_crs->createBoundCRSToWGS84IfPossible(dbContext)); } catch (const std::exception &e) { - proj_log_error(crs->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -1295,24 +1306,26 @@ PJ_OBJ *proj_obj_crs_create_bound_crs_to_WGS84(const PJ_OBJ *crs) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Objet of type CRS or GeodeticReferenceFrame (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_get_ellipsoid(const PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_ellipsoid(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { + SANITIZE_CTX(ctx); auto ptr = obj->obj.get(); if (dynamic_cast(ptr)) { - auto geodCRS = extractGeodeticCRS(obj, __FUNCTION__); + auto geodCRS = extractGeodeticCRS(ctx, obj, __FUNCTION__); if (geodCRS) { - return PJ_OBJ::create(obj->ctx, geodCRS->ellipsoid()); + return PJ_OBJ::create(geodCRS->ellipsoid()); } } else { auto datum = dynamic_cast(ptr); if (datum) { - return PJ_OBJ::create(obj->ctx, datum->ellipsoid()); + return PJ_OBJ::create(datum->ellipsoid()); } } - proj_log_error(obj->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a CRS or GeodeticReferenceFrame"); return nullptr; } @@ -1325,25 +1338,27 @@ PJ_OBJ *proj_obj_get_ellipsoid(const PJ_OBJ *obj) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type CRS (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_horizontal_datum(const PJ_OBJ *crs) { - auto geodCRS = extractGeodeticCRS(crs, __FUNCTION__); +PJ_OBJ *proj_obj_crs_get_horizontal_datum(PJ_CONTEXT *ctx, const PJ_OBJ *crs) { + SANITIZE_CTX(ctx); + auto geodCRS = extractGeodeticCRS(ctx, crs, __FUNCTION__); if (!geodCRS) { return nullptr; } const auto &datum = geodCRS->datum(); if (datum) { - return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(datum)); + return PJ_OBJ::create(NN_NO_CHECK(datum)); } const auto &datumEnsemble = geodCRS->datumEnsemble(); if (datumEnsemble) { - return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(datumEnsemble)); + return PJ_OBJ::create(NN_NO_CHECK(datumEnsemble)); } - proj_log_error(crs->ctx, __FUNCTION__, "CRS has no datum"); + proj_log_error(ctx, __FUNCTION__, "CRS has no datum"); return nullptr; } @@ -1351,6 +1366,7 @@ PJ_OBJ *proj_obj_crs_get_horizontal_datum(const PJ_OBJ *crs) { /** \brief Return ellipsoid parameters. * + * @param ctx PROJ context, or NULL for default context * @param ellipsoid Object of type Ellipsoid (must not be NULL) * @param out_semi_major_metre Pointer to a value to store the semi-major axis * in @@ -1366,16 +1382,16 @@ PJ_OBJ *proj_obj_crs_get_horizontal_datum(const PJ_OBJ *crs) { * flattening. or NULL * @return TRUE in case of success. */ -int proj_obj_ellipsoid_get_parameters(const PJ_OBJ *ellipsoid, +int proj_obj_ellipsoid_get_parameters(PJ_CONTEXT *ctx, const PJ_OBJ *ellipsoid, double *out_semi_major_metre, double *out_semi_minor_metre, int *out_is_semi_minor_computed, double *out_inv_flattening) { + SANITIZE_CTX(ctx); assert(ellipsoid); auto l_ellipsoid = dynamic_cast(ellipsoid->obj.get()); if (!l_ellipsoid) { - proj_log_error(ellipsoid->ctx, __FUNCTION__, - "Object is not a Ellipsoid"); + proj_log_error(ctx, __FUNCTION__, "Object is not a Ellipsoid"); return FALSE; } @@ -1404,25 +1420,27 @@ int proj_obj_ellipsoid_get_parameters(const PJ_OBJ *ellipsoid, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Objet of type CRS or GeodeticReferenceFrame (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_get_prime_meridian(const PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_prime_meridian(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { + SANITIZE_CTX(ctx); auto ptr = obj->obj.get(); if (dynamic_cast(ptr)) { - auto geodCRS = extractGeodeticCRS(obj, __FUNCTION__); + auto geodCRS = extractGeodeticCRS(ctx, obj, __FUNCTION__); if (geodCRS) { - return PJ_OBJ::create(obj->ctx, geodCRS->primeMeridian()); + return PJ_OBJ::create(geodCRS->primeMeridian()); } } else { auto datum = dynamic_cast(ptr); if (datum) { - return PJ_OBJ::create(obj->ctx, datum->primeMeridian()); + return PJ_OBJ::create(datum->primeMeridian()); } } - proj_log_error(obj->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a CRS or GeodeticReferenceFrame"); return nullptr; } @@ -1431,6 +1449,7 @@ PJ_OBJ *proj_obj_get_prime_meridian(const PJ_OBJ *obj) { /** \brief Return prime meridian parameters. * + * @param ctx PROJ context, or NULL for default context * @param prime_meridian Object of type PrimeMeridian (must not be NULL) * @param out_longitude Pointer to a value to store the longitude of the prime * meridian, in its native unit. or NULL @@ -1440,15 +1459,16 @@ PJ_OBJ *proj_obj_get_prime_meridian(const PJ_OBJ *obj) { * or NULL * @return TRUE in case of success. */ -int proj_obj_prime_meridian_get_parameters(const PJ_OBJ *prime_meridian, +int proj_obj_prime_meridian_get_parameters(PJ_CONTEXT *ctx, + const PJ_OBJ *prime_meridian, double *out_longitude, double *out_unit_conv_factor, const char **out_unit_name) { + SANITIZE_CTX(ctx); assert(prime_meridian); auto l_pm = dynamic_cast(prime_meridian->obj.get()); if (!l_pm) { - proj_log_error(prime_meridian->ctx, __FUNCTION__, - "Object is not a PrimeMeridian"); + proj_log_error(ctx, __FUNCTION__, "Object is not a PrimeMeridian"); return false; } const auto &longitude = l_pm->longitude(); @@ -1474,30 +1494,32 @@ int proj_obj_prime_meridian_get_parameters(const PJ_OBJ *prime_meridian, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Objet of type BoundCRS or CoordinateOperation (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error, or missing source CRS. */ -PJ_OBJ *proj_obj_get_source_crs(const PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_source_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { + SANITIZE_CTX(ctx); assert(obj); auto ptr = obj->obj.get(); auto boundCRS = dynamic_cast(ptr); if (boundCRS) { - return PJ_OBJ::create(obj->ctx, boundCRS->baseCRS()); + return PJ_OBJ::create(boundCRS->baseCRS()); } auto derivedCRS = dynamic_cast(ptr); if (derivedCRS) { - return PJ_OBJ::create(obj->ctx, derivedCRS->baseCRS()); + return PJ_OBJ::create(derivedCRS->baseCRS()); } auto co = dynamic_cast(ptr); if (co) { auto sourceCRS = co->sourceCRS(); if (sourceCRS) { - return PJ_OBJ::create(obj->ctx, NN_NO_CHECK(sourceCRS)); + return PJ_OBJ::create(NN_NO_CHECK(sourceCRS)); } return nullptr; } - proj_log_error(obj->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a BoundCRS or a CoordinateOperation"); return nullptr; } @@ -1511,26 +1533,28 @@ PJ_OBJ *proj_obj_get_source_crs(const PJ_OBJ *obj) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Objet of type BoundCRS or CoordinateOperation (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error, or missing target CRS. */ -PJ_OBJ *proj_obj_get_target_crs(const PJ_OBJ *obj) { +PJ_OBJ *proj_obj_get_target_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { + SANITIZE_CTX(ctx); assert(obj); auto ptr = obj->obj.get(); auto boundCRS = dynamic_cast(ptr); if (boundCRS) { - return PJ_OBJ::create(obj->ctx, boundCRS->hubCRS()); + return PJ_OBJ::create(boundCRS->hubCRS()); } auto co = dynamic_cast(ptr); if (co) { auto targetCRS = co->targetCRS(); if (targetCRS) { - return PJ_OBJ::create(obj->ctx, NN_NO_CHECK(targetCRS)); + return PJ_OBJ::create(NN_NO_CHECK(targetCRS)); } return nullptr; } - proj_log_error(obj->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a BoundCRS or a CoordinateOperation"); return nullptr; } @@ -1556,6 +1580,7 @@ PJ_OBJ *proj_obj_get_target_crs(const PJ_OBJ *obj) { * This is implemented for GeodeticCRS, ProjectedCRS, VerticalCRS and * CompoundCRS. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL * @param auth_name Authority name, or NULL for all authorities * @param options Placeholder for future options. Should be set to NULL. @@ -1567,8 +1592,10 @@ PJ_OBJ *proj_obj_get_target_crs(const PJ_OBJ *obj) { * released with proj_free_int_list(). * @return a list of matching reference CRS, or nullptr in case of error. */ -PJ_OBJ_LIST *proj_obj_identify(const PJ_OBJ *obj, const char *auth_name, +PJ_OBJ_LIST *proj_obj_identify(PJ_CONTEXT *ctx, const PJ_OBJ *obj, + const char *auth_name, const char *const *options, int **confidence) { + SANITIZE_CTX(ctx); assert(obj); (void)options; if (confidence) { @@ -1577,11 +1604,11 @@ PJ_OBJ_LIST *proj_obj_identify(const PJ_OBJ *obj, const char *auth_name, auto ptr = obj->obj.get(); auto crs = dynamic_cast(ptr); if (!crs) { - proj_log_error(obj->ctx, __FUNCTION__, "Object is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CRS"); } else { int *confidenceTemp = nullptr; try { - auto factory = AuthorityFactory::create(getDBcontext(obj->ctx), + auto factory = AuthorityFactory::create(getDBcontext(ctx), auth_name ? auth_name : ""); auto res = crs->identify(factory); std::vector objects; @@ -1594,8 +1621,7 @@ PJ_OBJ_LIST *proj_obj_identify(const PJ_OBJ *obj, const char *auth_name, ++i; } } - auto ret = internal::make_unique(obj->ctx, - std::move(objects)); + auto ret = internal::make_unique(std::move(objects)); if (confidence) { *confidence = confidenceTemp; confidenceTemp = nullptr; @@ -1603,7 +1629,7 @@ PJ_OBJ_LIST *proj_obj_identify(const PJ_OBJ *obj, const char *auth_name, return ret.release(); } catch (const std::exception &e) { delete[] confidenceTemp; - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } } return nullptr; @@ -1708,6 +1734,7 @@ void proj_free_string_list(PROJ_STRING_LIST list) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type DerivedCRS or BoundCRSs (must not be NULL) * @param out_method_name Pointer to a string value to store the method * (projection) name. or NULL @@ -1718,10 +1745,11 @@ void proj_free_string_list(PROJ_STRING_LIST list) { * @return Object of type SingleOperation that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, +PJ_OBJ *proj_obj_crs_get_coordoperation(PJ_CONTEXT *ctx, const PJ_OBJ *crs, const char **out_method_name, const char **out_method_auth_name, const char **out_method_code) { + SANITIZE_CTX(ctx); assert(crs); SingleOperationPtr co; @@ -1733,7 +1761,7 @@ PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, if (boundCRS) { co = boundCRS->transformation().as_nullable(); } else { - proj_log_error(crs->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a DerivedCRS or BoundCRS"); return nullptr; } @@ -1758,7 +1786,7 @@ PJ_OBJ *proj_obj_crs_get_coordoperation(const PJ_OBJ *crs, *out_method_code = nullptr; } } - return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(co)); + return PJ_OBJ::create(NN_NO_CHECK(co)); } // --------------------------------------------------------------------------- @@ -1868,7 +1896,7 @@ PJ_OBJ *proj_obj_create_geographic_crs( pmAngularUnitsConv); auto geogCRS = GeographicCRS::create(createPropertyMapName(crsName), datum, NN_NO_CHECK(cs)); - return PJ_OBJ::create(ctx, geogCRS); + return PJ_OBJ::create(geogCRS); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -1883,6 +1911,7 @@ PJ_OBJ *proj_obj_create_geographic_crs( * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crsName Name of the GeographicCRS. Or NULL * @param datum Datum. Must not be NULL. * @param ellipsoidalCS Coordinate system. Must not be NULL. @@ -1890,14 +1919,16 @@ PJ_OBJ *proj_obj_create_geographic_crs( * @return Object of type GeographicCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_geographic_crs_from_datum(const char *crsName, +PJ_OBJ *proj_obj_create_geographic_crs_from_datum(PJ_CONTEXT *ctx, + const char *crsName, PJ_OBJ *datum, PJ_OBJ *ellipsoidalCS) { + SANITIZE_CTX(ctx); auto l_datum = util::nn_dynamic_pointer_cast(datum->obj); if (!l_datum) { - proj_log_error(datum->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "datum is not a GeodeticReferenceFrame"); return nullptr; } @@ -1909,9 +1940,9 @@ PJ_OBJ *proj_obj_create_geographic_crs_from_datum(const char *crsName, auto geogCRS = GeographicCRS::create(createPropertyMapName(crsName), NN_NO_CHECK(l_datum), NN_NO_CHECK(cs)); - return PJ_OBJ::create(datum->ctx, geogCRS); + return PJ_OBJ::create(geogCRS); } catch (const std::exception &e) { - proj_log_error(datum->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } return nullptr; } @@ -1962,7 +1993,7 @@ PJ_OBJ *proj_obj_create_geocentric_crs( auto geodCRS = GeodeticCRS::create(createPropertyMapName(crsName), datum, cs::CartesianCS::createGeocentric(linearUnit)); - return PJ_OBJ::create(ctx, geodCRS); + return PJ_OBJ::create(geodCRS); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -1977,6 +2008,7 @@ PJ_OBJ *proj_obj_create_geocentric_crs( * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crsName Name of the GeographicCRS. Or NULL * @param datum Datum. Must not be NULL. * @param linearUnits Name of the linear units. Or NULL for Metre @@ -1986,26 +2018,28 @@ PJ_OBJ *proj_obj_create_geocentric_crs( * @return Object of type GeodeticCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(const char *crsName, +PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(PJ_CONTEXT *ctx, + const char *crsName, const PJ_OBJ *datum, const char *linearUnits, double linearUnitsConv) { + SANITIZE_CTX(ctx); try { const UnitOfMeasure linearUnit( createLinearUnit(linearUnits, linearUnitsConv)); auto l_datum = util::nn_dynamic_pointer_cast(datum->obj); if (!l_datum) { - proj_log_error(datum->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "datum is not a GeodeticReferenceFrame"); return nullptr; } auto geodCRS = GeodeticCRS::create( createPropertyMapName(crsName), NN_NO_CHECK(l_datum), cs::CartesianCS::createGeocentric(linearUnit)); - return PJ_OBJ::create(datum->ctx, geodCRS); + return PJ_OBJ::create(geodCRS); } catch (const std::exception &e) { - proj_log_error(datum->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } return nullptr; } @@ -2020,21 +2054,24 @@ PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(const char *crsName, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL * @param name New name. Must not be NULL * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ PROJ_DLL *proj_obj_alter_name(const PJ_OBJ *obj, const char *name) { +PJ_OBJ PROJ_DLL *proj_obj_alter_name(PJ_CONTEXT *ctx, const PJ_OBJ *obj, + const char *name) { + SANITIZE_CTX(ctx); auto crs = dynamic_cast(obj->obj.get()); if (!crs) { return nullptr; } try { - return PJ_OBJ::create(obj->ctx, crs->alterName(name)); + return PJ_OBJ::create(crs->alterName(name)); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } return nullptr; } @@ -2053,33 +2090,33 @@ PJ_OBJ PROJ_DLL *proj_obj_alter_name(const PJ_OBJ *obj, const char *name) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL * @param newGeodCRS Object of type GeodeticCRS. Must not be NULL * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_alter_geodetic_crs(const PJ_OBJ *obj, +PJ_OBJ *proj_obj_crs_alter_geodetic_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj, const PJ_OBJ *newGeodCRS) { + SANITIZE_CTX(ctx); auto l_newGeodCRS = util::nn_dynamic_pointer_cast(newGeodCRS->obj); if (!l_newGeodCRS) { - proj_log_error(obj->ctx, __FUNCTION__, - "newGeodCRS is not a GeodeticCRS"); + proj_log_error(ctx, __FUNCTION__, "newGeodCRS is not a GeodeticCRS"); return nullptr; } auto crs = dynamic_cast(obj->obj.get()); if (!crs) { - proj_log_error(obj->ctx, __FUNCTION__, "obj is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "obj is not a CRS"); return nullptr; } try { - return PJ_OBJ::create(obj->ctx, - crs->alterGeodeticCRS(NN_NO_CHECK(l_newGeodCRS))); + return PJ_OBJ::create(crs->alterGeodeticCRS(NN_NO_CHECK(l_newGeodCRS))); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -2094,6 +2131,7 @@ PJ_OBJ *proj_obj_crs_alter_geodetic_crs(const PJ_OBJ *obj, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL * @param angularUnits Name of the angular units. Or NULL for Degree * @param angularUnitsConv Conversion factor from the angular unit to radian. Or @@ -2102,11 +2140,12 @@ PJ_OBJ *proj_obj_crs_alter_geodetic_crs(const PJ_OBJ *obj, * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(const PJ_OBJ *obj, +PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, const char *angularUnits, double angularUnitsConv) { - auto geodCRS = proj_obj_crs_get_geodetic_crs(obj); + SANITIZE_CTX(ctx); + auto geodCRS = proj_obj_crs_get_geodetic_crs(ctx, obj); if (!geodCRS) { return nullptr; } @@ -2120,20 +2159,18 @@ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(const PJ_OBJ *obj, try { const UnitOfMeasure angUnit( createAngularUnit(angularUnits, angularUnitsConv)); - geogCRSAltered = PJ_OBJ::create( - obj->ctx, - GeographicCRS::create( - createPropertyMapName(proj_obj_get_name(geodCRS)), - geogCRS->datum(), geogCRS->datumEnsemble(), - geogCRS->coordinateSystem()->alterAngularUnit(angUnit))); + geogCRSAltered = PJ_OBJ::create(GeographicCRS::create( + createPropertyMapName(proj_obj_get_name(geodCRS)), geogCRS->datum(), + geogCRS->datumEnsemble(), + geogCRS->coordinateSystem()->alterAngularUnit(angUnit))); proj_obj_unref(geodCRS); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); proj_obj_unref(geodCRS); return nullptr; } - auto ret = proj_obj_crs_alter_geodetic_crs(obj, geogCRSAltered); + auto ret = proj_obj_crs_alter_geodetic_crs(ctx, obj, geogCRSAltered); proj_obj_unref(geogCRSAltered); return ret; } @@ -2149,6 +2186,7 @@ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(const PJ_OBJ *obj, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL * @param linearUnits Name of the linear units. Or NULL for Metre * @param linearUnitsConv Conversion factor from the linear unit to metre. Or @@ -2157,9 +2195,10 @@ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(const PJ_OBJ *obj, * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(const PJ_OBJ *obj, +PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, const char *linearUnits, double linearUnitsConv) { + SANITIZE_CTX(ctx); auto crs = dynamic_cast(obj->obj.get()); if (!crs) { return nullptr; @@ -2168,9 +2207,9 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(const PJ_OBJ *obj, try { const UnitOfMeasure linearUnit( createLinearUnit(linearUnits, linearUnitsConv)); - return PJ_OBJ::create(obj->ctx, crs->alterCSLinearUnit(linearUnit)); + return PJ_OBJ::create(crs->alterCSLinearUnit(linearUnit)); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -2186,6 +2225,7 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(const PJ_OBJ *obj, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param obj Object of type ProjectedCRS. Must not be NULL * @param linearUnits Name of the linear units. Or NULL for Metre * @param linearUnitsConv Conversion factor from the linear unit to metre. Or @@ -2198,10 +2238,12 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(const PJ_OBJ *obj, * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(const PJ_OBJ *obj, +PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(PJ_CONTEXT *ctx, + const PJ_OBJ *obj, const char *linearUnits, double linearUnitsConv, int convertToNewUnit) { + SANITIZE_CTX(ctx); auto crs = dynamic_cast(obj->obj.get()); if (!crs) { return nullptr; @@ -2210,11 +2252,10 @@ PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(const PJ_OBJ *obj, try { const UnitOfMeasure linearUnit( createLinearUnit(linearUnits, linearUnitsConv)); - return PJ_OBJ::create( - obj->ctx, crs->alterParametersLinearUnit(linearUnit, - convertToNewUnit == TRUE)); + return PJ_OBJ::create(crs->alterParametersLinearUnit( + linearUnit, convertToNewUnit == TRUE)); } catch (const std::exception &e) { - proj_log_error(obj->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -2235,12 +2276,12 @@ PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(const PJ_OBJ *obj, */ PJ_OBJ PROJ_DLL *proj_obj_create_engineering_crs(PJ_CONTEXT *ctx, const char *crsName) { + SANITIZE_CTX(ctx); try { - return PJ_OBJ::create( - ctx, EngineeringCRS::create( - createPropertyMapName(crsName), - EngineeringDatum::create(PropertyMap()), - CartesianCS::createEastingNorthing(UnitOfMeasure::METRE))); + return PJ_OBJ::create(EngineeringCRS::create( + createPropertyMapName(crsName), + EngineeringDatum::create(PropertyMap()), + CartesianCS::createEastingNorthing(UnitOfMeasure::METRE))); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; @@ -2275,6 +2316,7 @@ PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, const char *name, const char *method_auth_name, const char *method_code, int param_count, const PJ_PARAM_DESCRIPTION *params) { + SANITIZE_CTX(ctx); try { PropertyMap propConv; propConv.set(common::IdentifiedObject::NAME_KEY, @@ -2338,7 +2380,7 @@ PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, const char *name, values.emplace_back(ParameterValue::create(measure)); } return PJ_OBJ::create( - ctx, Conversion::create(propConv, propMethod, parameters, values)); + Conversion::create(propConv, propMethod, parameters, values)); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; @@ -2413,29 +2455,24 @@ PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, case PJ_CS_TYPE_CARTESIAN: { if (axis_count == 2) { - return PJ_OBJ::create( - ctx, CartesianCS::create(PropertyMap(), createAxis(axis[0]), - createAxis(axis[1]))); + return PJ_OBJ::create(CartesianCS::create( + PropertyMap(), createAxis(axis[0]), createAxis(axis[1]))); } else if (axis_count == 3) { - return PJ_OBJ::create( - ctx, CartesianCS::create(PropertyMap(), createAxis(axis[0]), - createAxis(axis[1]), - createAxis(axis[2]))); + return PJ_OBJ::create(CartesianCS::create( + PropertyMap(), createAxis(axis[0]), createAxis(axis[1]), + createAxis(axis[2]))); } break; } case PJ_CS_TYPE_ELLIPSOIDAL: { if (axis_count == 2) { - return PJ_OBJ::create( - ctx, - EllipsoidalCS::create(PropertyMap(), createAxis(axis[0]), - createAxis(axis[1]))); + return PJ_OBJ::create(EllipsoidalCS::create( + PropertyMap(), createAxis(axis[0]), createAxis(axis[1]))); } else if (axis_count == 3) { - return PJ_OBJ::create( - ctx, EllipsoidalCS::create( - PropertyMap(), createAxis(axis[0]), - createAxis(axis[1]), createAxis(axis[2]))); + return PJ_OBJ::create(EllipsoidalCS::create( + PropertyMap(), createAxis(axis[0]), createAxis(axis[1]), + createAxis(axis[2]))); } break; } @@ -2443,7 +2480,6 @@ PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, case PJ_CS_TYPE_VERTICAL: { if (axis_count == 1) { return PJ_OBJ::create( - ctx, VerticalCS::create(PropertyMap(), createAxis(axis[0]))); } break; @@ -2451,10 +2487,9 @@ PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, case PJ_CS_TYPE_SPHERICAL: { if (axis_count == 3) { - return PJ_OBJ::create( - ctx, EllipsoidalCS::create( - PropertyMap(), createAxis(axis[0]), - createAxis(axis[1]), createAxis(axis[2]))); + return PJ_OBJ::create(EllipsoidalCS::create( + PropertyMap(), createAxis(axis[0]), createAxis(axis[1]), + createAxis(axis[2]))); } break; } @@ -2462,7 +2497,6 @@ PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, case PJ_CS_TYPE_PARAMETRIC: { if (axis_count == 1) { return PJ_OBJ::create( - ctx, ParametricCS::create(PropertyMap(), createAxis(axis[0]))); } break; @@ -2474,33 +2508,29 @@ PJ_OBJ *proj_obj_create_cs(PJ_CONTEXT *ctx, PJ_COORDINATE_SYSTEM_TYPE type, axisVector.emplace_back(createAxis(axis[i])); } - return PJ_OBJ::create(ctx, - OrdinalCS::create(PropertyMap(), axisVector)); + return PJ_OBJ::create(OrdinalCS::create(PropertyMap(), axisVector)); } case PJ_CS_TYPE_DATETIMETEMPORAL: { if (axis_count == 1) { - return PJ_OBJ::create( - ctx, DateTimeTemporalCS::create(PropertyMap(), - createAxis(axis[0]))); + return PJ_OBJ::create(DateTimeTemporalCS::create( + PropertyMap(), createAxis(axis[0]))); } break; } case PJ_CS_TYPE_TEMPORALCOUNT: { if (axis_count == 1) { - return PJ_OBJ::create( - ctx, TemporalCountCS::create(PropertyMap(), - createAxis(axis[0]))); + return PJ_OBJ::create(TemporalCountCS::create( + PropertyMap(), createAxis(axis[0]))); } break; } case PJ_CS_TYPE_TEMPORALMEASURE: { if (axis_count == 1) { - return PJ_OBJ::create( - ctx, TemporalMeasureCS::create(PropertyMap(), - createAxis(axis[0]))); + return PJ_OBJ::create(TemporalMeasureCS::create( + PropertyMap(), createAxis(axis[0]))); } break; } @@ -2538,14 +2568,12 @@ PJ_OBJ *proj_obj_create_cartesian_2D_cs(PJ_CONTEXT *ctx, try { switch (type) { case PJ_CART2D_EASTING_NORTHING: - return PJ_OBJ::create( - ctx, CartesianCS::createEastingNorthing( - createLinearUnit(unit_name, unit_conv_factor))); + return PJ_OBJ::create(CartesianCS::createEastingNorthing( + createLinearUnit(unit_name, unit_conv_factor))); case PJ_CART2D_NORTHING_EASTING: - return PJ_OBJ::create( - ctx, CartesianCS::createNorthingEasting( - createLinearUnit(unit_name, unit_conv_factor))); + return PJ_OBJ::create(CartesianCS::createNorthingEasting( + createLinearUnit(unit_name, unit_conv_factor))); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2577,14 +2605,12 @@ PJ_OBJ *proj_obj_create_ellipsoidal_2D_cs(PJ_CONTEXT *ctx, try { switch (type) { case PJ_ELLPS2D_LONGITUDE_LATITUDE: - return PJ_OBJ::create( - ctx, EllipsoidalCS::createLongitudeLatitude( - createAngularUnit(unit_name, unit_conv_factor))); + return PJ_OBJ::create(EllipsoidalCS::createLongitudeLatitude( + createAngularUnit(unit_name, unit_conv_factor))); case PJ_ELLPS2D_LATITUDE_LONGITUDE: - return PJ_OBJ::create( - ctx, EllipsoidalCS::createLatitudeLongitude( - createAngularUnit(unit_name, unit_conv_factor))); + return PJ_OBJ::create(EllipsoidalCS::createLatitudeLongitude( + createAngularUnit(unit_name, unit_conv_factor))); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2600,6 +2626,7 @@ PJ_OBJ *proj_obj_create_ellipsoidal_2D_cs(PJ_CONTEXT *ctx, * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs_name CRS name. Or NULL * @param geodetic_crs Base GeodeticCRS. Must not be NULL. * @param conversion Conversion. Must not be NULL. @@ -2609,10 +2636,11 @@ PJ_OBJ *proj_obj_create_ellipsoidal_2D_cs(PJ_CONTEXT *ctx, * proj_obj_unref(), or NULL in case of error. */ -PJ_OBJ *proj_obj_create_projected_crs(const char *crs_name, +PJ_OBJ *proj_obj_create_projected_crs(PJ_CONTEXT *ctx, const char *crs_name, const PJ_OBJ *geodetic_crs, const PJ_OBJ *conversion, const PJ_OBJ *coordinate_system) { + SANITIZE_CTX(ctx); auto geodCRS = util::nn_dynamic_pointer_cast(geodetic_crs->obj); if (!geodCRS) { @@ -2628,13 +2656,11 @@ PJ_OBJ *proj_obj_create_projected_crs(const char *crs_name, return nullptr; } try { - return PJ_OBJ::create( - geodetic_crs->ctx, - ProjectedCRS::create(createPropertyMapName(crs_name), - NN_NO_CHECK(geodCRS), NN_NO_CHECK(conv), - NN_NO_CHECK(cs))); + return PJ_OBJ::create(ProjectedCRS::create( + createPropertyMapName(crs_name), NN_NO_CHECK(geodCRS), + NN_NO_CHECK(conv), NN_NO_CHECK(cs))); } catch (const std::exception &e) { - proj_log_error(geodetic_crs->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); } return nullptr; } @@ -2643,9 +2669,8 @@ PJ_OBJ *proj_obj_create_projected_crs(const char *crs_name, //! @cond Doxygen_Suppress -static PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, - const ConversionNNPtr &conv) { - return PJ_OBJ::create(ctx, conv); +static PJ_OBJ *proj_obj_create_conversion(const ConversionNNPtr &conv) { + return PJ_OBJ::create(conv); } //! @endcond @@ -2662,9 +2687,10 @@ static PJ_OBJ *proj_obj_create_conversion(PJ_CONTEXT *ctx, * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). */ PJ_OBJ *proj_obj_create_conversion_utm(PJ_CONTEXT *ctx, int zone, int north) { + SANITIZE_CTX(ctx); try { auto conv = Conversion::createUTM(PropertyMap(), zone, north != 0); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2685,6 +2711,7 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2695,7 +2722,7 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2717,6 +2744,7 @@ PJ_OBJ *proj_obj_create_conversion_gauss_schreiber_transverse_mercator( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2727,7 +2755,7 @@ PJ_OBJ *proj_obj_create_conversion_gauss_schreiber_transverse_mercator( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2749,6 +2777,7 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator_south_oriented( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2759,7 +2788,7 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator_south_oriented( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2780,6 +2809,7 @@ PJ_OBJ *proj_obj_create_conversion_two_point_equidistant( double latitudeSecondPoint, double longitudeSeconPoint, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2792,7 +2822,7 @@ PJ_OBJ *proj_obj_create_conversion_two_point_equidistant( Angle(longitudeSeconPoint, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2812,6 +2842,7 @@ PJ_OBJ *proj_obj_create_conversion_tunisia_mapping_grid( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2821,7 +2852,7 @@ PJ_OBJ *proj_obj_create_conversion_tunisia_mapping_grid( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2843,6 +2874,7 @@ PJ_OBJ *proj_obj_create_conversion_albers_equal_area( double eastingFalseOrigin, double northingFalseOrigin, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2855,7 +2887,7 @@ PJ_OBJ *proj_obj_create_conversion_albers_equal_area( Angle(latitudeSecondParallel, angUnit), Length(eastingFalseOrigin, linearUnit), Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2876,6 +2908,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_1sp( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2886,7 +2919,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_1sp( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2908,6 +2941,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp( double eastingFalseOrigin, double northingFalseOrigin, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2920,7 +2954,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp( Angle(latitudeSecondParallel, angUnit), Length(eastingFalseOrigin, linearUnit), Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2944,6 +2978,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_michigan( double ellipsoidScalingFactor, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2957,7 +2992,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_michigan( Length(eastingFalseOrigin, linearUnit), Length(northingFalseOrigin, linearUnit), Scale(ellipsoidScalingFactor)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -2980,6 +3015,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_belgium( double eastingFalseOrigin, double northingFalseOrigin, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -2992,7 +3028,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_belgium( Angle(latitudeSecondParallel, angUnit), Length(eastingFalseOrigin, linearUnit), Length(northingFalseOrigin, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3013,6 +3049,7 @@ PJ_OBJ *proj_obj_create_conversion_azimuthal_equidistant( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3023,7 +3060,7 @@ PJ_OBJ *proj_obj_create_conversion_azimuthal_equidistant( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3044,6 +3081,7 @@ PJ_OBJ *proj_obj_create_conversion_guam_projection( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3054,7 +3092,7 @@ PJ_OBJ *proj_obj_create_conversion_guam_projection( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3075,6 +3113,7 @@ PJ_OBJ *proj_obj_create_conversion_bonne( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3085,7 +3124,7 @@ PJ_OBJ *proj_obj_create_conversion_bonne( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3107,6 +3146,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area_spherical( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3117,7 +3157,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area_spherical( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3138,6 +3178,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3148,7 +3189,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3168,6 +3209,7 @@ PJ_OBJ *proj_obj_create_conversion_cassini_soldner( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3177,7 +3219,7 @@ PJ_OBJ *proj_obj_create_conversion_cassini_soldner( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3199,6 +3241,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_conic( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3210,7 +3253,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_conic( Angle(latitudeSecondParallel, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3230,6 +3273,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_i( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3239,7 +3283,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_i( Conversion::createEckertI(PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3259,6 +3303,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_ii( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3268,7 +3313,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_ii( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3288,6 +3333,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iii( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3297,7 +3343,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iii( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3317,6 +3363,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iv( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3326,7 +3373,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iv( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3346,6 +3393,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_v( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3355,7 +3403,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_v( Conversion::createEckertV(PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3375,6 +3423,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_vi( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3384,7 +3433,7 @@ PJ_OBJ *proj_obj_create_conversion_eckert_vi( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3405,6 +3454,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3415,7 +3465,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3437,6 +3487,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical_spherical( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3447,7 +3498,7 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical_spherical( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3467,6 +3518,7 @@ PJ_OBJ *proj_obj_create_conversion_gall( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3476,7 +3528,7 @@ PJ_OBJ *proj_obj_create_conversion_gall( Conversion::createGall(PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3496,6 +3548,7 @@ PJ_OBJ *proj_obj_create_conversion_goode_homolosine( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3505,7 +3558,7 @@ PJ_OBJ *proj_obj_create_conversion_goode_homolosine( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3525,6 +3578,7 @@ PJ_OBJ *proj_obj_create_conversion_interrupted_goode_homolosine( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3534,7 +3588,7 @@ PJ_OBJ *proj_obj_create_conversion_interrupted_goode_homolosine( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3555,6 +3609,7 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_x( PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3564,7 +3619,7 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_x( PropertyMap(), Angle(centerLong, angUnit), Length(height, linearUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3585,6 +3640,7 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_y( PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3594,7 +3650,7 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_y( PropertyMap(), Angle(centerLong, angUnit), Length(height, linearUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3614,6 +3670,7 @@ PJ_OBJ *proj_obj_create_conversion_gnomonic( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3623,7 +3680,7 @@ PJ_OBJ *proj_obj_create_conversion_gnomonic( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3646,6 +3703,7 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_a( double angleFromRectifiedToSkrewGrid, double scale, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3658,7 +3716,7 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_a( Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3682,6 +3740,7 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_b( double eastingProjectionCentre, double northingProjectionCentre, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3694,7 +3753,7 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_b( Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), Length(eastingProjectionCentre, linearUnit), Length(northingProjectionCentre, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3719,6 +3778,7 @@ proj_obj_create_conversion_hotine_oblique_mercator_two_point_natural_origin( double northingProjectionCentre, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3731,7 +3791,7 @@ proj_obj_create_conversion_hotine_oblique_mercator_two_point_natural_origin( Angle(latitudePoint2, angUnit), Angle(longitudePoint2, angUnit), Scale(scale), Length(eastingProjectionCentre, linearUnit), Length(northingProjectionCentre, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3753,6 +3813,7 @@ PJ_OBJ *proj_obj_create_conversion_international_map_world_polyconic( double latitudeSecondParallel, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3764,7 +3825,7 @@ PJ_OBJ *proj_obj_create_conversion_international_map_world_polyconic( Angle(latitudeSecondParallel, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3786,6 +3847,7 @@ PJ_OBJ *proj_obj_create_conversion_krovak_north_oriented( double scaleFactorPseudoStandardParallel, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3799,7 +3861,7 @@ PJ_OBJ *proj_obj_create_conversion_krovak_north_oriented( Scale(scaleFactorPseudoStandardParallel), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3821,6 +3883,7 @@ PJ_OBJ *proj_obj_create_conversion_krovak( double scaleFactorPseudoStandardParallel, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3834,7 +3897,7 @@ PJ_OBJ *proj_obj_create_conversion_krovak( Scale(scaleFactorPseudoStandardParallel), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3855,6 +3918,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_azimuthal_equal_area( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3865,7 +3929,7 @@ PJ_OBJ *proj_obj_create_conversion_lambert_azimuthal_equal_area( Angle(longitudeNatOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3885,6 +3949,7 @@ PJ_OBJ *proj_obj_create_conversion_miller_cylindrical( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3894,7 +3959,7 @@ PJ_OBJ *proj_obj_create_conversion_miller_cylindrical( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3915,6 +3980,7 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_a( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3925,7 +3991,7 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_a( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3946,6 +4012,7 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_b( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3955,7 +4022,7 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_b( PropertyMap(), Angle(latitudeFirstParallel, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -3976,6 +4043,7 @@ PJ_OBJ *proj_obj_create_conversion_popular_visualisation_pseudo_mercator( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -3985,7 +4053,7 @@ PJ_OBJ *proj_obj_create_conversion_popular_visualisation_pseudo_mercator( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4005,6 +4073,7 @@ PJ_OBJ *proj_obj_create_conversion_mollweide( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4014,7 +4083,7 @@ PJ_OBJ *proj_obj_create_conversion_mollweide( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4034,6 +4103,7 @@ PJ_OBJ *proj_obj_create_conversion_new_zealand_mapping_grid( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4043,7 +4113,7 @@ PJ_OBJ *proj_obj_create_conversion_new_zealand_mapping_grid( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4064,6 +4134,7 @@ PJ_OBJ *proj_obj_create_conversion_oblique_stereographic( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4074,7 +4145,7 @@ PJ_OBJ *proj_obj_create_conversion_oblique_stereographic( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4094,6 +4165,7 @@ PJ_OBJ *proj_obj_create_conversion_orthographic( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4103,7 +4175,7 @@ PJ_OBJ *proj_obj_create_conversion_orthographic( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4123,6 +4195,7 @@ PJ_OBJ *proj_obj_create_conversion_american_polyconic( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4132,7 +4205,7 @@ PJ_OBJ *proj_obj_create_conversion_american_polyconic( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4153,6 +4226,7 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_a( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4163,7 +4237,7 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_a( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4184,6 +4258,7 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_b( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4193,7 +4268,7 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_b( PropertyMap(), Angle(latitudeStandardParallel, angUnit), Angle(longitudeOfOrigin, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4213,6 +4288,7 @@ PJ_OBJ *proj_obj_create_conversion_robinson( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4222,7 +4298,7 @@ PJ_OBJ *proj_obj_create_conversion_robinson( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4242,6 +4318,7 @@ PJ_OBJ *proj_obj_create_conversion_sinusoidal( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4251,7 +4328,7 @@ PJ_OBJ *proj_obj_create_conversion_sinusoidal( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4272,6 +4349,7 @@ PJ_OBJ *proj_obj_create_conversion_stereographic( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4282,7 +4360,7 @@ PJ_OBJ *proj_obj_create_conversion_stereographic( Angle(centerLong, angUnit), Scale(scale), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4302,6 +4380,7 @@ PJ_OBJ *proj_obj_create_conversion_van_der_grinten( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4311,7 +4390,7 @@ PJ_OBJ *proj_obj_create_conversion_van_der_grinten( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4331,6 +4410,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_i( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4340,7 +4420,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_i( Conversion::createWagnerI(PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4360,6 +4440,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_ii( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4369,7 +4450,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_ii( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4390,6 +4471,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iii( double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4399,7 +4481,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iii( PropertyMap(), Angle(latitudeTrueScale, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4419,6 +4501,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iv( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4428,7 +4511,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iv( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4448,6 +4531,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_v( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4457,7 +4541,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_v( Conversion::createWagnerV(PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4477,6 +4561,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vi( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4486,7 +4571,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vi( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4506,6 +4591,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vii( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4515,7 +4601,7 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vii( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4536,6 +4622,7 @@ PJ_OBJ *proj_obj_create_conversion_quadrilateralized_spherical_cube( PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4545,7 +4632,7 @@ PJ_OBJ *proj_obj_create_conversion_quadrilateralized_spherical_cube( PropertyMap(), Angle(centerLat, angUnit), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4566,6 +4653,7 @@ PJ_OBJ *proj_obj_create_conversion_spherical_cross_track_height( double pegPointHeading, double pegPointHeight, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4575,7 +4663,7 @@ PJ_OBJ *proj_obj_create_conversion_spherical_cross_track_height( PropertyMap(), Angle(pegPointLat, angUnit), Angle(pegPointLong, angUnit), Angle(pegPointHeading, angUnit), Length(pegPointHeight, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4595,6 +4683,7 @@ PJ_OBJ *proj_obj_create_conversion_equal_earth( PJ_CONTEXT *ctx, double centerLong, double falseEasting, double falseNorthing, const char *angUnitName, double angUnitConvFactor, const char *linearUnitName, double linearUnitConvFactor) { + SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( createLinearUnit(linearUnitName, linearUnitConvFactor)); @@ -4604,7 +4693,7 @@ PJ_OBJ *proj_obj_create_conversion_equal_earth( PropertyMap(), Angle(centerLong, angUnit), Length(falseEasting, linearUnit), Length(falseNorthing, linearUnit)); - return proj_obj_create_conversion(ctx, conv); + return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); } @@ -4618,21 +4707,23 @@ PJ_OBJ *proj_obj_create_conversion_equal_earth( * a PROJ pipeline, checking in particular that referenced grids are * available. * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type CoordinateOperation or derived classes * (must not be NULL) * @return TRUE or FALSE. */ -int proj_coordoperation_is_instanciable(const PJ_OBJ *coordoperation) { +int proj_coordoperation_is_instanciable(PJ_CONTEXT *ctx, + const PJ_OBJ *coordoperation) { assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { - proj_log_error(coordoperation->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateOperation"); return 0; } - auto dbContext = getDBcontextNoException(coordoperation->ctx, __FUNCTION__); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); try { return op->isPROJInstanciable(dbContext) ? 1 : 0; } catch (const std::exception &) { @@ -4644,16 +4735,18 @@ int proj_coordoperation_is_instanciable(const PJ_OBJ *coordoperation) { /** \brief Return the number of parameters of a SingleOperation * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) */ -int proj_coordoperation_get_param_count(const PJ_OBJ *coordoperation) { +int proj_coordoperation_get_param_count(PJ_CONTEXT *ctx, + const PJ_OBJ *coordoperation) { + SANITIZE_CTX(ctx); assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { - proj_log_error(coordoperation->ctx, __FUNCTION__, - "Object is not a SingleOperation"); + proj_log_error(ctx, __FUNCTION__, "Object is not a SingleOperation"); return 0; } return static_cast(op->parameterValues().size()); @@ -4663,20 +4756,22 @@ int proj_coordoperation_get_param_count(const PJ_OBJ *coordoperation) { /** \brief Return the index of a parameter of a SingleOperation * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) * @param name Parameter name. Must not be NULL * @return index (>=0), or -1 in case of error. */ -int proj_coordoperation_get_param_index(const PJ_OBJ *coordoperation, +int proj_coordoperation_get_param_index(PJ_CONTEXT *ctx, + const PJ_OBJ *coordoperation, const char *name) { + SANITIZE_CTX(ctx); assert(coordoperation); assert(name); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { - proj_log_error(coordoperation->ctx, __FUNCTION__, - "Object is not a SingleOperation"); + proj_log_error(ctx, __FUNCTION__, "Object is not a SingleOperation"); return -1; } int index = 0; @@ -4693,6 +4788,7 @@ int proj_coordoperation_get_param_index(const PJ_OBJ *coordoperation, /** \brief Return a parameter of a SingleOperation * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) * @param index Parameter index. @@ -4713,25 +4809,25 @@ int proj_coordoperation_get_param_index(const PJ_OBJ *coordoperation, * @return TRUE in case of success. */ -int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, - const char **out_name, +int proj_coordoperation_get_param(PJ_CONTEXT *ctx, const PJ_OBJ *coordoperation, + int index, const char **out_name, const char **out_auth_name, const char **out_code, double *out_value, const char **out_value_string, double *out_unit_conv_factor, const char **out_unit_name) { + SANITIZE_CTX(ctx); assert(coordoperation); auto op = dynamic_cast(coordoperation->obj.get()); if (!op) { - proj_log_error(coordoperation->ctx, __FUNCTION__, - "Object is not a SingleOperation"); + proj_log_error(ctx, __FUNCTION__, "Object is not a SingleOperation"); return false; } const auto ¶meters = op->method()->parameters(); const auto &values = op->parameterValues(); if (static_cast(index) >= parameters.size() || static_cast(index) >= values.size()) { - proj_log_error(coordoperation->ctx, __FUNCTION__, "Invalid index"); + proj_log_error(ctx, __FUNCTION__, "Invalid index"); return false; } @@ -4805,20 +4901,23 @@ int proj_coordoperation_get_param(const PJ_OBJ *coordoperation, int index, /** \brief Return the number of grids used by a CoordinateOperation * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type CoordinateOperation or derived classes * (must not be NULL) */ -int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { +int proj_coordoperation_get_grid_used_count(PJ_CONTEXT *ctx, + const PJ_OBJ *coordoperation) { + SANITIZE_CTX(ctx); assert(coordoperation); auto co = dynamic_cast(coordoperation->obj.get()); if (!co) { - proj_log_error(coordoperation->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateOperation"); return 0; } - auto dbContext = getDBcontextNoException(coordoperation->ctx, __FUNCTION__); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); try { if (!coordoperation->gridsNeededAsked) { coordoperation->gridsNeededAsked = true; @@ -4829,7 +4928,7 @@ int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { } return static_cast(coordoperation->gridsNeeded.size()); } catch (const std::exception &e) { - proj_log_error(coordoperation->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return 0; } } @@ -4838,6 +4937,7 @@ int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { /** \brief Return a parameter of a SingleOperation * + * @param ctx PROJ context, or NULL for default context * @param coordoperation Objet of type SingleOperation or derived classes * (must not be NULL) * @param index Parameter index. @@ -4860,13 +4960,15 @@ int proj_coordoperation_get_grid_used_count(const PJ_OBJ *coordoperation) { */ int proj_coordoperation_get_grid_used( - const PJ_OBJ *coordoperation, int index, const char **out_short_name, - const char **out_full_name, const char **out_package_name, - const char **out_url, int *out_direct_download, int *out_open_license, - int *out_available) { - const int count = proj_coordoperation_get_grid_used_count(coordoperation); + PJ_CONTEXT *ctx, const PJ_OBJ *coordoperation, int index, + const char **out_short_name, const char **out_full_name, + const char **out_package_name, const char **out_url, + int *out_direct_download, int *out_open_license, int *out_available) { + SANITIZE_CTX(ctx); + const int count = + proj_coordoperation_get_grid_used_count(ctx, coordoperation); if (index < 0 || index >= count) { - proj_log_error(coordoperation->ctx, __FUNCTION__, "Invalid index"); + proj_log_error(ctx, __FUNCTION__, "Invalid index"); return false; } @@ -4907,12 +5009,11 @@ int proj_coordoperation_get_grid_used( /** \brief Opaque object representing an operation factory context. */ struct PJ_OPERATION_FACTORY_CONTEXT { //! @cond Doxygen_Suppress - PJ_CONTEXT *ctx; CoordinateOperationContextNNPtr operationContext; explicit PJ_OPERATION_FACTORY_CONTEXT( - PJ_CONTEXT *ctxIn, CoordinateOperationContextNNPtr &&operationContextIn) - : ctx(ctxIn), operationContext(std::move(operationContextIn)) {} + CoordinateOperationContextNNPtr &&operationContextIn) + : operationContext(std::move(operationContextIn)) {} PJ_OPERATION_FACTORY_CONTEXT(const PJ_OPERATION_FACTORY_CONTEXT &) = delete; PJ_OPERATION_FACTORY_CONTEXT & @@ -4948,12 +5049,12 @@ proj_create_operation_factory_context(PJ_CONTEXT *ctx, const char *authority) { auto operationContext = CoordinateOperationContext::create(authFactory, nullptr, 0.0); return new PJ_OPERATION_FACTORY_CONTEXT( - ctx, std::move(operationContext)); + std::move(operationContext)); } else { auto operationContext = CoordinateOperationContext::create(nullptr, nullptr, 0.0); return new PJ_OPERATION_FACTORY_CONTEXT( - ctx, std::move(operationContext)); + std::move(operationContext)); } } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4977,13 +5078,20 @@ void proj_operation_factory_context_unref(PJ_OPERATION_FACTORY_CONTEXT *ctx) { // --------------------------------------------------------------------------- /** \brief Set the desired accuracy of the resulting coordinate transformations. - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param accuracy Accuracy in meter (or 0 to disable the filter). */ void proj_operation_factory_context_set_desired_accuracy( - PJ_OPERATION_FACTORY_CONTEXT *ctx, double accuracy) { - assert(ctx); - ctx->operationContext->setDesiredAccuracy(accuracy); + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + double accuracy) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + factory_ctx->operationContext->setDesiredAccuracy(accuracy); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } } // --------------------------------------------------------------------------- @@ -4994,18 +5102,26 @@ void proj_operation_factory_context_set_desired_accuracy( * For an area of interest crossing the anti-meridian, west_lon_degree will be * greater than east_lon_degree. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param west_lon_degree West longitude (in degrees). * @param south_lat_degree South latitude (in degrees). * @param east_lon_degree East longitude (in degrees). * @param north_lat_degree North latitude (in degrees). */ void proj_operation_factory_context_set_area_of_interest( - PJ_OPERATION_FACTORY_CONTEXT *ctx, double west_lon_degree, - double south_lat_degree, double east_lon_degree, double north_lat_degree) { - assert(ctx); - ctx->operationContext->setAreaOfInterest(Extent::createFromBBOX( - west_lon_degree, south_lat_degree, east_lon_degree, north_lat_degree)); + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + double west_lon_degree, double south_lat_degree, double east_lon_degree, + double north_lat_degree) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + factory_ctx->operationContext->setAreaOfInterest( + Extent::createFromBBOX(west_lon_degree, south_lat_degree, + east_lon_degree, north_lat_degree)); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } } // --------------------------------------------------------------------------- @@ -5016,32 +5132,40 @@ void proj_operation_factory_context_set_area_of_interest( * * The default is PJ_CRS_EXTENT_SMALLEST. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param use How source and target CRS extent should be used. */ void proj_operation_factory_context_set_crs_extent_use( - PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_CRS_EXTENT_USE use) { - assert(ctx); - switch (use) { - case PJ_CRS_EXTENT_NONE: - ctx->operationContext->setSourceAndTargetCRSExtentUse( - CoordinateOperationContext::SourceTargetCRSExtentUse::NONE); - break; + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + PROJ_CRS_EXTENT_USE use) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + switch (use) { + case PJ_CRS_EXTENT_NONE: + factory_ctx->operationContext->setSourceAndTargetCRSExtentUse( + CoordinateOperationContext::SourceTargetCRSExtentUse::NONE); + break; - case PJ_CRS_EXTENT_BOTH: - ctx->operationContext->setSourceAndTargetCRSExtentUse( - CoordinateOperationContext::SourceTargetCRSExtentUse::BOTH); - break; + case PJ_CRS_EXTENT_BOTH: + factory_ctx->operationContext->setSourceAndTargetCRSExtentUse( + CoordinateOperationContext::SourceTargetCRSExtentUse::BOTH); + break; - case PJ_CRS_EXTENT_INTERSECTION: - ctx->operationContext->setSourceAndTargetCRSExtentUse( - CoordinateOperationContext::SourceTargetCRSExtentUse::INTERSECTION); - break; + case PJ_CRS_EXTENT_INTERSECTION: + factory_ctx->operationContext->setSourceAndTargetCRSExtentUse( + CoordinateOperationContext::SourceTargetCRSExtentUse:: + INTERSECTION); + break; - case PJ_CRS_EXTENT_SMALLEST: - ctx->operationContext->setSourceAndTargetCRSExtentUse( - CoordinateOperationContext::SourceTargetCRSExtentUse::SMALLEST); - break; + case PJ_CRS_EXTENT_SMALLEST: + factory_ctx->operationContext->setSourceAndTargetCRSExtentUse( + CoordinateOperationContext::SourceTargetCRSExtentUse::SMALLEST); + break; + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); } } @@ -5054,22 +5178,31 @@ void proj_operation_factory_context_set_crs_extent_use( * * The default is PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param criterion patial criterion to use */ void PROJ_DLL proj_operation_factory_context_set_spatial_criterion( - PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_SPATIAL_CRITERION criterion) { - assert(ctx); - switch (criterion) { - case PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT: - ctx->operationContext->setSpatialCriterion( - CoordinateOperationContext::SpatialCriterion::STRICT_CONTAINMENT); - break; + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + PROJ_SPATIAL_CRITERION criterion) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + switch (criterion) { + case PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT: + factory_ctx->operationContext->setSpatialCriterion( + CoordinateOperationContext::SpatialCriterion:: + STRICT_CONTAINMENT); + break; - case PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION: - ctx->operationContext->setSpatialCriterion( - CoordinateOperationContext::SpatialCriterion::PARTIAL_INTERSECTION); - break; + case PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION: + factory_ctx->operationContext->setSpatialCriterion( + CoordinateOperationContext::SpatialCriterion:: + PARTIAL_INTERSECTION); + break; + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); } } @@ -5079,29 +5212,37 @@ void PROJ_DLL proj_operation_factory_context_set_spatial_criterion( * * The default is USE_FOR_SORTING. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param use how grid availability is used. */ void PROJ_DLL proj_operation_factory_context_set_grid_availability_use( - PJ_OPERATION_FACTORY_CONTEXT *ctx, PROJ_GRID_AVAILABILITY_USE use) { - assert(ctx); - switch (use) { - case PROJ_GRID_AVAILABILITY_USED_FOR_SORTING: - ctx->operationContext->setGridAvailabilityUse( - CoordinateOperationContext::GridAvailabilityUse::USE_FOR_SORTING); - break; + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + PROJ_GRID_AVAILABILITY_USE use) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + switch (use) { + case PROJ_GRID_AVAILABILITY_USED_FOR_SORTING: + factory_ctx->operationContext->setGridAvailabilityUse( + CoordinateOperationContext::GridAvailabilityUse:: + USE_FOR_SORTING); + break; - case PROJ_GRID_AVAILABILITY_DISCARD_OPERATION_IF_MISSING_GRID: - ctx->operationContext->setGridAvailabilityUse( - CoordinateOperationContext::GridAvailabilityUse:: - DISCARD_OPERATION_IF_MISSING_GRID); - break; + case PROJ_GRID_AVAILABILITY_DISCARD_OPERATION_IF_MISSING_GRID: + factory_ctx->operationContext->setGridAvailabilityUse( + CoordinateOperationContext::GridAvailabilityUse:: + DISCARD_OPERATION_IF_MISSING_GRID); + break; - case PROJ_GRID_AVAILABILITY_IGNORED: - ctx->operationContext->setGridAvailabilityUse( - CoordinateOperationContext::GridAvailabilityUse:: - IGNORE_GRID_AVAILABILITY); - break; + case PROJ_GRID_AVAILABILITY_IGNORED: + factory_ctx->operationContext->setGridAvailabilityUse( + CoordinateOperationContext::GridAvailabilityUse:: + IGNORE_GRID_AVAILABILITY); + break; + } + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); } } @@ -5112,13 +5253,21 @@ void PROJ_DLL proj_operation_factory_context_set_grid_availability_use( * * The default is true. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param usePROJNames whether PROJ alternative grid names should be used */ void proj_operation_factory_context_set_use_proj_alternative_grid_names( - PJ_OPERATION_FACTORY_CONTEXT *ctx, int usePROJNames) { - assert(ctx); - ctx->operationContext->setUsePROJAlternativeGridNames(usePROJNames != 0); + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, + int usePROJNames) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + factory_ctx->operationContext->setUsePROJAlternativeGridNames( + usePROJNames != 0); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } } // --------------------------------------------------------------------------- @@ -5140,13 +5289,19 @@ void proj_operation_factory_context_set_use_proj_alternative_grid_names( * * The default is true. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param allow whether intermediate CRS may be used. */ void proj_operation_factory_context_set_allow_use_intermediate_crs( - PJ_OPERATION_FACTORY_CONTEXT *ctx, int allow) { - assert(ctx); - ctx->operationContext->setAllowUseIntermediateCRS(allow != 0); + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, int allow) { + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + factory_ctx->operationContext->setAllowUseIntermediateCRS(allow != 0); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); + } } // --------------------------------------------------------------------------- @@ -5154,21 +5309,27 @@ void proj_operation_factory_context_set_allow_use_intermediate_crs( /** \brief Restrict the potential pivot CRSs that can be used when trying to * build a coordinate operation between two CRS that have no direct operation. * - * @param ctx Operation factory context. must not be NULL + * @param ctx PROJ context, or NULL for default context + * @param factory_ctx Operation factory context. must not be NULL * @param list_of_auth_name_codes an array of strings NLL terminated, * with the format { "auth_name1", "code1", "auth_name2", "code2", ... NULL } */ void proj_operation_factory_context_set_allowed_intermediate_crs( - PJ_OPERATION_FACTORY_CONTEXT *ctx, + PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, const char *const *list_of_auth_name_codes) { - assert(ctx); - std::vector> pivots; - for (auto iter = list_of_auth_name_codes; iter && iter[0] && iter[1]; - iter += 2) { - pivots.emplace_back(std::pair( - std::string(iter[0]), std::string(iter[1]))); + SANITIZE_CTX(ctx); + assert(factory_ctx); + try { + std::vector> pivots; + for (auto iter = list_of_auth_name_codes; iter && iter[0] && iter[1]; + iter += 2) { + pivots.emplace_back(std::pair( + std::string(iter[0]), std::string(iter[1]))); + } + factory_ctx->operationContext->setIntermediateCRS(pivots); + } catch (const std::exception &e) { + proj_log_error(ctx, __FUNCTION__, e.what()); } - ctx->operationContext->setIntermediateCRS(pivots); } // --------------------------------------------------------------------------- @@ -5183,6 +5344,7 @@ void proj_operation_factory_context_set_allowed_intermediate_crs( * by increasing accuracy. Operations with unknown accuracy are sorted last, * whatever their area. * + * @param ctx PROJ context, or NULL for default context * @param source_crs source CRS. Must not be NULL. * @param target_crs source CRS. Must not be NULL. * @param operationContext Search context. Must not be NULL. @@ -5190,22 +5352,21 @@ void proj_operation_factory_context_set_allowed_intermediate_crs( * proj_obj_list_unref(), or NULL in case of error. */ PJ_OBJ_LIST *proj_obj_create_operations( - const PJ_OBJ *source_crs, const PJ_OBJ *target_crs, + PJ_CONTEXT *ctx, const PJ_OBJ *source_crs, const PJ_OBJ *target_crs, const PJ_OPERATION_FACTORY_CONTEXT *operationContext) { + SANITIZE_CTX(ctx); assert(source_crs); assert(target_crs); assert(operationContext); auto sourceCRS = nn_dynamic_pointer_cast(source_crs->obj); if (!sourceCRS) { - proj_log_error(operationContext->ctx, __FUNCTION__, - "source_crs is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "source_crs is not a CRS"); return nullptr; } auto targetCRS = nn_dynamic_pointer_cast(target_crs->obj); if (!targetCRS) { - proj_log_error(operationContext->ctx, __FUNCTION__, - "target_crs is not a CRS"); + proj_log_error(ctx, __FUNCTION__, "target_crs is not a CRS"); return nullptr; } @@ -5218,9 +5379,9 @@ PJ_OBJ_LIST *proj_obj_create_operations( for (const auto &op : ops) { objects.emplace_back(op); } - return new PJ_OBJ_LIST(operationContext->ctx, std::move(objects)); + return new PJ_OBJ_LIST(std::move(objects)); } catch (const std::exception &e) { - proj_log_error(operationContext->ctx, __FUNCTION__, e.what()); + proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; } } @@ -5244,19 +5405,22 @@ int proj_obj_list_get_count(const PJ_OBJ_LIST *result) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param result Objet of type PJ_OBJ_LIST (must not be NULL) * @param index Index * @return a new object that must be unreferenced with proj_obj_unref(), * or nullptr in case of error. */ -PJ_OBJ *proj_obj_list_get(const PJ_OBJ_LIST *result, int index) { +PJ_OBJ *proj_obj_list_get(PJ_CONTEXT *ctx, const PJ_OBJ_LIST *result, + int index) { + SANITIZE_CTX(ctx); assert(result); if (index < 0 || index >= proj_obj_list_get_count(result)) { - proj_log_error(result->ctx, __FUNCTION__, "Invalid index"); + proj_log_error(ctx, __FUNCTION__, "Invalid index"); return nullptr; } - return PJ_OBJ::create(result->ctx, result->objects[index]); + return PJ_OBJ::create(result->objects[index]); } // --------------------------------------------------------------------------- @@ -5274,14 +5438,18 @@ void proj_obj_list_unref(PJ_OBJ_LIST *result) { delete result; } /** \brief Return the accuracy (in metre) of a coordinate operation. * + * @param ctx PROJ context, or NULL for default context + * @param coordoperation Coordinate operation. Must not be NULL. * @return the accuracy, or a negative value if unknown or in case of error. */ -double proj_coordoperation_get_accuracy(const PJ_OBJ *coordoperation) { +double proj_coordoperation_get_accuracy(PJ_CONTEXT *ctx, + const PJ_OBJ *coordoperation) { + SANITIZE_CTX(ctx); assert(coordoperation); auto co = dynamic_cast(coordoperation->obj.get()); if (!co) { - proj_log_error(coordoperation->ctx, __FUNCTION__, + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateOperation"); return -1; } @@ -5304,22 +5472,24 @@ double proj_coordoperation_get_accuracy(const PJ_OBJ *coordoperation) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type SingleCRS (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error (or if there is no datum) */ -PJ_OBJ *proj_obj_crs_get_datum(const PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_get_datum(PJ_CONTEXT *ctx, const PJ_OBJ *crs) { + SANITIZE_CTX(ctx); assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { - proj_log_error(crs->ctx, __FUNCTION__, "Object is not a SingleCRS"); + proj_log_error(ctx, __FUNCTION__, "Object is not a SingleCRS"); return nullptr; } const auto &datum = l_crs->datum(); if (!datum) { return nullptr; } - return PJ_OBJ::create(crs->ctx, NN_NO_CHECK(datum)); + return PJ_OBJ::create(NN_NO_CHECK(datum)); } // --------------------------------------------------------------------------- @@ -5330,33 +5500,37 @@ PJ_OBJ *proj_obj_crs_get_datum(const PJ_OBJ *crs) { * use. * It should be used by at most one thread at a time. * + * @param ctx PROJ context, or NULL for default context * @param crs Objet of type SingleCRS (must not be NULL) * @return Object that must be unreferenced with proj_obj_unref(), or NULL * in case of error. */ -PJ_OBJ *proj_obj_crs_get_coordinate_system(const PJ_OBJ *crs) { +PJ_OBJ *proj_obj_crs_get_coordinate_system(PJ_CONTEXT *ctx, const PJ_OBJ *crs) { + SANITIZE_CTX(ctx); assert(crs); auto l_crs = dynamic_cast(crs->obj.get()); if (!l_crs) { - proj_log_error(crs->ctx, __FUNCTION__, "Object is not a SingleCRS"); + proj_log_error(ctx, __FUNCTION__, "Object is not a SingleCRS"); return nullptr; } - return PJ_OBJ::create(crs->ctx, l_crs->coordinateSystem()); + return PJ_OBJ::create(l_crs->coordinateSystem()); } // --------------------------------------------------------------------------- /** \brief Returns the type of the coordinate system. * + * @param ctx PROJ context, or NULL for default context * @param cs Objet of type CoordinateSystem (must not be NULL) * @return type, or PJ_CS_TYPE_UNKNOWN in case of error. */ -PJ_COORDINATE_SYSTEM_TYPE proj_obj_cs_get_type(const PJ_OBJ *cs) { +PJ_COORDINATE_SYSTEM_TYPE proj_obj_cs_get_type(PJ_CONTEXT *ctx, + const PJ_OBJ *cs) { + SANITIZE_CTX(ctx); assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { - proj_log_error(cs->ctx, __FUNCTION__, - "Object is not a CoordinateSystem"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateSystem"); return PJ_CS_TYPE_UNKNOWN; } if (dynamic_cast(l_cs)) { @@ -5393,15 +5567,16 @@ PJ_COORDINATE_SYSTEM_TYPE proj_obj_cs_get_type(const PJ_OBJ *cs) { /** \brief Returns the number of axis of the coordinate system. * + * @param ctx PROJ context, or NULL for default context * @param cs Objet of type CoordinateSystem (must not be NULL) * @return number of axis, or -1 in case of error. */ -int proj_obj_cs_get_axis_count(const PJ_OBJ *cs) { +int proj_obj_cs_get_axis_count(PJ_CONTEXT *ctx, const PJ_OBJ *cs) { + SANITIZE_CTX(ctx); assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { - proj_log_error(cs->ctx, __FUNCTION__, - "Object is not a CoordinateSystem"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateSystem"); return -1; } return static_cast(l_cs->axisList().size()); @@ -5411,6 +5586,7 @@ int proj_obj_cs_get_axis_count(const PJ_OBJ *cs) { /** \brief Returns information on an axis * + * @param ctx PROJ context, or NULL for default context * @param cs Objet of type CoordinateSystem (must not be NULL) * @param index Index of the coordinate system (between 0 and * proj_obj_cs_get_axis_count() - 1) @@ -5425,21 +5601,21 @@ int proj_obj_cs_get_axis_count(const PJ_OBJ *cs) { * unit name. or NULL * @return TRUE in case of success */ -int proj_obj_cs_get_axis_info(const PJ_OBJ *cs, int index, +int proj_obj_cs_get_axis_info(PJ_CONTEXT *ctx, const PJ_OBJ *cs, int index, const char **out_name, const char **out_abbrev, const char **out_direction, double *out_unit_conv_factor, const char **out_unit_name) { + SANITIZE_CTX(ctx); assert(cs); auto l_cs = dynamic_cast(cs->obj.get()); if (!l_cs) { - proj_log_error(cs->ctx, __FUNCTION__, - "Object is not a CoordinateSystem"); + proj_log_error(ctx, __FUNCTION__, "Object is not a CoordinateSystem"); return false; } const auto &axisList = l_cs->axisList(); if (index < 0 || static_cast(index) >= axisList.size()) { - proj_log_error(cs->ctx, __FUNCTION__, "Invalid index"); + proj_log_error(ctx, __FUNCTION__, "Invalid index"); return false; } const auto &axis = axisList[index]; -- cgit v1.2.3 From 2d1deb2da9eab38febb4d4ce92faffa5d25a1e58 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Fri, 30 Nov 2018 02:54:00 +0100 Subject: C API: more camel_casification of parameters --- src/c_api.cpp | 1847 ++++++++++++++++++++++++++++++--------------------------- 1 file changed, 987 insertions(+), 860 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index 5f9ed5c2..c7ba992e 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -1820,31 +1820,33 @@ static UnitOfMeasure createAngularUnit(const char *name, double convFactor) { // --------------------------------------------------------------------------- static GeodeticReferenceFrameNNPtr createGeodeticReferenceFrame( - PJ_CONTEXT *ctx, const char *datumName, const char *ellipsoidName, - double semiMajorMetre, double invFlattening, const char *primeMeridianName, - double primeMeridianOffset, const char *angularUnits, - double angularUnitsConv) { + PJ_CONTEXT *ctx, const char *datum_name, const char *ellps_name, + double semi_major_metre, double inv_flattening, + const char *prime_meridian_name, double prime_meridian_offset, + const char *angular_units, double angular_units_conv) { const UnitOfMeasure angUnit( - createAngularUnit(angularUnits, angularUnitsConv)); + createAngularUnit(angular_units, angular_units_conv)); auto dbContext = getDBcontext(ctx); - auto body = Ellipsoid::guessBodyName(dbContext, semiMajorMetre); - auto ellpsName = createPropertyMapName(ellipsoidName); - auto ellps = - invFlattening != 0.0 - ? Ellipsoid::createFlattenedSphere( - ellpsName, Length(semiMajorMetre), Scale(invFlattening), body) - : Ellipsoid::createSphere(ellpsName, Length(semiMajorMetre), body); + auto body = Ellipsoid::guessBodyName(dbContext, semi_major_metre); + auto ellpsName = createPropertyMapName(ellps_name); + auto ellps = inv_flattening != 0.0 + ? Ellipsoid::createFlattenedSphere( + ellpsName, Length(semi_major_metre), + Scale(inv_flattening), body) + : Ellipsoid::createSphere(ellpsName, + Length(semi_major_metre), body); auto pm = PrimeMeridian::create( - PropertyMap().set(common::IdentifiedObject::NAME_KEY, - primeMeridianName ? primeMeridianName - : primeMeridianOffset == 0.0 - ? (ellps->celestialBody() == - Ellipsoid::EARTH - ? "Greenwich" - : "Reference meridian") - : "unnamed"), - Angle(primeMeridianOffset, angUnit)); - return GeodeticReferenceFrame::create(createPropertyMapName(datumName), + PropertyMap().set( + common::IdentifiedObject::NAME_KEY, + prime_meridian_name + ? prime_meridian_name + : prime_meridian_offset == 0.0 + ? (ellps->celestialBody() == Ellipsoid::EARTH + ? "Greenwich" + : "Reference meridian") + : "unnamed"), + Angle(prime_meridian_offset, angUnit)); + return GeodeticReferenceFrame::create(createPropertyMapName(datum_name), ellps, util::optional(), pm); } @@ -1860,41 +1862,42 @@ static GeodeticReferenceFrameNNPtr createGeodeticReferenceFrame( * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param crsName Name of the GeographicCRS. Or NULL - * @param datumName Name of the GeodeticReferenceFrame. Or NULL - * @param ellipsoidName Name of the Ellipsoid. Or NULL - * @param semiMajorMetre Ellipsoid semi-major axis, in metres. - * @param invFlattening Ellipsoid inverse flattening. Or 0 for a sphere. - * @param primeMeridianName Name of the PrimeMeridian. Or NULL - * @param primeMeridianOffset Offset of the prime meridian, expressed in the + * @param crs_name Name of the GeographicCRS. Or NULL + * @param datum_name Name of the GeodeticReferenceFrame. Or NULL + * @param ellps_name Name of the Ellipsoid. Or NULL + * @param semi_major_metre Ellipsoid semi-major axis, in metres. + * @param inv_flattening Ellipsoid inverse flattening. Or 0 for a sphere. + * @param prime_meridian_name Name of the PrimeMeridian. Or NULL + * @param prime_meridian_offset Offset of the prime meridian, expressed in the * specified angular units. - * @param pmAngularUnits Name of the angular units. Or NULL for Degree - * @param pmAngularUnitsConv Conversion factor from the angular unit to radian. + * @param pm_angular_units Name of the angular units. Or NULL for Degree + * @param pm_angular_units_conv Conversion factor from the angular unit to + * radian. * Or - * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL - * @param ellipsoidalCS Coordinate system. Must not be NULL. + * 0 for Degree if pm_angular_units == NULL. Otherwise should be not NULL + * @param ellipsoidal_cs Coordinate system. Must not be NULL. * * @return Object of type GeographicCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_create_geographic_crs( - PJ_CONTEXT *ctx, const char *crsName, const char *datumName, - const char *ellipsoidName, double semiMajorMetre, double invFlattening, - const char *primeMeridianName, double primeMeridianOffset, - const char *pmAngularUnits, double pmAngularUnitsConv, - PJ_OBJ *ellipsoidalCS) { + PJ_CONTEXT *ctx, const char *crs_name, const char *datum_name, + const char *ellps_name, double semi_major_metre, double inv_flattening, + const char *prime_meridian_name, double prime_meridian_offset, + const char *pm_angular_units, double pm_angular_units_conv, + PJ_OBJ *ellipsoidal_cs) { SANITIZE_CTX(ctx); - auto cs = util::nn_dynamic_pointer_cast(ellipsoidalCS->obj); + auto cs = util::nn_dynamic_pointer_cast(ellipsoidal_cs->obj); if (!cs) { return nullptr; } try { auto datum = createGeodeticReferenceFrame( - ctx, datumName, ellipsoidName, semiMajorMetre, invFlattening, - primeMeridianName, primeMeridianOffset, pmAngularUnits, - pmAngularUnitsConv); - auto geogCRS = GeographicCRS::create(createPropertyMapName(crsName), + ctx, datum_name, ellps_name, semi_major_metre, inv_flattening, + prime_meridian_name, prime_meridian_offset, pm_angular_units, + pm_angular_units_conv); + auto geogCRS = GeographicCRS::create(createPropertyMapName(crs_name), datum, NN_NO_CHECK(cs)); return PJ_OBJ::create(geogCRS); } catch (const std::exception &e) { @@ -1912,17 +1915,17 @@ PJ_OBJ *proj_obj_create_geographic_crs( * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param crsName Name of the GeographicCRS. Or NULL + * @param crs_name Name of the GeographicCRS. Or NULL * @param datum Datum. Must not be NULL. - * @param ellipsoidalCS Coordinate system. Must not be NULL. + * @param ellipsoidal_cs Coordinate system. Must not be NULL. * * @return Object of type GeographicCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_create_geographic_crs_from_datum(PJ_CONTEXT *ctx, - const char *crsName, + const char *crs_name, PJ_OBJ *datum, - PJ_OBJ *ellipsoidalCS) { + PJ_OBJ *ellipsoidal_cs) { SANITIZE_CTX(ctx); auto l_datum = @@ -1932,13 +1935,13 @@ PJ_OBJ *proj_obj_create_geographic_crs_from_datum(PJ_CONTEXT *ctx, "datum is not a GeodeticReferenceFrame"); return nullptr; } - auto cs = util::nn_dynamic_pointer_cast(ellipsoidalCS->obj); + auto cs = util::nn_dynamic_pointer_cast(ellipsoidal_cs->obj); if (!cs) { return nullptr; } try { auto geogCRS = - GeographicCRS::create(createPropertyMapName(crsName), + GeographicCRS::create(createPropertyMapName(crs_name), NN_NO_CHECK(l_datum), NN_NO_CHECK(cs)); return PJ_OBJ::create(geogCRS); } catch (const std::exception &e) { @@ -1956,42 +1959,43 @@ PJ_OBJ *proj_obj_create_geographic_crs_from_datum(PJ_CONTEXT *ctx, * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param crsName Name of the GeographicCRS. Or NULL - * @param datumName Name of the GeodeticReferenceFrame. Or NULL - * @param ellipsoidName Name of the Ellipsoid. Or NULL - * @param semiMajorMetre Ellipsoid semi-major axis, in metres. - * @param invFlattening Ellipsoid inverse flattening. Or 0 for a sphere. - * @param primeMeridianName Name of the PrimeMeridian. Or NULL - * @param primeMeridianOffset Offset of the prime meridian, expressed in the + * @param crs_name Name of the GeographicCRS. Or NULL + * @param datum_name Name of the GeodeticReferenceFrame. Or NULL + * @param ellps_name Name of the Ellipsoid. Or NULL + * @param semi_major_metre Ellipsoid semi-major axis, in metres. + * @param inv_flattening Ellipsoid inverse flattening. Or 0 for a sphere. + * @param prime_meridian_name Name of the PrimeMeridian. Or NULL + * @param prime_meridian_offset Offset of the prime meridian, expressed in the * specified angular units. - * @param angularUnits Name of the angular units. Or NULL for Degree - * @param angularUnitsConv Conversion factor from the angular unit to radian. Or - * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL - * @param linearUnits Name of the linear units. Or NULL for Metre - * @param linearUnitsConv Conversion factor from the linear unit to metre. Or - * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * @param angular_units Name of the angular units. Or NULL for Degree + * @param angular_units_conv Conversion factor from the angular unit to radian. + * Or + * 0 for Degree if angular_units == NULL. Otherwise should be not NULL + * @param linear_units Name of the linear units. Or NULL for Metre + * @param linear_units_conv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linear_units == NULL. Otherwise should be not NULL * * @return Object of type GeodeticCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_create_geocentric_crs( - PJ_CONTEXT *ctx, const char *crsName, const char *datumName, - const char *ellipsoidName, double semiMajorMetre, double invFlattening, - const char *primeMeridianName, double primeMeridianOffset, - const char *angularUnits, double angularUnitsConv, const char *linearUnits, - double linearUnitsConv) { + PJ_CONTEXT *ctx, const char *crs_name, const char *datum_name, + const char *ellps_name, double semi_major_metre, double inv_flattening, + const char *prime_meridian_name, double prime_meridian_offset, + const char *angular_units, double angular_units_conv, + const char *linear_units, double linear_units_conv) { SANITIZE_CTX(ctx); try { const UnitOfMeasure linearUnit( - createLinearUnit(linearUnits, linearUnitsConv)); + createLinearUnit(linear_units, linear_units_conv)); auto datum = createGeodeticReferenceFrame( - ctx, datumName, ellipsoidName, semiMajorMetre, invFlattening, - primeMeridianName, primeMeridianOffset, angularUnits, - angularUnitsConv); + ctx, datum_name, ellps_name, semi_major_metre, inv_flattening, + prime_meridian_name, prime_meridian_offset, angular_units, + angular_units_conv); auto geodCRS = - GeodeticCRS::create(createPropertyMapName(crsName), datum, + GeodeticCRS::create(createPropertyMapName(crs_name), datum, cs::CartesianCS::createGeocentric(linearUnit)); return PJ_OBJ::create(geodCRS); } catch (const std::exception &e) { @@ -2009,24 +2013,24 @@ PJ_OBJ *proj_obj_create_geocentric_crs( * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param crsName Name of the GeographicCRS. Or NULL + * @param crs_name Name of the GeographicCRS. Or NULL * @param datum Datum. Must not be NULL. - * @param linearUnits Name of the linear units. Or NULL for Metre - * @param linearUnitsConv Conversion factor from the linear unit to metre. Or - * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * @param linear_units Name of the linear units. Or NULL for Metre + * @param linear_units_conv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linear_units == NULL. Otherwise should be not NULL * * @return Object of type GeodeticCRS that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(PJ_CONTEXT *ctx, - const char *crsName, + const char *crs_name, const PJ_OBJ *datum, - const char *linearUnits, - double linearUnitsConv) { + const char *linear_units, + double linear_units_conv) { SANITIZE_CTX(ctx); try { const UnitOfMeasure linearUnit( - createLinearUnit(linearUnits, linearUnitsConv)); + createLinearUnit(linear_units, linear_units_conv)); auto l_datum = util::nn_dynamic_pointer_cast(datum->obj); if (!l_datum) { @@ -2035,7 +2039,7 @@ PJ_OBJ *proj_obj_create_geocentric_crs_from_datum(PJ_CONTEXT *ctx, return nullptr; } auto geodCRS = GeodeticCRS::create( - createPropertyMapName(crsName), NN_NO_CHECK(l_datum), + createPropertyMapName(crs_name), NN_NO_CHECK(l_datum), cs::CartesianCS::createGeocentric(linearUnit)); return PJ_OBJ::create(geodCRS); } catch (const std::exception &e) { @@ -2080,10 +2084,10 @@ PJ_OBJ PROJ_DLL *proj_obj_alter_name(PJ_CONTEXT *ctx, const PJ_OBJ *obj, /** \brief Return a copy of the CRS with its geodetic CRS changed * - * Currently, when obj is a GeodeticCRS, it returns a clone of newGeodCRS - * When obj is a ProjectedCRS, it replaces its base CRS with newGeodCRS. + * Currently, when obj is a GeodeticCRS, it returns a clone of new_geod_crs + * When obj is a ProjectedCRS, it replaces its base CRS with new_geod_crs. * When obj is a CompoundCRS, it replaces the GeodeticCRS part of the horizontal - * CRS with newGeodCRS. + * CRS with new_geod_crs. * In other cases, it returns a clone of obj. * * The returned object must be unreferenced with proj_obj_unref() after @@ -2092,18 +2096,18 @@ PJ_OBJ PROJ_DLL *proj_obj_alter_name(PJ_CONTEXT *ctx, const PJ_OBJ *obj, * * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL - * @param newGeodCRS Object of type GeodeticCRS. Must not be NULL + * @param new_geod_crs Object of type GeodeticCRS. Must not be NULL * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_crs_alter_geodetic_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj, - const PJ_OBJ *newGeodCRS) { + const PJ_OBJ *new_geod_crs) { SANITIZE_CTX(ctx); - auto l_newGeodCRS = - util::nn_dynamic_pointer_cast(newGeodCRS->obj); - if (!l_newGeodCRS) { - proj_log_error(ctx, __FUNCTION__, "newGeodCRS is not a GeodeticCRS"); + auto l_new_geod_crs = + util::nn_dynamic_pointer_cast(new_geod_crs->obj); + if (!l_new_geod_crs) { + proj_log_error(ctx, __FUNCTION__, "new_geod_crs is not a GeodeticCRS"); return nullptr; } @@ -2114,7 +2118,8 @@ PJ_OBJ *proj_obj_crs_alter_geodetic_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj, } try { - return PJ_OBJ::create(crs->alterGeodeticCRS(NN_NO_CHECK(l_newGeodCRS))); + return PJ_OBJ::create( + crs->alterGeodeticCRS(NN_NO_CHECK(l_new_geod_crs))); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; @@ -2133,16 +2138,17 @@ PJ_OBJ *proj_obj_crs_alter_geodetic_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj, * * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL - * @param angularUnits Name of the angular units. Or NULL for Degree - * @param angularUnitsConv Conversion factor from the angular unit to radian. Or - * 0 for Degree if angularUnits == NULL. Otherwise should be not NULL + * @param angular_units Name of the angular units. Or NULL for Degree + * @param angular_units_conv Conversion factor from the angular unit to radian. + * Or + * 0 for Degree if angular_units == NULL. Otherwise should be not NULL * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, - const char *angularUnits, - double angularUnitsConv) { + const char *angular_units, + double angular_units_conv) { SANITIZE_CTX(ctx); auto geodCRS = proj_obj_crs_get_geodetic_crs(ctx, obj); @@ -2158,7 +2164,7 @@ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, PJ_OBJ *geogCRSAltered = nullptr; try { const UnitOfMeasure angUnit( - createAngularUnit(angularUnits, angularUnitsConv)); + createAngularUnit(angular_units, angular_units_conv)); geogCRSAltered = PJ_OBJ::create(GeographicCRS::create( createPropertyMapName(proj_obj_get_name(geodCRS)), geogCRS->datum(), geogCRS->datumEnsemble(), @@ -2188,16 +2194,16 @@ PJ_OBJ *proj_obj_crs_alter_cs_angular_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, * * @param ctx PROJ context, or NULL for default context * @param obj Object of type CRS. Must not be NULL - * @param linearUnits Name of the linear units. Or NULL for Metre - * @param linearUnitsConv Conversion factor from the linear unit to metre. Or - * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL + * @param linear_units Name of the linear units. Or NULL for Metre + * @param linear_units_conv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linear_units == NULL. Otherwise should be not NULL * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, - const char *linearUnits, - double linearUnitsConv) { + const char *linear_units, + double linear_units_conv) { SANITIZE_CTX(ctx); auto crs = dynamic_cast(obj->obj.get()); if (!crs) { @@ -2206,7 +2212,7 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, try { const UnitOfMeasure linearUnit( - createLinearUnit(linearUnits, linearUnitsConv)); + createLinearUnit(linear_units, linear_units_conv)); return PJ_OBJ::create(crs->alterCSLinearUnit(linearUnit)); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2227,10 +2233,10 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, * * @param ctx PROJ context, or NULL for default context * @param obj Object of type ProjectedCRS. Must not be NULL - * @param linearUnits Name of the linear units. Or NULL for Metre - * @param linearUnitsConv Conversion factor from the linear unit to metre. Or - * 0 for Metre if linearUnits == NULL. Otherwise should be not NULL - * @param convertToNewUnit TRUE if exisiting values should be converted from + * @param linear_units Name of the linear units. Or NULL for Metre + * @param linear_units_conv Conversion factor from the linear unit to metre. Or + * 0 for Metre if linear_units == NULL. Otherwise should be not NULL + * @param convert_to_new_unit TRUE if exisiting values should be converted from * their current unit to the new unit. If FALSE, their value will be left * unchanged and the unit overriden (so the resulting CRS will not be * equivalent to the original one for reprojection purposes). @@ -2240,9 +2246,9 @@ PJ_OBJ *proj_obj_crs_alter_cs_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, */ PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(PJ_CONTEXT *ctx, const PJ_OBJ *obj, - const char *linearUnits, - double linearUnitsConv, - int convertToNewUnit) { + const char *linear_units, + double linear_units_conv, + int convert_to_new_unit) { SANITIZE_CTX(ctx); auto crs = dynamic_cast(obj->obj.get()); if (!crs) { @@ -2251,9 +2257,9 @@ PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(PJ_CONTEXT *ctx, try { const UnitOfMeasure linearUnit( - createLinearUnit(linearUnits, linearUnitsConv)); + createLinearUnit(linear_units, linear_units_conv)); return PJ_OBJ::create(crs->alterParametersLinearUnit( - linearUnit, convertToNewUnit == TRUE)); + linearUnit, convert_to_new_unit == TRUE)); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); return nullptr; @@ -2269,17 +2275,17 @@ PJ_OBJ *proj_obj_crs_alter_parameters_linear_unit(PJ_CONTEXT *ctx, * It should be used by at most one thread at a time. * * @param ctx PROJ context, or NULL for default context - * @param crsName CRS name. Or NULL. + * @param crs_name CRS name. Or NULL. * * @return Object that must be unreferenced with * proj_obj_unref(), or NULL in case of error. */ PJ_OBJ PROJ_DLL *proj_obj_create_engineering_crs(PJ_CONTEXT *ctx, - const char *crsName) { + const char *crs_name) { SANITIZE_CTX(ctx); try { return PJ_OBJ::create(EngineeringCRS::create( - createPropertyMapName(crsName), + createPropertyMapName(crs_name), EngineeringDatum::create(PropertyMap()), CartesianCS::createEastingNorthing(UnitOfMeasure::METRE))); } catch (const std::exception &e) { @@ -2684,7 +2690,8 @@ static PJ_OBJ *proj_obj_create_conversion(const ConversionNNPtr &conv) { * * See osgeo::proj::operation::Conversion::createUTM(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_utm(PJ_CONTEXT *ctx, int zone, int north) { SANITIZE_CTX(ctx); @@ -2703,25 +2710,26 @@ PJ_OBJ *proj_obj_create_conversion_utm(PJ_CONTEXT *ctx, int zone, int north) { * * See osgeo::proj::operation::Conversion::createTransverseMercator(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_transverse_mercator( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createTransverseMercator( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2736,25 +2744,26 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator( * See * osgeo::proj::operation::Conversion::createGaussSchreiberTransverseMercator(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_gauss_schreiber_transverse_mercator( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGaussSchreiberTransverseMercator( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2769,25 +2778,26 @@ PJ_OBJ *proj_obj_create_conversion_gauss_schreiber_transverse_mercator( * See * osgeo::proj::operation::Conversion::createTransverseMercatorSouthOriented(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_transverse_mercator_south_oriented( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createTransverseMercatorSouthOriented( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2801,27 +2811,29 @@ PJ_OBJ *proj_obj_create_conversion_transverse_mercator_south_oriented( * * See osgeo::proj::operation::Conversion::createTwoPointEquidistant(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_two_point_equidistant( - PJ_CONTEXT *ctx, double latitudeFirstPoint, double longitudeFirstPoint, - double latitudeSecondPoint, double longitudeSeconPoint, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_point, double longitude_first_point, + double latitude_second_point, double longitude_secon_point, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createTwoPointEquidistant( - PropertyMap(), Angle(latitudeFirstPoint, angUnit), - Angle(longitudeFirstPoint, angUnit), - Angle(latitudeSecondPoint, angUnit), - Angle(longitudeSeconPoint, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_point, angUnit), + Angle(longitude_first_point, angUnit), + Angle(latitude_second_point, angUnit), + Angle(longitude_secon_point, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2835,23 +2847,25 @@ PJ_OBJ *proj_obj_create_conversion_two_point_equidistant( * * See osgeo::proj::operation::Conversion::createTunisiaMappingGrid(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_tunisia_mapping_grid( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createTunisiaMappingGrid( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2865,28 +2879,30 @@ PJ_OBJ *proj_obj_create_conversion_tunisia_mapping_grid( * * See osgeo::proj::operation::Conversion::createAlbersEqualArea(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_albers_equal_area( - PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, - double latitudeFirstParallel, double latitudeSecondParallel, - double eastingFalseOrigin, double northingFalseOrigin, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_false_origin, + double longitude_false_origin, double latitude_first_parallel, + double latitude_second_parallel, double easting_false_origin, + double northing_false_origin, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createAlbersEqualArea( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); + PropertyMap(), Angle(latitude_false_origin, angUnit), + Angle(longitude_false_origin, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(easting_false_origin, linearUnit), + Length(northing_false_origin, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2900,25 +2916,26 @@ PJ_OBJ *proj_obj_create_conversion_albers_equal_area( * * See osgeo::proj::operation::Conversion::createLambertConicConformal_1SP(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_1sp( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertConicConformal_1SP( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2932,28 +2949,30 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_1sp( * * See osgeo::proj::operation::Conversion::createLambertConicConformal_2SP(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp( - PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, - double latitudeFirstParallel, double latitudeSecondParallel, - double eastingFalseOrigin, double northingFalseOrigin, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_false_origin, + double longitude_false_origin, double latitude_first_parallel, + double latitude_second_parallel, double easting_false_origin, + double northing_false_origin, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertConicConformal_2SP( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); + PropertyMap(), Angle(latitude_false_origin, angUnit), + Angle(longitude_false_origin, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(easting_false_origin, linearUnit), + Length(northing_false_origin, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -2968,30 +2987,31 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp( * See * osgeo::proj::operation::Conversion::createLambertConicConformal_2SP_Michigan(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_michigan( - PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, - double latitudeFirstParallel, double latitudeSecondParallel, - double eastingFalseOrigin, double northingFalseOrigin, - double ellipsoidScalingFactor, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_false_origin, + double longitude_false_origin, double latitude_first_parallel, + double latitude_second_parallel, double easting_false_origin, + double northing_false_origin, double ellipsoid_scaling_factor, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertConicConformal_2SP_Michigan( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit), - Scale(ellipsoidScalingFactor)); + PropertyMap(), Angle(latitude_false_origin, angUnit), + Angle(longitude_false_origin, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(easting_false_origin, linearUnit), + Length(northing_false_origin, linearUnit), + Scale(ellipsoid_scaling_factor)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3006,28 +3026,30 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_michigan( * See * osgeo::proj::operation::Conversion::createLambertConicConformal_2SP_Belgium(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_belgium( - PJ_CONTEXT *ctx, double latitudeFalseOrigin, double longitudeFalseOrigin, - double latitudeFirstParallel, double latitudeSecondParallel, - double eastingFalseOrigin, double northingFalseOrigin, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_false_origin, + double longitude_false_origin, double latitude_first_parallel, + double latitude_second_parallel, double easting_false_origin, + double northing_false_origin, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertConicConformal_2SP_Belgium( - PropertyMap(), Angle(latitudeFalseOrigin, angUnit), - Angle(longitudeFalseOrigin, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(eastingFalseOrigin, linearUnit), - Length(northingFalseOrigin, linearUnit)); + PropertyMap(), Angle(latitude_false_origin, angUnit), + Angle(longitude_false_origin, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(easting_false_origin, linearUnit), + Length(northing_false_origin, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3041,25 +3063,26 @@ PJ_OBJ *proj_obj_create_conversion_lambert_conic_conformal_2sp_belgium( * * See osgeo::proj::operation::Conversion::createAzimuthalEquidistant(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_azimuthal_equidistant( - PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_nat_origin, double longitude_nat_origin, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createAzimuthalEquidistant( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_nat_origin, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3073,25 +3096,26 @@ PJ_OBJ *proj_obj_create_conversion_azimuthal_equidistant( * * See osgeo::proj::operation::Conversion::createGuamProjection(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_guam_projection( - PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_nat_origin, double longitude_nat_origin, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGuamProjection( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_nat_origin, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3105,25 +3129,26 @@ PJ_OBJ *proj_obj_create_conversion_guam_projection( * * See osgeo::proj::operation::Conversion::createBonne(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_bonne( - PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_nat_origin, double longitude_nat_origin, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = Conversion::createBonne(PropertyMap(), - Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); + auto conv = Conversion::createBonne( + PropertyMap(), Angle(latitude_nat_origin, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3138,25 +3163,26 @@ PJ_OBJ *proj_obj_create_conversion_bonne( * See * osgeo::proj::operation::Conversion::createLambertCylindricalEqualAreaSpherical(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area_spherical( - PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_parallel, + double longitude_nat_origin, double false_easting, double false_northing, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertCylindricalEqualAreaSpherical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_parallel, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3170,25 +3196,26 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area_spherical( * * See osgeo::proj::operation::Conversion::createLambertCylindricalEqualArea(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area( - PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_parallel, + double longitude_nat_origin, double false_easting, double false_northing, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertCylindricalEqualArea( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_parallel, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3202,23 +3229,25 @@ PJ_OBJ *proj_obj_create_conversion_lambert_cylindrical_equal_area( * * See osgeo::proj::operation::Conversion::createCassiniSoldner(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_cassini_soldner( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createCassiniSoldner( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3232,27 +3261,29 @@ PJ_OBJ *proj_obj_create_conversion_cassini_soldner( * * See osgeo::proj::operation::Conversion::createEquidistantConic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_equidistant_conic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, - double latitudeFirstParallel, double latitudeSecondParallel, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double latitude_first_parallel, double latitude_second_parallel, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEquidistantConic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3266,23 +3297,27 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_conic( * * See osgeo::proj::operation::Conversion::createEckertI(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_eckert_i( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_eckert_i(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = - Conversion::createEckertI(PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); + auto conv = Conversion::createEckertI( + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3296,23 +3331,25 @@ PJ_OBJ *proj_obj_create_conversion_eckert_i( * * See osgeo::proj::operation::Conversion::createEckertII(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_eckert_ii( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEckertII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3326,23 +3363,25 @@ PJ_OBJ *proj_obj_create_conversion_eckert_ii( * * See osgeo::proj::operation::Conversion::createEckertIII(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_eckert_iii( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEckertIII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3356,23 +3395,25 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iii( * * See osgeo::proj::operation::Conversion::createEckertIV(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_eckert_iv( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEckertIV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3386,23 +3427,27 @@ PJ_OBJ *proj_obj_create_conversion_eckert_iv( * * See osgeo::proj::operation::Conversion::createEckertV(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_eckert_v( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_eckert_v(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = - Conversion::createEckertV(PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); + auto conv = Conversion::createEckertV( + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3416,23 +3461,25 @@ PJ_OBJ *proj_obj_create_conversion_eckert_v( * * See osgeo::proj::operation::Conversion::createEckertVI(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_eckert_vi( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEckertVI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3446,25 +3493,26 @@ PJ_OBJ *proj_obj_create_conversion_eckert_vi( * * See osgeo::proj::operation::Conversion::createEquidistantCylindrical(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical( - PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_parallel, + double longitude_nat_origin, double false_easting, double false_northing, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEquidistantCylindrical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_parallel, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3479,25 +3527,26 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical( * See * osgeo::proj::operation::Conversion::createEquidistantCylindricalSpherical(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical_spherical( - PJ_CONTEXT *ctx, double latitudeFirstParallel, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_parallel, + double longitude_nat_origin, double false_easting, double false_northing, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEquidistantCylindricalSpherical( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_parallel, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3511,23 +3560,27 @@ PJ_OBJ *proj_obj_create_conversion_equidistant_cylindrical_spherical( * * See osgeo::proj::operation::Conversion::createGall(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_gall( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_gall(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = - Conversion::createGall(PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + Conversion::createGall(PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3541,23 +3594,25 @@ PJ_OBJ *proj_obj_create_conversion_gall( * * See osgeo::proj::operation::Conversion::createGoodeHomolosine(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_goode_homolosine( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGoodeHomolosine( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3571,23 +3626,25 @@ PJ_OBJ *proj_obj_create_conversion_goode_homolosine( * * See osgeo::proj::operation::Conversion::createInterruptedGoodeHomolosine(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_interrupted_goode_homolosine( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createInterruptedGoodeHomolosine( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3602,23 +3659,25 @@ PJ_OBJ *proj_obj_create_conversion_interrupted_goode_homolosine( * * See osgeo::proj::operation::Conversion::createGeostationarySatelliteSweepX(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_x( - PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double height, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGeostationarySatelliteSweepX( - PropertyMap(), Angle(centerLong, angUnit), - Length(height, linearUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(height, linearUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3633,23 +3692,25 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_x( * * See osgeo::proj::operation::Conversion::createGeostationarySatelliteSweepY(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_y( - PJ_CONTEXT *ctx, double centerLong, double height, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double height, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGeostationarySatelliteSweepY( - PropertyMap(), Angle(centerLong, angUnit), - Length(height, linearUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(height, linearUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3663,23 +3724,25 @@ PJ_OBJ *proj_obj_create_conversion_geostationary_satellite_sweep_y( * * See osgeo::proj::operation::Conversion::createGnomonic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_gnomonic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createGnomonic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3694,28 +3757,30 @@ PJ_OBJ *proj_obj_create_conversion_gnomonic( * See * osgeo::proj::operation::Conversion::createHotineObliqueMercatorVariantA(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_a( - PJ_CONTEXT *ctx, double latitudeProjectionCentre, - double longitudeProjectionCentre, double azimuthInitialLine, - double angleFromRectifiedToSkrewGrid, double scale, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_projection_centre, + double longitude_projection_centre, double azimuth_initial_line, + double angle_from_rectified_to_skrew_grid, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createHotineObliqueMercatorVariantA( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeProjectionCentre, angUnit), - Angle(azimuthInitialLine, angUnit), - Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_projection_centre, angUnit), + Angle(longitude_projection_centre, angUnit), + Angle(azimuth_initial_line, angUnit), + Angle(angle_from_rectified_to_skrew_grid, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3730,29 +3795,30 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_a( * See * osgeo::proj::operation::Conversion::createHotineObliqueMercatorVariantB(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_b( - PJ_CONTEXT *ctx, double latitudeProjectionCentre, - double longitudeProjectionCentre, double azimuthInitialLine, - double angleFromRectifiedToSkrewGrid, double scale, - double eastingProjectionCentre, double northingProjectionCentre, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_projection_centre, + double longitude_projection_centre, double azimuth_initial_line, + double angle_from_rectified_to_skrew_grid, double scale, + double easting_projection_centre, double northing_projection_centre, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createHotineObliqueMercatorVariantB( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeProjectionCentre, angUnit), - Angle(azimuthInitialLine, angUnit), - Angle(angleFromRectifiedToSkrewGrid, angUnit), Scale(scale), - Length(eastingProjectionCentre, linearUnit), - Length(northingProjectionCentre, linearUnit)); + PropertyMap(), Angle(latitude_projection_centre, angUnit), + Angle(longitude_projection_centre, angUnit), + Angle(azimuth_initial_line, angUnit), + Angle(angle_from_rectified_to_skrew_grid, angUnit), Scale(scale), + Length(easting_projection_centre, linearUnit), + Length(northing_projection_centre, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3767,30 +3833,33 @@ PJ_OBJ *proj_obj_create_conversion_hotine_oblique_mercator_variant_b( * See * osgeo::proj::operation::Conversion::createHotineObliqueMercatorTwoPointNaturalOrigin(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ * proj_obj_create_conversion_hotine_oblique_mercator_two_point_natural_origin( - PJ_CONTEXT *ctx, double latitudeProjectionCentre, double latitudePoint1, - double longitudePoint1, double latitudePoint2, double longitudePoint2, - double scale, double eastingProjectionCentre, - double northingProjectionCentre, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_projection_centre, double latitude_point1, + double longitude_point1, double latitude_point2, double longitude_point2, + double scale, double easting_projection_centre, + double northing_projection_centre, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createHotineObliqueMercatorTwoPointNaturalOrigin( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(latitudePoint1, angUnit), Angle(longitudePoint1, angUnit), - Angle(latitudePoint2, angUnit), Angle(longitudePoint2, angUnit), - Scale(scale), Length(eastingProjectionCentre, linearUnit), - Length(northingProjectionCentre, linearUnit)); + PropertyMap(), Angle(latitude_projection_centre, angUnit), + Angle(latitude_point1, angUnit), + Angle(longitude_point1, angUnit), + Angle(latitude_point2, angUnit), + Angle(longitude_point2, angUnit), Scale(scale), + Length(easting_projection_centre, linearUnit), + Length(northing_projection_centre, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3805,26 +3874,28 @@ proj_obj_create_conversion_hotine_oblique_mercator_two_point_natural_origin( * See * osgeo::proj::operation::Conversion::createInternationalMapWorldPolyconic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_international_map_world_polyconic( - PJ_CONTEXT *ctx, double centerLong, double latitudeFirstParallel, - double latitudeSecondParallel, double falseEasting, double falseNorthing, - const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double latitude_first_parallel, + double latitude_second_parallel, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createInternationalMapWorldPolyconic( - PropertyMap(), Angle(centerLong, angUnit), - Angle(latitudeFirstParallel, angUnit), - Angle(latitudeSecondParallel, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Angle(latitude_first_parallel, angUnit), + Angle(latitude_second_parallel, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3838,29 +3909,32 @@ PJ_OBJ *proj_obj_create_conversion_international_map_world_polyconic( * * See osgeo::proj::operation::Conversion::createKrovakNorthOriented(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_krovak_north_oriented( - PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeOfOrigin, - double colatitudeConeAxis, double latitudePseudoStandardParallel, - double scaleFactorPseudoStandardParallel, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_projection_centre, + double longitude_of_origin, double colatitude_cone_axis, + double latitude_pseudo_standard_parallel, + double scale_factor_pseudo_standard_parallel, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createKrovakNorthOriented( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeOfOrigin, angUnit), - Angle(colatitudeConeAxis, angUnit), - Angle(latitudePseudoStandardParallel, angUnit), - Scale(scaleFactorPseudoStandardParallel), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_projection_centre, angUnit), + Angle(longitude_of_origin, angUnit), + Angle(colatitude_cone_axis, angUnit), + Angle(latitude_pseudo_standard_parallel, angUnit), + Scale(scale_factor_pseudo_standard_parallel), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3874,29 +3948,32 @@ PJ_OBJ *proj_obj_create_conversion_krovak_north_oriented( * * See osgeo::proj::operation::Conversion::createKrovak(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_krovak( - PJ_CONTEXT *ctx, double latitudeProjectionCentre, double longitudeOfOrigin, - double colatitudeConeAxis, double latitudePseudoStandardParallel, - double scaleFactorPseudoStandardParallel, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_projection_centre, + double longitude_of_origin, double colatitude_cone_axis, + double latitude_pseudo_standard_parallel, + double scale_factor_pseudo_standard_parallel, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createKrovak( - PropertyMap(), Angle(latitudeProjectionCentre, angUnit), - Angle(longitudeOfOrigin, angUnit), - Angle(colatitudeConeAxis, angUnit), - Angle(latitudePseudoStandardParallel, angUnit), - Scale(scaleFactorPseudoStandardParallel), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_projection_centre, angUnit), + Angle(longitude_of_origin, angUnit), + Angle(colatitude_cone_axis, angUnit), + Angle(latitude_pseudo_standard_parallel, angUnit), + Scale(scale_factor_pseudo_standard_parallel), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3910,25 +3987,26 @@ PJ_OBJ *proj_obj_create_conversion_krovak( * * See osgeo::proj::operation::Conversion::createLambertAzimuthalEqualArea(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_lambert_azimuthal_equal_area( - PJ_CONTEXT *ctx, double latitudeNatOrigin, double longitudeNatOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_nat_origin, double longitude_nat_origin, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createLambertAzimuthalEqualArea( - PropertyMap(), Angle(latitudeNatOrigin, angUnit), - Angle(longitudeNatOrigin, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_nat_origin, angUnit), + Angle(longitude_nat_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3942,23 +4020,25 @@ PJ_OBJ *proj_obj_create_conversion_lambert_azimuthal_equal_area( * * See osgeo::proj::operation::Conversion::createMillerCylindrical(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_miller_cylindrical( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createMillerCylindrical( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -3972,25 +4052,26 @@ PJ_OBJ *proj_obj_create_conversion_miller_cylindrical( * * See osgeo::proj::operation::Conversion::createMercatorVariantA(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_mercator_variant_a( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createMercatorVariantA( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4004,24 +4085,25 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_a( * * See osgeo::proj::operation::Conversion::createMercatorVariantB(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_mercator_variant_b( - PJ_CONTEXT *ctx, double latitudeFirstParallel, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_first_parallel, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createMercatorVariantB( - PropertyMap(), Angle(latitudeFirstParallel, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_first_parallel, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4036,23 +4118,25 @@ PJ_OBJ *proj_obj_create_conversion_mercator_variant_b( * See * osgeo::proj::operation::Conversion::createPopularVisualisationPseudoMercator(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_popular_visualisation_pseudo_mercator( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createPopularVisualisationPseudoMercator( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4066,23 +4150,25 @@ PJ_OBJ *proj_obj_create_conversion_popular_visualisation_pseudo_mercator( * * See osgeo::proj::operation::Conversion::createMollweide(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_mollweide( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createMollweide( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4096,23 +4182,25 @@ PJ_OBJ *proj_obj_create_conversion_mollweide( * * See osgeo::proj::operation::Conversion::createNewZealandMappingGrid(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_new_zealand_mapping_grid( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createNewZealandMappingGrid( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4126,25 +4214,26 @@ PJ_OBJ *proj_obj_create_conversion_new_zealand_mapping_grid( * * See osgeo::proj::operation::Conversion::createObliqueStereographic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_oblique_stereographic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createObliqueStereographic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4158,23 +4247,25 @@ PJ_OBJ *proj_obj_create_conversion_oblique_stereographic( * * See osgeo::proj::operation::Conversion::createOrthographic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_orthographic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createOrthographic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4188,23 +4279,25 @@ PJ_OBJ *proj_obj_create_conversion_orthographic( * * See osgeo::proj::operation::Conversion::createAmericanPolyconic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_american_polyconic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createAmericanPolyconic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4218,25 +4311,26 @@ PJ_OBJ *proj_obj_create_conversion_american_polyconic( * * See osgeo::proj::operation::Conversion::createPolarStereographicVariantA(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_a( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createPolarStereographicVariantA( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4250,24 +4344,26 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_a( * * See osgeo::proj::operation::Conversion::createPolarStereographicVariantB(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_b( - PJ_CONTEXT *ctx, double latitudeStandardParallel, double longitudeOfOrigin, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_standard_parallel, + double longitude_of_origin, double false_easting, double false_northing, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createPolarStereographicVariantB( - PropertyMap(), Angle(latitudeStandardParallel, angUnit), - Angle(longitudeOfOrigin, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_standard_parallel, angUnit), + Angle(longitude_of_origin, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4281,23 +4377,27 @@ PJ_OBJ *proj_obj_create_conversion_polar_stereographic_variant_b( * * See osgeo::proj::operation::Conversion::createRobinson(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_robinson( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_robinson(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createRobinson( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4311,23 +4411,25 @@ PJ_OBJ *proj_obj_create_conversion_robinson( * * See osgeo::proj::operation::Conversion::createSinusoidal(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_sinusoidal( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createSinusoidal( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4341,25 +4443,26 @@ PJ_OBJ *proj_obj_create_conversion_sinusoidal( * * See osgeo::proj::operation::Conversion::createStereographic(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_stereographic( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double scale, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, double scale, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createStereographic( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Scale(scale), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Scale(scale), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4373,23 +4476,25 @@ PJ_OBJ *proj_obj_create_conversion_stereographic( * * See osgeo::proj::operation::Conversion::createVanDerGrinten(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_van_der_grinten( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createVanDerGrinten( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4403,23 +4508,27 @@ PJ_OBJ *proj_obj_create_conversion_van_der_grinten( * * See osgeo::proj::operation::Conversion::createWagnerI(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_wagner_i( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_wagner_i(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = - Conversion::createWagnerI(PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); + auto conv = Conversion::createWagnerI( + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4433,23 +4542,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_i( * * See osgeo::proj::operation::Conversion::createWagnerII(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_wagner_ii( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createWagnerII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4463,24 +4574,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_ii( * * See osgeo::proj::operation::Conversion::createWagnerIII(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_wagner_iii( - PJ_CONTEXT *ctx, double latitudeTrueScale, double centerLong, - double falseEasting, double falseNorthing, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double latitude_true_scale, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createWagnerIII( - PropertyMap(), Angle(latitudeTrueScale, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(latitude_true_scale, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4494,23 +4606,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iii( * * See osgeo::proj::operation::Conversion::createWagnerIV(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_wagner_iv( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createWagnerIV( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4524,23 +4638,27 @@ PJ_OBJ *proj_obj_create_conversion_wagner_iv( * * See osgeo::proj::operation::Conversion::createWagnerV(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). - */ -PJ_OBJ *proj_obj_create_conversion_wagner_v( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). + */ +PJ_OBJ *proj_obj_create_conversion_wagner_v(PJ_CONTEXT *ctx, double center_long, + double false_easting, + double false_northing, + const char *ang_unit_name, + double ang_unit_conv_factor, + const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); - auto conv = - Conversion::createWagnerV(PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); + auto conv = Conversion::createWagnerV( + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4554,23 +4672,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_v( * * See osgeo::proj::operation::Conversion::createWagnerVI(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_wagner_vi( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createWagnerVI( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4584,23 +4704,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vi( * * See osgeo::proj::operation::Conversion::createWagnerVII(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_wagner_vii( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createWagnerVII( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4615,23 +4737,25 @@ PJ_OBJ *proj_obj_create_conversion_wagner_vii( * See * osgeo::proj::operation::Conversion::createQuadrilateralizedSphericalCube(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_quadrilateralized_spherical_cube( - PJ_CONTEXT *ctx, double centerLat, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_lat, double center_long, + double false_easting, double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createQuadrilateralizedSphericalCube( - PropertyMap(), Angle(centerLat, angUnit), - Angle(centerLong, angUnit), Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_lat, angUnit), + Angle(center_long, angUnit), Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4645,24 +4769,25 @@ PJ_OBJ *proj_obj_create_conversion_quadrilateralized_spherical_cube( * * See osgeo::proj::operation::Conversion::createSphericalCrossTrackHeight(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_spherical_cross_track_height( - PJ_CONTEXT *ctx, double pegPointLat, double pegPointLong, - double pegPointHeading, double pegPointHeight, const char *angUnitName, - double angUnitConvFactor, const char *linearUnitName, - double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double peg_point_lat, double peg_point_long, + double peg_point_heading, double peg_point_height, + const char *ang_unit_name, double ang_unit_conv_factor, + const char *linear_unit_name, double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createSphericalCrossTrackHeight( - PropertyMap(), Angle(pegPointLat, angUnit), - Angle(pegPointLong, angUnit), Angle(pegPointHeading, angUnit), - Length(pegPointHeight, linearUnit)); + PropertyMap(), Angle(peg_point_lat, angUnit), + Angle(peg_point_long, angUnit), Angle(peg_point_heading, angUnit), + Length(peg_point_height, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); @@ -4676,23 +4801,25 @@ PJ_OBJ *proj_obj_create_conversion_spherical_cross_track_height( * * See osgeo::proj::operation::Conversion::createEqualEarth(). * - * Linear parameters are expressed in (linearUnitName, linearUnitConvFactor). - * Angular parameters are expressed in (angUnitName, angUnitConvFactor). + * Linear parameters are expressed in (linear_unit_name, + * linear_unit_conv_factor). + * Angular parameters are expressed in (ang_unit_name, ang_unit_conv_factor). */ PJ_OBJ *proj_obj_create_conversion_equal_earth( - PJ_CONTEXT *ctx, double centerLong, double falseEasting, - double falseNorthing, const char *angUnitName, double angUnitConvFactor, - const char *linearUnitName, double linearUnitConvFactor) { + PJ_CONTEXT *ctx, double center_long, double false_easting, + double false_northing, const char *ang_unit_name, + double ang_unit_conv_factor, const char *linear_unit_name, + double linear_unit_conv_factor) { SANITIZE_CTX(ctx); try { UnitOfMeasure linearUnit( - createLinearUnit(linearUnitName, linearUnitConvFactor)); + createLinearUnit(linear_unit_name, linear_unit_conv_factor)); UnitOfMeasure angUnit( - createAngularUnit(angUnitName, angUnitConvFactor)); + createAngularUnit(ang_unit_name, ang_unit_conv_factor)); auto conv = Conversion::createEqualEarth( - PropertyMap(), Angle(centerLong, angUnit), - Length(falseEasting, linearUnit), - Length(falseNorthing, linearUnit)); + PropertyMap(), Angle(center_long, angUnit), + Length(false_easting, linearUnit), + Length(false_northing, linearUnit)); return proj_obj_create_conversion(conv); } catch (const std::exception &e) { proj_log_error(ctx, __FUNCTION__, e.what()); -- cgit v1.2.3 From b6a5c445e202e61c64b0986679a6e0a83724c322 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Fri, 30 Nov 2018 16:15:36 +0100 Subject: API: move all advanced PJ_OBJ creation functions in a dedicated proj_experimental.h header --- src/c_api.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index c7ba992e..a0dbecc2 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -52,6 +52,7 @@ // clang-format off #include "proj_internal.h" #include "proj.h" +#include "proj_experimental.h" #include "projects.h" // clang-format on -- cgit v1.2.3 From 9d19d5578705e06990fb716adcb9e6a1529424aa Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Fri, 30 Nov 2018 18:37:12 +0100 Subject: importFromWKT: morph GDAL_WKT1 datum names into their EPSG spelling --- src/c_api.cpp | 48 +++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 41 insertions(+), 7 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index a0dbecc2..30365297 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -409,8 +409,13 @@ PJ_OBJ *proj_obj_create_from_wkt(PJ_CONTEXT *ctx, const char *wkt, assert(wkt); (void)options; try { + WKTParser parser; + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); + if (dbContext) { + parser.attachDatabaseContext(NN_NO_CHECK(dbContext)); + } auto identifiedObject = nn_dynamic_pointer_cast( - WKTParser().createFromWKT(wkt)); + parser.createFromWKT(wkt)); if (identifiedObject) { return PJ_OBJ::create(NN_NO_CHECK(identifiedObject)); } @@ -442,8 +447,13 @@ PJ_OBJ *proj_obj_create_from_proj_string(PJ_CONTEXT *ctx, (void)options; assert(proj_string); try { + PROJStringParser parser; + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); + if (dbContext) { + parser.attachDatabaseContext(NN_NO_CHECK(dbContext)); + } auto identifiedObject = nn_dynamic_pointer_cast( - PROJStringParser().createFromPROJString(proj_string)); + parser.createFromPROJString(proj_string)); if (identifiedObject) { return PJ_OBJ::create(NN_NO_CHECK(identifiedObject)); } @@ -961,7 +971,8 @@ const char *proj_obj_as_wkt(PJ_CONTEXT *ctx, const PJ_OBJ *obj, const WKTFormatter::Convention convention = static_cast(type); try { - auto formatter = WKTFormatter::create(convention); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); + auto formatter = WKTFormatter::create(convention, dbContext); for (auto iter = options; iter && iter[0]; ++iter) { const char *value; if ((value = getOptionValue(*iter, "MULTILINE="))) { @@ -1827,7 +1838,7 @@ static GeodeticReferenceFrameNNPtr createGeodeticReferenceFrame( const char *angular_units, double angular_units_conv) { const UnitOfMeasure angUnit( createAngularUnit(angular_units, angular_units_conv)); - auto dbContext = getDBcontext(ctx); + auto dbContext = getDBcontextNoException(ctx, __FUNCTION__); auto body = Ellipsoid::guessBodyName(dbContext, semi_major_metre); auto ellpsName = createPropertyMapName(ellps_name); auto ellps = inv_flattening != 0.0 @@ -1847,9 +1858,32 @@ static GeodeticReferenceFrameNNPtr createGeodeticReferenceFrame( : "Reference meridian") : "unnamed"), Angle(prime_meridian_offset, angUnit)); - return GeodeticReferenceFrame::create(createPropertyMapName(datum_name), - ellps, util::optional(), - pm); + + std::string datumName(datum_name ? datum_name : "unnamed"); + if (datumName == "WGS_1984") { + datumName = GeodeticReferenceFrame::EPSG_6326->nameStr(); + } else if (datumName.find('_') != std::string::npos) { + // Likely coming from WKT1 + if (dbContext) { + auto authFactory = + AuthorityFactory::create(NN_NO_CHECK(dbContext), std::string()); + auto res = authFactory->createObjectsFromName( + datumName, + {AuthorityFactory::ObjectType::GEODETIC_REFERENCE_FRAME}, true, + 1); + if (!res.empty()) { + const auto &refDatum = res.front(); + if (metadata::Identifier::isEquivalentName( + datumName.c_str(), refDatum->nameStr().c_str())) { + datumName = refDatum->nameStr(); + } + } + } + } + + return GeodeticReferenceFrame::create( + createPropertyMapName(datumName.c_str()), ellps, + util::optional(), pm); } //! @endcond -- cgit v1.2.3 From ccae82ec36d9c5177e3fd24d8d04a1d4c5f7e1ab Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Sat, 1 Dec 2018 23:20:33 +0100 Subject: C API: rename parameter to reflect its output status --- src/c_api.cpp | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) (limited to 'src/c_api.cpp') diff --git a/src/c_api.cpp b/src/c_api.cpp index 30365297..7a991765 100644 --- a/src/c_api.cpp +++ b/src/c_api.cpp @@ -1596,8 +1596,8 @@ PJ_OBJ *proj_obj_get_target_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { * @param obj Object of type CRS. Must not be NULL * @param auth_name Authority name, or NULL for all authorities * @param options Placeholder for future options. Should be set to NULL. - * @param confidence Output parameter. Pointer to an array of integers that will - * be allocated by the function and filled with the confidence values + * @param out_confidence Output parameter. Pointer to an array of integers that + * will be allocated by the function and filled with the confidence values * (0-100). There are as many elements in this array as * proj_obj_list_get_count() * returns on the return value of this function. *confidence should be @@ -1606,12 +1606,13 @@ PJ_OBJ *proj_obj_get_target_crs(PJ_CONTEXT *ctx, const PJ_OBJ *obj) { */ PJ_OBJ_LIST *proj_obj_identify(PJ_CONTEXT *ctx, const PJ_OBJ *obj, const char *auth_name, - const char *const *options, int **confidence) { + const char *const *options, + int **out_confidence) { SANITIZE_CTX(ctx); assert(obj); (void)options; - if (confidence) { - *confidence = nullptr; + if (out_confidence) { + *out_confidence = nullptr; } auto ptr = obj->obj.get(); auto crs = dynamic_cast(ptr); @@ -1624,7 +1625,7 @@ PJ_OBJ_LIST *proj_obj_identify(PJ_CONTEXT *ctx, const PJ_OBJ *obj, auth_name ? auth_name : ""); auto res = crs->identify(factory); std::vector objects; - confidenceTemp = confidence ? new int[res.size()] : nullptr; + confidenceTemp = out_confidence ? new int[res.size()] : nullptr; size_t i = 0; for (const auto &pair : res) { objects.push_back(pair.first); @@ -1634,8 +1635,8 @@ PJ_OBJ_LIST *proj_obj_identify(PJ_CONTEXT *ctx, const PJ_OBJ *obj, } } auto ret = internal::make_unique(std::move(objects)); - if (confidence) { - *confidence = confidenceTemp; + if (out_confidence) { + *out_confidence = confidenceTemp; confidenceTemp = nullptr; } return ret.release(); -- cgit v1.2.3