HDF5ImageRasterBand::HDF5ImageRasterBand( HDF5ImageDataset *poDS, int nBand,
GDALDataType eType )
{
char **papszMetaGlobal;
this->poDS = poDS;
this->nBand = nBand;
eDataType = eType;
bNoDataSet = FALSE;
dfNoDataValue = -9999;
nBlockXSize = poDS->GetRasterXSize( );
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Take a copy of Global Metadata since I can't pass Raster */
/* variable to Iterate function. */
/* -------------------------------------------------------------------- */
papszMetaGlobal = CSLDuplicate( poDS->papszMetadata );
CSLDestroy( poDS->papszMetadata );
poDS->papszMetadata = NULL;
if( poDS->poH5Objects->nType == H5G_DATASET ) {
poDS->CreateMetadata( poDS->poH5Objects, H5G_DATASET );
}
/* -------------------------------------------------------------------- */
/* Recover Global Metadat and set Band Metadata */
/* -------------------------------------------------------------------- */
SetMetadata( poDS->papszMetadata );
CSLDestroy( poDS->papszMetadata );
poDS->papszMetadata = CSLDuplicate( papszMetaGlobal );
CSLDestroy( papszMetaGlobal );
/* check for chunksize and set it as the blocksize (optimizes read) */
hid_t listid = H5Dget_create_plist(((HDF5ImageDataset * )poDS)->dataset_id);
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3];
int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
nBlockXSize = (int) panChunkDims[nDimSize-1];
nBlockYSize = (int) panChunkDims[nDimSize-2];
}
H5Pclose(listid);
}
}
HDF5ImageRasterBand::HDF5ImageRasterBand( HDF5ImageDataset *poDSIn, int nBandIn,
GDALDataType eType ) :
bNoDataSet(false),
dfNoDataValue(-9999.0)
{
poDS = poDSIn;
nBand = nBandIn;
eDataType = eType;
nBlockXSize = poDS->GetRasterXSize( );
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Take a copy of Global Metadata since I can't pass Raster */
/* variable to Iterate function. */
/* -------------------------------------------------------------------- */
char **papszMetaGlobal = CSLDuplicate( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = NULL;
if( poDSIn->poH5Objects->nType == H5G_DATASET ) {
poDSIn->CreateMetadata( poDSIn->poH5Objects, H5G_DATASET );
}
/* -------------------------------------------------------------------- */
/* Recover Global Metadata and set Band Metadata */
/* -------------------------------------------------------------------- */
SetMetadata( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = CSLDuplicate( papszMetaGlobal );
CSLDestroy( papszMetaGlobal );
/* check for chunksize and set it as the blocksize (optimizes read) */
const hid_t listid = H5Dget_create_plist(poDSIn->dataset_id);
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3] = {0, 0, 0};
const int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
CPL_IGNORE_RET_VAL(nDimSize);
CPLAssert(nDimSize == poDSIn->ndims);
nBlockXSize = (int) panChunkDims[poDSIn->GetXIndex()];
nBlockYSize = (int) panChunkDims[poDSIn->GetYIndex()];
}
H5Pclose(listid);
}
}
SEXP
RGDAL_GetCategoryNames(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
char **pcCNames = pRasterBand->GetCategoryNames();
if (pcCNames == NULL) return(R_NilValue);
pcCNames = CSLDuplicate(pcCNames);
SEXP sxpCNames;
PROTECT(sxpCNames = allocVector(STRSXP, CSLCount(pcCNames)));
int i;
for (i = 0; i < CSLCount(pcCNames); ++i) {
const char *field = CSLGetField(pcCNames, i);
SET_VECTOR_ELT(sxpCNames, i, mkChar(field));
}
UNPROTECT(1);
return(sxpCNames);
}
CPLErr GDALMultiDomainMetadata::SetMetadata( char **papszMetadata,
const char *pszDomain )
{
if( pszDomain == NULL )
pszDomain = "";
int iDomain = CSLFindString( papszDomainList, pszDomain );
if( iDomain == -1 )
{
int nDomainCount;
papszDomainList = CSLAddString( papszDomainList, pszDomain );
nDomainCount = CSLCount( papszDomainList );
papoMetadataLists = (CPLStringList **)
CPLRealloc( papoMetadataLists, sizeof(void*)*(nDomainCount+1) );
papoMetadataLists[nDomainCount] = NULL;
papoMetadataLists[nDomainCount-1] = new CPLStringList();
iDomain = nDomainCount-1;
}
papoMetadataLists[iDomain]->Assign( CSLDuplicate( papszMetadata ) );
// we want to mark name/value pair domains as being sorted for fast
// access.
if( !EQUALN(pszDomain,"xml:",4) && !EQUAL(pszDomain, "SUBDATASETS") )
papoMetadataLists[iDomain]->Sort();
return CE_None;
}
void CPLHTTPInitializeRequest(CPLHTTPRequest *psRequest, const char *pszURL, const char *const *papszOptions) {
psRequest->pszURL = CPLStrdup(pszURL);
psRequest->papszOptions = CSLDuplicate(const_cast<char **>(papszOptions));
psRequest->nStatus = 0;
psRequest->pszContentType = 0;
psRequest->pszError = 0;
psRequest->pabyData = 0;
psRequest->nDataLen = 0;
psRequest->nDataAlloc = 0;
psRequest->m_curl_handle = 0;
psRequest->m_headers = 0;
psRequest->m_curl_error = 0;
psRequest->m_curl_handle = curl_easy_init();
if (psRequest->m_curl_handle == NULL) {
CPLError(CE_Fatal, CPLE_AppDefined, "CPLHTTPInitializeRequest(): Unable to create CURL handle.");
}
char** papszOptionsDup = CSLDuplicate(const_cast<char **>(psRequest->papszOptions));
/* Set User-Agent */
const char *pszUserAgent = CSLFetchNameValue(papszOptionsDup, "USERAGENT");
if (pszUserAgent == NULL)
papszOptionsDup = CSLAddNameValue(papszOptionsDup, "USERAGENT",
"GDAL WMS driver (http://www.gdal.org/frmt_wms.html)");
/* Set URL */
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_URL, psRequest->pszURL);
/* Set Headers (copied&pasted from cpl_http.cpp, but unused by callers of CPLHTTPInitializeRequest) .*/
const char *headers = CSLFetchNameValue(const_cast<char **>(psRequest->papszOptions), "HEADERS");
if (headers != NULL) {
psRequest->m_headers = curl_slist_append(psRequest->m_headers, headers);
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_HTTPHEADER, psRequest->m_headers);
}
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_WRITEDATA, psRequest);
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_WRITEFUNCTION, CPLHTTPWriteFunc);
psRequest->m_curl_error = reinterpret_cast<char *>(CPLMalloc(CURL_ERROR_SIZE + 1));
psRequest->m_curl_error[0] = '\0';
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_ERRORBUFFER, psRequest->m_curl_error);
CPLHTTPSetOptions(psRequest->m_curl_handle, papszOptionsDup);
CSLDestroy(papszOptionsDup);
}
CPLErr RawRasterBand::SetCategoryNames( char ** papszNewNames )
{
CSLDestroy( papszCategoryNames );
papszCategoryNames = CSLDuplicate( papszNewNames );
return CE_None;
}
OGRWritableDWGLayer::OGRWritableDWGLayer( const char *pszLayerName,
char **papszOptionsIn,
OGRWritableDWGDataSource *poDSIn )
{
poDS = poDSIn;
papszOptions = CSLDuplicate( papszOptionsIn );
pDb = poDS->pDb;
/* -------------------------------------------------------------------- */
/* Create the DWGdirect layer object. */
/* -------------------------------------------------------------------- */
// Add a new layer to the drawing
OdDbLayerTablePtr pLayers;
OdDbLayerTableRecordPtr pLayer;
pLayers = pDb->getLayerTableId().safeOpenObject(OdDb::kForWrite);
pLayer = OdDbLayerTableRecord::createObject();
// Name must be set before a table object is added to a table.
pLayer->setName( pszLayerName );
// Add the object to the table.
hLayerId = pLayers->add(pLayer);
/* -------------------------------------------------------------------- */
/* Check for a layer color. */
/* -------------------------------------------------------------------- */
const char *pszColor = CSLFetchNameValue(papszOptionsIn,"COLOR");
if( pszColor != NULL )
{
char **papszTokens =
CSLTokenizeStringComplex( pszColor, ",", FALSE, FALSE );
if( CSLCount( papszTokens ) != 3 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"COLOR=%s setting not parsable. Should be 'red,green,blue'.",
pszColor );
}
else
{
OdCmColor oColor;
oColor.setRGB( atoi(papszTokens[0]),
atoi(papszTokens[1]),
atoi(papszTokens[2]) );
pLayer->setColor( oColor );
}
}
/* -------------------------------------------------------------------- */
/* Create the starting OGRFeatureDefn. */
/* -------------------------------------------------------------------- */
poFeatureDefn = new OGRFeatureDefn( pszLayerName );
poFeatureDefn->Reference();
}
int OGRDGNDataSource::PreCreate( const char *pszFilename,
char **papszOptions )
{
this->papszOptions = CSLDuplicate( papszOptions );
pszName = CPLStrdup( pszFilename );
return TRUE;
}
CPLErr VRTRasterBand::SetCategoryNames( char ** papszNewNames )
{
reinterpret_cast<VRTDataset *>( poDS )->SetNeedsFlush();
CSLDestroy( m_papszCategoryNames );
m_papszCategoryNames = CSLDuplicate( papszNewNames );
return CE_None;
}
CPLErr GDALGeorefPamDataset::SetMetadata( char ** papszMetadata,
const char * pszDomain )
{
if( m_bPAMLoaded && (pszDomain == NULL || EQUAL(pszDomain, "")) )
{
CSLDestroy(m_papszMainMD);
m_papszMainMD = CSLDuplicate(papszMetadata);
}
return GDALPamDataset::SetMetadata(papszMetadata, pszDomain);
}
CPLErr VRTRasterBand::SetCategoryNames( char ** papszNewNames )
{
((VRTDataset *) poDS)->SetNeedsFlush();
CSLDestroy( papszCategoryNames );
papszCategoryNames = CSLDuplicate( papszNewNames );
return CE_None;
}
OGRErr OGRUnionLayer::SetIgnoredFields( const char **papszFields )
{
OGRErr eErr = OGRLayer::SetIgnoredFields(papszFields);
if( eErr != OGRERR_NONE )
return eErr;
CSLDestroy(papszIgnoredFields);
papszIgnoredFields = papszFields ? CSLDuplicate((char**)papszFields) : NULL;
return eErr;
}
CPLErr VRTDriver::SetMetadata( char **papszMetadata, const char *pszDomain )
{
if( pszDomain && EQUAL(pszDomain,"SourceParsers") )
{
CSLDestroy( papszSourceParsers );
papszSourceParsers = CSLDuplicate( papszMetadata );
return CE_None;
}
return GDALDriver::SetMetadata( papszMetadata, pszDomain );
}
int msContourLayerWhichShapes(layerObj *layer, rectObj rect, int isQuery)
{
rectObj newRect;
contourLayerInfo *clinfo = (contourLayerInfo *) layer->layerinfo;
if (layer->debug)
msDebug("Entering msContourLayerWhichShapes().\n");
if (clinfo == NULL) {
msSetError(MS_MISCERR, "Assertion failed: Contour layer not opened!!!",
"msContourLayerWhichShapes()");
return MS_FAILURE;
}
newRect = rect;
#ifdef USE_PROJ
/* if necessary, project the searchrect to source coords */
if (msProjectionsDiffer( &(layer->map->projection), &(layer->projection))) {
if (msProjectRect(&layer->projection, &layer->map->projection, &newRect)
!= MS_SUCCESS ) {
msDebug("msContourLayerWhichShapes(%s): unable to reproject map request rectangle into layer projection, canceling.\n", layer->name);
return MS_FAILURE;
}
}
#endif
/* regenerate the raster io */
msConnPoolRelease(&clinfo->ogrLayer, clinfo->hOGRDS);
msLayerClose(&clinfo->ogrLayer);
/* Open the raster source */
if (msContourLayerReadRaster(layer, newRect) != MS_SUCCESS)
return MS_FAILURE;
/* Generate Contour Dataset */
if (msContourLayerGenerateContour(layer) != MS_SUCCESS)
return MS_FAILURE;
GDALClose(clinfo->hDS);
clinfo->hDS = NULL;
free(clinfo->buffer);
/* Open our virtual ogr layer */
if (msLayerOpen(&clinfo->ogrLayer) != MS_SUCCESS)
return MS_FAILURE;
clinfo->ogrLayer.numitems = layer->numitems;
clinfo->ogrLayer.items = CSLDuplicate(layer->items);
return msLayerWhichShapes(&clinfo->ogrLayer, rect, isQuery);
}
CPLErr GDALPamRasterBand::SetCategoryNames( char ** papszNewNames )
{
PamInitialize();
if( !psPam )
return GDALRasterBand::SetCategoryNames( papszNewNames );
CSLDestroy( psPam->papszCategoryNames );
psPam->papszCategoryNames = CSLDuplicate( papszNewNames );
psPam->poParentDS->MarkPamDirty();
return CE_None;
}
// set the metdata as a CSLStringList
CPLErr KEARasterBand::SetMetadata(char **papszMetadata, const char *pszDomain)
{
// only deal with 'default' domain - no geolocation etc
if( ( pszDomain != NULL ) && ( *pszDomain != '\0' ) )
return CE_Failure;
int nIndex = 0;
char *pszName;
const char *pszValue;
try
{
// iterate through each one
while( papszMetadata[nIndex] != NULL )
{
pszName = NULL;
pszValue = CPLParseNameValue( papszMetadata[nIndex], &pszName );
if( pszValue == NULL )
pszValue = "";
if( pszName != NULL )
{
// it is LAYER_TYPE? if so handle seperately
if( EQUAL( pszName, "LAYER_TYPE" ) )
{
if( EQUAL( pszValue, "athematic" ) )
{
this->m_pImageIO->setImageBandLayerType(this->nBand, kealib::kea_continuous );
}
else
{
this->m_pImageIO->setImageBandLayerType(this->nBand, kealib::kea_thematic );
}
}
else
{
// write it into the image
this->m_pImageIO->setImageBandMetaData(this->nBand, pszName, pszValue );
}
CPLFree(pszName);
}
nIndex++;
}
}
catch (kealib::KEAIOException &e)
{
return CE_Failure;
}
// destroy our list and duplicate the one passed in
// and use that as our list from now on
CSLDestroy(m_papszMetadataList);
m_papszMetadataList = CSLDuplicate(papszMetadata);
return CE_None;
}
GDALOverviewDataset::GDALOverviewDataset(GDALDataset* poMainDS,
int nOvrLevel,
int bThisLevelOnly,
int bOwnDS)
{
this->poMainDS = poMainDS;
this->nOvrLevel = nOvrLevel;
this->bOwnDS = bOwnDS;
this->bThisLevelOnly = bThisLevelOnly;
eAccess = poMainDS->GetAccess();
nRasterXSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetXSize();
nRasterYSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetYSize();
poOvrDS = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetDataset();
if( poOvrDS != NULL && poOvrDS == poMainDS )
{
CPLDebug("GDAL", "Dataset of overview is the same as the main band. This is not expected");
poOvrDS = NULL;
}
nBands = poMainDS->GetRasterCount();
for(int i=0; i<nBands; i++)
{
SetBand(i+1, new GDALOverviewBand(this, i+1));
}
nGCPCount = 0;
pasGCPList = NULL;
papszMD_RPC = NULL;
papszMD_GEOLOCATION = NULL;
/* We create a fake driver that has the same name as the original */
/* one, but we cannot use the real driver object, so that code */
/* doesn't try to cast the GDALOverviewDataset* as a native dataset */
/* object */
if( poMainDS->GetDriver() != NULL )
{
poDriver = new GDALDriver();
poDriver->SetDescription(poMainDS->GetDriver()->GetDescription());
poDriver->SetMetadata(poMainDS->GetDriver()->GetMetadata());
}
SetDescription( poMainDS->GetDescription() );
CPLDebug( "GDAL", "GDALOverviewDataset(%s, this=%p) creation.",
poMainDS->GetDescription(), this );
papszOpenOptions = CSLDuplicate(poMainDS->GetOpenOptions());
/* Add OVERVIEW_LEVEL if not called from GDALOpenEx() but directly */
papszOpenOptions = CSLSetNameValue(papszOpenOptions, "OVERVIEW_LEVEL",
CPLSPrintf("%d", nOvrLevel));
}
OGRS57DataSource::OGRS57DataSource(char** papszOpenOptions)
{
nLayers = 0;
papoLayers = NULL;
nModules = 0;
papoModules = NULL;
poClassContentExplorer = NULL;
poWriter = NULL;
pszName = NULL;
poSpatialRef = new OGRSpatialReference();
poSpatialRef->SetWellKnownGeogCS( "WGS84" );
bExtentsSet = FALSE;
/* -------------------------------------------------------------------- */
/* Allow initialization of options from the environment. */
/* -------------------------------------------------------------------- */
if( papszOpenOptions != NULL )
{
papszOptions = CSLDuplicate(papszOpenOptions);
}
else
{
const char *pszOptString = CPLGetConfigOption( "OGR_S57_OPTIONS", NULL );
papszOptions = NULL;
if ( pszOptString )
{
char **papszCurOption;
papszOptions =
CSLTokenizeStringComplex( pszOptString, ",", FALSE, FALSE );
if ( papszOptions && *papszOptions )
{
CPLDebug( "S57", "The following S57 options are being set:" );
papszCurOption = papszOptions;
while( *papszCurOption )
CPLDebug( "S57", " %s", *papszCurOption++ );
}
}
}
}
SEXP
RGDAL_GetMetadata(SEXP sxpObj, SEXP sxpDomain) {
void *pGDALObj = getGDALObjPtr(sxpObj);
const char *domain = asString(sxpDomain);
char **metadata = ((GDALMajorObject *)pGDALObj)->GetMetadata(domain);
if (metadata == NULL) return(R_NilValue);
metadata = CSLDuplicate(metadata);
SEXP sxpMetadata, sxpNames;
PROTECT(sxpMetadata = allocVector(VECSXP, CSLCount(metadata)));
PROTECT(sxpNames = allocVector(STRSXP, CSLCount(metadata)));
int i;
for (i = 0; i < CSLCount(metadata); ++i) {
const char *field = CSLGetField(metadata, i);
char *tag = NULL;
const char *value = CPLParseNameValue(field, &tag);
SET_VECTOR_ELT(sxpMetadata, i, value ? mkChar(value) : mkChar(""));
SET_STRING_ELT(sxpNames, i, tag ? mkChar(tag) : mkChar(""));
}
setAttrib(sxpMetadata, R_NamesSymbol, sxpNames);
UNPROTECT(2);
return(sxpMetadata);
}
GDALDataset* PDFWritableVectorDataset::Create( const char * pszName,
CPL_UNUSED int nXSize,
CPL_UNUSED int nYSize,
int nBands,
CPL_UNUSED GDALDataType eType,
char ** papszOptions )
{
if( nBands != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"PDFWritableVectorDataset::Create() can only be called with "
"nBands = 0 to create a vector-only PDF");
return NULL;
}
PDFWritableVectorDataset* poDataset = new PDFWritableVectorDataset();
poDataset->SetDescription(pszName);
poDataset->papszOptions = CSLDuplicate(papszOptions);
return poDataset;
}
// set the whole metadata as a CSLStringList
CPLErr KEADataset::SetMetadata(char **papszMetadata, const char *pszDomain)
{
// only deal with 'default' domain - no geolocation etc
if( ( pszDomain != NULL ) && ( *pszDomain != '\0' ) )
return CE_Failure;
int nIndex = 0;
char *pszName;
const char *pszValue;
try
{
// go through each item
while( papszMetadata[nIndex] != NULL )
{
// get the value/name
pszName = NULL;
pszValue = CPLParseNameValue( papszMetadata[nIndex], &pszName );
if( pszValue == NULL )
pszValue = "";
if( pszName != NULL )
{
// set it with imageio
this->m_pImageIO->setImageMetaData(pszName, pszValue );
CPLFree(pszName);
}
nIndex++;
}
}
catch (kealib::KEAIOException &e)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to write metadata: %s", e.what() );
return CE_Failure;
}
// destroy our one and replace it
CSLDestroy(m_papszMetadataList);
m_papszMetadataList = CSLDuplicate(papszMetadata);
return CE_None;
}
void GDALDefaultOverviews::Initialize( GDALDataset *poDSIn,
const char * pszBasename,
char **papszSiblingFiles,
int bNameIsOVR )
{
poDS = poDSIn;
/* -------------------------------------------------------------------- */
/* If we were already initialized, destroy the old overview */
/* file handle. */
/* -------------------------------------------------------------------- */
if( poODS != NULL )
{
GDALClose( poODS );
poODS = NULL;
CPLDebug(
"GDAL",
"GDALDefaultOverviews::Initialize() called twice - "
"this is odd and perhaps dangerous!" );
}
/* -------------------------------------------------------------------- */
/* Store the initialization information for later use in */
/* OverviewScan() */
/* -------------------------------------------------------------------- */
bCheckedForOverviews = FALSE;
CPLFree( pszInitName );
pszInitName = NULL;
if( pszBasename != NULL )
pszInitName = CPLStrdup(pszBasename);
bInitNameIsOVR = CPL_TO_BOOL(bNameIsOVR);
CSLDestroy( papszInitSiblingFiles );
papszInitSiblingFiles = NULL;
if( papszSiblingFiles != NULL )
papszInitSiblingFiles = CSLDuplicate(papszSiblingFiles);
}
OGRS57DataSource::OGRS57DataSource(char** papszOpenOptionsIn) :
pszName(NULL),
nLayers(0),
papoLayers(NULL),
poSpatialRef(new OGRSpatialReference()),
papszOptions(NULL),
nModules(0),
papoModules(NULL),
poWriter(NULL),
poClassContentExplorer(NULL),
bExtentsSet(false)
{
poSpatialRef->SetWellKnownGeogCS( "WGS84" );
/* -------------------------------------------------------------------- */
/* Allow initialization of options from the environment. */
/* -------------------------------------------------------------------- */
if( papszOpenOptionsIn != NULL )
{
papszOptions = CSLDuplicate(papszOpenOptionsIn);
return;
}
const char *pszOptString = CPLGetConfigOption( "OGR_S57_OPTIONS", NULL );
if ( pszOptString == NULL )
return;
papszOptions =
CSLTokenizeStringComplex( pszOptString, ",", FALSE, FALSE );
if ( papszOptions && *papszOptions )
{
CPLDebug( "S57", "The following S57 options are being set:" );
char **papszCurOption = papszOptions;
while( *papszCurOption )
CPLDebug( "S57", " %s", *papszCurOption++ );
}
}
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);
}
static
void* GDALCreateSimilarGeoLocTransformer( void *hTransformArg, double dfRatioX, double dfRatioY )
{
VALIDATE_POINTER1( hTransformArg, "GDALCreateSimilarGeoLocTransformer", NULL );
GDALGeoLocTransformInfo *psInfo = (GDALGeoLocTransformInfo *) hTransformArg;
char** papszGeolocationInfo = CSLDuplicate(psInfo->papszGeolocationInfo);
if( dfRatioX != 1.0 || dfRatioY != 1.0 )
{
GDALGeoLocRescale(papszGeolocationInfo, "PIXEL_OFFSET", dfRatioX, 0.0);
GDALGeoLocRescale(papszGeolocationInfo, "LINE_OFFSET", dfRatioY, 0.0);
GDALGeoLocRescale(papszGeolocationInfo, "PIXEL_STEP", 1.0 / dfRatioX, 1.0);
GDALGeoLocRescale(papszGeolocationInfo, "LINE_STEP", 1.0 / dfRatioY, 1.0);
}
psInfo = (GDALGeoLocTransformInfo*) GDALCreateGeoLocTransformer(
NULL, papszGeolocationInfo, psInfo->bReversed );
CSLDestroy(papszGeolocationInfo);
return psInfo;
}
int OGRTABDataSource::Create( const char * pszName, char **papszOptions )
{
CPLAssert(m_pszName == nullptr);
m_pszName = CPLStrdup(pszName);
m_papszOptions = CSLDuplicate(papszOptions);
m_bUpdate = TRUE;
const char *pszOpt = CSLFetchNameValue(papszOptions, "FORMAT");
if( pszOpt != nullptr && EQUAL(pszOpt, "MIF") )
m_bCreateMIF = TRUE;
else if( EQUAL(CPLGetExtension(pszName),"mif") ||
EQUAL(CPLGetExtension(pszName),"mid") )
m_bCreateMIF = TRUE;
if( (pszOpt = CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != nullptr )
{
if( EQUAL(pszOpt, "QUICK") )
m_bQuickSpatialIndexMode = TRUE;
else if( EQUAL(pszOpt, "OPTIMIZED") )
m_bQuickSpatialIndexMode = FALSE;
}
m_nBlockSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "512"));
// Create a new empty directory.
VSIStatBufL sStat;
if( strlen(CPLGetExtension(pszName)) == 0 )
{
if( VSIStatL( pszName, &sStat ) == 0 )
{
if( !VSI_ISDIR(sStat.st_mode) )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attempt to create dataset named %s,\n"
"but that is an existing file.",
pszName);
return FALSE;
}
}
else
{
if( VSIMkdir(pszName, 0755) != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unable to create directory %s.",
pszName);
return FALSE;
}
}
m_pszDirectory = CPLStrdup(pszName);
}
// Create a new single file.
else
{
IMapInfoFile *poFile = nullptr;
const char *pszEncoding( CSLFetchNameValue( papszOptions, "ENCODING" ) );
const char *pszCharset( IMapInfoFile::EncodingToCharset( pszEncoding ) );
if( m_bCreateMIF )
{
poFile = new MIFFile;
if( poFile->Open(m_pszName, TABWrite, FALSE, pszCharset) != 0 )
{
delete poFile;
return FALSE;
}
}
else
{
TABFile *poTabFile = new TABFile;
if( poTabFile->Open(m_pszName, TABWrite, FALSE,
m_nBlockSize, pszCharset) != 0 )
{
delete poTabFile;
return FALSE;
}
poFile = poTabFile;
}
m_nLayerCount = 1;
m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));
m_papoLayers[0] = poFile;
m_pszDirectory = CPLStrdup(CPLGetPath(pszName));
m_bSingleFile = TRUE;
}
return TRUE;
}
void OGRS57DataSource::SetOptionList( char ** papszNewOptions )
{
CSLDestroy( papszOptions );
papszOptions = CSLDuplicate( papszNewOptions );
}
int msUVRASTERLayerWhichShapes(layerObj *layer, rectObj rect, int isQuery)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
imageObj *image_tmp;
outputFormatObj *outputformat = NULL;
mapObj *map_tmp;
double map_cellsize;
unsigned int spacing;
int width, height, u_src_off, v_src_off, i, x, y;
char **alteredProcessing = NULL, *saved_layer_mask;
char **savedProcessing = NULL;
if (layer->debug)
msDebug("Entering msUVRASTERLayerWhichShapes().\n");
if( uvlinfo == NULL )
return MS_FAILURE;
/* QUERY NOT SUPPORTED YET */
if (isQuery == MS_TRUE) {
msSetError( MS_MISCERR, "Query is not supported for UV layer.", "msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
if( CSLFetchNameValue( layer->processing, "BANDS" ) == NULL ) {
msSetError( MS_MISCERR, "BANDS processing option is required for UV layer. You have to specified 2 bands.",
"msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
/*
** Allocate mapObj structure
*/
map_tmp = (mapObj *)msSmallCalloc(sizeof(mapObj),1);
if(initMap(map_tmp) == -1) { /* initialize this map */
msFree(map_tmp);
return(MS_FAILURE);
}
/* -------------------------------------------------------------------- */
/* Determine desired spacing. Default to 32 if not otherwise set */
/* -------------------------------------------------------------------- */
spacing = 32;
if( CSLFetchNameValue( layer->processing, "UV_SPACING" ) != NULL ) {
spacing =
atoi(CSLFetchNameValue( layer->processing, "UV_SPACING" ));
}
width = (int)ceil(layer->map->width/spacing);
height = (int)ceil(layer->map->height/spacing);
map_cellsize = MS_MAX(MS_CELLSIZE(rect.minx, rect.maxx,layer->map->width),
MS_CELLSIZE(rect.miny,rect.maxy,layer->map->height));
map_tmp->cellsize = map_cellsize*spacing;
if (layer->debug)
msDebug("msUVRASTERLayerWhichShapes(): width: %d, height: %d, cellsize: %g\n",
width, height, map_tmp->cellsize);
/* Initialize our dummy map */
MS_INIT_COLOR(map_tmp->imagecolor, 255,255,255,255);
map_tmp->resolution = layer->map->resolution;
map_tmp->defresolution = layer->map->defresolution;
outputformat = (outputFormatObj *) msSmallCalloc(1,sizeof(outputFormatObj));
outputformat->bands = uvlinfo->band_count = 2;
outputformat->name = NULL;
outputformat->driver = NULL;
outputformat->refcount = 0;
outputformat->vtable = NULL;
outputformat->device = NULL;
outputformat->renderer = MS_RENDER_WITH_RAWDATA;
outputformat->imagemode = MS_IMAGEMODE_FLOAT32;
msAppendOutputFormat(map_tmp, outputformat);
msCopyHashTable(&map_tmp->configoptions, &layer->map->configoptions);
map_tmp->mappath = msStrdup(layer->map->mappath);
map_tmp->shapepath = msStrdup(layer->map->shapepath);
map_tmp->extent.minx = rect.minx-(0.5*map_cellsize)+(0.5*map_tmp->cellsize);
map_tmp->extent.miny = rect.miny-(0.5*map_cellsize)+(0.5*map_tmp->cellsize);
map_tmp->extent.maxx = map_tmp->extent.minx+((width-1)*map_tmp->cellsize);
map_tmp->extent.maxy = map_tmp->extent.miny+((height-1)*map_tmp->cellsize);
map_tmp->gt.rotation_angle = 0.0;
msCopyProjection(&map_tmp->projection, &layer->projection);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): extent: %g %g %g %g\n",
map_tmp->extent.minx, map_tmp->extent.miny,
map_tmp->extent.maxx, map_tmp->extent.maxy);
/* important to use that function, to compute map
geotransform, used by the resampling*/
msMapSetSize(map_tmp, width, height);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): geotransform: %g %g %g %g %g %g\n",
map_tmp->gt.geotransform[0], map_tmp->gt.geotransform[1],
map_tmp->gt.geotransform[2], map_tmp->gt.geotransform[3],
map_tmp->gt.geotransform[4], map_tmp->gt.geotransform[5]);
uvlinfo->extent = map_tmp->extent;
image_tmp = msImageCreate(width, height, map_tmp->outputformatlist[0],
NULL, NULL, map_tmp->resolution, map_tmp->defresolution,
&(map_tmp->imagecolor));
/* Default set to AVERAGE resampling */
if( CSLFetchNameValue( layer->processing, "RESAMPLE" ) == NULL ) {
alteredProcessing = CSLDuplicate( layer->processing );
alteredProcessing =
CSLSetNameValue( alteredProcessing, "RESAMPLE",
"AVERAGE");
savedProcessing = layer->processing;
layer->processing = alteredProcessing;
}
/* disable masking at this level: we don't want to apply the mask at the raster level,
* it will be applied with the correct cellsize and image size in the vector rendering
* phase.
*/
saved_layer_mask = layer->mask;
layer->mask = NULL;
if (msDrawRasterLayerLow(map_tmp, layer, image_tmp, NULL ) == MS_FAILURE) {
msSetError(MS_MISCERR, "Unable to draw raster data.", "msUVRASTERLayerWhichShapes()");
layer->mask = saved_layer_mask;
return MS_FAILURE;
}
/* restore layer mask */
layer->mask = saved_layer_mask;
/* restore the saved processing */
if (alteredProcessing != NULL) {
layer->processing = savedProcessing;
CSLDestroy(alteredProcessing);
}
/* free old query arrays */
if (uvlinfo->u) {
for (i=0; i<uvlinfo->width; ++i) {
free(uvlinfo->u[i]);
}
free(uvlinfo->u);
}
if (uvlinfo->v) {
for (i=0; i<uvlinfo->height; ++i) {
free(uvlinfo->v[i]);
}
free(uvlinfo->v);
}
/* Update our uv layer structure */
uvlinfo->width = width;
uvlinfo->height = height;
uvlinfo->query_results = width*height;
uvlinfo->u = (float **)msSmallMalloc(sizeof(float *)*width);
uvlinfo->v = (float **)msSmallMalloc(sizeof(float *)*width);
for (x = 0; x < width; ++x) {
uvlinfo->u[x] = (float *)msSmallMalloc(height * sizeof(float));
uvlinfo->v[x] = (float *)msSmallMalloc(height * sizeof(float));
for (y = 0; y < height; ++y) {
u_src_off = v_src_off = x + y * width;
v_src_off += width*height;
uvlinfo->u[x][y] = image_tmp->img.raw_float[u_src_off];
uvlinfo->v[x][y] = image_tmp->img.raw_float[v_src_off];
/* null vector? update the number of results */
if (uvlinfo->u[x][y] == 0 && uvlinfo->v[x][y] == 0)
--uvlinfo->query_results;
}
}
msFreeImage(image_tmp); /* we do not need the imageObj anymore */
msFreeMap(map_tmp);
uvlinfo->next_shape = 0;
return MS_SUCCESS;
}
int OGRShapeDataSource::Open( GDALOpenInfo* poOpenInfo,
int bTestOpen, int bForceSingleFileDataSource )
{
CPLAssert( nLayers == 0 );
const char * pszNewName = poOpenInfo->pszFilename;
int bUpdate = poOpenInfo->eAccess == GA_Update;
papszOpenOptions = CSLDuplicate( poOpenInfo->papszOpenOptions );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
bSingleFileDataSource = bForceSingleFileDataSource;
/* -------------------------------------------------------------------- */
/* If bSingleFileDataSource is TRUE we don't try to do anything else. */
/* This is only utilized when the OGRShapeDriver::Create() */
/* method wants to create a stub OGRShapeDataSource for a */
/* single shapefile. The driver will take care of creating the */
/* file by callingICreateLayer(). */
/* -------------------------------------------------------------------- */
if( bSingleFileDataSource )
return TRUE;
/* -------------------------------------------------------------------- */
/* Is the given path a directory or a regular file? */
/* -------------------------------------------------------------------- */
if( !poOpenInfo->bStatOK )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s is neither a file or directory, Shape access failed.\n",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Build a list of filenames we figure are Shape files. */
/* -------------------------------------------------------------------- */
if( !poOpenInfo->bIsDirectory )
{
if( !OpenFile( pszNewName, bUpdate, bTestOpen ) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open shapefile %s.\n"
"It may be corrupt or read-only file accessed in update mode.\n",
pszNewName );
return FALSE;
}
bSingleFileDataSource = TRUE;
return TRUE;
}
else
{
char **papszCandidates = CPLReadDir( pszNewName );
int iCan, nCandidateCount = CSLCount( papszCandidates );
int bMightBeOldCoverage = FALSE;
std::set<CPLString> osLayerNameSet;
for( iCan = 0; iCan < nCandidateCount; iCan++ )
{
char *pszFilename;
const char *pszCandidate = papszCandidates[iCan];
const char *pszLayerName = CPLGetBasename(pszCandidate);
CPLString osLayerName(pszLayerName);
#ifdef WIN32
/* On Windows, as filenames are case insensitive, a shapefile layer can be made of */
/* foo.shp and FOO.DBF, so to detect unique layer names, put them */
/* upper case in the unique set used for detection */
osLayerName.toupper();
#endif
if( EQUAL(pszCandidate,"ARC") )
bMightBeOldCoverage = TRUE;
if( strlen(pszCandidate) < 4
|| !EQUAL(pszCandidate+strlen(pszCandidate)-4,".shp") )
continue;
pszFilename =
CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL));
osLayerNameSet.insert(osLayerName);
#ifdef IMMEDIATE_OPENING
if( !OpenFile( pszFilename, bUpdate, bTestOpen )
&& !bTestOpen )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open shapefile %s.\n"
"It may be corrupt or read-only file accessed in update mode.\n",
pszFilename );
CPLFree( pszFilename );
CSLDestroy( papszCandidates );
return FALSE;
}
#else
oVectorLayerName.push_back(pszFilename);
#endif
CPLFree( pszFilename );
}
// Try and .dbf files without apparent associated shapefiles.
for( iCan = 0; iCan < nCandidateCount; iCan++ )
{
char *pszFilename;
const char *pszCandidate = papszCandidates[iCan];
const char *pszLayerName = CPLGetBasename(pszCandidate);
CPLString osLayerName(pszLayerName);
#ifdef WIN32
osLayerName.toupper();
#endif
// We don't consume .dbf files in a directory that looks like
// an old style Arc/Info (for PC?) that unless we found at least
// some shapefiles. See Bug 493.
if( bMightBeOldCoverage && osLayerNameSet.size() == 0 )
continue;
if( strlen(pszCandidate) < 4
|| !EQUAL(pszCandidate+strlen(pszCandidate)-4,".dbf") )
continue;
if( osLayerNameSet.find(osLayerName) != osLayerNameSet.end() )
continue;
// We don't want to access .dbf files with an associated .tab
// file, or it will never get recognised as a mapinfo dataset.
int iCan2, bFoundTAB = FALSE;
for( iCan2 = 0; iCan2 < nCandidateCount; iCan2++ )
{
const char *pszCandidate2 = papszCandidates[iCan2];
if( EQUALN(pszCandidate2,pszLayerName,strlen(pszLayerName))
&& EQUAL(pszCandidate2 + strlen(pszLayerName), ".tab") )
bFoundTAB = TRUE;
}
if( bFoundTAB )
continue;
pszFilename =
CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL));
osLayerNameSet.insert(osLayerName);
#ifdef IMMEDIATE_OPENING
if( !OpenFile( pszFilename, bUpdate, bTestOpen )
&& !bTestOpen )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open dbf file %s.\n"
"It may be corrupt or read-only file accessed in update mode.\n",
pszFilename );
CPLFree( pszFilename );
CSLDestroy( papszCandidates );
return FALSE;
}
#else
oVectorLayerName.push_back(pszFilename);
#endif
CPLFree( pszFilename );
}
CSLDestroy( papszCandidates );
#ifdef IMMEDIATE_OPENING
int nDirLayers = nLayers;
#else
int nDirLayers = oVectorLayerName.size();
#endif
CPLErrorReset();
return nDirLayers > 0 || !bTestOpen;
}
}
int OGRGeoconceptDataSource::Create( const char *pszName, char** papszOptions )
{
const char *pszConf;
const char *pszExtension;
if( _pszName ) CPLFree(_pszName);
_papszOptions = CSLDuplicate( papszOptions );
pszConf= CSLFetchNameValue(papszOptions,"CONFIG");
if( pszConf != NULL )
{
_pszGCT = CPLStrdup(pszConf);
}
_pszExt = (char *)CSLFetchNameValue(papszOptions,"EXTENSION");
pszExtension = CSLFetchNameValue(papszOptions,"EXTENSION");
if( pszExtension == NULL )
{
_pszExt = CPLStrdup(CPLGetExtension(pszName));
}
else
{
_pszExt = CPLStrdup(pszExtension);
}
if( strlen(_pszExt) == 0 )
{
if( VSIMkdir( pszName, 0755 ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Directory %s already exists"
" as geoconcept datastore or"
" is made up of a non existing list of directories.",
pszName );
return FALSE;
}
_pszDirectory = CPLStrdup( pszName );
CPLFree(_pszExt);
_pszExt = CPLStrdup("gxt");
char *pszbName = CPLStrdup(CPLGetBasename( pszName ));
if (strlen(pszbName)==0) {/* pszName ends with '/' */
CPLFree(pszbName);
char *pszNameDup= CPLStrdup(pszName);
pszNameDup[strlen(pszName)-2] = '\0';
pszbName = CPLStrdup(CPLGetBasename( pszNameDup ));
CPLFree(pszNameDup);
}
_pszName = CPLStrdup((char *)CPLFormFilename( _pszDirectory, pszbName, NULL ));
CPLFree(pszbName);
}
else
{
_pszDirectory = CPLStrdup( CPLGetPath(pszName) );
_pszName = CPLStrdup( pszName );
}
/* -------------------------------------------------------------------- */
/* Create a new single file. */
/* OGRGeoconceptDriver::CreateLayer() will do the job. */
/* -------------------------------------------------------------------- */
_bSingleNewFile = TRUE;
if( !LoadFile( "wt" ) )
{
CPLDebug( "GEOCONCEPT",
"Failed to create Geoconcept %s.",
pszName );
return FALSE;
}
return TRUE;
}
