基于GDAL的栅格数据/遥感影像IO (非分块)

最新推荐文章于 2024-03-08 10:49:22 发布
最新推荐文章于 2024-03-08 10:49:22 发布
阅读量2k 收藏 3
点赞数 1
分类专栏： CPP RS&GIS 文章标签： gdal openmp 遥感 栅格数据 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whuyao/article/details/51227144
版权

这个封装的目的主要是为了简化GDAL的读写文件的使用，支持投影变换，支持openMP。
需要的库：GDAL 2.x, Proj
库的网址：http://www.gdal.org
支持常见栅格影像

GDALRead.h

/************************************************************************/
/* This class is wrote for supercomputer to read image use parallel.
/* Not support Block read & write
/* But support multi-thread
/* Author: Y. Yao
/* E-mail: whuyao@foxmail.com
/* Version: v4.0
/************************************************************************/

#ifndef CLASS_GDAL_READ
#define CLASS_GDAL_READ

#include "gdal_priv.h"
#include "ogr_core.h"
#include "ogr_spatialref.h"

class CGDALRead
{
public:
    CGDALRead(void);
    ~CGDALRead(void);

public:
    bool loadFrom(const char* _filename);
    unsigned char* read(size_t _row, size_t _col, size_t _band);
    unsigned char* readL(size_t _row, size_t _col, size_t _band);   //extension read-data

    //get data via bilinear interpolation
    template<class TT> double linRead(double _row, double _col, size_t _band);

public:
    void close();
    bool isValid();

public:
    GDALDataset* poDataset();
    size_t rows();
    size_t cols();
    size_t bandnum();
    size_t datalength();
    double invalidValue();
    unsigned char* imgData();
    GDALDataType datatype();
    double* geotransform();
    char* projectionRef();
    size_t perPixelSize();

public:
    bool world2Pixel(double lat, double lon, double *pcol, double *prow);
    bool pixel2World(double *lat, double *lon, double col, double row);
    bool pixel2Ground(double col,double row,double* pX,double* pY);
    bool ground2Pixel(double X,double Y,double* pcol,double* prow);

protected:
    template<class TT> bool readData();

protected:
    GDALDataset* mpoDataset;    //=>
    size_t mnRows;                  //
    size_t mnCols;                  //
    size_t mnBands;             //
    unsigned char* mpData;      //=>
    GDALDataType mgDataType;    //
    size_t mnDatalength;            //=>
    double mpGeoTransform[6];   //
    char msProjectionRef[2048]; //
    char msFilename[2048];      //
    double mdInvalidValue;
    size_t mnPerPixSize;            //=>

public:
    OGRSpatialReferenceH srcSR;
    OGRSpatialReferenceH latLongSR;
    OGRCoordinateTransformationH poTransform;       //pixel->world
    OGRCoordinateTransformationH poTransformT;      //world->pixel
};

#endif

GDALRead.cpp

#include "GDALRead.h"
#include "ogrsf_frmts.h"
#include <iostream>
using namespace std;

CGDALRead::CGDALRead(void)
{
    mpoDataset = NULL;
    mpData = NULL;
    mgDataType = GDT_Byte;
    mnRows = mnCols = mnBands = -1;
    mnDatalength = -1;
    mpData = NULL;
    memset(mpGeoTransform, 0, 6*sizeof(double));
    strcpy(msProjectionRef, "");
    strcpy(msFilename, "");
    mdInvalidValue = 0.0f;
    mnPerPixSize = 1;

    //
    srcSR = NULL;
    latLongSR = NULL;
    poTransform = NULL;
    poTransformT = NULL;
}


CGDALRead::~CGDALRead(void)
{
    close();
}

