static SEXP
GDALColorTable2Matrix(GDALColorTableH ctab) {
installErrorHandler();
int ncol = GDALGetColorEntryCount(ctab);
uninstallErrorHandlerAndTriggerError();
SEXP cmat = allocMatrix(INTSXP, ncol, 4);
installErrorHandler();
for (int i = 0; i < ncol; ++i) {
const GDALColorEntry* ce = GDALGetColorEntry(ctab, i);
INTEGER(cmat)[i] = static_cast<int>(ce->c1);
INTEGER(cmat)[i + ncol] = static_cast<int>(ce->c2);
INTEGER(cmat)[i + 2 * ncol] = static_cast<int>(ce->c3);
INTEGER(cmat)[i + 3 * ncol] = static_cast<int>(ce->c4);
}
uninstallErrorHandlerAndTriggerError();
return(cmat);
}
/* changed to return proj4 string 20060212 RSB */
SEXP
RGDAL_GetProjectionRef(SEXP sDataset) {
OGRSpatialReference oSRS;
char *pszSRS_WKT = NULL;
SEXP ans;
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
installErrorHandler();
pszSRS_WKT = (char*) pDataset->GetProjectionRef();
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
oSRS.importFromWkt( &pszSRS_WKT );
oSRS.exportToProj4( &pszSRS_WKT );
uninstallErrorHandlerAndTriggerError();
PROTECT(ans = NEW_CHARACTER(1));
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(pszSRS_WKT));
installErrorHandler();
CPLFree( pszSRS_WKT );
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(ans);
}
SEXP
RGDAL_Init(void) {
// CPLSetErrorHandler((CPLErrorHandler)__errorHandler);
// CPLPushErrorHandler((CPLErrorHandler)__errorHandler);
#ifdef GDALV2
installErrorHandler();
GDALAllRegister();
uninstallErrorHandlerAndTriggerError();
#else
installErrorHandler();
GDALAllRegister();
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
OGRRegisterAll();
uninstallErrorHandlerAndTriggerError();
#endif
return(R_NilValue);
}
SEXP
RGDAL_GenCMap(SEXP input1, SEXP input2, SEXP input3, SEXP output, SEXP nColors, SEXP setCMap) {
GDALRasterBand* band1 = getGDALRasterPtr(input1);
GDALRasterBand* band2 = getGDALRasterPtr(input2);
GDALRasterBand* band3 = getGDALRasterPtr(input3);
GDALColorTable ctab;
int ncol = asInteger(nColors);
if (ncol < 2 || ncol > 256)
error("Number of colors should range from 2 to 256");
installErrorHandler();
int err = GDALComputeMedianCutPCT(band1, band2, band3, NULL,
ncol, &ctab, NULL, NULL);
if (err == CE_Failure) {
uninstallErrorHandlerAndTriggerError();
error("Error generating color table");
}
uninstallErrorHandlerAndTriggerError();
if (output != R_NilValue) {
GDALRasterBand* target = getGDALRasterPtr(output);
installErrorHandler();
err = GDALDitherRGB2PCT(band1, band2, band3, target, &ctab, NULL, NULL);
if (err == CE_Failure) {
uninstallErrorHandlerAndTriggerError();
error("Image dithering failed");
}
uninstallErrorHandlerAndTriggerError();
if (asLogical(setCMap)) {
installErrorHandler();
err = GDALSetRasterColorTable(target, &ctab);
if (err == CE_Failure) {
uninstallErrorHandlerAndTriggerError();
warning("Unable to set color table");
}
uninstallErrorHandlerAndTriggerError();
}
}
return(GDALColorTable2Matrix(&ctab));
}
SEXP
RGDAL_CreateDataset(SEXP sxpDriver, SEXP sDim, SEXP sType,
SEXP sOpts, SEXP sFile) {
GDALDriver *pDriver = getGDALDriverPtr(sxpDriver);
GDALDataset *pDataset;
const char *filename = asString(sFile);
int i/*, n*/;
char **papszCreateOptions = NULL;
#ifdef RGDALDEBUG
Rprintf("Opening dataset: %s\n", filename);
// fflush(stderr);
#endif
if (filename == NULL) error("Invalid file name\n");
GDALDataType eGDALType = (GDALDataType) asInteger(sType);
installErrorHandler();
for (i=0; i < length(sOpts); i++) papszCreateOptions = CSLAddString(
papszCreateOptions, CHAR(STRING_ELT(sOpts, i)) );
#ifdef RGDALDEBUG
for (i=0; i < CSLCount(papszCreateOptions); i++)
Rprintf("option %d: %s\n", i, CSLGetField(papszCreateOptions, i));
#endif
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
pDataset = pDriver->Create(filename,
INTEGER(sDim)[0],
INTEGER(sDim)[1],
INTEGER(sDim)[2],
eGDALType, papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
CSLDestroy(papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
if (pDataset == NULL) error("Unable to create dataset\n");
installErrorHandler();
pDataset->SetDescription(filename);
uninstallErrorHandlerAndTriggerError();
SEXP sxpHandle = R_MakeExternalPtr((void *) pDataset,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
SEXP RGDAL_CPLGetConfigOption(SEXP inOption) {
installErrorHandler();
if (CPLGetConfigOption(asString(inOption), NULL) == NULL) {
uninstallErrorHandlerAndTriggerError();
return(R_NilValue);
}
SEXP res;
PROTECT(res=NEW_CHARACTER(1));
installErrorHandler();
SET_STRING_ELT(res, 0,
COPY_TO_USER_STRING(CPLGetConfigOption(asString(inOption), NULL)));
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(res);
}
SEXP
RGDAL_GetColorInterp(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
installErrorHandler();
GDALColorInterp eCI = pRasterBand->GetColorInterpretation();
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
const char *desc = GDALGetColorInterpretationName(eCI);
uninstallErrorHandlerAndTriggerError();
return(mkString_safe(desc));
}
SEXP
RGDAL_CloseHandle(SEXP sxpHandle) {
GDALDataset *pDataset =
(GDALDataset *) R_ExternalPtrAddr(sxpHandle);
#ifdef RGDALDEBUG
Rprintf("Closing GDAL dataset handle %p... ", (void *) pDataset);
#endif
installErrorHandler();
if (pDataset != NULL) {
// Even Roualt 120816
GDALClose((GDALDatasetH)pDataset);
// pDataset->~GDALDataset();
R_ClearExternalPtr(sxpHandle);
#ifdef RGDALDEBUG
Rprintf(" destroyed ... ");
#endif
}
uninstallErrorHandlerAndTriggerError();
#ifdef RGDALDEBUG
Rprintf("done.\n");
#endif
return(R_NilValue);
}
SEXP
RGDAL_GetGeoTransform(SEXP sxpDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
SEXP sxpGeoTrans = allocVector(REALSXP, 6);
SEXP ceFail = NEW_LOGICAL(1);
LOGICAL_POINTER(ceFail)[0] = FALSE;
installErrorHandler();
CPLErr err = pDataset->GetGeoTransform(REAL(sxpGeoTrans));
if (err == CE_Failure) {
REAL(sxpGeoTrans)[0] = 0; // x-origin ul
REAL(sxpGeoTrans)[1] = 1; // x-resolution (pixel width)
REAL(sxpGeoTrans)[2] = 0; // x-oblique
REAL(sxpGeoTrans)[3] = (double) pDataset->GetRasterYSize();
// y-origin ul; 091028
REAL(sxpGeoTrans)[4] = 0; // y-oblique
REAL(sxpGeoTrans)[5] = -1; // y-resolution (pixel height); 091028 added sign
LOGICAL_POINTER(ceFail)[0] = TRUE;
}
setAttrib(sxpGeoTrans, install("CE_Failure"), ceFail);
uninstallErrorHandlerAndTriggerError();
return(sxpGeoTrans);
}
SEXP
RGDAL_GetMetadata(SEXP sDataset, SEXP tag) {
char **papszMetadata;
SEXP ans;
int i, n, pc=0;
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
installErrorHandler();
if (tag == R_NilValue) {
papszMetadata = pDataset->GetMetadata( NULL );
} else {
papszMetadata = pDataset->GetMetadata(CHAR(STRING_ELT(tag, 0)));
}
uninstallErrorHandlerAndTriggerError();
if (CSLCount(papszMetadata) == 0) return(R_NilValue);
for (n=0; papszMetadata[n] != NULL; n++);
PROTECT(ans = NEW_CHARACTER(n)); pc++;
for (i=0; i<n; i++)
SET_STRING_ELT(ans, i, COPY_TO_USER_STRING(papszMetadata[i]));
UNPROTECT(pc);
return(ans);
}
static void
deleteFile(GDALDriver *pDriver, const char *filename) {
#ifdef RGDALDEBUG
Rprintf("Deleting temp file: %s... ", filename);
// fflush(stderr);
#endif
installErrorHandler();
if (strcmp(GDALGetDriverLongName( pDriver ), "In Memory Raster") != 0) {
// CPLErr eErr = pDriver->Delete(filename);
GDALDeleteDataset((GDALDriverH) pDriver, filename);
/* if (eErr == CE_Failure)
warning("Failed to delete dataset: %s\n", filename);*/
}
uninstallErrorHandlerAndTriggerError();
#ifdef RGDALDEBUG
Rprintf("done.\n", filename);
// fflush(stderr);
#endif
return;
}
SEXP
RGDAL_CopyDataset(SEXP sxpDataset, SEXP sxpDriver,
SEXP sxpStrict, SEXP sxpOpts,
SEXP sxpFile) {
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
char **papszCreateOptions = NULL;
int i;
const char *filename = asString(sxpFile);
if (filename == NULL) error("Invalid filename\n");
GDALDriver *pDriver = getGDALDriverPtr(sxpDriver);
installErrorHandler();
for (i=0; i < length(sxpOpts); i++) papszCreateOptions = CSLAddString(
papszCreateOptions, CHAR(STRING_ELT(sxpOpts, i)) );
uninstallErrorHandlerAndTriggerError();
#ifdef RGDALDEBUG
installErrorHandler();
for (i=0; i < CSLCount(papszCreateOptions); i++)
Rprintf("option %d: %s\n", i, CSLGetField(papszCreateOptions, i));
uninstallErrorHandlerAndTriggerError();
#endif
installErrorHandler();
GDALDataset *pDatasetCopy = pDriver->CreateCopy(filename,
pDataset, asInteger(sxpStrict),
papszCreateOptions, NULL, NULL);
uninstallErrorHandlerAndTriggerError();
if (pDatasetCopy == NULL) error("Dataset copy failed\n");
installErrorHandler();
CSLDestroy(papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
SEXP sxpHandle = R_MakeExternalPtr((void *) pDatasetCopy,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
SEXP RGDAL_CPLSetConfigOption(SEXP inOption, SEXP value) {
installErrorHandler();
if (value == R_NilValue)
CPLSetConfigOption(asString(inOption), NULL);
else
CPLSetConfigOption(asString(inOption), asString(value));
uninstallErrorHandlerAndTriggerError();
return(R_NilValue);
}
SEXP
RGDAL_GetDriverLongName(SEXP sxpDriver) {
GDALDriver *pDriver = getGDALDriverPtr(sxpDriver);
installErrorHandler();
const char *desc = GDALGetDriverLongName( pDriver );
uninstallErrorHandlerAndTriggerError();
return(mkString_safe(desc));
}
SEXP
RGDAL_GetDescription(SEXP sxpObj) {
void *pGDALObj = getGDALObjPtr(sxpObj);
installErrorHandler();
const char *desc = ((GDALMajorObject *)pGDALObj)->GetDescription();
uninstallErrorHandlerAndTriggerError();
return(mkString_safe(desc));
}
SEXP
RGDAL_GetOffset(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
double res;
installErrorHandler();
res = pRasterBand->GetOffset();
uninstallErrorHandlerAndTriggerError();
return(ScalarReal(res));
}
SEXP
RGDAL_GetAccess(SEXP sxpDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
int res;
installErrorHandler();
res = pDataset->GetAccess() == GA_ReadOnly;
uninstallErrorHandlerAndTriggerError();
return(ScalarLogical(res));
}
SEXP
RGDAL_GetRasterAccess(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
int res;
installErrorHandler();
res = pRasterBand->GetAccess() == GA_ReadOnly;
uninstallErrorHandlerAndTriggerError();
return(ScalarLogical(res));
}
SEXP
RGDAL_GetRasterCount(SEXP sDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
int res;
installErrorHandler();
res = pDataset->GetRasterCount();
uninstallErrorHandlerAndTriggerError();
return(ScalarInteger(res));
}
SEXP
RGDAL_GetYSize(SEXP sRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sRasterBand);
int res;
installErrorHandler();
res = pRasterBand->GetYSize();
uninstallErrorHandlerAndTriggerError();
return(ScalarInteger(res));
}
SEXP
RGDAL_SetCategoryNames(SEXP sxpRasterBand, SEXP sxpNames) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
char **nameList = NULL;
int i;
installErrorHandler();
for (i = 0; i < length(sxpNames); ++i)
nameList = CSLAddString(nameList, asString(sxpNames, i));
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
CPLErr err = pRasterBand->SetCategoryNames(nameList);
if (err == CE_Failure) warning("Failed to set category names");
uninstallErrorHandlerAndTriggerError();
return(sxpRasterBand);
}
SEXP
RGDAL_GDAL_DATA_Info(void) {
SEXP ans;
PROTECT(ans=NEW_CHARACTER(1));
installErrorHandler();
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(CSVFilename( "prime_meridian.csv" )));
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(ans);
}
SEXP
RGDAL_OpenDataset(SEXP filename, SEXP read_only, SEXP silent) {
const char *fn = asString(filename);
GDALAccess RWFlag;
if (asLogical(read_only))
RWFlag = GA_ReadOnly;
else
RWFlag = GA_Update;
/* Modification suggested by Even Rouault, 2009-08-08: */
CPLErrorReset();
if (asLogical(silent))
CPLPushErrorHandler(CPLQuietErrorHandler);
else
installErrorHandler();
GDALDataset *pDataset = (GDALDataset *) GDALOpen(fn, RWFlag);
if (pDataset == NULL)
error("%s\n", CPLGetLastErrorMsg());
if (asLogical(silent))
CPLPopErrorHandler();
else
uninstallErrorHandlerAndTriggerError();
/* Similarly to SWIG bindings, the following lines will cause
RGDAL_OpenDataset() to fail on - uncleared - errors even if pDataset is not
NULL. They could also be just removed. While pDataset != NULL, there's some
hope ;-) */
/* CPLErr eclass = CPLGetLastErrorType();
if (pDataset != NULL && eclass == CE_Failure) {
GDALClose(pDataset);
pDataset = NULL;
__errorHandler(eclass, CPLGetLastErrorNo(), CPLGetLastErrorMsg());
}*/
SEXP sxpHandle = R_MakeExternalPtr((void *) pDataset,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
SEXP
RGDAL_GetCategoryNames(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
installErrorHandler();
char **pcCNames = pRasterBand->GetCategoryNames();
uninstallErrorHandlerAndTriggerError();
if (pcCNames == NULL) return(R_NilValue);
installErrorHandler();
pcCNames = CSLDuplicate(pcCNames);
uninstallErrorHandlerAndTriggerError();
SEXP sxpCNames;
installErrorHandler();
int ii = CSLCount(pcCNames);
uninstallErrorHandlerAndTriggerError();
PROTECT(sxpCNames = allocVector(STRSXP, ii));
int i;
installErrorHandler();
for (i = 0; i < ii; ++i) {
const char *field = CSLGetField(pcCNames, i);
SET_STRING_ELT(sxpCNames, i, mkChar(field));
}
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(sxpCNames);
}
SEXP
RGDAL_GetNoDataValue(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
int hasNoDataValue;
installErrorHandler();
double noDataValue = pRasterBand->GetNoDataValue(&hasNoDataValue);
uninstallErrorHandlerAndTriggerError();
return(hasNoDataValue ? ScalarReal(noDataValue) : R_NilValue);
}
SEXP
RGDAL_GetRasterBlockSize(SEXP rasterObj) {
GDALRasterBand *raster = getGDALRasterPtr(rasterObj);
SEXP blockSize = allocVector(INTSXP, 2);
installErrorHandler();
raster->GetBlockSize(INTEGER(blockSize) + 1, INTEGER(blockSize));
uninstallErrorHandlerAndTriggerError();
return(blockSize);
}
SEXP
RGDAL_GetColorTable(SEXP rasterObj) {
GDALRasterBandH rasterBand = getGDALRasterPtr(rasterObj);
installErrorHandler();
GDALColorTableH ctab = GDALGetRasterColorTable(rasterBand);
uninstallErrorHandlerAndTriggerError();
if (ctab == NULL) return(R_NilValue);
return(GDALColorTable2Matrix(ctab));
}
/* added RSB 20060212 */
SEXP
RGDAL_SetProject(SEXP sxpDataset, SEXP proj4string) {
OGRSpatialReference oSRS;
char *pszSRS_WKT = NULL;
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
installErrorHandler();
oSRS.importFromProj4(CHAR(STRING_ELT(proj4string, 0)));
oSRS.exportToWkt( &pszSRS_WKT );
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
OGRErr err = pDataset->SetProjection(pszSRS_WKT);
CPLFree( pszSRS_WKT );
if (err == CE_Failure)
warning("Failed to set projection\n");
uninstallErrorHandlerAndTriggerError();
return(sxpDataset);
}
SEXP
RGDAL_GDALVersionInfo(SEXP str) {
SEXP ans;
PROTECT(ans=NEW_CHARACTER(1));
installErrorHandler();
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(GDALVersionInfo(asString(str))));
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(ans);
}
SEXP p4s_to_wkt(SEXP p4s, SEXP esri) {
OGRSpatialReference hSRS = NULL;
char *pszSRS_WKT = NULL;
SEXP ans;
installErrorHandler();
if (hSRS.importFromProj4(CHAR(STRING_ELT(p4s, 0))) != OGRERR_NONE) {
uninstallErrorHandlerAndTriggerError();
error("Can't parse PROJ.4-style parameter string");
}
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
if (INTEGER_POINTER(esri)[0] == 1) hSRS.morphToESRI();
hSRS.exportToWkt(&pszSRS_WKT);
uninstallErrorHandlerAndTriggerError();
PROTECT(ans=NEW_CHARACTER(1));
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(pszSRS_WKT));
UNPROTECT(1);
return(ans);
}
