fix: chain engineering CRS transforms through intermediate projected CRS

When an EngineeringCRS has registered transformations to projected CRSs
(e.g. via similarity transformation), PROJ could not compose a pipeline
to a *different* projected CRS on the same datum. For example, if
engineering CRS A has a transformation to UTM zone 31N, PROJ returned
0 operations when asked to transform A to UTM zone 32N.

Add findOpsInRegistryDirectFrom() and use it in createOperationsFromDatabase()
to look up all registered transformations from/to the engineering CRS and
chain through the intermediate CRS to reach the target.

Tested with EPSG:5800 (Astra Minas Grid) -> EPSG:22193 (Campo Inchauspe
/ Argentina 3) which chains through EPSG:22192 (Argentina 2).

Author: phaarnes

src/iso19111/operation/coordinateoperationfactory.cpp

@@ -608,6 +608,10 @@ struct CoordinateOperationFactory::Private {
     findOpsInRegistryDirectTo(const crs::CRSNNPtr &targetCRS,
                               Private::Context &context);
 
+    static std::vector<CoordinateOperationNNPtr>
+    findOpsInRegistryDirectFrom(const crs::CRSNNPtr &sourceCRS,
+                                Private::Context &context);
+
     static std::vector<CoordinateOperationNNPtr>
     findsOpsInRegistryWithIntermediate(
         const crs::CRSNNPtr &sourceCRS, const crs::CRSNNPtr &targetCRS,
@@ -1995,6 +1999,71 @@ CoordinateOperationFactory::Private::findOpsInRegistryDirectTo(
     return std::vector<CoordinateOperationNNPtr>();
 }
 
+// ---------------------------------------------------------------------------
+
+// Look in the authority registry for operations from sourceCRS
+std::vector<CoordinateOperationNNPtr>
+CoordinateOperationFactory::Private::findOpsInRegistryDirectFrom(
+    const crs::CRSNNPtr &sourceCRS, Private::Context &context) {
+#ifdef TRACE_CREATE_OPERATIONS
+    ENTER_BLOCK("findOpsInRegistryDirectFrom(" +
+                objectAsStr(sourceCRS.get()) + " --> {any})");
+#endif
+
+    const auto &authFactory = context.context->getAuthorityFactory();
+    assert(authFactory);
+
+    std::list<std::pair<std::string, std::string>> ids;
+    buildCRSIds(sourceCRS, context, ids);
+
+    const auto gridAvailabilityUse = context.context->getGridAvailabilityUse();
+    for (const auto &id : ids) {
+        const auto &srcAuthName = id.first;
+        const auto &srcCode = id.second;
+
+        const auto authorities(getCandidateAuthorities(
+            authFactory, srcAuthName, srcAuthName));
+        std::vector<CoordinateOperationNNPtr> res;
+        for (const auto &authName : authorities) {
+            const auto tmpAuthFactory = io::AuthorityFactory::create(
+                authFactory->databaseContext(), authName);
+            auto resTmp =
+                tmpAuthFactory->createFromCoordinateReferenceSystemCodes(
+                    srcAuthName, srcCode, std::string(), std::string(),
+                    context.context->getUsePROJAlternativeGridNames(),
+
+                    gridAvailabilityUse ==
+                            CoordinateOperationContext::GridAvailabilityUse::
+                                DISCARD_OPERATION_IF_MISSING_GRID ||
+                        gridAvailabilityUse ==
+                            CoordinateOperationContext::GridAvailabilityUse::
+                                KNOWN_AVAILABLE,
+                    gridAvailabilityUse ==
+                        CoordinateOperationContext::GridAvailabilityUse::
+                            KNOWN_AVAILABLE,
+                    context.context->getDiscardSuperseded(), true, true,
+                    context.extent1, context.extent2);
+            res.insert(res.end(), resTmp.begin(), resTmp.end());
+            if (authName == "PROJ") {
+                continue;
+            }
+            if (!res.empty()) {
+                auto resFiltered =
+                    FilterResults(res, context.context, context.extent1,
+                                  context.extent2, false)
+                        .getRes();
+#ifdef TRACE_CREATE_OPERATIONS
+                logTrace("filtering reduced from " +
+                         toString(static_cast<int>(res.size())) + " to " +
+                         toString(static_cast<int>(resFiltered.size())));
+#endif
+                return resFiltered;
+            }
+        }
+    }
+    return std::vector<CoordinateOperationNNPtr>();
+}
+
 //! @endcond
 
 // ---------------------------------------------------------------------------
@@ -3940,6 +4009,71 @@ bool CoordinateOperationFactory::Private::createOperationsFromDatabase(
         return true;
     }
 
+    // Special case for EngineeringCRS: if no direct transformation found,
+    // look up all registered transformations from the engineering CRS and
+    // try to chain through them to reach the target CRS.
+    // This handles cases like engineering CRS → ProjectedCRS_A (registered)
+    // chained with ProjectedCRS_A → ProjectedCRS_B (same datum reprojection).
+    if (res.empty()) {
+        auto engSrc =
+            dynamic_cast<const crs::EngineeringCRS *>(sourceCRS.get());
+        auto engDst =
+            dynamic_cast<const crs::EngineeringCRS *>(targetCRS.get());
+        if (engSrc && !engDst) {
+            auto opsFromEng = findOpsInRegistryDirectFrom(sourceCRS, context);
+            for (const auto &opFromEng : opsFromEng) {
+                auto intermediateCRS = opFromEng->targetCRS();
+                if (intermediateCRS &&
+                    !intermediateCRS->_isEquivalentTo(
+                        targetCRS.get(),
+                        util::IComparable::Criterion::EQUIVALENT)) {
+                    auto opsToTarget = createOperations(
+                        NN_NO_CHECK(intermediateCRS), sourceEpoch, targetCRS,
+                        targetEpoch, context);
+                    for (const auto &opToTarget : opsToTarget) {
+                        try {
+                            res.emplace_back(
+                                ConcatenatedOperation::createComputeMetadata(
+                                    {opFromEng, opToTarget},
+                                    context.disallowEmptyIntersection()));
+                        } catch (
+                            const InvalidOperationEmptyIntersection &) {
+                        }
+                    }
+                }
+            }
+            if (!res.empty()) {
+                return true;
+            }
+        } else if (engDst && !engSrc) {
+            auto opsToEng = findOpsInRegistryDirectTo(targetCRS, context);
+            for (const auto &opToEng : opsToEng) {
+                auto intermediateCRS = opToEng->sourceCRS();
+                if (intermediateCRS &&
+                    !intermediateCRS->_isEquivalentTo(
+                        sourceCRS.get(),
+                        util::IComparable::Criterion::EQUIVALENT)) {
+                    auto opsFromSource = createOperations(
+                        sourceCRS, sourceEpoch,
+                        NN_NO_CHECK(intermediateCRS), targetEpoch, context);
+                    for (const auto &opFromSource : opsFromSource) {
+                        try {
+                            res.emplace_back(
+                                ConcatenatedOperation::createComputeMetadata(
+                                    {opFromSource, opToEng},
+                                    context.disallowEmptyIntersection()));
+                        } catch (
+                            const InvalidOperationEmptyIntersection &) {
+                        }
+                    }
+                }
+            }
+            if (!res.empty()) {
+                return true;
+            }
+        }
+    }
+
     bool doFilterAndCheckPerfectOp = false;
 
     bool sameGeodeticDatum = false;

test/unit/test_operationfactory.cpp

@@ -12142,3 +12142,52 @@ TEST(operation, createOperation_defmodel_from_database) {
               "+step +proj=unitconvert +xy_in=rad +z_in=m +xy_out=deg +z_out=m "
               "+step +proj=axisswap +order=2,1");
 }
+
+// ---------------------------------------------------------------------------
+
+TEST(
+    operation,
+    engineeringCRS_to_projectedCRS_through_intermediate_same_datum) {
+    // Test that PROJ can compose a pipeline from an engineering CRS to a
+    // projected CRS via chaining through an intermediate projected CRS that
+    // has a registered transformation from the engineering CRS.
+    //
+    // EPSG:5800 (Astra Minas Grid) has a registered transformation
+    // (EPSG:1035) to EPSG:22192 (Campo Inchauspe / Argentina 2).
+    // EPSG:22193 (Campo Inchauspe / Argentina 3) shares the same datum
+    // (Campo Inchauspe) but a different zone.
+    // PROJ should chain: engineering → Argentina 2 → inv(zone 2) → zone 3.
+    auto authFactory =
+        AuthorityFactory::create(DatabaseContext::create(), "EPSG");
+
+    // Direct transformation should work (EPSG:1035)
+    {
+        auto ctxt =
+            CoordinateOperationContext::create(authFactory, nullptr, 0.0);
+        ctxt->setSourceAndTargetCRSExtentUse(
+            CoordinateOperationContext::SourceTargetCRSExtentUse::NONE);
+        auto list = CoordinateOperationFactory::create()->createOperations(
+            authFactory->createCoordinateReferenceSystem("5800"),
+            authFactory->createCoordinateReferenceSystem("22192"), ctxt);
+        ASSERT_GE(list.size(), 1U);
+        EXPECT_EQ(list[0]->nameStr(),
+                  "Astra Minas to Campo Inchauspe / Argentina 2 (1)");
+    }
+
+    // Chained transformation to a different zone on the same datum
+    {
+        auto ctxt =
+            CoordinateOperationContext::create(authFactory, nullptr, 0.0);
+        ctxt->setSourceAndTargetCRSExtentUse(
+            CoordinateOperationContext::SourceTargetCRSExtentUse::NONE);
+        auto list = CoordinateOperationFactory::create()->createOperations(
+            authFactory->createCoordinateReferenceSystem("5800"),
+            authFactory->createCoordinateReferenceSystem("22193"), ctxt);
+        ASSERT_GE(list.size(), 1U);
+        // Should chain through the registered transformation to Argentina 2,
+        // then reproject from zone 2 to zone 3 (same datum)
+        EXPECT_EQ(list[0]->nameStr(),
+                  "Astra Minas to Campo Inchauspe / Argentina 2 (1) + "
+                  "Inverse of Argentina zone 2 + Argentina zone 3");
+    }
+}