void CGDALRead::close()
{
    if (mpoDataset != NULL)
    {
        GDALClose(mpoDataset);
        mpoDataset = NULL;      
    }

    if (mpData != NULL)
    {
        delete []mpData;
        mpData = NULL;
    }

    mgDataType = GDT_Byte;
    mnDatalength = -1;
    mnRows = mnCols = mnBands = -1;
    mpData = NULL;
    memset(mpGeoTransform, 0, 6*sizeof(double));
    strcpy(msProjectionRef, "");
    strcpy(msFilename, "");
    mdInvalidValue = 0.0f;
    mnPerPixSize = 1;

    //destory
    if (poTransform!=NULL)
        OCTDestroyCoordinateTransformation(poTransform);
    poTransform = NULL;

    if (poTransformT!=NULL)
        OCTDestroyCoordinateTransformation(poTransformT);
    poTransformT = NULL;

    if (latLongSR != NULL)
        OSRDestroySpatialReference(latLongSR);
    latLongSR = NULL;

    if (srcSR!=NULL)
        OSRDestroySpatialReference(srcSR);
    srcSR = NULL;


}

bool CGDALRead::isValid()
{
    if (mpoDataset == NULL || mpData == NULL)
    {
        return false;
    }

    return true;

}

GDALDataset* CGDALRead::poDataset()
{
    return mpoDataset;
}

size_t CGDALRead::rows()
{
    return mnRows;
}

size_t CGDALRead::cols()
{
    return mnCols;
}

size_t CGDALRead::bandnum()
{
    return mnBands;
}

unsigned char* CGDALRead::imgData()
{
    return mpData;
}

GDALDataType CGDALRead::datatype()
{
    return mgDataType;
}

double* CGDALRead::geotransform()
{
    return mpGeoTransform;
}

char* CGDALRead::projectionRef()
{
    return msProjectionRef;
}

size_t CGDALRead::datalength()
{
    return mnDatalength;
}

double CGDALRead::invalidValue()
{
    return mdInvalidValue;
}

size_t CGDALRead::perPixelSize()
{
    return mnPerPixSize;
}

bool CGDALRead::loadFrom( const char* _filename )
{
    //close fore image
    close();

    //register
    if(GDALGetDriverCount() == 0)
    {
        GDALAllRegister();
        OGRRegisterAll();
        CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");
    }

    //open image
    mpoDataset = (GDALDataset*)GDALOpenShared(_filename, GA_ReadOnly);

    if (mpoDataset == NULL)
    {
        cout<<"CGDALRead::loadFrom : read file error!"<<endl;
        return false;
    }

    strcpy(msFilename, _filename);

    //get attribute
    mnRows = mpoDataset->GetRasterYSize();
    mnCols = mpoDataset->GetRasterXSize();
    mnBands = mpoDataset->GetRasterCount();
    mgDataType = mpoDataset->GetRasterBand(1)->GetRasterDataType();
    mdInvalidValue = mpoDataset->GetRasterBand(1)->GetNoDataValue();

    //mapinfo
    mpoDataset->GetGeoTransform(mpGeoTransform);
    strcpy(msProjectionRef, mpoDataset->GetProjectionRef());

    srcSR = OSRNewSpatialReference(msProjectionRef); // ground
    latLongSR = OSRCloneGeogCS(srcSR);  //geo
    poTransform =OCTNewCoordinateTransformation(srcSR, latLongSR);
    poTransformT =OCTNewCoordinateTransformation(latLongSR, srcSR);



    //get data
    bool bRlt = false;
    switch(mgDataType)
    {
    case GDT_Byte:
        mnPerPixSize = sizeof(unsigned char);
        bRlt = readData<unsigned char>();
        break;
    case GDT_UInt16:
        mnPerPixSize = sizeof(unsigned short);
        bRlt = readData<unsigned short>();
        break;
    case GDT_Int16:
        mnPerPixSize = sizeof(short);
        bRlt = readData<short>();
        break;
    case GDT_UInt32:
        mnPerPixSize = sizeof(unsigned int);
        bRlt = readData<unsigned int>();
        break;
    case GDT_Int32:
        mnPerPixSize = sizeof(int);
        bRlt = readData<int>();
        break;
    case GDT_Float32:
        mnPerPixSize = sizeof(float);
        bRlt = readData<float>();
        break;
    case GDT_Float64:
        mnPerPixSize = sizeof(double);
        bRlt = readData<double>();
        break;
    default:
        cout<<"CGDALRead::loadFrom : unknown data type!"<<endl;
        close();
        return false;
    }

    if (bRlt == false)
    {
        cout<<"CGDALRead::loadFrom : read data error!"<<endl;
        close();
        return false;
    }


    return true;
}

