1916 lines
51 KiB
C++
1916 lines
51 KiB
C++
// Copyright 2021 Airbus Defence and Space
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#define _GNU_SOURCE 1
|
|
#include "godal.h"
|
|
#include <gdal.h>
|
|
#include <ogr_srs_api.h>
|
|
#include <cpl_conv.h>
|
|
#include "cpl_port.h"
|
|
#include "cpl_string.h"
|
|
#include "cpl_vsi.h"
|
|
#include "cpl_vsi_virtual.h"
|
|
#include <gdal_frmts.h>
|
|
#include <ogrsf_frmts.h>
|
|
#include <dlfcn.h>
|
|
#include <cassert>
|
|
|
|
#include <gdal_utils.h>
|
|
#include <gdal_alg.h>
|
|
#include <gdalgrid.h>
|
|
|
|
extern "C" {
|
|
extern long long int _gogdalSizeCallback(char* key, char** errorString);
|
|
extern int _gogdalMultiReadCallback(char* key, int nRanges, void* pocbuffers, void* coffsets, void* clengths, char** errorString);
|
|
extern size_t _gogdalReadCallback(char* key, void* buffer, size_t off, size_t clen, char** errorString);
|
|
extern int goErrorHandler(int loggerID, CPLErr lvl, int code, const char *msg);
|
|
}
|
|
|
|
static void godalErrorHandler(CPLErr e, CPLErrorNum n, const char* msg) {
|
|
cctx *ctx = (cctx*)CPLGetErrorHandlerUserData();
|
|
assert(ctx!=nullptr);
|
|
if (ctx->handlerIdx !=0) {
|
|
int ret = goErrorHandler(ctx->handlerIdx, e, n, msg);
|
|
if(ret!=0 && ctx->failed==0) {
|
|
ctx->failed=1;
|
|
}
|
|
} else {
|
|
//let's be strict and treat all warnings as errors
|
|
if (e < CE_Warning)
|
|
{
|
|
fprintf(stderr, "GDAL: %s\n", msg);
|
|
return;
|
|
}
|
|
if (ctx->errMessage == nullptr)
|
|
{
|
|
ctx->errMessage = (char *)malloc(strlen(msg) + 1);
|
|
strcpy(ctx->errMessage, msg);
|
|
}
|
|
else
|
|
{
|
|
ctx->errMessage = (char *)realloc(ctx->errMessage, strlen(ctx->errMessage) + strlen(msg) + 3);
|
|
strcat(ctx->errMessage, "\n");
|
|
strcat(ctx->errMessage, msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void godalWrap(cctx *ctx) {
|
|
CPLPushErrorHandlerEx(&godalErrorHandler,ctx);
|
|
if(ctx->configOptions!=nullptr) {
|
|
char **options = ctx->configOptions;
|
|
for(char* option=*options; option; option=*(++options)) {
|
|
char *idx = strchr(option,'=');
|
|
if(idx) {
|
|
*idx='\0';
|
|
CPLSetThreadLocalConfigOption(option,idx+1);
|
|
*idx='=';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void godalUnwrap() {
|
|
cctx *ctx = (cctx*)CPLGetErrorHandlerUserData();
|
|
CPLPopErrorHandler();
|
|
if(ctx->configOptions!=nullptr) {
|
|
char **options = ctx->configOptions;
|
|
for(char* option=*options; option; option=*(++options)) {
|
|
char *idx = strchr(option,'=');
|
|
if(idx) {
|
|
*idx='\0';
|
|
CPLSetThreadLocalConfigOption(option,nullptr);
|
|
*idx='=';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline int failed(cctx *ctx) {
|
|
if (ctx->errMessage!=nullptr || ctx->failed!=0) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline void forceError(cctx *ctx) {
|
|
if (ctx->errMessage == nullptr && ctx->failed==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "unknown error");
|
|
}
|
|
}
|
|
inline void forceCPLError(cctx *ctx, CPLErr err) {
|
|
if (ctx->errMessage == nullptr && ctx->failed==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "unknown cpl error %d", err);
|
|
}
|
|
}
|
|
inline void forceOGRError(cctx *ctx, OGRErr err) {
|
|
if (ctx->errMessage == nullptr && ctx->failed==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "unknown ogr error %d", err);
|
|
}
|
|
}
|
|
|
|
void godalSetMetadataItem(cctx *ctx, GDALMajorObjectH mo, char *ckey, char *cval, char *cdom) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetMetadataItem(mo,ckey,cval,cdom);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
void godalClearMetadata(cctx *ctx, GDALMajorObjectH mo, char *cdom) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetMetadata(mo,nullptr,cdom);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
void godalSetDescription(cctx *ctx, GDALMajorObjectH mo, char *desc) {
|
|
godalWrap(ctx);
|
|
GDALSetDescription(mo,desc);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalSetRasterColorInterpretation(cctx *ctx, GDALRasterBandH bnd, GDALColorInterp ci) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetRasterColorInterpretation(bnd,ci);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALDatasetH godalOpen(cctx *ctx, const char *name, unsigned int nOpenFlags, const char *const *papszAllowedDrivers,
|
|
const char *const *papszOpenOptions, const char *const *papszSiblingFiles) {
|
|
godalWrap(ctx);
|
|
GDALDatasetH ret = GDALOpenEx(name,nOpenFlags,papszAllowedDrivers,papszOpenOptions,papszSiblingFiles);
|
|
if (ret == nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalClose(cctx *ctx, GDALDatasetH ds) {
|
|
godalWrap(ctx);
|
|
GDALClose(ds);
|
|
godalUnwrap();
|
|
}
|
|
|
|
typedef void (*fn_def)(void);
|
|
|
|
int _go_registerDriver(const char *driver, const char *prefix) {
|
|
char *fnname = (char*)calloc(1,strlen(driver)+strlen(prefix)+1);
|
|
sprintf(fnname,"%s%s",prefix,driver);
|
|
void *fcn = dlsym(RTLD_DEFAULT,fnname);
|
|
free(fnname);
|
|
if (fcn != nullptr) {
|
|
fn_def fnptr = (fn_def)fcn;
|
|
fnptr();
|
|
} else {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int godalRegisterDriver(const char *fnname) {
|
|
void *fcn = dlsym(RTLD_DEFAULT,fnname);
|
|
if (fcn != nullptr) {
|
|
fn_def fnptr = (fn_def)fcn;
|
|
fnptr();
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void godalRegisterPlugins(){
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 8, 0)
|
|
GDALRegisterPlugins();
|
|
#endif
|
|
}
|
|
|
|
void godalRegisterPlugin(cctx *ctx, const char *name){
|
|
godalWrap(ctx);
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 8, 0)
|
|
CPLErr ret = GDALRegisterPlugin(name);
|
|
if (ret != 0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
#else
|
|
CPLError(CE_Failure, CPLE_NotSupported, "GDALRegisterPlugin is only supported in GDAL version >= 3.8");
|
|
#endif
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALDatasetH godalCreate(cctx *ctx, GDALDriverH drv, const char* name, int width, int height, int nbands,
|
|
GDALDataType dtype, char **options) {
|
|
godalWrap(ctx);
|
|
GDALDatasetH ret = GDALCreate(drv,name,width,height,nbands,dtype,options);
|
|
if (ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalDatasetSetSpatialRef(cctx *ctx, GDALDatasetH ds, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetSpatialRef(ds,sr);
|
|
if (ret!=0) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
char *exportToWKT(cctx *ctx, OGRSpatialReferenceH sr) {
|
|
char *pszSRS = nullptr;
|
|
OGRErr gret = OSRExportToWkt(sr,&pszSRS);
|
|
if (gret!=OGRERR_NONE && !failed(ctx)) {
|
|
forceOGRError(ctx, gret);
|
|
}
|
|
if(failed(ctx)) {
|
|
CPLFree(pszSRS);
|
|
pszSRS=nullptr;
|
|
}
|
|
|
|
/*TODO: handle wkt2 retry
|
|
if (gret!=OGRERR_NONE || failed(ctx)) {
|
|
CPLFree(pszSRS);
|
|
pszSRS = nullptr;
|
|
const char *const apszOptions[] = {"FORMAT=WKT2", nullptr};
|
|
gret = oOutputSRS.exportToWkt(&pszSRS, apszOptions);
|
|
if (gret!=OGRERR_NONE || failed(ctx)) {
|
|
forceOGRError(ctx, gret);
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
return pszSRS;
|
|
}
|
|
|
|
void godalSetProjection(cctx *ctx, GDALDatasetH ds, char *wkt) {
|
|
godalWrap(ctx);
|
|
if(wkt==nullptr||*wkt==0) {
|
|
CPLErr ret = GDALSetSpatialRef(ds,nullptr);
|
|
if (ret != 0)
|
|
{
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
OGRSpatialReferenceH sr = OSRNewSpatialReference(nullptr);
|
|
OSRSetAxisMappingStrategy(sr, OAMS_TRADITIONAL_GIS_ORDER);
|
|
|
|
OGRErr gret = OSRSetFromUserInput(sr,wkt);
|
|
if (gret!=OGRERR_NONE || failed(ctx)) {
|
|
forceOGRError(ctx,gret);
|
|
godalUnwrap();
|
|
OSRDestroySpatialReference(sr);
|
|
return;
|
|
}
|
|
CPLErr ret = GDALSetSpatialRef(ds,sr);
|
|
if (ret!=0) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
OSRDestroySpatialReference(sr);
|
|
}
|
|
|
|
char *godalExportToWKT(cctx *ctx, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
char *pszSRS = exportToWKT(ctx, sr);
|
|
godalUnwrap();
|
|
return pszSRS;
|
|
}
|
|
|
|
OGRSpatialReferenceH godalCreateWKTSpatialRef(cctx *ctx, char *wkt){
|
|
godalWrap(ctx);
|
|
OGRSpatialReferenceH sr = OSRNewSpatialReference(nullptr);
|
|
OSRSetAxisMappingStrategy(sr, OAMS_TRADITIONAL_GIS_ORDER);
|
|
OGRErr gret = OSRImportFromWkt(sr, &wkt);
|
|
if(gret!=0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
if( failed(ctx) ) {
|
|
OSRDestroySpatialReference(sr);
|
|
return nullptr;
|
|
}
|
|
return sr;
|
|
}
|
|
|
|
OGRSpatialReferenceH godalCreateProj4SpatialRef(cctx *ctx, char *proj) {
|
|
godalWrap(ctx);
|
|
OGRSpatialReferenceH sr = OSRNewSpatialReference(nullptr);
|
|
OSRSetAxisMappingStrategy(sr, OAMS_TRADITIONAL_GIS_ORDER);
|
|
OGRErr gret = OSRImportFromProj4(sr, proj);
|
|
if(gret!=0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
if( failed(ctx) ) {
|
|
OSRDestroySpatialReference(sr);
|
|
return nullptr;
|
|
}
|
|
return sr;
|
|
}
|
|
|
|
OGRSpatialReferenceH godalCreateEPSGSpatialRef(cctx *ctx, int epsgCode) {
|
|
godalWrap(ctx);
|
|
OGRSpatialReferenceH sr = OSRNewSpatialReference(nullptr);
|
|
OSRSetAxisMappingStrategy(sr, OAMS_TRADITIONAL_GIS_ORDER);
|
|
OGRErr gret = OSRImportFromEPSG(sr, epsgCode);
|
|
if(gret!=0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
if( failed(ctx) ) {
|
|
OSRDestroySpatialReference(sr);
|
|
return nullptr;
|
|
}
|
|
return sr;
|
|
}
|
|
|
|
OGRSpatialReferenceH godalCreateUserSpatialRef(cctx *ctx, char *userInput) {
|
|
godalWrap(ctx);
|
|
OGRSpatialReferenceH sr = OSRNewSpatialReference(nullptr);
|
|
OSRSetAxisMappingStrategy(sr, OAMS_TRADITIONAL_GIS_ORDER);
|
|
OGRErr gret = OSRSetFromUserInput(sr, userInput);
|
|
if(gret!=0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
if( failed(ctx) ) {
|
|
OSRDestroySpatialReference(sr);
|
|
return nullptr;
|
|
}
|
|
return sr;
|
|
}
|
|
|
|
void godalValidateSpatialRef(cctx *ctx, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OSRValidate(sr);
|
|
if(gret!=0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
OGRCoordinateTransformationH godalNewCoordinateTransformation(cctx *ctx, OGRSpatialReferenceH src, OGRSpatialReferenceH dst) {
|
|
godalWrap(ctx);
|
|
OGRCoordinateTransformationH tr = OCTNewCoordinateTransformation(src,dst);
|
|
if ( tr == nullptr ) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return tr;
|
|
}
|
|
|
|
void godalSetGeoTransform(cctx *ctx, GDALDatasetH ds, double *gt){
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetGeoTransform(ds,gt);
|
|
if( ret != 0 ) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalGetGeoTransform(cctx *ctx, GDALDatasetH ds, double *gt){
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALGetGeoTransform(ds,gt);
|
|
if( ret != 0 ) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalRasterSize(GDALDatasetH ds, int *xsize, int *ysize) {
|
|
*xsize = GDALGetRasterXSize(ds);
|
|
*ysize = GDALGetRasterYSize(ds);
|
|
}
|
|
|
|
GDALRasterBandH* godalBandOverviews(GDALRasterBandH bnd) {
|
|
int count = GDALGetOverviewCount(bnd);
|
|
if(count == 0) {
|
|
return nullptr;
|
|
}
|
|
GDALRasterBandH *ret = (GDALRasterBandH*)malloc((count+1)*sizeof(GDALRasterBandH));
|
|
ret[count]=nullptr;
|
|
for(int i=0; i<count; i++) {
|
|
ret[i]=GDALGetOverview(bnd,i);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
GDALRasterBandH* godalRasterBands(GDALDatasetH ds) {
|
|
int count = GDALGetRasterCount(ds);
|
|
if(count == 0) {
|
|
return nullptr;
|
|
}
|
|
GDALRasterBandH *ret = (GDALRasterBandH*)malloc((count+1)*sizeof(GDALRasterBandH));
|
|
ret[count]=nullptr;
|
|
for(int i=0; i<count; i++) {
|
|
ret[i]=GDALGetRasterBand(ds,i+1);
|
|
}
|
|
return ret;
|
|
}
|
|
OGRLayerH* godalVectorLayers(GDALDatasetH ds) {
|
|
int count = GDALDatasetGetLayerCount(ds);
|
|
if(count == 0) {
|
|
return nullptr;
|
|
}
|
|
OGRLayerH *ret = (OGRLayerH*)malloc((count+1)*sizeof(OGRLayerH));
|
|
ret[count]=nullptr;
|
|
for(int i=0; i<count; i++) {
|
|
ret[i]=GDALDatasetGetLayer(ds,i);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void godalSetDatasetNoDataValue(cctx *ctx, GDALDatasetH ds, double nd) {
|
|
godalWrap(ctx);
|
|
int count = GDALGetRasterCount(ds);
|
|
if(count==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "cannot set nodata value on dataset with no raster bands");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
CPLErr ret = CE_None;
|
|
for(int i=1; i<=count;i++) {
|
|
CPLErr br = GDALSetRasterNoDataValue(GDALGetRasterBand(ds,i),nd);
|
|
if(br!=0 && ret==0) {
|
|
ret = br;
|
|
}
|
|
}
|
|
if ( ret != 0 ) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalSetRasterNoDataValue(cctx *ctx, GDALRasterBandH bnd, double nd) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSetRasterNoDataValue(bnd,nd);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalDeleteRasterNoDataValue(cctx *ctx, GDALRasterBandH bnd) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALDeleteRasterNoDataValue(bnd);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalSetDatasetScaleOffset(cctx *ctx, GDALDatasetH ds, double scale, double offset) {
|
|
godalWrap(ctx);
|
|
int count = GDALGetRasterCount(ds);
|
|
if(count==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "cannot set scale and offset on dataset with no raster bands");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
CPLErr ret = CE_None;
|
|
for(int i=1; i<=count;i++) {
|
|
CPLErr br;
|
|
|
|
br = GDALSetRasterScale(GDALGetRasterBand(ds,i),scale);
|
|
if(br!=0 && ret==0) {
|
|
ret = br;
|
|
}
|
|
|
|
br = GDALSetRasterOffset(GDALGetRasterBand(ds,i),offset);
|
|
if(br!=0 && ret==0) {
|
|
ret = br;
|
|
}
|
|
}
|
|
if ( ret != 0 ) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalSetRasterScaleOffset(cctx *ctx, GDALRasterBandH bnd, double scale, double offset) {
|
|
godalWrap(ctx);
|
|
CPLErr ret;
|
|
|
|
ret = GDALSetRasterScale(bnd,scale);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
|
|
ret = GDALSetRasterOffset(bnd,offset);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALRasterBandH godalCreateMaskBand(cctx *ctx, GDALRasterBandH bnd, int flags) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALCreateMaskBand(bnd, flags);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx,ret);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
GDALRasterBandH mbnd = GDALGetMaskBand(bnd);
|
|
if( mbnd == nullptr ) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return mbnd;
|
|
}
|
|
GDALRasterBandH godalCreateDatasetMaskBand(cctx *ctx, GDALDatasetH ds, int flags) {
|
|
godalWrap(ctx);
|
|
if (GDALGetRasterCount(ds) == 0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "cannot create mask band on dataset with no bands");
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
CPLErr ret = GDALCreateDatasetMaskBand(ds, flags);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
GDALRasterBandH mbnd = GDALGetMaskBand(GDALGetRasterBand(ds,1));
|
|
if( mbnd == nullptr ) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return mbnd;
|
|
}
|
|
|
|
GDALDatasetH godalTranslate(cctx *ctx, char *dstName, GDALDatasetH ds, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALTranslateOptions *translateopts = GDALTranslateOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALTranslateOptionsFree(translateopts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALTranslate(dstName, ds, translateopts, &usageErr);
|
|
GDALTranslateOptionsFree(translateopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
GDALDatasetH godalDatasetWarp(cctx *ctx, char *dstName, int nSrcCount, GDALDatasetH *srcDS, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALWarpAppOptions *warpopts = GDALWarpAppOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALWarpAppOptionsFree(warpopts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALWarp(dstName, nullptr, nSrcCount, srcDS, warpopts, &usageErr);
|
|
GDALWarpAppOptionsFree(warpopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalDatasetWarpInto(cctx *ctx, GDALDatasetH dstDs, int nSrcCount, GDALDatasetH *srcDS, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALWarpAppOptions *warpopts = GDALWarpAppOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALWarpAppOptionsFree(warpopts);
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALWarp(nullptr, dstDs, nSrcCount, srcDS, warpopts, &usageErr);
|
|
GDALWarpAppOptionsFree(warpopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALDatasetH godalDatasetVectorTranslate(cctx *ctx, char *dstName, GDALDatasetH ds, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALVectorTranslateOptions *opts = GDALVectorTranslateOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALVectorTranslateOptionsFree(opts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALVectorTranslate(dstName, nullptr, 1, &ds, opts, &usageErr);
|
|
GDALVectorTranslateOptionsFree(opts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalClearOverviews(cctx *ctx, GDALDatasetH ds) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALBuildOverviews(ds,"NEAREST",0,nullptr,0,nullptr,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalBuildOverviews(cctx *ctx, GDALDatasetH ds, const char *resampling, int nLevels, int *levels,
|
|
int nBands, int *bands) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALBuildOverviews(ds,resampling,nLevels,levels,nBands,bands,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalBandScaleOffset(GDALRasterBandH bnd, double *scale, double *offset) {
|
|
int pbSuccess = 0;
|
|
*scale = GDALGetRasterScale(bnd, &pbSuccess);
|
|
if (pbSuccess == 0) {
|
|
*scale = 1;
|
|
}
|
|
*offset = GDALGetRasterOffset(bnd, &pbSuccess);
|
|
if (pbSuccess == 0) {
|
|
*offset = 0;
|
|
}
|
|
}
|
|
|
|
void godalDatasetStructure(GDALDatasetH ds, int *sx, int *sy, int *bsx, int *bsy, double *scale, double *offset, int *bandCount, int *dtype) {
|
|
*sx=GDALGetRasterXSize(ds);
|
|
*sy=GDALGetRasterYSize(ds);
|
|
*bandCount=GDALGetRasterCount(ds);
|
|
*dtype=GDT_Unknown;
|
|
*bsx=*bsy=0;
|
|
if ( *bandCount > 0 ) {
|
|
GDALRasterBandH band = GDALGetRasterBand(ds,1);
|
|
*dtype = GDALGetRasterDataType(band);
|
|
GDALGetBlockSize(band,bsx,bsy);
|
|
godalBandScaleOffset(band, scale, offset);
|
|
}
|
|
}
|
|
void godalBandStructure(GDALRasterBandH bnd, int *sx, int *sy, int *bsx, int *bsy, double *scale, double *offset, int *dtype) {
|
|
*sx=GDALGetRasterBandXSize(bnd);
|
|
*sy=GDALGetRasterBandYSize(bnd);
|
|
*dtype=GDT_Unknown;
|
|
*bsx=*bsy=0;
|
|
*dtype = GDALGetRasterDataType(bnd);
|
|
GDALGetBlockSize(bnd, bsx, bsy);
|
|
godalBandScaleOffset(bnd, scale, offset);
|
|
}
|
|
|
|
void godalBandRasterIO(cctx *ctx, GDALRasterBandH bnd, GDALRWFlag rw, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer,
|
|
int nBXSize, int nBYSize, GDALDataType eBDataType, int nPixelSpace, int nLineSpace, GDALRIOResampleAlg alg) {
|
|
godalWrap(ctx);
|
|
GDALRasterIOExtraArg exargs;
|
|
INIT_RASTERIO_EXTRA_ARG(exargs);
|
|
if (alg != GRIORA_NearestNeighbour) {
|
|
exargs.eResampleAlg = alg;
|
|
}
|
|
CPLErr ret = GDALRasterIOEx(bnd, rw, nDSXOff, nDSYOff, nDSXSize, nDSYSize, pBuffer, nBXSize, nBYSize,
|
|
eBDataType, nPixelSpace, nLineSpace, &exargs);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalDatasetRasterIO(cctx *ctx, GDALDatasetH ds, GDALRWFlag rw, int nDSXOff, int nDSYOff, int nDSXSize, int nDSYSize, void *pBuffer,
|
|
int nBXSize, int nBYSize, GDALDataType eBDataType, int nBandCount, int *panBandCount,
|
|
int nPixelSpace, int nLineSpace, int nBandSpace, GDALRIOResampleAlg alg) {
|
|
godalWrap(ctx);
|
|
GDALRasterIOExtraArg exargs;
|
|
INIT_RASTERIO_EXTRA_ARG(exargs);
|
|
if (alg != GRIORA_NearestNeighbour) {
|
|
exargs.eResampleAlg = alg;
|
|
}
|
|
CPLErr ret = GDALDatasetRasterIOEx(ds, rw, nDSXOff, nDSYOff, nDSXSize, nDSYSize, pBuffer, nBXSize, nBYSize,
|
|
eBDataType, nBandCount, panBandCount, nPixelSpace, nLineSpace, nBandSpace, &exargs);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFillRaster(cctx *ctx, GDALRasterBandH bnd, double real, double imag) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALFillRaster(bnd,real,imag);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
|
|
}
|
|
|
|
void godalPolygonize(cctx *ctx, GDALRasterBandH in, GDALRasterBandH mask, OGRLayerH layer,int fieldIndex, char **opts) {
|
|
godalWrap(ctx);
|
|
if (fieldIndex >= OGR_FD_GetFieldCount(OGR_L_GetLayerDefn(layer))) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "invalid fieldIndex");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
CPLErr ret = GDALPolygonize(in,mask,layer,fieldIndex,opts,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalSieveFilter(cctx *ctx, GDALRasterBandH bnd, GDALRasterBandH mask, GDALRasterBandH dst, int sizeThreshold, int connectedNess) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALSieveFilter(bnd,mask,dst,sizeThreshold,connectedNess,nullptr,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFillNoData(cctx *ctx, GDALRasterBandH in, GDALRasterBandH mask, int maxDistance, int iterations, char **opts) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALFillNodata(in,mask,maxDistance,0,iterations,opts,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALDatasetH godalRasterize(cctx *ctx, char *dstName, GDALDatasetH dstDS, GDALDatasetH ds, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALRasterizeOptions *ropts = GDALRasterizeOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALRasterizeOptionsFree(ropts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALRasterize(dstName, dstDS, ds, ropts, &usageErr);
|
|
GDALRasterizeOptionsFree(ropts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalRasterizeGeometry(cctx *ctx, GDALDatasetH ds, OGRGeometryH geom, int *bands, int nBands, double *vals, int allTouched) {
|
|
const char *opts[2] = { "ALL_TOUCHED=TRUE",nullptr };
|
|
char **copts=(char**)opts;
|
|
if (!allTouched) {
|
|
copts=nullptr;
|
|
}
|
|
godalWrap(ctx);
|
|
CPLErr ret = GDALRasterizeGeometries(ds,nBands,bands,1,&geom,nullptr,nullptr,vals,copts,nullptr,nullptr);
|
|
if(ret!=0){
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalLayerDeleteFeature(cctx *ctx, OGRLayerH layer, OGRFeatureH feat) {
|
|
godalWrap(ctx);
|
|
GIntBig fid = OGR_F_GetFID(feat);
|
|
if (fid == OGRNullFID) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "cannot delete feature with no FID");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
OGRErr gret = OGR_L_DeleteFeature(layer,fid);
|
|
if(gret!=0){
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalLayerSetFeature(cctx *ctx, OGRLayerH layer, OGRFeatureH feat) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_L_SetFeature(layer,feat);
|
|
if(gret!=0){
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalLayerSetGeometryColumnName(cctx *ctx, OGRLayerH layer, char *name) {
|
|
godalWrap(ctx);
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 6, 0)
|
|
OGRGeomFieldDefnH fieldWithNewName = OGR_GFld_Create(name, OGRwkbGeometryType(0));
|
|
OGRErr gret = OGR_L_AlterGeomFieldDefn(layer, 0, fieldWithNewName, ALTER_GEOM_FIELD_DEFN_NAME_FLAG);
|
|
if(gret!=0){
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
#else
|
|
CPLError(CE_Failure, CPLE_NotSupported, "OGR_L_AlterGeomFieldDefn is only supported in GDAL version >= 3.6");
|
|
#endif
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetGeometryColumnName(cctx *ctx, OGRFeatureH feat, char *name) {
|
|
godalWrap(ctx);
|
|
OGRGeomFieldDefnH gfdef = OGR_F_GetGeomFieldDefnRef(feat, 0);
|
|
if(gfdef != nullptr){
|
|
OGR_GFld_SetName(gfdef, name);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetGeometry(cctx *ctx, OGRFeatureH feat, OGRGeometryH geom) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_F_SetGeometry(feat,geom);
|
|
if(gret!=0){
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldInteger(cctx *ctx, OGRFeatureH feat, int fieldIndex, int value) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldInteger(feat, fieldIndex, value);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldInteger64(cctx *ctx, OGRFeatureH feat, int fieldIndex, long long value) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldInteger64(feat, fieldIndex, value);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldDouble(cctx *ctx, OGRFeatureH feat, int fieldIndex, double value) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldDouble(feat, fieldIndex, value);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldString(cctx *ctx, OGRFeatureH feat, int fieldIndex, char *value) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldString(feat, fieldIndex, value);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldDateTime(cctx *ctx, OGRFeatureH feat, int fieldIndex, int year, int month, int day, int hour, int minute, int second, int tzFlag) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldDateTime(feat, fieldIndex, year, month, day, hour, minute, second, tzFlag);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldIntegerList(cctx *ctx, OGRFeatureH feat, int fieldIndex, int nbValues, int *values) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldIntegerList(feat, fieldIndex, nbValues, values);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldInteger64List(cctx *ctx, OGRFeatureH feat, int fieldIndex, int nbValues, long long *values) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldInteger64List(feat, fieldIndex, nbValues, values);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldDoubleList(cctx *ctx, OGRFeatureH feat, int fieldIndex, int nbValues, double *values) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldDoubleList(feat, fieldIndex, nbValues, values);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldStringList(cctx *ctx, OGRFeatureH feat, int fieldIndex, char **values) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldStringList(feat, fieldIndex, values);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalFeatureSetFieldBinary(cctx *ctx, OGRFeatureH feat, int fieldIndex, int nbBytes, void *value) {
|
|
godalWrap(ctx);
|
|
OGR_F_SetFieldBinary(feat, fieldIndex, nbBytes, value);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godal_OGR_G_AddGeometry(cctx *ctx, OGRGeometryH geom, OGRGeometryH subGeom) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_G_AddGeometry(geom,subGeom);
|
|
if(gret!=0){
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_Simplify(cctx *ctx, OGRGeometryH in, double tolerance) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_Simplify(in,tolerance);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_Buffer(cctx *ctx, OGRGeometryH in, double tolerance, int segments) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_Buffer(in,tolerance,segments);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_Difference(cctx *ctx, OGRGeometryH geom1, OGRGeometryH geom2) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_Difference(geom1, geom2);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_GetGeometryRef(cctx *ctx, OGRGeometryH in, int subGeomIndex) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_GetGeometryRef(in, subGeomIndex);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
int godal_OGR_G_Intersects(cctx *ctx, OGRGeometryH geom1, OGRGeometryH geom2) {
|
|
godalWrap(ctx);
|
|
int ret = OGR_G_Intersects(geom1, geom2);
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_Intersection(cctx *ctx, OGRGeometryH geom1, OGRGeometryH geom2) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_Intersection(geom1, geom2);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRGeometryH godal_OGR_G_Union(cctx *ctx, OGRGeometryH geom1, OGRGeometryH geom2) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH ret = OGR_G_Union(geom1, geom2);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRLayerH godalCreateLayer(cctx *ctx, GDALDatasetH ds, char *name, OGRSpatialReferenceH sr, OGRwkbGeometryType gtype) {
|
|
godalWrap(ctx);
|
|
OGRLayerH ret = OGR_DS_CreateLayer(ds,name,sr,gtype,nullptr);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRLayerH godalCopyLayer(cctx *ctx, GDALDatasetH ds, OGRLayerH layer, char *name) {
|
|
godalWrap(ctx);
|
|
OGRLayerH ret = OGR_DS_CopyLayer(ds,layer, name,nullptr);
|
|
if(ret==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
void godalLayerGetExtent(cctx *ctx, OGRLayerH layer, OGREnvelope *envelope) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_L_GetExtent(layer, envelope, 1);
|
|
if (gret != OGRERR_NONE) {
|
|
forceOGRError(ctx,gret);
|
|
} else if(envelope==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalLayerFeatureCount(cctx *ctx, OGRLayerH layer, int *count) {
|
|
godalWrap(ctx);
|
|
GIntBig gcount = OGR_L_GetFeatureCount(layer, 1);
|
|
*count=(int)gcount;
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalGetColorTable(GDALRasterBandH bnd, GDALPaletteInterp *interp, int *nEntries, short **entries) {
|
|
GDALColorTableH ct = GDALGetRasterColorTable(bnd);
|
|
if( ct == nullptr ) {
|
|
*interp=GPI_Gray;
|
|
*nEntries=0;
|
|
*entries=nullptr;
|
|
return;
|
|
}
|
|
*interp = GDALGetPaletteInterpretation(ct);
|
|
*nEntries = GDALGetColorEntryCount(ct);
|
|
*entries = (short*)malloc(*nEntries*4*sizeof(short));
|
|
for (int i=0;i<*nEntries;i++) {
|
|
const GDALColorEntry *ce = GDALGetColorEntry(ct,i);
|
|
(*entries)[i*4]=ce->c1;
|
|
(*entries)[i*4+1]=ce->c2;
|
|
(*entries)[i*4+2]=ce->c3;
|
|
(*entries)[i*4+3]=ce->c4;
|
|
}
|
|
}
|
|
|
|
void godalSetColorTable(cctx *ctx, GDALRasterBandH bnd, GDALPaletteInterp interp, int nEntries, short *entries) {
|
|
godalWrap(ctx);
|
|
CPLErr gret;
|
|
if (nEntries == 0)
|
|
{
|
|
gret = GDALSetRasterColorTable(bnd, nullptr);
|
|
}
|
|
else
|
|
{
|
|
GDALColorTableH ct = GDALCreateColorTable(interp);
|
|
for (int i = nEntries - 1; i >= 0; i--)
|
|
{
|
|
GDALColorEntry gce = {entries[i * 4], entries[i * 4 + 1], entries[i * 4 + 2], entries[i * 4 + 3]};
|
|
GDALSetColorEntry(ct, i, &gce);
|
|
}
|
|
gret = GDALSetRasterColorTable(bnd, ct);
|
|
GDALDestroyColorTable(ct);
|
|
}
|
|
if (gret != 0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
VSILFILE *godalVSIOpen(cctx *ctx, const char *name) {
|
|
godalWrap(ctx);
|
|
VSILFILE *fp = VSIFOpenExL(name,"r",1);
|
|
if(fp==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if(failed(ctx)&&fp!=nullptr) {
|
|
VSIFCloseL(fp);
|
|
fp=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return fp;
|
|
}
|
|
|
|
void godalVSIUnlink(cctx *ctx, const char *fname) {
|
|
godalWrap(ctx);
|
|
int ret = VSIUnlink(fname);
|
|
if(ret!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
char* godalVSIClose(VSILFILE *f) {
|
|
cctx ctx{nullptr,0,0,nullptr};
|
|
godalWrap(&ctx);
|
|
int ret = VSIFCloseL(f);
|
|
if(ret!=0) {
|
|
forceError(&ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ctx.errMessage;
|
|
}
|
|
|
|
size_t godalVSIRead(VSILFILE *f, void *buf, int len, char **errmsg) {
|
|
cctx ctx{nullptr,0,0,nullptr};
|
|
godalWrap(&ctx);
|
|
size_t read = VSIFReadL(buf,1,len,f);
|
|
godalUnwrap();
|
|
*errmsg=ctx.errMessage;
|
|
return read;
|
|
}
|
|
|
|
void godalRasterHistogram(cctx *ctx, GDALRasterBandH bnd, double *min, double *max, int *buckets,
|
|
unsigned long long **values, int bIncludeOutOfRange, int bApproxOK) {
|
|
godalWrap(ctx);
|
|
CPLErr ret = CE_None;
|
|
if (*buckets == 0) {
|
|
ret=GDALGetDefaultHistogramEx(bnd,min,max,buckets,values,1,nullptr,nullptr);
|
|
} else {
|
|
*values = (unsigned long long*) VSIMalloc(*buckets*sizeof(GUIntBig));
|
|
ret=GDALGetRasterHistogramEx(bnd,*min,*max,*buckets,*values,bIncludeOutOfRange,bApproxOK,nullptr,nullptr);
|
|
}
|
|
if (ret != 0) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalComputeRasterStatistics(cctx *ctx, GDALRasterBandH bnd, int bApproxOK, double *pdfMin, double *pdfMax, double *pdfMean, double *pdfStdDev){
|
|
godalWrap(ctx);
|
|
CPLErr ret = CE_None;
|
|
ret = GDALComputeRasterStatistics(bnd, bApproxOK, pdfMin, pdfMax, pdfMean, pdfStdDev, nullptr, nullptr);
|
|
if (ret != 0) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
int godalGetRasterStatistics(cctx *ctx, GDALRasterBandH bnd, int bApproxOK, double *pdfMin, double *pdfMax, double *pdfMean, double *pdfStdDev){
|
|
godalWrap(ctx);
|
|
CPLErr ret = CE_None;
|
|
ret = GDALGetRasterStatistics(bnd, bApproxOK, 0, pdfMin, pdfMax, pdfMean, pdfStdDev);
|
|
if (ret != 0 && ret != CE_Warning) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
return (ret == 0);
|
|
}
|
|
|
|
|
|
void godalSetRasterStatistics(cctx *ctx, GDALRasterBandH bnd, double dfMin, double dfMax, double dfMean, double dfStdDev){
|
|
godalWrap(ctx);
|
|
CPLErr ret = CE_None;
|
|
ret = GDALSetRasterStatistics(bnd, dfMin, dfMax, dfMean, dfStdDev);
|
|
if (ret != 0) {
|
|
forceCPLError(ctx,ret);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalClearRasterStatistics(cctx *ctx, GDALDatasetH ds){
|
|
godalWrap(ctx);
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 2, 0)
|
|
GDALDatasetClearStatistics(ds);
|
|
#else
|
|
CPLError(CE_Failure, CPLE_NotSupported, "GDALDatasetClearStatistics not supported with gdal < 3.2");
|
|
#endif
|
|
godalUnwrap();
|
|
}
|
|
|
|
OGRGeometryH godalNewGeometryFromGeoJSON(cctx *ctx, char *geoJSON) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH gptr = OGR_G_CreateGeometryFromJson(geoJSON);
|
|
if (gptr == nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if (failed(ctx) && gptr != nullptr) {
|
|
OGR_G_DestroyGeometry(gptr);
|
|
gptr = nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return gptr;
|
|
}
|
|
|
|
OGRGeometryH godalNewGeometryFromWKT(cctx *ctx, char *wkt, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH gptr = nullptr;
|
|
char **wktPtr = &wkt;
|
|
OGRErr gret = OGR_G_CreateFromWkt(wktPtr,sr,&gptr);
|
|
if (gret != OGRERR_NONE) {
|
|
forceOGRError(ctx,gret);
|
|
} else if(gptr==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if(failed(ctx) && gptr!=nullptr) {
|
|
OGR_G_DestroyGeometry(gptr);
|
|
gptr=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return gptr;
|
|
}
|
|
|
|
OGRGeometryH godalNewGeometryFromWKB(cctx *ctx, void *wkb, int wkbLen, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
OGRGeometryH gptr=nullptr;
|
|
OGRErr gret = OGR_G_CreateFromWkb(wkb,sr,&gptr, wkbLen);
|
|
if (gret != OGRERR_NONE) {
|
|
forceOGRError(ctx,gret);
|
|
} else if(gptr==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if(failed(ctx) && gptr!=nullptr) {
|
|
OGR_G_DestroyGeometry(gptr);
|
|
gptr=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return gptr;
|
|
}
|
|
|
|
char* godalExportGeometryWKT(cctx *ctx, OGRGeometryH in) {
|
|
godalWrap(ctx);
|
|
char *wkt=nullptr;
|
|
OGRErr gret = OGR_G_ExportToWkt(in,&wkt);
|
|
if (gret != OGRERR_NONE) {
|
|
forceOGRError(ctx,gret);
|
|
} else if(wkt==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if(failed(ctx) && wkt!=nullptr) {
|
|
CPLFree(wkt);
|
|
wkt=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return wkt;
|
|
}
|
|
|
|
void godalExportGeometryWKB(cctx *ctx, void **wkb, int *wkbLen, OGRGeometryH in) {
|
|
godalWrap(ctx);
|
|
*wkbLen=OGR_G_WkbSize(in);
|
|
if (*wkbLen == 0) {
|
|
*wkb=nullptr;
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
*wkb = malloc(*wkbLen);
|
|
OGRErr gret = OGR_G_ExportToIsoWkb(in,wkbNDR,(unsigned char*)*wkb);
|
|
if (gret != 0) {
|
|
forceOGRError(ctx,gret);
|
|
free(*wkb);
|
|
*wkb=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
char* godalExportGeometryGeoJSON(cctx *ctx, OGRGeometryH in, int precision) {
|
|
godalWrap(ctx);
|
|
char* opts[2];
|
|
char precOpt[64];
|
|
snprintf(precOpt,64,"COORDINATE_PRECISION=%d",precision);
|
|
opts[0]=precOpt;
|
|
opts[1]=nullptr;
|
|
char *gj = OGR_G_ExportToJsonEx(in,opts);
|
|
if (gj==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if (failed(ctx) && gj!=nullptr) {
|
|
CPLFree(gj);
|
|
gj=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return gj;
|
|
}
|
|
|
|
char* godalExportGeometryGML(cctx *ctx, OGRGeometryH in, char **switches) {
|
|
godalWrap(ctx);
|
|
char *gml = OGR_G_ExportToGMLEx(in, switches);
|
|
if(gml==nullptr) {
|
|
forceError(ctx);
|
|
}
|
|
if (failed(ctx) && gml!=nullptr) {
|
|
CPLFree(gml);
|
|
gml=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return gml;
|
|
}
|
|
|
|
void godalGeometryTransformTo(cctx *ctx, OGRGeometryH geom, OGRSpatialReferenceH sr) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_G_TransformTo(geom,sr);
|
|
if (gret != 0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
OGR_G_AssignSpatialReference(geom, sr);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalGeometryTransform(cctx *ctx, OGRGeometryH geom, OGRCoordinateTransformationH trn, OGRSpatialReferenceH dst) {
|
|
godalWrap(ctx);
|
|
OGRErr gret = OGR_G_Transform(geom,trn);
|
|
if (gret != 0) {
|
|
forceOGRError(ctx,gret);
|
|
}
|
|
OGR_G_AssignSpatialReference(geom, dst);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalLayerCreateFeature(cctx *ctx, OGRLayerH layer, OGRFeatureH feat) {
|
|
godalWrap(ctx);
|
|
OGRErr oe = OGR_L_CreateFeature(layer,feat);
|
|
if(oe != OGRERR_NONE) {
|
|
forceOGRError(ctx,oe);
|
|
}
|
|
godalUnwrap();
|
|
}
|
|
|
|
OGRFeatureH godalLayerNewFeature(cctx *ctx, OGRLayerH layer, OGRGeometryH geom) {
|
|
godalWrap(ctx);
|
|
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( layer ) );
|
|
if(hFeature==nullptr) {
|
|
forceError(ctx);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
OGRErr oe=OGRERR_NONE;
|
|
if (hFeature!=nullptr && geom!=nullptr) {
|
|
oe = OGR_F_SetGeometry(hFeature,geom);
|
|
if (oe == OGRERR_NONE) {
|
|
oe = OGR_L_CreateFeature(layer,hFeature);
|
|
}
|
|
}
|
|
if(oe != OGRERR_NONE) {
|
|
forceOGRError(ctx,oe);
|
|
}
|
|
if(failed(ctx) && hFeature!=nullptr) {
|
|
OGR_F_Destroy(hFeature);
|
|
hFeature=nullptr;
|
|
}
|
|
godalUnwrap();
|
|
return hFeature;
|
|
}
|
|
|
|
GDALDatasetH godalBuildVRT(cctx *ctx, char *dstName, char **sources, char **switches) {
|
|
godalWrap(ctx);
|
|
GDALBuildVRTOptions *ropts = GDALBuildVRTOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALBuildVRTOptionsFree(ropts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
int usageErr=0;
|
|
int nSources = 0;
|
|
char **src = sources;
|
|
for( char **src = sources; *src; src++) {
|
|
nSources++;
|
|
}
|
|
|
|
GDALDatasetH ret = GDALBuildVRT(dstName, nSources, nullptr, sources, ropts, &usageErr);
|
|
GDALBuildVRTOptionsFree(ropts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
namespace cpl
|
|
{
|
|
|
|
/************************************************************************/
|
|
/* VSIGoFilesystemHandler */
|
|
/************************************************************************/
|
|
|
|
class VSIGoFilesystemHandler final : public VSIFilesystemHandler
|
|
{
|
|
CPL_DISALLOW_COPY_ASSIGN(VSIGoFilesystemHandler)
|
|
private:
|
|
size_t m_buffer, m_cache;
|
|
|
|
public:
|
|
VSIGoFilesystemHandler(size_t bufferSize, size_t cacheSize);
|
|
~VSIGoFilesystemHandler() override;
|
|
|
|
VSIVirtualHandle *Open(const char *pszFilename,
|
|
const char *pszAccess,
|
|
bool bSetError
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 3, 0)
|
|
, CSLConstList /*papszOptions*/
|
|
#endif
|
|
) override;
|
|
|
|
int Stat(const char *pszFilename, VSIStatBufL *pStatBuf, int nFlags) override;
|
|
#if GDAL_VERSION_NUM >= 3020000
|
|
char **SiblingFiles(const char *pszFilename) override;
|
|
#endif
|
|
int HasOptimizedReadMultiRange(const char *pszPath) override;
|
|
};
|
|
|
|
/************************************************************************/
|
|
/* VSIGoHandle */
|
|
/************************************************************************/
|
|
|
|
class VSIGoHandle final : public VSIVirtualHandle
|
|
{
|
|
CPL_DISALLOW_COPY_ASSIGN(VSIGoHandle)
|
|
private:
|
|
char *m_filename;
|
|
vsi_l_offset m_cur, m_size;
|
|
int m_eof;
|
|
|
|
public:
|
|
VSIGoHandle(const char *filename, vsi_l_offset size);
|
|
~VSIGoHandle() override;
|
|
|
|
#if GDAL_VERSION_NUM >= 3060000
|
|
bool HasPRead() const override;
|
|
size_t PRead(void * /*pBuffer*/, size_t /* nSize */, vsi_l_offset /*nOffset*/) const override;
|
|
#endif
|
|
vsi_l_offset Tell() override;
|
|
int Seek(vsi_l_offset nOffset, int nWhence) override;
|
|
size_t Read(void *pBuffer, size_t nSize, size_t nCount) override;
|
|
int ReadMultiRange(int nRanges, void **ppData, const vsi_l_offset *panOffsets, const size_t *panSizes) override;
|
|
VSIRangeStatus GetRangeStatus(vsi_l_offset nOffset, vsi_l_offset nLength) override;
|
|
int Eof() override;
|
|
int Close() override;
|
|
size_t Write(const void *pBuffer, size_t nSize, size_t nCount) override;
|
|
int Flush() override;
|
|
int Truncate(vsi_l_offset nNewSize) override;
|
|
};
|
|
|
|
VSIGoHandle::VSIGoHandle(const char *filename, vsi_l_offset size)
|
|
{
|
|
m_filename = strdup(filename);
|
|
m_cur = 0;
|
|
m_eof = 0;
|
|
m_size = size;
|
|
}
|
|
|
|
VSIGoHandle::~VSIGoHandle()
|
|
{
|
|
free(m_filename);
|
|
}
|
|
|
|
size_t VSIGoHandle::Write(const void *pBuffer, size_t nSize, size_t nCount)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "Write not implemented for go handlers");
|
|
return -1;
|
|
}
|
|
int VSIGoHandle::Flush()
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "Flush not implemented for go handlers");
|
|
return -1;
|
|
}
|
|
int VSIGoHandle::Truncate(vsi_l_offset nNewSize)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "Truncate not implemented for go handlers");
|
|
return -1;
|
|
}
|
|
int VSIGoHandle::Seek(vsi_l_offset nOffset, int nWhence)
|
|
{
|
|
if (nWhence == SEEK_SET)
|
|
{
|
|
m_cur = nOffset;
|
|
}
|
|
else if (nWhence == SEEK_CUR)
|
|
{
|
|
m_cur += nOffset;
|
|
}
|
|
else
|
|
{
|
|
m_cur = m_size;
|
|
}
|
|
m_eof = 0;
|
|
return 0;
|
|
}
|
|
|
|
vsi_l_offset VSIGoHandle::Tell()
|
|
{
|
|
return m_cur;
|
|
}
|
|
|
|
int VSIGoHandle::Eof()
|
|
{
|
|
return m_eof;
|
|
}
|
|
|
|
int VSIGoHandle::Close()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
size_t VSIGoHandle::Read(void *pBuffer, size_t nSize, size_t nCount)
|
|
{
|
|
if (nSize * nCount == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
char *err = nullptr;
|
|
size_t read = _gogdalReadCallback(m_filename, pBuffer, m_cur, nSize * nCount, &err);
|
|
if (err)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "%s", err);
|
|
errno = EIO;
|
|
free(err);
|
|
return 0;
|
|
}
|
|
if (read != nSize * nCount)
|
|
{
|
|
m_eof = 1;
|
|
}
|
|
size_t readblocks = read / nSize;
|
|
m_cur += readblocks * nSize;
|
|
return readblocks;
|
|
}
|
|
|
|
#if GDAL_VERSION_NUM >= 3060000
|
|
bool VSIGoHandle::HasPRead() const
|
|
{
|
|
return true;
|
|
}
|
|
size_t VSIGoHandle::PRead( void* pBuffer, size_t nSize, vsi_l_offset nOffset ) const
|
|
{
|
|
char *err = nullptr;
|
|
_gogdalMultiReadCallback(m_filename, 1, &pBuffer, (void *)&nOffset, (void *)&nSize,
|
|
&err);
|
|
if (err)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "%s", err);
|
|
errno = EIO;
|
|
free(err);
|
|
return 0;
|
|
}
|
|
return nSize;
|
|
}
|
|
#endif
|
|
|
|
int VSIGoHandle::ReadMultiRange(int nRanges, void **ppData, const vsi_l_offset *panOffsets, const size_t *panSizes)
|
|
{
|
|
int iRange;
|
|
int nMergedRanges = 1;
|
|
for (iRange = 0; iRange < nRanges - 1; iRange++)
|
|
{
|
|
if (panOffsets[iRange] + panSizes[iRange] != panOffsets[iRange + 1])
|
|
{
|
|
nMergedRanges++;
|
|
}
|
|
}
|
|
char *err = nullptr;
|
|
if (nMergedRanges == nRanges)
|
|
{
|
|
int ret = _gogdalMultiReadCallback(m_filename, nRanges, (void *)ppData, (void *)panOffsets, (void *)panSizes, &err);
|
|
if (err)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "%s", err);
|
|
errno = EIO;
|
|
free(err);
|
|
return -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
vsi_l_offset *mOffsets = new vsi_l_offset[nMergedRanges];
|
|
size_t *mSizes = new size_t[nMergedRanges];
|
|
char **mData = new char *[nMergedRanges];
|
|
|
|
int curRange = 0;
|
|
mSizes[curRange] = panSizes[0];
|
|
mOffsets[curRange] = panOffsets[0];
|
|
for (iRange = 0; iRange < nRanges - 1; iRange++)
|
|
{
|
|
if (panOffsets[iRange] + panSizes[iRange] == panOffsets[iRange + 1])
|
|
{
|
|
mSizes[curRange] += panSizes[iRange + 1];
|
|
}
|
|
else
|
|
{
|
|
mData[curRange] = new char[mSizes[curRange]];
|
|
//start a new range
|
|
curRange++;
|
|
mSizes[curRange] = panSizes[iRange + 1];
|
|
mOffsets[curRange] = panOffsets[iRange + 1];
|
|
}
|
|
}
|
|
mData[curRange] = new char[mSizes[curRange]];
|
|
|
|
int ret = _gogdalMultiReadCallback(m_filename, nRanges, (void *)ppData, (void *)panOffsets, (void *)panSizes, &err);
|
|
|
|
if (err == nullptr)
|
|
{
|
|
curRange = 0;
|
|
size_t curOffset = panSizes[0];
|
|
memcpy(ppData[0], mData[0], panSizes[0]);
|
|
for (iRange = 0; iRange < nRanges - 1; iRange++)
|
|
{
|
|
if (panOffsets[iRange] + panSizes[iRange] == panOffsets[iRange + 1])
|
|
{
|
|
memcpy(ppData[iRange + 1], mData[curRange] + curOffset, panSizes[iRange + 1]);
|
|
curOffset += panSizes[iRange + 1];
|
|
}
|
|
else
|
|
{
|
|
curRange++;
|
|
memcpy(ppData[iRange + 1], mData[curRange], panSizes[iRange + 1]);
|
|
curOffset = panSizes[iRange + 1];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "%s", err);
|
|
errno = EIO;
|
|
free(err);
|
|
ret = -1;
|
|
}
|
|
|
|
delete[] mOffsets;
|
|
delete[] mSizes;
|
|
for (int i = 0; i < nMergedRanges; i++)
|
|
{
|
|
delete[] mData[i];
|
|
}
|
|
delete[] mData;
|
|
|
|
return ret;
|
|
}
|
|
|
|
VSIRangeStatus VSIGoHandle::GetRangeStatus(vsi_l_offset nOffset, vsi_l_offset nLength)
|
|
{
|
|
return VSI_RANGE_STATUS_UNKNOWN;
|
|
}
|
|
|
|
VSIGoFilesystemHandler::VSIGoFilesystemHandler(size_t bufferSize, size_t cacheSize)
|
|
{
|
|
m_buffer = bufferSize;
|
|
m_cache = (cacheSize < bufferSize) ? bufferSize : cacheSize;
|
|
}
|
|
VSIGoFilesystemHandler::~VSIGoFilesystemHandler() {}
|
|
|
|
VSIVirtualHandle *VSIGoFilesystemHandler::Open(const char *pszFilename,
|
|
const char *pszAccess,
|
|
bool bSetError
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 3, 0)
|
|
, CSLConstList /*papszOptions*/
|
|
#endif
|
|
)
|
|
{
|
|
if (strchr(pszAccess, 'w') != NULL ||
|
|
strchr(pszAccess, '+') != NULL)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "Only read-only mode is supported");
|
|
return nullptr;
|
|
}
|
|
char *err = nullptr;
|
|
long long s = _gogdalSizeCallback((char *)pszFilename, &err);
|
|
|
|
if (s == -1)
|
|
{
|
|
if (err != nullptr && bSetError)
|
|
{
|
|
VSIError(VSIE_FileError, "%s", err);
|
|
}
|
|
errno = ENOENT;
|
|
return nullptr;
|
|
}
|
|
if (m_buffer == 0)
|
|
{
|
|
return new VSIGoHandle(pszFilename, s);
|
|
}
|
|
else
|
|
{
|
|
return VSICreateCachedFile(new VSIGoHandle(pszFilename, s), m_buffer, m_cache);
|
|
}
|
|
}
|
|
|
|
int VSIGoFilesystemHandler::Stat(const char *pszFilename,
|
|
VSIStatBufL *pStatBuf,
|
|
int nFlags)
|
|
{
|
|
char *err = nullptr;
|
|
long long s = _gogdalSizeCallback((char *)pszFilename, &err);
|
|
if (s == -1)
|
|
{
|
|
if (nFlags & VSI_STAT_SET_ERROR_FLAG)
|
|
{
|
|
CPLError(CE_Failure, CPLE_AppDefined, "%s", err);
|
|
errno = ENOENT;
|
|
}
|
|
return -1;
|
|
}
|
|
memset(pStatBuf, 0, sizeof(VSIStatBufL));
|
|
pStatBuf->st_mode = S_IFREG;
|
|
|
|
if (nFlags & VSI_STAT_SIZE_FLAG)
|
|
{
|
|
pStatBuf->st_size = s;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VSIGoFilesystemHandler::HasOptimizedReadMultiRange(const char * /*pszPath*/)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
#if GDAL_VERSION_NUM >= 3020000
|
|
char **VSIGoFilesystemHandler::SiblingFiles(const char *pszFilename)
|
|
{
|
|
return (char **)calloc(1, sizeof(char *));
|
|
}
|
|
#endif
|
|
|
|
} // namespace cpl
|
|
|
|
void VSIInstallGoHandler(cctx *ctx, const char *pszPrefix, size_t bufferSize, size_t cacheSize)
|
|
{
|
|
godalWrap(ctx);
|
|
CSLConstList papszPrefix = VSIFileManager::GetPrefixes();
|
|
for( size_t i = 0; papszPrefix && papszPrefix[i]; ++i ) {
|
|
if(strcmp(papszPrefix[i],pszPrefix)==0) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "handler already registered on prefix");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
}
|
|
VSIFilesystemHandler *poHandler = new cpl::VSIGoFilesystemHandler(bufferSize, cacheSize);
|
|
const std::string sPrefix(pszPrefix);
|
|
VSIFileManager::InstallHandler(sPrefix, poHandler);
|
|
godalUnwrap();
|
|
}
|
|
|
|
void test_godal_error_handling(cctx *ctx) {
|
|
godalWrap(ctx);
|
|
CPLDebug("godal","this is a debug message");
|
|
CPLError(CE_Warning, CPLE_AppDefined, "this is a warning message");
|
|
CPLError(CE_Failure, CPLE_AppDefined, "this is a failure message");
|
|
godalUnwrap();
|
|
}
|
|
|
|
void godalGridCreate(cctx *ctx, char *pszAlgorithm, GDALGridAlgorithm eAlgorithm, GUInt32 nPoints, const double *padfX, const double *padfY, const double *padfZ, double dfXMin,
|
|
double dfXMax, double dfYMin, double dfYMax, GUInt32 nXSize, GUInt32 nYSize, GDALDataType eType, void *pData) {
|
|
godalWrap(ctx);
|
|
CPLErr ret;
|
|
|
|
if (!GDALHasTriangulation() && eAlgorithm == GGA_Linear) {
|
|
CPLError(CE_Failure, CPLE_AppDefined, "unable to run GGA_Linear algorithm, since GDAL built without QHull support");
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
|
|
void *ppOptions;
|
|
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 7, 0)
|
|
ret = GDALGridParseAlgorithmAndOptions(pszAlgorithm, &eAlgorithm, &ppOptions);
|
|
#else
|
|
ret = ParseAlgorithmAndOptions(pszAlgorithm, &eAlgorithm, &ppOptions);
|
|
#endif
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
|
|
ret = GDALGridCreate(eAlgorithm, ppOptions, nPoints, padfX, padfY,
|
|
padfZ, dfXMin, dfXMax, dfYMin, dfYMax, nXSize, nYSize,
|
|
eType, pData, nullptr, nullptr);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
|
|
godalUnwrap();
|
|
}
|
|
|
|
GDALDatasetH godalGrid(cctx *ctx, const char *pszDest, GDALDatasetH hSrcDS, char **switches) {
|
|
godalWrap(ctx);
|
|
|
|
GDALGridOptions *gridopts = GDALGridOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALGridOptionsFree(gridopts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALGrid(pszDest, hSrcDS, gridopts, &usageErr);
|
|
GDALGridOptionsFree(gridopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
GDALDatasetH godalNearblack(cctx *ctx, const char *pszDest, GDALDatasetH hDstDS, GDALDatasetH hSrcDS, char **switches) {
|
|
godalWrap(ctx);
|
|
|
|
GDALNearblackOptions *nbopts = GDALNearblackOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALNearblackOptionsFree(nbopts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALNearblack(pszDest, hDstDS, hSrcDS, nbopts, &usageErr);
|
|
GDALNearblackOptionsFree(nbopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
GDALDatasetH godalDem(cctx *ctx, const char *pszDest, const char *pszProcessing, const char *pszColorFilename, GDALDatasetH hSrcDS, char **switches) {
|
|
godalWrap(ctx);
|
|
|
|
GDALDEMProcessingOptions *demopts = GDALDEMProcessingOptionsNew(switches,nullptr);
|
|
if(failed(ctx)) {
|
|
GDALDEMProcessingOptionsFree(demopts);
|
|
godalUnwrap();
|
|
return nullptr;
|
|
}
|
|
|
|
int usageErr=0;
|
|
GDALDatasetH ret = GDALDEMProcessing(pszDest, hSrcDS, pszProcessing, pszColorFilename, demopts, &usageErr);
|
|
GDALDEMProcessingOptionsFree(demopts);
|
|
if(ret==nullptr || usageErr!=0) {
|
|
forceError(ctx);
|
|
}
|
|
|
|
godalUnwrap();
|
|
return ret;
|
|
}
|
|
|
|
OGRSpatialReferenceH godalGetGCPSpatialRef(GDALDatasetH hSrcDS) {
|
|
return GDALGetGCPSpatialRef(hSrcDS);
|
|
}
|
|
|
|
const GCPsAndCount godalGetGCPs(GDALDatasetH hSrcDS) {
|
|
return GCPsAndCount {
|
|
.gcpList = GDALGetGCPs(hSrcDS),
|
|
.numGCPs = GDALGetGCPCount(hSrcDS),
|
|
};
|
|
}
|
|
|
|
const char *godalGetGCPProjection(GDALDatasetH hSrcDS) {
|
|
return GDALGetGCPProjection(hSrcDS);
|
|
}
|
|
|
|
void godalSetGCPs(cctx *ctx, GDALDatasetH hSrcDS, int numGCPs, goGCPList GCPList, const char *pszGCPProjection) {
|
|
godalWrap(ctx);
|
|
|
|
GDAL_GCP *GDALGCPList = goGCPListToGDALGCP(GCPList, numGCPs);
|
|
|
|
CPLErr ret = GDALSetGCPs(hSrcDS, numGCPs, GDALGCPList, pszGCPProjection);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
|
|
GDALDeinitGCPs(numGCPs, GDALGCPList);
|
|
CPLFree(GDALGCPList);
|
|
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
|
|
void godalSetGCPs2(cctx *ctx, GDALDatasetH hSrcDS, int numGCPs, goGCPList GCPList, OGRSpatialReferenceH hSRS) {
|
|
godalWrap(ctx);
|
|
|
|
GDAL_GCP *GDALGCPList = goGCPListToGDALGCP(GCPList, numGCPs);
|
|
|
|
CPLErr ret = GDALSetGCPs2(hSrcDS, numGCPs, GDALGCPList, hSRS);
|
|
if(ret!=0) {
|
|
forceCPLError(ctx, ret);
|
|
}
|
|
|
|
GDALDeinitGCPs(numGCPs, GDALGCPList);
|
|
CPLFree(GDALGCPList);
|
|
|
|
godalUnwrap();
|
|
return;
|
|
}
|
|
|
|
GDAL_GCP *goGCPListToGDALGCP(goGCPList GCPList, int numGCPs) {
|
|
GDAL_GCP *ret = static_cast<GDAL_GCP *>(CPLCalloc(numGCPs, sizeof(GDAL_GCP)));
|
|
GDALInitGCPs(numGCPs, ret);
|
|
|
|
for (int i = 0; i < numGCPs; i++)
|
|
{
|
|
ret[i].pszId = CPLStrdup(GCPList.pszIds[i]);
|
|
ret[i].pszInfo = CPLStrdup(GCPList.pszInfos[i]);
|
|
ret[i].dfGCPPixel = GCPList.dfGCPPixels[i];
|
|
ret[i].dfGCPLine = GCPList.dfGCPLines[i];
|
|
ret[i].dfGCPX = GCPList.dfGCPXs[i];
|
|
ret[i].dfGCPY = GCPList.dfGCPYs[i];
|
|
ret[i].dfGCPZ = GCPList.dfGCPZs[i];
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void godalGCPListToGeoTransform(cctx *ctx, goGCPList GCPList, int numGCPs, double *gt){
|
|
godalWrap(ctx);
|
|
|
|
GDAL_GCP *GDALGCPList = goGCPListToGDALGCP(GCPList, numGCPs);
|
|
|
|
int ret = GDALGCPsToGeoTransform(numGCPs, GDALGCPList, gt, TRUE);
|
|
if(ret!=TRUE) {
|
|
forceError(ctx);
|
|
}
|
|
|
|
GDALDeinitGCPs(numGCPs, GDALGCPList);
|
|
CPLFree(GDALGCPList);
|
|
|
|
godalUnwrap();
|
|
} |