1.生成矫正影像 给定一张TIF格式的影像，给定一套格网重投影坐标，输出一张新的TIF影像（要求是分块存储格式Tiled TIF）； 1）实现为C++动态库，输出函数的接口定义如下： imgPath是输入的TIF影像路径； outImgPath是输出的TIF影像路径，要求以Tiled TIF格式存储，分块大小为256； gridWidth是原影像的格网矫正宽度，通常为64； gridPoints是原影像的格网矫正坐标，此数组中坐标点的顺序是逐行顺序存储。 假设影像宽高分别为W,H，那么gridPoints中的点数为ceil(W/64)*H； 由于矫正坐标的最小值不一定为（0，0），因而输出影像是以矫正坐标的覆盖范围来决定影像的宽高，同时要求将矫正坐标的最小值作为偏移坐标值写入到TIF数据的GeoTransform头信息中。 2）功能要求： 影像可能较大，因而不能完全加载全部影像到内存进行处理，所以只能分块处理； 速度较快，一张1GB的TIF数据，处理时间不能超过20秒； 自编一个程序测试上述接口；

以下是C++动态库的接口定义：

/**
 * 生成矫正影像
 *
 * @param imgPath 输入的TIF影像路径
 * @param outImgPath 输出的TIF影像路径，要求以Tiled TIF格式存储，分块大小为256
 * @param gridWidth 原影像的格网矫正宽度，通常为64
 * @param gridPoints 原影像的格网矫正坐标，此数组中坐标点的顺序是逐行顺序存储。假设影像宽高分别为W,H，那么gridPoints中的点数为ceil(W/64)*H
 * @return true表示成功，false表示失败
 */
bool generateCorrectedImage(const std::string& imgPath, const std::string& outImgPath, int gridWidth, const std::vector<cv::Point2f>& gridPoints);

实现思路：

1. 打开输入影像，读取影像的宽度和高度。
2. 根据输入的格网矫正宽度和影像宽度计算出格网行数。
3. 构建一个二维数组，表示格网点的坐标。
4. 遍历格网点的坐标，计算出每个格网单元的仿射变换矩阵，并将其存储到一个 vector 中。
5. 打开输出影像，设置影像的宽度、高度、波段数和数据类型，设置 GeoTransform 信息，并创建 Tiled TIF 文件。
6. 分块处理，对每个块进行矫正，将矫正后的块写入输出影像中。
7. 关闭输入和输出影像。

以下是实现的代码：

#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>
#include <gdal_priv.h>
#include <cpl_conv.h>

// 定义分块大小
const int TILE_SIZE = 256;

// 生成仿射变换矩阵
cv::Mat getAffineTransformMatrix(const std::vector<cv::Point2f>& srcPoints, const std::vector<cv::Point2f>& dstPoints)
{
    cv::Mat srcMat = cv::Mat(srcPoints);
    cv::Mat dstMat = cv::Mat(dstPoints);

    return cv::getAffineTransform(srcMat, dstMat);
}

// 获取瓦片坐标系下的坐标范围
void getTileRange(int& xStart, int& yStart, int& xEnd, int& yEnd, int width, int height)
{
    xStart = std::max(0, xStart);
    yStart = std::max(0, yStart);
    xEnd = std::min(width / TILE_SIZE, xEnd);
    yEnd = std::min(height / TILE_SIZE, yEnd);
}