template<class TT> bool CGDALRead::readData()
{
    if (mpoDataset == NULL)
        return false;

    //new space
    mnDatalength = mnRows*mnCols*mnBands*sizeof(TT);
    mpData = new unsigned char[(size_t)mnDatalength];

    //raster IO
    CPLErr _err= mpoDataset->RasterIO(GF_Read, 0, 0, mnCols, mnRows, mpData, \
                mnCols, mnRows, mgDataType, mnBands, 0, 0, 0, 0);

    if (_err != CE_None)
    {
        cout<<"CGDALRead::readData : raster io error!"<<endl;
        return false;
    }

    return true;
}

unsigned char* CGDALRead::read( size_t _row, size_t _col, size_t _band )
{
    return &(mpData[(_band*mnRows*mnCols + _row*mnCols + _col)*mnPerPixSize]);
}

unsigned char* CGDALRead::readL( size_t _row, size_t _col, size_t _band )
{
    //if out of rect, take mirror
    if (_row < 0)
        _row = -_row;
    else if (_row >= mnRows)
        _row = mnRows - (_row - (mnRows - 1));

    if (_col < 0)
        _col = -_col;
    else if (_col >= mnCols)
        _col = mnCols - (_col - (mnCols - 1));

    return &(mpData[(_band*mnRows*mnCols + _row*mnCols + _col)*mnPerPixSize]);
}

template<class TT> double CGDALRead::linRead( double _row, double _col, size_t _band )
{
    TT val[4];
    double t1, t2, t, tx1, ty1;

    //calculate the excursion
    float xpos = _row - size_t(_row);
    float ypos = _col - size_t(_col);

    //get the pixel value of 4-neighbour
    tx1 = _row+1.0; ty1 = _col+1.0;

    val[0] =*(TT*)ReadL(size_t(_row), size_t(_col), bands); //band
    val[1] =*(TT*)ReadL(size_t(tx1), size_t(_col), bands);
    val[2] =*(TT*)ReadL(size_t(_row), size_t(ty1), bands);
    val[3] =*(TT*)ReadL(size_t(tx1), size_t(ty1), bands);

    //y-direction size_terpolation
    t1 = (1-ypos)*(double)val[0]+ypos*(double)val[2];
    t2 = (1-ypos)*(double)val[1]+ypos*(double)val[3];

    //x-direction size_terpolation
    t = (1-xpos)*t1 + xpos*t2;

    return (double)t;
}

bool CGDALRead::world2Pixel( double lat, double lon, double *x, double *y )
{
//  if (poTransformT==NULL)
//  {
//      poTransformT =OCTNewCoordinateTransformation(latLongSR, srcSR);
//  }

    if(poTransformT != NULL)
    {
        double height;
        OCTTransform(poTransformT,1, &lon, &lat, &height);

        double  adfInverseGeoTransform[6];
        GDALInvGeoTransform(mpGeoTransform, adfInverseGeoTransform);
        GDALApplyGeoTransform(adfInverseGeoTransform, lon,lat, x, y);

        return true;
    }
    else
    {
        return false;
    }

}

bool CGDALRead::pixel2World( double *lat, double *lon, double x, double y )
{
    if (poTransform!=NULL)
    {
        OCTDestroyCoordinateTransformation(poTransform);
        poTransform =OCTNewCoordinateTransformation(latLongSR, srcSR);
    }

    GDALApplyGeoTransform(mpGeoTransform, x, y, lon, lat);

    if(poTransform != NULL)
    {
        double height;
        OCTTransform(poTransform,1, lon, lat, &height);
        return true;
    }
    else
    {
        return false;
    }
}

bool CGDALRead::pixel2Ground( double x,double y,double* pX,double* pY )
{
    GDALApplyGeoTransform(mpGeoTransform, x, y, pX, pY);

    return true;
}

bool CGDALRead::ground2Pixel( double X,double Y,double* px,double* py )
{
    double  adfInverseGeoTransform[6];

    GDALInvGeoTransform(mpGeoTransform, adfInverseGeoTransform);
    GDALApplyGeoTransform(adfInverseGeoTransform, X, Y, px, py);

    return true;
}

