Hey there! Let's sort out this coordinate projection issue you're facing with the GDAL/OGR C++ API. You mentioned your code runs but gives incorrect coordinates, and the root cause is missing the "starting reference" from your input TIFF dataset—exactly why gdaltranslate works (it automatically reads that metadata under the hood). Here's how to implement the correct workflow in C++:

Key Steps You're Likely Missing #

The core issue is that you need to explicitly:

• Open your TIFF dataset to access its spatial reference (SRS) and geotransform metadata.
• Create a coordinate transformation object using the TIFF's SRS as the source, and WGS84 (EPSG:4326, standard lat/lon) as the target.
• Convert your pixel/XY coordinates to projection coordinates first (if needed), then to lat/lon.

Full Working Code Example #

#include "gdal_priv.h"
#include "ogr_spatialref.h"
#include "cpl_error.h"
#include <iostream>

int main() {
    // Initialize GDAL/OGR environment (critical—don't skip this!)
    GDALAllRegister();
    OGRRegisterAll();

    // 1. Open your input TIFF dataset
    const char* tiffPath = "your_input_file.tif";
    GDALDataset* dataset = (GDALDataset*)GDALOpen(tiffPath, GA_ReadOnly);
    if (!dataset) {
        std::cerr << "Failed to open TIFF dataset: " << tiffPath << std::endl;
        return 1;
    }

    // 2. Extract geotransform (converts pixel coordinates to projection coordinates)
    double geoTransform[6];
    if (dataset->GetGeoTransform(geoTransform) != CE_None) {
        std::cerr << "Failed to retrieve geotransform from dataset" << std::endl;
        GDALClose(dataset);
        return 1;
    }

    // 3. Get the input TIFF's spatial reference system (SRS)
    OGRSpatialReference* inputSRS = new OGRSpatialReference(dataset->GetProjectionRef());
    if (inputSRS->Validate() != OGRERR_NONE) {
        std::cerr << "Invalid spatial reference in input TIFF" << std::endl;
        delete inputSRS;
        GDALClose(dataset);
        return 1;
    }

    // 4. Define target SRS: WGS84 (EPSG:4326, standard lat/lon)
    OGRSpatialReference* outputSRS = new OGRSpatialReference();
    if (outputSRS->ImportFromEPSG(4326) != OGRERR_NONE) {
        std::cerr << "Failed to initialize WGS84 spatial reference" << std::endl;
        delete inputSRS;
        delete outputSRS;
        GDALClose(dataset);
        return 1;
    }

    // 5. Create coordinate transformation object
    OGRCoordinateTransformation* transform = OGRCreateCoordinateTransformation(inputSRS, outputSRS);
    if (!transform) {
        std::cerr << "Failed to create coordinate transformation object" << std::endl;
        delete inputSRS;
        delete outputSRS;
        GDALClose(dataset);
        return 1;
    }

    // Example: Convert a pixel coordinate (xPixel, yPixel) to lat/lon
    double xPixel = 150.0; // Replace with your X pixel
    double yPixel = 250.0; // Replace with your Y pixel

    // First: Convert pixel coordinates to projection coordinates
    double xProj = geoTransform[0] + xPixel * geoTransform[1] + yPixel * geoTransform[2];
    double yProj = geoTransform[3] + xPixel * geoTransform[4] + yPixel * geoTransform[5];

    // Second: Convert projection coordinates to lat/lon
    double lon = xProj;
    double lat = yProj;
    if (transform->TransformPoint(&lon, &lat, nullptr)) {
        std::cout << "Success! Converted coordinates:\n";
        std::cout << "Longitude: " << lon << "\nLatitude: " << lat << std::endl;
    } else {
        std::cerr << "Failed to transform coordinates" << std::endl;
        // Get detailed error info if needed:
        // std::cerr << "Error: " << CPLGetLastErrorMsg() << std::endl;
    }

    // Clean up resources
    delete transform;
    delete inputSRS;
    delete outputSRS;
    GDALClose(dataset);
    GDALDestroyDriverManager();

    return 0;
}

Critical Notes #

• If your XY points are already projection coordinates (not pixels): Skip the pixel-to-projection conversion step—directly pass your XY values to TransformPoint.
• Verify your TIFF's metadata: Use gdalinfo your_input.tif in the command line to confirm the projection and geotransform match what your code is reading. This helps rule out corrupt or mislabeled TIFFs.
• Error handling: Add CPLGetLastErrorMsg() calls (like the commented line) to get detailed error messages if transformations fail—this is invaluable for debugging.

Why gdaltranslate Works #

When you run gdaltranslate, it automatically opens the input TIFF, reads its SRS/geotransform, and sets up the coordinate transformation pipeline for you. Your code was missing that explicit dataset opening and metadata retrieval step, which is why it lacked the "starting reference" needed for accurate conversion.

内容的提问来源于stack exchange，提问作者René Orozco