bool generateCorrectedImage(const std::string& imgPath, const std::string& outImgPath, int gridWidth, const std::vector<cv::Point2f>& gridPoints)
{
    GDALAllRegister();
    GDALDataset* pSrcDs = static_cast<GDALDataset*>(GDALOpen(imgPath.c_str(), GA_ReadOnly));
    if (pSrcDs == nullptr)
    {
        std::cerr << "Failed to open source image " << imgPath << std::endl;
        return false;
    }

    int width = pSrcDs->GetRasterXSize();
    int height = pSrcDs->GetRasterYSize();

    // 计算格网矫正行数
    int gridRowCount = static_cast<int>(std::ceil(static_cast<double>(width) / gridWidth));

    // 构建格网点坐标数组
    std::vector<cv::Point2f> srcPoints, dstPoints;
    for (int y = 0; y < height; ++y)
    {
        for (int x = 0; x < width; ++x)
        {
            int row = y / gridWidth;
            int col = x / gridWidth;
            int idx = row * gridRowCount + col;

            // 如果 idx 超出了范围，说明该像素不在格网上，跳过
            if (idx >= gridPoints.size()) continue;

            cv::Point2f srcPoint(x, y);
            cv::Point2f dstPoint = gridPoints[idx];

            srcPoints.push_back(srcPoint);
            dstPoints.push_back(dstPoint);
        }
    }

    // 计算仿射变换矩阵
    cv::Mat affineMat = getAffineTransformMatrix(srcPoints, dstPoints);

    // 打开输出影像
    GDALDriver* pDriver = GetGDALDriverManager()->GetDriverByName("GTiff");
    char** pOptions = nullptr;
    pOptions = CSLSetNameValue(pOptions, "TILED", "YES");
    pOptions = CSLSetNameValue(pOptions, "BLOCKXSIZE", std::to_string(TILE_SIZE).c_str());
    pOptions = CSLSetNameValue(pOptions, "BLOCKYSIZE", std::to_string(TILE_SIZE).c_str());
    GDALDataset* pDstDs = pDriver->Create(outImgPath.c_str(), width, height, pSrcDs->GetRasterCount(), GDT_Byte, pOptions);
    CSLDestroy(pOptions);

    // 设置 GeoTransform 信息
    double adfGeoTransform[6] = { 0 };
    pSrcDs->GetGeoTransform(adfGeoTransform);
    adfGeoTransform[0] += affineMat.at<double>(0, 2);
    adfGeoTransform[3] += affineMat.at<double>(1, 2);
    pDstDs->SetGeoTransform(adfGeoTransform);
    pDstDs->SetProjection(pSrcDs->GetProjectionRef());

    // 分块处理
    for (int y = 0; y < height; y += TILE_SIZE)
    {
        for (int x = 0; x < width; x += TILE_SIZE)
        {
            // 获取当前块的范围
            int xStart = x / TILE_SIZE;
            int yStart = y / TILE_SIZE;
            int xEnd = (x + TILE_SIZE) / TILE_SIZE;
            int yEnd = (y + TILE_SIZE) / TILE_SIZE;
            getTileRange(xStart, yStart, xEnd, yEnd, width, height);

            // 读取源块
            cv::Rect roi(x, y, TILE_SIZE, TILE_SIZE);
            if (roi.x + roi.width > width) roi.width = width - roi.x;
            if (roi.y + roi.height > height) roi.height = height - roi.y;
            cv::Mat srcMat;
            pSrcDs->RasterIO(GF_Read, roi.x, roi.y, roi.width, roi.height, srcMat.data, roi.width, roi.height, GDT_Byte,
                pSrcDs->GetRasterCount(), nullptr, 0, 0, 0);

            // 矫正块
            cv::Mat dstMat;
            cv::warpAffine(srcMat, dstMat, affineMat, cv::Size(TILE_SIZE, TILE_SIZE), cv::INTER_LINEAR, cv::BORDER_REFLECT);

            // 写入目标块
            for (int ty = yStart; ty < yEnd; ++ty)
            {
                for (int tx = xStart; tx < xEnd; ++tx)
                {
                    int tileX = tx * TILE_SIZE;
                    int tileY = ty * TILE_SIZE;
                    cv::Rect tileRoi(tileX, tileY, TILE_SIZE, TILE_SIZE);
                    if (tileRoi.x + tileRoi.width > width) tileRoi.width = width - tileRoi.x;
                    if (tileRoi.y + tileRoi.height > height) tileRoi.height = height - tileRoi.y;

                    pDstDs->RasterIO(GF_Write, tileRoi.x, tileRoi.y, tileRoi.width, tileRoi.height, dstMat.data, tileRoi.width, tileRoi.height,
                        GDT_Byte, pDstDs->GetRasterCount(), nullptr, 0, 0, 0);
                }
            }
        }
    }

    // 关闭数据集
    GDALClose(pSrcDs);
    GDALClose(pDstDs);

    return true;
}

测试代码：

int main(int argc, char** argv)
{
    std::string imgPath = "/path/to/input/image.tif";
    std::string outImgPath = "/path/to/output/image.tif";
    int gridWidth = 64;
    std::vector<cv::Point2f> gridPoints = { /* 格网点坐标数组 */ };

    generateCorrectedImage(imgPath, outImgPath, gridWidth, gridPoints);

    return 0;
}