GDALWrite.h

/************************************************************************/
/* This class is wrote for supercomputer to write image use parallel.
/* Not support Block read & write
/* But support multi-thread
/* Author: Y. Yao
/* E-mail: whuyao@foxmail.com
/* Version: v4.0
/************************************************************************/

#ifndef CLASS_GDAL_WRITE
#define CLASS_GDAL_WRITE

#include "gdal_priv.h"
#include "ogr_core.h"
#include "ogr_spatialref.h"

class CGDALRead;

class CGDALWrite
{
public:
    CGDALWrite(void);
    ~CGDALWrite(void);

public:
    bool init(const char* _filename, size_t _rows, size_t _cols, size_t _bandnum,\
                double _pGeoTransform[6], const char* _sProjectionRef, \
                GDALDataType _datatype = GDT_Byte, \
                double _dInvalidVal = 0.0f);

    bool init(const char* _filename, CGDALRead* pRead);

    bool init(const char* _filename, CGDALRead* pRead, size_t bandnum, \
                GDALDataType _datatype = GDT_Byte, \
                double _dInvalidVal = 0.0f);

    void write(size_t _row, size_t _col, size_t _band, void* pVal);

public:
    void close();

public:
    GDALDriver* poDriver();
    GDALDataset* poDataset();
    size_t rows();
    size_t cols();
    size_t bandnum();
    size_t datalength();
    double invalidValue();
    unsigned char* imgData();
    GDALDataType datatype();
    double* geotransform();
    char* projectionRef();
    size_t perPixelSize();

public:
    bool world2Pixel(double lat, double lon, double *pcol, double *prow);
    bool pixel2World(double *lat, double *lon, double col, double row);
    bool pixel2Ground(double col,double row,double* pX,double* pY);
    bool ground2Pixel(double X,double Y,double* pcol,double* prow);

protected:
    template<class TT> bool createData();

protected:
    GDALDriver* mpoDriver;      //can not release this, maybe cause some memory error!
    GDALDataset* mpoDataset;    //=>
    size_t mnRows;                  //
    size_t mnCols;                  //
    size_t mnBands;             //
    unsigned char* mpData;      //=>
    GDALDataType mgDataType;    //
    size_t mnDatalength;            //=>
    double mpGeoTransform[6];   //
    char msProjectionRef[2048]; //
    char msFilename[2048];      //
    double mdInvalidValue;      //
    size_t mnPerPixSize;            //=>

public:
    OGRSpatialReferenceH srcSR;
    OGRSpatialReferenceH latLongSR;
    OGRCoordinateTransformationH poTransform;   //pixel->world
    OGRCoordinateTransformationH poTransformT;  //world->pixel
};

#endif

GDALWrite.cpp

#include "GDALWrite.h"
#include "ogrsf_frmts.h"
#include "GDALRead.h"
#include <iostream>
using namespace std;


CGDALWrite::CGDALWrite(void)
{
    mpoDriver = NULL;
    mpoDataset = NULL;
    mnRows = mnCols = mnBands = -1;
    mpData = NULL;
    mgDataType = GDT_Byte;
    mnDatalength = 0;
    memset(mpGeoTransform, 0, 6*sizeof(double));
    strcpy(msProjectionRef, "");
    strcpy(msFilename, "");
    mdInvalidValue = 0.0f;
    mnPerPixSize = 1;

    //
    srcSR = NULL;
    latLongSR = NULL;
    poTransform = NULL;
    poTransformT = NULL;
}


CGDALWrite::~CGDALWrite(void)
{
    close();
}

