Modify the default strategy of researching intermediate CRS to do it only if there is no direct transformation

5 files changed, 103 insertions, 51 deletions

diff --git a/src/apps/projinfo.cpp b/src/apps/projinfo.cpp
index 29cf5fc3..9f908c8a 100644
--- a/src/apps/projinfo.cpp
+++ b/src/apps/projinfo.cpp
@@ -88,8 +88,8 @@ static void usage() {
         << "                [--grid-check none|discard_missing|sort] "
            "[--show-superseded]"
         << std::endl
-        << "                [--pivot-crs none|{auth:code[,auth:code]*}]"
-        << std::endl
+        << "                [--pivot-crs always|if_no_direct_transformation|"
+        << "never|{auth:code[,auth:code]*}]" << std::endl
         << "                [--boundcrs-to-wgs84]" << std::endl
         << "                [--main-db-path path] [--aux-db-path path]*"
         << std::endl
@@ -139,7 +139,7 @@ static std::string c_ify_string(const std::string &str) {
 static BaseObjectNNPtr buildObject(DatabaseContextPtr dbContext,
                                    const std::string &user_string,
                                    bool kindIsCRS, const std::string &context,
-                                   bool buildBoundCRSToWGS84, bool allowPivots,
+                                   bool buildBoundCRSToWGS84, CoordinateOperationContext::IntermediateCRSUse allowUseIntermediateCRS,
                                    bool quiet) {
     BaseObjectPtr obj;
 
@@ -213,7 +213,7 @@ static BaseObjectNNPtr buildObject(DatabaseContextPtr dbContext,
     if (buildBoundCRSToWGS84) {
         auto crs = std::dynamic_pointer_cast<CRS>(obj);
         if (crs) {
-            obj = crs->createBoundCRSToWGS84IfPossible(dbContext, allowPivots)
+            obj = crs->createBoundCRSToWGS84IfPossible(dbContext, allowUseIntermediateCRS)
                       .as_nullable();
         }
     }
@@ -224,7 +224,7 @@ static BaseObjectNNPtr buildObject(DatabaseContextPtr dbContext,
 // ---------------------------------------------------------------------------
 
 static void outputObject(DatabaseContextPtr dbContext, BaseObjectNNPtr obj,
-                         bool allowPivots, const OutputOptions &outputOpt) {
+                         CoordinateOperationContext::IntermediateCRSUse allowUseIntermediateCRS, const OutputOptions &outputOpt) {
 
     auto identified = dynamic_cast<const IdentifiedObject *>(obj.get());
     if (!outputOpt.quiet && identified && identified->isDeprecated()) {
@@ -272,7 +272,7 @@ static void outputObject(DatabaseContextPtr dbContext, BaseObjectNNPtr obj,
                     objToExport =
                         nn_dynamic_pointer_cast<IPROJStringExportable>(
                             crs->createBoundCRSToWGS84IfPossible(dbContext,
-                                                                 allowPivots));
+                                                                 allowUseIntermediateCRS));
                 }
                 if (!objToExport) {
                     objToExport = projStringExportable;
@@ -412,7 +412,7 @@ static void outputObject(DatabaseContextPtr dbContext, BaseObjectNNPtr obj,
                 if (crs) {
                     objToExport = nn_dynamic_pointer_cast<IWKTExportable>(
                         crs->createBoundCRSToWGS84IfPossible(dbContext,
-                                                             allowPivots));
+                                                             allowUseIntermediateCRS));
                 }
                 if (!objToExport) {
                     objToExport = wktExportable;
@@ -516,12 +516,14 @@ static void outputOperations(
     CoordinateOperationContext::SpatialCriterion spatialCriterion,
     CoordinateOperationContext::SourceTargetCRSExtentUse crsExtentUse,
     CoordinateOperationContext::GridAvailabilityUse gridAvailabilityUse,
-    bool allowPivots,
+    CoordinateOperationContext::IntermediateCRSUse allowUseIntermediateCRS,
     const std::vector<std::pair<std::string, std::string>> &pivots,
     const std::string &authority, bool usePROJGridAlternatives,
     bool showSuperseded, const OutputOptions &outputOpt, bool summary) {
     auto sourceObj = buildObject(dbContext, sourceCRSStr, true, "source CRS",
-                                 false, false, outputOpt.quiet);
+                                 false,
+                                 CoordinateOperationContext::IntermediateCRSUse::NEVER,
+                                 outputOpt.quiet);
     auto sourceCRS = nn_dynamic_pointer_cast<CRS>(sourceObj);
     if (!sourceCRS) {
         std::cerr << "source CRS string is not a CRS" << std::endl;
@@ -529,7 +531,9 @@ static void outputOperations(
     }
 
     auto targetObj = buildObject(dbContext, targetCRSStr, true, "target CRS",
-                                 false, false, outputOpt.quiet);
+                                 false,
+                                 CoordinateOperationContext::IntermediateCRSUse::NEVER,
+                                 outputOpt.quiet);
     auto targetCRS = nn_dynamic_pointer_cast<CRS>(targetObj);
     if (!targetCRS) {
         std::cerr << "target CRS string is not a CRS" << std::endl;
@@ -548,7 +552,7 @@ static void outputOperations(
         ctxt->setSpatialCriterion(spatialCriterion);
         ctxt->setSourceAndTargetCRSExtentUse(crsExtentUse);
         ctxt->setGridAvailabilityUse(gridAvailabilityUse);
-        ctxt->setAllowUseIntermediateCRS(allowPivots);
+        ctxt->setAllowUseIntermediateCRS(allowUseIntermediateCRS);
         ctxt->setIntermediateCRS(pivots);
         ctxt->setUsePROJAlternativeGridNames(usePROJGridAlternatives);
         ctxt->setDiscardSuperseded(!showSuperseded);
@@ -560,7 +564,7 @@ static void outputOperations(
         std::exit(1);
     }
     if (outputOpt.quiet && !list.empty()) {
-        outputObject(dbContext, list[0], allowPivots, outputOpt);
+        outputObject(dbContext, list[0], allowUseIntermediateCRS, outputOpt);
         return;
     }
     if (summary) {
@@ -586,7 +590,7 @@ static void outputOperations(
             }
             outputOperationSummary(op);
             std::cout << std::endl;
-            outputObject(dbContext, op, allowPivots, outputOpt);
+            outputObject(dbContext, op, allowUseIntermediateCRS, outputOpt);
         }
     }
 }
@@ -617,7 +621,8 @@ int main(int argc, char **argv) {
     bool buildBoundCRSToWGS84 = false;
     CoordinateOperationContext::GridAvailabilityUse gridAvailabilityUse =
         CoordinateOperationContext::GridAvailabilityUse::USE_FOR_SORTING;
-    bool allowPivots = true;
+    CoordinateOperationContext::IntermediateCRSUse allowUseIntermediateCRS =
+    CoordinateOperationContext::IntermediateCRSUse::IF_NO_DIRECT_TRANSFORMATION;
     std::vector<std::pair<std::string, std::string>> pivots;
     bool usePROJGridAlternatives = true;
     std::string mainDBPath;
@@ -814,8 +819,15 @@ int main(int argc, char **argv) {
         } else if (arg == "--pivot-crs" && i + 1 < argc) {
             i++;
             auto value(argv[i]);
-            if (ci_equal(std::string(value), "none")) {
-                allowPivots = false;
+            if (ci_equal(std::string(value), "always")) {
+                allowUseIntermediateCRS =
+                    CoordinateOperationContext::IntermediateCRSUse::ALWAYS;
+            } else if (ci_equal(std::string(value), "if_no_direct_transformation")) {
+                allowUseIntermediateCRS =
+                    CoordinateOperationContext::IntermediateCRSUse::IF_NO_DIRECT_TRANSFORMATION;
+            } else if (ci_equal(std::string(value), "never")) {
+                allowUseIntermediateCRS =
+                    CoordinateOperationContext::IntermediateCRSUse::NEVER;
             } else {
                 auto splitValue(split(value, ','));
                 for (const auto &v : splitValue) {
@@ -915,7 +927,7 @@ int main(int argc, char **argv) {
 
     if (!user_string.empty()) {
         auto obj(buildObject(dbContext, user_string, kindIsCRS, "input string",
-                             buildBoundCRSToWGS84, allowPivots,
+                             buildBoundCRSToWGS84, allowUseIntermediateCRS,
                              outputOpt.quiet));
         if (guessDialect) {
             auto dialect = WKTParser().guessDialect(user_string);
@@ -933,7 +945,7 @@ int main(int argc, char **argv) {
             }
             std::cout << std::endl;
         }
-        outputObject(dbContext, obj, allowPivots, outputOpt);
+        outputObject(dbContext, obj, allowUseIntermediateCRS, outputOpt);
         if (identify) {
             auto crs = dynamic_cast<CRS *>(obj.get());
             if (crs) {
@@ -1043,7 +1055,7 @@ int main(int argc, char **argv) {
 
         outputOperations(
             dbContext, sourceCRSStr, targetCRSStr, bboxFilter, spatialCriterion,
-            crsExtentUse, gridAvailabilityUse, allowPivots, pivots, authority,
+            crsExtentUse, gridAvailabilityUse, allowUseIntermediateCRS, pivots, authority,
             usePROJGridAlternatives, showSuperseded, outputOpt, summary);
     }
 
diff --git a/src/iso19111/c_api.cpp b/src/iso19111/c_api.cpp
index 79732bab..b3f200fe 100644
--- a/src/iso19111/c_api.cpp
+++ b/src/iso19111/c_api.cpp
@@ -1475,7 +1475,8 @@ PJ *proj_crs_create_bound_crs(PJ_CONTEXT *ctx, const PJ *base_crs,
  * @param options null-terminated list of options, or NULL. Currently
  * supported options are:
  * <ul>
- * <li>ALLOW_INTERMEDIATE_CRS=YES/NO. Defaults to NO. When set to YES,
+ * <li>ALLOW_INTERMEDIATE_CRS=ALWAYS/IF_NO_DIRECT_TRANSFORMATION/NEVER. Defaults
+ * to NEVER. When set to ALWAYS/IF_NO_DIRECT_TRANSFORMATION,
  * intermediate CRS may be considered when computing the possible
  * transformations. Slower.</li>
  * </ul>
@@ -1493,11 +1494,18 @@ PJ *proj_crs_create_bound_crs_to_WGS84(PJ_CONTEXT *ctx, const PJ *crs,
     }
     auto dbContext = getDBcontextNoException(ctx, __FUNCTION__);
     try {
-        bool allowIntermediateCRS = false;
+        CoordinateOperationContext::IntermediateCRSUse allowIntermediateCRS =
+            CoordinateOperationContext::IntermediateCRSUse::NEVER;
         for (auto iter = options; iter && iter[0]; ++iter) {
             const char *value;
             if ((value = getOptionValue(*iter, "ALLOW_INTERMEDIATE_CRS="))) {
-                allowIntermediateCRS = ci_equal(value, "YES");
+                if (ci_equal(value, "YES") || ci_equal(value, "ALWAYS")) {
+                    allowIntermediateCRS =
+                        CoordinateOperationContext::IntermediateCRSUse::ALWAYS;
+                } else if (ci_equal(value, "IF_NO_DIRECT_TRANSFORMATION")) {
+                    allowIntermediateCRS = CoordinateOperationContext::
+                        IntermediateCRSUse::IF_NO_DIRECT_TRANSFORMATION;
+                }
             } else {
                 std::string msg("Unknown option :");
                 msg += *iter;
@@ -6378,22 +6386,36 @@ void proj_operation_factory_context_set_use_proj_alternative_grid_names(
  * The current implementation is limited to researching one intermediate
  * step.
  *
- * By default, all potential C candidates will be used.
- * proj_operation_factory_context_set_allowed_intermediate_crs()
- * can be used to restrict them.
- *
- * The default is true.
+ * By default, with the IF_NO_DIRECT_TRANSFORMATION stratgey, all potential
+ * C candidates will be used if there is no direct tranformation.
  *
  * @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.
+ * @param use whether and how intermediate CRS may be used.
  */
 void proj_operation_factory_context_set_allow_use_intermediate_crs(
-    PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx, int allow) {
+    PJ_CONTEXT *ctx, PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
+    PROJ_INTERMEDIATE_CRS_USE use) {
     SANITIZE_CTX(ctx);
     assert(factory_ctx);
     try {
-        factory_ctx->operationContext->setAllowUseIntermediateCRS(allow != 0);
+        switch (use) {
+        case PROJ_INTERMEDIATE_CRS_USE_ALWAYS:
+            factory_ctx->operationContext->setAllowUseIntermediateCRS(
+                CoordinateOperationContext::IntermediateCRSUse::ALWAYS);
+            break;
+
+        case PROJ_INTERMEDIATE_CRS_USE_IF_NO_DIRECT_TRANSFORMATION:
+            factory_ctx->operationContext->setAllowUseIntermediateCRS(
+                CoordinateOperationContext::IntermediateCRSUse::
+                    IF_NO_DIRECT_TRANSFORMATION);
+            break;
+
+        case PROJ_INTERMEDIATE_CRS_USE_NEVER:
+            factory_ctx->operationContext->setAllowUseIntermediateCRS(
+                CoordinateOperationContext::IntermediateCRSUse::NEVER);
+            break;
+        }
     } catch (const std::exception &e) {
         proj_log_error(ctx, __FUNCTION__, e.what());
     }
diff --git a/src/iso19111/coordinateoperation.cpp b/src/iso19111/coordinateoperation.cpp
index d964cdc1..2128124b 100644
--- a/src/iso19111/coordinateoperation.cpp
+++ b/src/iso19111/coordinateoperation.cpp
@@ -9242,7 +9242,8 @@ struct CoordinateOperationContext::Private {
     bool usePROJNames_ = true;
     GridAvailabilityUse gridAvailabilityUse_ =
         GridAvailabilityUse::USE_FOR_SORTING;
-    bool allowUseIntermediateCRS_ = true;
+    IntermediateCRSUse allowUseIntermediateCRS_ = CoordinateOperationContext::
+        IntermediateCRSUse::IF_NO_DIRECT_TRANSFORMATION;
     std::vector<std::pair<std::string, std::string>>
         intermediateCRSAuthCodes_{};
     bool discardSuperseded_ = true;
@@ -9436,18 +9437,17 @@ CoordinateOperationContext::getGridAvailabilityUse() const {
  *
  * Concretely if in the database there is an operation from A to C
  * (or C to A), and another one from C to B (or B to C), but no direct
- * operation between A and B, setting this parameter to true, allow
- * chaining both operations.
+ * operation between A and B, setting this parameter to
+ * ALWAYS/IF_NO_DIRECT_TRANSFORMATION, allow chaining both operations.
  *
  * The current implementation is limited to researching one intermediate
  * step.
  *
- * By default, all potential C candidates will be used. setIntermediateCRS()
- * can be used to restrict them.
- *
- * The default is true.
+ * By default, with the IF_NO_DIRECT_TRANSFORMATION stratgey, all potential
+ * C candidates will be used if there is no direct tranformation.
  */
-void CoordinateOperationContext::setAllowUseIntermediateCRS(bool use) {
+void CoordinateOperationContext::setAllowUseIntermediateCRS(
+    IntermediateCRSUse use) {
     d->allowUseIntermediateCRS_ = use;
 }
 
@@ -9458,12 +9458,13 @@ void CoordinateOperationContext::setAllowUseIntermediateCRS(bool use) {
  *
  * Concretely if in the database there is an operation from A to C
  * (or C to A), and another one from C to B (or B to C), but no direct
- * operation between A and B, setting this parameter to true, allow
- * chaining both operations.
+ * operation between A and B, setting this parameter to
+ * ALWAYS/IF_NO_DIRECT_TRANSFORMATION, allow chaining both operations.
  *
- * The default is true.
+ * The default is IF_NO_DIRECT_TRANSFORMATION.
  */
-bool CoordinateOperationContext::getAllowUseIntermediateCRS() const {
+CoordinateOperationContext::IntermediateCRSUse
+CoordinateOperationContext::getAllowUseIntermediateCRS() const {
     return d->allowUseIntermediateCRS_;
 }
 
@@ -10401,9 +10402,6 @@ findOpsInRegistryDirect(const crs::CRSNNPtr &sourceCRS,
 static std::vector<CoordinateOperationNNPtr> findsOpsInRegistryWithIntermediate(
     const crs::CRSNNPtr &sourceCRS, const crs::CRSNNPtr &targetCRS,
     const CoordinateOperationContextNNPtr &context) {
-    if (!context->getAllowUseIntermediateCRS()) {
-        return std::vector<CoordinateOperationNNPtr>();
-    }
 
     const auto &authFactory = context->getAuthorityFactory();
     assert(authFactory);
@@ -11215,7 +11213,13 @@ CoordinateOperationFactory::Private::createOperations(
 
             // NAD27 to NAD83 has tens of results already. No need to look
             // for a pivot
-            if (res.size() < 5 || getenv("PROJ_FORCE_SEARCH_PIVOT")) {
+            if ((res.empty() &&
+                 context.context->getAllowUseIntermediateCRS() ==
+                     CoordinateOperationContext::IntermediateCRSUse::
+                         IF_NO_DIRECT_TRANSFORMATION) ||
+                context.context->getAllowUseIntermediateCRS() ==
+                    CoordinateOperationContext::IntermediateCRSUse::ALWAYS ||
+                getenv("PROJ_FORCE_SEARCH_PIVOT")) {
                 auto resWithIntermediate = findsOpsInRegistryWithIntermediate(
                     sourceCRS, targetCRS, context.context);
                 res.insert(res.end(), resWithIntermediate.begin(),
diff --git a/src/iso19111/crs.cpp b/src/iso19111/crs.cpp
index ebbed7a1..01a588e3 100644
--- a/src/iso19111/crs.cpp
+++ b/src/iso19111/crs.cpp
@@ -375,9 +375,10 @@ VerticalCRSPtr CRS::extractVerticalCRS() const {
  *
  * @return a CRS.
  */
-CRSNNPtr
-CRS::createBoundCRSToWGS84IfPossible(const io::DatabaseContextPtr &dbContext,
-                                     bool allowIntermediateCRS) const {
+CRSNNPtr CRS::createBoundCRSToWGS84IfPossible(
+    const io::DatabaseContextPtr &dbContext,
+    operation::CoordinateOperationContext::IntermediateCRSUse
+        allowIntermediateCRSUse) const {
     auto thisAsCRS = NN_NO_CHECK(
         std::static_pointer_cast<CRS>(shared_from_this().as_nullable()));
     auto boundCRS = util::nn_dynamic_pointer_cast<BoundCRS>(thisAsCRS);
@@ -442,7 +443,7 @@ CRS::createBoundCRSToWGS84IfPossible(const io::DatabaseContextPtr &dbContext,
                 authority == "any" ? std::string() : authority);
             auto ctxt = operation::CoordinateOperationContext::create(
                 authFactory, extent, 0.0);
-            ctxt->setAllowUseIntermediateCRS(allowIntermediateCRS);
+            ctxt->setAllowUseIntermediateCRS(allowIntermediateCRSUse);
             // ctxt->setSpatialCriterion(
             //    operation::CoordinateOperationContext::SpatialCriterion::PARTIAL_INTERSECTION);
             auto list =
diff --git a/src/proj.h b/src/proj.h
index f25c3228..af22c341 100644
--- a/src/proj.h
+++ b/src/proj.h
@@ -629,6 +629,19 @@ typedef enum {
     PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
 } PROJ_SPATIAL_CRITERION;
 
+    /** Describe if and how intermediate CRS should be used */
+typedef enum {
+    /** Always search for intermediate CRS. */
+    PROJ_INTERMEDIATE_CRS_USE_ALWAYS,
+
+    /** Only attempt looking for intermediate CRS if there is no direct
+        * transformation available. */
+    PROJ_INTERMEDIATE_CRS_USE_IF_NO_DIRECT_TRANSFORMATION,
+
+    /* Do not attempt looking for intermediate CRS. */
+    PROJ_INTERMEDIATE_CRS_USE_NEVER,
+} PROJ_INTERMEDIATE_CRS_USE;
+
 /** Type of coordinate system. */
 typedef enum
 {
@@ -906,7 +919,7 @@ void PROJ_DLL proj_operation_factory_context_set_use_proj_alternative_grid_names
 void PROJ_DLL proj_operation_factory_context_set_allow_use_intermediate_crs(
     PJ_CONTEXT *ctx,
     PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
-    int allow);
+    PROJ_INTERMEDIATE_CRS_USE use);
 
 void PROJ_DLL proj_operation_factory_context_set_allowed_intermediate_crs(
     PJ_CONTEXT *ctx,