gdal_geotransform.h

/******************************************************************************
 *
 * Name:     gdal_geotransform.h
 * Project:  GDAL Core
 * Purpose:  Declaration of GDALGeoTransform class
 * Author:   Even Rouault, <even.rouault@spatialys.com>
 *
 ******************************************************************************
 * Copyright (c) 2025, Even Rouault, <even.rouault@spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef GDALGEOTRANSFORM_H_INCLUDED
#define GDALGEOTRANSFORM_H_INCLUDED
 
#include "gdal.h"
 
#include <utility>
 
class GDALRasterWindow;
 
/* ******************************************************************** */
/*                             GDALGeoTransform                         */
/* ******************************************************************** */

class CPL_DLL GDALGeoTransform
{
  public:
    // NOTE to GDAL developers: do not reorder those coefficients!

    double xorig = 0;

    double xscale = 1;

    double xrot = 0;

    double yorig = 0;

    double yrot = 0;

    double yscale = 1;

    inline GDALGeoTransform() = default;

    inline explicit GDALGeoTransform(const double coeffs[6])
    {
        static_assert(sizeof(GDALGeoTransform) == 6 * sizeof(double),
                      "Wrong size for GDALGeoTransform");
        xorig = coeffs[0];
        xscale = coeffs[1];
        xrot = coeffs[2];
        yorig = coeffs[3];
        yrot = coeffs[4];
        yscale = coeffs[5];
    }

    inline GDALGeoTransform(double xorigIn, double xscaleIn, double xrotIn,
                            double yorigIn, double yrotIn, double yscaleIn)
    {
        xorig = xorigIn;
        xscale = xscaleIn;
        xrot = xrotIn;
        yorig = yorigIn;
        yrot = yrotIn;
        yscale = yscaleIn;
    }

    template <typename T> inline double operator[](T idx) const
    {
        return *(&xorig + idx);
    }

    template <typename T> inline double &operator[](T idx)
    {
        return *(&xorig + idx);
    }

    inline bool operator==(const GDALGeoTransform &other) const
    {
        return xorig == other.xorig && xscale == other.xscale &&
               xrot == other.xrot && yorig == other.yorig &&
               yrot == other.yrot && yscale == other.yscale;
    }

    inline bool operator!=(const GDALGeoTransform &other) const
    {
        return !(operator==(other));
    }

    inline const double *data() const
    {
        return &xorig;
    }

    inline double *data()
    {
        return &xorig;
    }

 
    inline void Apply(double dfPixel, double dfLine, double *pdfGeoX,
                      double *pdfGeoY) const
    {
        GDALApplyGeoTransform(data(), dfPixel, dfLine, pdfGeoX, pdfGeoY);
    }

    bool Apply(const OGREnvelope &env, GDALRasterWindow &window) const;

    bool Apply(const GDALRasterWindow &window, OGREnvelope &env) const;

 
    inline std::pair<double, double> Apply(double dfPixel, double dfLine) const
    {
        double dfOutX, dfOutY;
        GDALApplyGeoTransform(data(), dfPixel, dfLine, &dfOutX, &dfOutY);
        return {dfOutX, dfOutY};
    }

    inline bool GetInverse(GDALGeoTransform &inverse) const
    {
        return GDALInvGeoTransform(data(), inverse.data()) == TRUE;
    }

    inline void Rescale(double dfXRatio, double dfYRatio)
    {
        xscale *= dfXRatio;
        xrot *= dfYRatio;
        yrot *= dfXRatio;
        yscale *= dfYRatio;
    }

    inline bool IsAxisAligned() const
    {
        return xrot == 0 && yrot == 0;
    }
};
 
#endif