void CGDALWrite::close()
{
    //write into data
    if (mpoDataset!=NULL && mpData!=NULL)
    {
        mpoDataset->RasterIO(GF_Write, 0, 0, mnCols, mnRows, \
            mpData, mnCols, mnRows, mgDataType, mnBands, 0, 0, 0, 0);
        mpoDataset->FlushCache();
    }


    release memory
    if (mpoDataset!=NULL)
    {
        GDALClose(mpoDataset);
        mpoDataset = NULL;
    }

    mnRows = mnCols = mnBands = -1;

    if (mpData!=NULL)
    {
        delete []mpData;
        mpData = NULL;
    }



    mgDataType = GDT_Byte;
    mnDatalength = 0;
    memset(mpGeoTransform, 0, 6*sizeof(double));
    strcpy(msProjectionRef, "");
    strcpy(msFilename, "");
    mdInvalidValue = 0.0f;
    mnPerPixSize = 1;

    //destory
    if (poTransform!=NULL)
        OCTDestroyCoordinateTransformation(poTransform);
    poTransform = NULL;

    if (poTransformT!=NULL)
        OCTDestroyCoordinateTransformation(poTransformT);
    poTransformT = NULL;

    if (latLongSR != NULL)
        OSRDestroySpatialReference(latLongSR);
    latLongSR = NULL;

    if (srcSR!=NULL)
        OSRDestroySpatialReference(srcSR);
    srcSR = NULL;

//  if (mpoDriver!=NULL)
//  {
//      //GDALDestroyDriver(mpoDriver);
//      delete mpoDriver;
//      mpoDriver = NULL;
//  }

}

GDALDriver* CGDALWrite::poDriver()
{
    return mpoDriver;
}

GDALDataset* CGDALWrite::poDataset()
{
    return mpoDataset;
}

size_t CGDALWrite::rows()
{
    return mnRows;
}

size_t CGDALWrite::cols()
{
    return mnCols;
}

size_t CGDALWrite::bandnum()
{
    return mnBands;
}

size_t CGDALWrite::datalength()
{
    return mnDatalength;
}

double CGDALWrite::invalidValue()
{
    return mdInvalidValue;
}

unsigned char* CGDALWrite::imgData()
{
    return mpData;
}

GDALDataType CGDALWrite::datatype()
{
    return mgDataType;
}

double* CGDALWrite::geotransform()
{
    return mpGeoTransform;
}

char* CGDALWrite::projectionRef()
{
    return msProjectionRef;
}

size_t CGDALWrite::perPixelSize()
{
    return mnPerPixSize;
}

bool CGDALWrite::init( const char* _filename, size_t _rows, size_t _cols, size_t _bandnum, double _pGeoTransform[6], const char* _sProjectionRef, GDALDataType _datatype /*= GDT_Byte*/, double _dInvalidVal /*= 0.0f*/ )
{
    close();

    //register
    if(GDALGetDriverCount() == 0)
    {
        GDALAllRegister();
        OGRRegisterAll();
        CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");
    }

    //load
    mpoDriver = GetGDALDriverManager()->GetDriverByName("GTiff");
    if (mpoDriver == NULL)
    {
        cout<<"CGDALWrite::init : Create poDriver Failed."<<endl;
        close();
        return false;
    }

    //
    strcpy(msFilename, _filename);
    mnRows = _rows;
    mnCols = _cols;
    mnBands = _bandnum;

    for (size_t i=0; i<6; i++)
        mpGeoTransform[i] = _pGeoTransform[i];

    strcpy(msProjectionRef, _sProjectionRef);
    mgDataType = _datatype;
    mdInvalidValue = _dInvalidVal;

    //create podataset
    char** papseMetadata = mpoDriver->GetMetadata();
    mpoDataset = mpoDriver->Create(msFilename, mnCols, mnRows, mnBands, mgDataType, papseMetadata);
    if (mpoDataset == NULL)
    {
        cout<<"CGDALWrite::init : Create poDataset Failed."<<endl;
        close();
        return false;       
    }

    //create others
    srcSR = OSRNewSpatialReference(msProjectionRef); // ground
    latLongSR = OSRCloneGeogCS(srcSR);  //geo
    poTransform =OCTNewCoordinateTransformation(srcSR, latLongSR);
    poTransformT =OCTNewCoordinateTransformation(latLongSR, srcSR);

    //add projection and coordinate
    poDataset()->SetGeoTransform(mpGeoTransform);
    poDataset()->SetProjection(msProjectionRef);
    for (size_t i =0; i<mnBands; i++)
    {
        poDataset()->GetRasterBand(i+1)->SetNoDataValue(mdInvalidValue);
    }

    //create data
    bool bRlt = false;
    switch(mgDataType)
    {
    case GDT_Byte:
        bRlt = createData<unsigned char>();
        break;
    case GDT_UInt16:
        bRlt = createData<unsigned short>();
        break;
    case GDT_Int16:
        bRlt = createData<short>();
        break;
    case GDT_UInt32:
        bRlt = createData<unsigned int>();
        break;
    case GDT_Int32:
        bRlt = createData<int>();
        break;
    case GDT_Float32:
        bRlt = createData<float>();
        break;
    case GDT_Float64:
        bRlt = createData<double>();
        break;
    default:
        cout<<"CGDALWrite::init : unknown data type!"<<endl;
        close();
        return false;
    }

    if (bRlt == false)
    {
        cout<<"CGDALWrite::init : Create data error!"<<endl;
        close();
        return false;
    }

    return true;
}

