给定一张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秒; 自编一个程序测试上述接口; 3）环境要求： C++， GDAL3.0.2，VS 2017 推荐使用GDAL3.0.2读写影像

好的，这是一个比较复杂的任务，需要使用GDAL库进行处理。下面是代码实现和说明。

1. 安装GDAL库

首先，需要安装GDAL库，下载地址为：https://gdal.org/download.html 。选择对应系统的二进制安装程序进行安装即可。

2. 编写C++动态库

根据题目要求，需要编写一个C++动态库，其中包含一个输出函数的接口定义。下面是代码实现：

#ifndef IMAGEPROCESSOR_H
#define IMAGEPROCESSOR_H

#include <string>
#include <vector>

class ImageProcessor
{
public:
    ImageProcessor();
    ~ImageProcessor();

    bool processImage(const std::string& imgPath, const std::string& outImgPath, int gridWidth, const std::vector<double>& gridPoints);

private:
    bool readBlock(int x, int y, int blockWidth, int blockHeight);
    bool writeBlock(int x, int y, int blockWidth, int blockHeight);

private:
    std::string m_imgPath;
    std::string m_outImgPath;
    int m_gridWidth;
    std::vector<double> m_gridPoints;
    int m_blockWidth;
    int m_blockHeight;
    int m_blockSize;
    int m_numBlocksX;
    int m_numBlocksY;
    double m_xMin;
    double m_yMax;
    double m_xMax;
    double m_yMin;
    double* m_pData;
};

#endif // IMAGEPROCESSOR_H

其中，processImage函数用于处理影像，imgPath是输入影像的路径，outImgPath是输出影像的路径，gridWidth是格网宽度，gridPoints是格网坐标数组。readBlock函数用于读取影像块，writeBlock函数用于写入影像块。

3. 实现processImage函数

下面是processImage函数的实现：

bool ImageProcessor::processImage(const std::string& imgPath, const std::string& outImgPath, int gridWidth, const std::vector<double>& gridPoints)
{
    m_imgPath = imgPath;
    m_outImgPath = outImgPath;
    m_gridWidth = gridWidth;
    m_gridPoints = gridPoints;

    // 打开输入影像
    GDALAllRegister();
    GDALDataset* pSrcDS = (GDALDataset*)GDALOpen(m_imgPath.c_str(), GA_ReadOnly);
    if (pSrcDS == NULL)
    {
        printf("Open source image failed!\n");
        return false;
    }

    // 获取输入影像的基本信息
    int width = pSrcDS->GetRasterXSize();
    int height = pSrcDS->GetRasterYSize();
    int numBands = pSrcDS->GetRasterCount();
    double geoTransform[6];
    pSrcDS->GetGeoTransform(geoTransform);
    double xRes = geoTransform[1];
    double yRes = geoTransform[5];

    // 计算块大小和块数
    m_blockWidth = 256;
    m_blockHeight = 256;
    m_blockSize = m_blockWidth * m_blockHeight;
    m_numBlocksX = (width + m_blockWidth - 1) / m_blockWidth;
    m_numBlocksY = (height + m_blockHeight - 1) / m_blockHeight;

    // 创建输出影像
    GDALDriver* pDriver = GetGDALDriverManager()->GetDriverByName("GTiff");
    GDALDataset* pDstDS = pDriver->Create(m_outImgPath.c_str(), width, height, numBands, GDT_Float32, NULL);
    if (pDstDS == NULL)
    {
        printf("Create destination image failed!\n");
        return false;
    }
    pDstDS->SetGeoTransform(geoTransform);
    pDstDS->SetProjection(pSrcDS->GetProjectionRef());

    // 计算矫正后的范围
    m_xMin = m_gridPoints[0];
    m_yMax = m_gridPoints[1];
    m_xMax = m_gridPoints[m_gridPoints.size() - 2];
    m_yMin = m_gridPoints[m_gridPoints.size() - 1];
    for (int i = 0; i < m_gridPoints.size(); i += 2)
    {
        double x = m_gridPoints[i];
        double y = m_gridPoints[i + 1];
        if (x < m_xMin) m_xMin = x;
        if (x > m_xMax) m_xMax = x;
        if (y < m_yMin) m_yMin = y;
        if (y > m_yMax) m_yMax = y;
    }

    // 计算输出影像中的偏移坐标
    double dstX = m_xMin;
    double dstY = m_yMax;
    int dstXOff = (int)((dstX - geoTransform[0]) / geoTransform[1] + 0.5);
    int dstYOff = (int)((dstY - geoTransform[3]) / geoTransform[5] + 0.5);
    double dstGeoTransform[6] = { dstX, geoTransform[1], geoTransform[2], dstY, geoTransform[4], geoTransform[5] };
    pDstDS->SetGeoTransform(dstGeoTransform);

    // 分块处理
    m_pData = new double[m_blockSize * numBands];
    for (int j = 0; j < m_numBlocksY; j++)
    {
        for (int i = 0; i < m_numBlocksX; i++)
        {
            int x = i * m_blockWidth;
            int y = j * m_blockHeight;
            int blockWidth = m_blockWidth;
            int blockHeight = m_blockHeight;
            if (x + blockWidth > width) blockWidth = width - x;
            if (y + blockHeight > height) blockHeight = height - y;
            if (!readBlock(x, y, blockWidth, blockHeight))
            {
                return false;
            }
            for (int k = 0; k < gridPoints.size(); k += 2)
            {
                double xSrc = gridPoints[k];
                double ySrc = gridPoints[k + 1];
                int xDst = (int)((xSrc - dstX) / xRes + 0.5);
                int yDst = (int)((dstY - ySrc) / yRes + 0.5);
                if (xDst >= 0 && xDst < width && yDst >= 0 && yDst < height)
                {
                    double* pData = m_pData + (yDst - y) * blockWidth * numBands + (xDst - x) * numBands;
                    double* pSrcData = (double*)pSrcDS->GetRasterBand(1)->ReadBlock(xDst / m_blockWidth, yDst / m_blockHeight);
                    for (int n = 0; n < numBands; n++)
                    {
                        pData[n] = pSrcData[(yDst % m_blockHeight) * m_blockWidth + (xDst % m_blockWidth) + n * m_blockSize];
                    }
                }
            }
            if (!writeBlock(x, y, blockWidth, blockHeight))
            {
                return false;
            }
        }
    }

    return true;
}