bool CGDALWrite::init( const char* _filename, CGDALRead* pRead )
{
    if (pRead == NULL)
    {
        cout<<"CGDALWrite::init : CGDALRead Point is Null."<<endl;
        return false;
    }

    return init(_filename, pRead->rows(), pRead->cols(), pRead->bandnum(), \
        pRead->geotransform(), pRead->projectionRef(), pRead->datatype(), 
        pRead->invalidValue());
}

bool CGDALWrite::init( const char* _filename, CGDALRead* pRead, size_t bandnum, GDALDataType _datatype /*= GDT_Byte*/, double _dInvalidVal /*= 0.0f*/ )
{
    if (pRead == NULL)
    {
        cout<<"CGDALWrite::init : CGDALRead Point is Null."<<endl;
        return false;
    }

    return init(_filename, pRead->rows(), pRead->cols(), bandnum, \
                pRead->geotransform(), pRead->projectionRef(), _datatype, 
                _dInvalidVal);

}

template<class TT> bool CGDALWrite::createData()
{
    if (mpoDataset == NULL)
        return false;

    if (mpData!=NULL)
        delete mpData;
    mpData = NULL;

    mnPerPixSize = sizeof(TT);
    mnDatalength = mnRows*mnCols*mnBands*mnPerPixSize;
    mpData = new unsigned char[mnDatalength];
    memset(mpData, 0, mnDatalength);
    return true;
}

void CGDALWrite::write( size_t _row, size_t _col, size_t _band, void* pVal )
{
    size_t nloc = (_band*mnRows*mnCols + _row*mnCols + _col)*mnPerPixSize;
    memcpy(mpData+nloc, pVal, mnPerPixSize);    
}

bool CGDALWrite::world2Pixel( double lat, double lon, double *x, double *y )
{
//  if (poTransformT==NULL)
//  {
//      poTransformT =OCTNewCoordinateTransformation(latLongSR, srcSR);
//  }


    if(poTransformT != NULL)
    {
        double height;
        OCTTransform(poTransformT,1, &lon, &lat, &height);

        double  adfInverseGeoTransform[6];
        GDALInvGeoTransform(mpGeoTransform, adfInverseGeoTransform);
        GDALApplyGeoTransform(adfInverseGeoTransform, lon,lat, x, y);

        return true;
    }
    else
    {
        return false;
    }
}

bool CGDALWrite::pixel2World( double *lat, double *lon, double x, double y )
{
    if (poTransform!=NULL)
    {
        OCTDestroyCoordinateTransformation(poTransform);
        poTransform =OCTNewCoordinateTransformation(latLongSR, srcSR);
    }

    GDALApplyGeoTransform(mpGeoTransform, x, y, lon, lat);

    if(poTransform != NULL)
    {
        double height;
        OCTTransform(poTransform,1, lon, lat, &height);
        return true;
    }
    else
    {
        return false;
    }
}

bool CGDALWrite::pixel2Ground( double x,double y,double* pX,double* pY )
{
    GDALApplyGeoTransform(mpGeoTransform, x, y, pX, pY);

    return true;
}