该函数首先打开输入影像，并获取影像的基本信息，计算块大小和块数。接下来，创建输出影像，并计算矫正后的范围和输出影像中的偏移坐标。最后，通过分块处理的方式，依次读取每个块，将块内的像素按照矫正后的坐标进行重采样，然后写入到输出影像中。

4. 实现readBlock和writeBlock函数

下面是readBlock和writeBlock函数的实现：

bool ImageProcessor::readBlock(int x, int y, int blockWidth, int blockHeight)
{
    GDALDataset* pSrcDS = (GDALDataset*)GDALOpen(m_imgPath.c_str(), GA_ReadOnly);
    if (pSrcDS == NULL)
    {
        printf("Open source image failed!\n");
        return false;
    }

    int numBands = pSrcDS->GetRasterCount();
    for (int i = 0; i < numBands; i++)
    {
        GDALRasterBand* pBand = pSrcDS->GetRasterBand(i + 1);
        pBand->ReadBlock(x / m_blockWidth, y / m_blockHeight, m_pData + i * m_blockSize);
    }

    GDALClose(pSrcDS);

    return true;
}

bool ImageProcessor::writeBlock(int x, int y, int blockWidth, int blockHeight)
{
    GDALDataset* pDstDS = (GDALDataset*)GDALOpen(m_outImgPath.c_str(), GA_Update);
    if (pDstDS == NULL)
    {
        printf("Open destination image failed!\n");
        return false;
    }

    int numBands = pDstDS->GetRasterCount();
    for (int i = 0; i < numBands; i++)
    {
        GDALRasterBand* pBand = pDstDS->GetRasterBand(i + 1);
        pBand->WriteBlock(x / m_blockWidth, y / m_blockHeight, m_pData + i * m_blockSize);
    }

    GDALClose(pDstDS);

    return true;
}

readBlock函数用于读取输入影像的指定块，writeBlock函数用于将输出影像的指定块写入到文件中。

5. 编写测试程序

下面是一个简单的测试程序：

#include "ImageProcessor.h"

int main()
{
    std::string imgPath = "input.tif";
    std::string outImgPath = "output.tif";
    int gridWidth = 64;
    std::vector<double> gridPoints = { 0, 0, 64, 0, 0, 64, 64, 64 };

    ImageProcessor processor;
    processor.processImage(imgPath, outImgPath, gridWidth, gridPoints);

    return 0;
}

该程序读取名为input.tif的影像，按照给定的格网坐标进行重采样，并将结果保存到名为output.tif的影像中。

以上就是实现一个分块处理TIF影像并进行格网矫正的C++动态库的方法。需要注意的是，由于影像可能较大，因此需要采用分块处理的方式，这样才能避免内存不足的问题。同时，为了处理速度，需要使用GDAL库进行影像读写操作。