bool CGDALWrite::ground2Pixel( double X,double Y,double* px,double* py )
{
    double  adfInverseGeoTransform[6];

    GDALInvGeoTransform(mpGeoTransform, adfInverseGeoTransform);
    GDALApplyGeoTransform(adfInverseGeoTransform, X, Y, px, py);

    return true;
}
尧哥大魔王
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Python的GDAL高分变率遥感影像配准算法
05-30
（1）基于SIFT与Ransac算法完成两景高分辨率遥感影像特征特征提取以及几何变换进行配准。 （2）为避免同名点过大区域错误配准，可进行影像的分块配准，需要注意的是两景影像保证行、列数一致。 （3）因数据上传限制...
使用GDAL进行坐标转换
alex1801
02-24 4459
我国的基本比例尺地形图（1：5千，1：1万，1：2.5万，1：10万，1：25万，1：50万，1：100万）中，大于或等于1：50万均采用高斯-克吕格投影（Gauss_Kruger），又叫横轴墨卡托投影（Transverse Mercator）；投影坐标系统是根据某种映射关系，将地理坐标系统中由经纬度确定的三维球面坐标投影到二维的平面上所使用的坐标系统。地图投影就是把地球表面的任意点，利用一定数学法则，转换到地图平面上的理论和方法，一般有两种坐标系来进行表示，分别是地理坐标系和投影坐标系。
【Python Mapnik+GDAL实现免发布切片服务】
qq_22865879的博客
06-19 629
基于Mapnik创建切片的方案，实现数据免发布预览
GDAL并行IO的疑问
weixin_34253539的博客
04-13 390
GDAL是否可以支持并行I/O？ 最近使用GDAL并行IO读写实验，我们采用GDAL库+MPI+NFS在fedora15系统上开展，实验证明该方法没有遇到预先设想的问题， 比如：写文件冲突。目前我也不清楚是否是NFS有内在机制会协调各个进程之间的先后顺序，总之现在看来并行计算是没有问题的，但是 不少人说GDAL是不支持并行IO的，有人采用令牌循环的方式写文件，实质还是串行。该天换个大数据试试...
使用Python和GDAL处理遥感影像数据超详细教程
晚来天欲雪，能饮一杯无？
12-16 9176
在本教程中，我们将学习使用 Python 和地理空间数据抽象库 GDAL 自动处理栅格数据的基本技术。
利用GDAL实现影像的几何校正
热门推荐
心如止水-GISer的成长之路
06-01 2万+
一、概述    遥感影像和地理坐标进行关联的方式一般有好几种，一种是直接给出了仿射变换系数，即6个参数，左上角地理坐标，纵横方向上的分辨率，以及旋转系数。在这种情况下，求出某一像素点的地理坐标非常容易，直接用公式可以求出，具体代码如下：void CPL_STDCALL GDALApplyGeoTransform(double *padfGeoTransform,
Python+gdal实现img/tiff遥感影像的PCA（主成分分析）
07-12
对数据进行归一化处理（直接减去均值） 计算归一化后的数据集的协方差矩阵 计算协方差矩阵的特征值和特征向量 保留最重要的k个特征（通常k要小于n），也可以自己制定，也可以选择一个阈值，然后通过前k个特征值之和...
基于Python-GDAL的遥感影像镶嵌脚本
03-29
- 读取影像数据 - 将数据写入输出文件的相应位置 6. **设置输出文件的地理信息**：包括投影、行列坐标等，确保镶嵌后的图像具有地理参考。 7. **保存并关闭文件**：最后，使用`ds.FlushCache()`保存结果，`ds = ...
GDAL_RW.zip_GDAL_gdal分块_gdal图像分块_遥感_遥感影像读写
09-21
GDAL_RW.zip是基于GDAL的一个实用工具，能够高效地管理和操作遥感影像，提高数据处理的效率。无论你是GIS开发者还是遥感分析师，了解并掌握GDAL及其分块读写技术，都将极大地提升你的工作效率和项目质量。
基于GDAL实现多shp多影像的栅格数据批量裁剪
05-26
因为遥感影像大部分都是栅格数据，所以GDAL库非常适合处理遥感影像、如光谱指数计算、波段合成、批量下载等。 本资源使用Python的GDAL库，实现一个或多个矢量文件，批量对一个或多个栅格数据进行裁剪，大大减少了...
深入解析GDAL库的RasterIO()函数
xiaoxiaoxiao的博客
10-12 1万+
转自：http://blog.csdn.net/liminlu0314/article/details/8301585 首先说明一下GDALRasterBand的RasterIO函数，波段类的RasterIO函数相比GDALDataset类的RasterIO函数比较简单，先从这个简单的说起。图像还是以上面的图为例，我们只取第一个波段为例进行说明。第一个波段的图像如下图所示：
python 使用gdal生成tif数值不对的问题，另附python使用gdal读写tif文件
lionhenryzxxy的博客
11-12 3882
想了一下，先说一下读写tif这两个基本操作吧 1、读取tif为矩阵 #获取文件句柄 handle = gdal.Open(‘123.tif’) #获取文件的列数、行数和波段数 col = handle.RasterXsize row = handle.RasterYsize #获取放射信息和投影信息 geotrans = handle.GetGeoTransform() geoi...
Python—图像中无效值像元最临近填充
shanyanyi7173的博客
04-01 1464
import gdal import numpy as np from scipy import ndimage as nd file = r"D:\微信公众号\数据填补\处理前.tif" outfile = r"D:\微信公众号\数据填补\处理后.tif" ds = gdal.Open(file) cols = ds.RasterXSize rows = ds.RasterYSize geo = ds.GetGeoTransform() proj = ds.GetProjection() band = .
Python CGDAL类——支持栅格数据的栅格计算/线性增强/滤波增强
liuph_的博客
09-09 2090
# -*- coding: UTF-8 -*- ''' python version: 2.7.11 numpy ver=1.11.1 gdal ver=2.0.3 Author: Liuph Date: 2016/9/9 Description: This is a GDAL Class adapted from the Python GDAL_OGR Cookbook document
GDAL(python) 之GeoTransform（3）
最新发布
weixin_45973418的博客
03-08 449
使用GDAL库读出的dataset带有两个重要的地理参数，分别是Projection（暂未搞清这个是干啥的）和GeoTransform（用作仿射变换的）。有了这两个参数，就确定了影像的地理位置。注意：本代码仅测试输出的top和botton可以上下接起来，并不讨论top.tif和bottopm.tif的真实投影位置。左上角x坐标， 水平分辨率，旋转参数， 左上角y坐标，旋转参数，竖直分辨率（负值，原点坐标在左上角）。再GDAL for Python中，GeoTransform是一个六个元素的元组。
GDAL栅格数据处理教程
weixin_44785184的博客
02-20 4401
本文结合实例详细讲解了如何使用GDAL操作栅格数据，包括栅格数据的读写，以及一些常用的栅格数据处理操作，如坐标变换、裁剪、镶嵌、插值等。
GDAL中GDALDataType中值与其在C++中数据类型对应
阿a楞的博客
11-29 5561
GDAL中的GDALDataType是一个枚举型，其中的值为： GDT_Unknown : 未知数据类型 GDT_Byte : 8bit正整型 (C++中对应unsigned char) GDT_UInt16 : 16bit正整型 (C++中对应 unsigned short) GDT_Int16 : 16bit整型 (C++中对应 short 或 short int) GDT_UInt...
GDAL:影像镶嵌
hpu_lx
01-17 2175
//main.cpp #include "../IndexCalculation/IndexCalculation/ImageMosaicing.h" #include <iostream> #include <vector> #include <algorithm> #include "gdal_priv.h" using namespace std; ...
win7 VS2015编译GDAL 正在创建库 gdal_i.lib 和对象 gdal_i.exp时候报错：LINK : error LNK2001: 无法解析的外部符号 _OSRValidate
Jeacean的博客
12-24 2093
win7 VS2015编译GDAL 正在创建库 gdal_i.lib 和对象 gdal_i.exp时候报错：LINK : error LNK2001: 无法解析的外部符号 _OSRValidate … 编译器：VS2015 操作系统：win7 X64 GDAL版本：gdal_3.0.1 错误信息如下 正在创建库 gdal_i.lib 和对象 gdal_i.exp LINK : error LNK2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值