void GDALWMSMiniDriver_TiledWMS::TiledImageRequest(CPLString *url, const GDALWMSImageRequestInfo &iri, const GDALWMSTiledImageRequestInfo &tiri) {
*url = m_base_url;
URLAppend(url,CSLGetField(m_requests,-tiri.m_level));
URLSearchAndReplace(url,"${GDAL_BBOX}","%013.8f,%013.8f,%013.8f,%013.8f",
iri.m_x0,iri.m_y1,iri.m_x1,iri.m_y0);
URLAppend(url,m_end_url);
}
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);
}
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_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_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);
}
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);
}
void ILI1Reader::ReadGeom(char **stgeom, OGRwkbGeometryType eType, OGRFeature *feature) {
char **tokens = NULL;
const char *firsttok = NULL;
int end = FALSE;
int isArc = FALSE;
OGRLineString *ogrLine = NULL; //current line
OGRLinearRing *ogrRing = NULL; //current ring
OGRPolygon *ogrPoly = NULL; //current polygon
OGRPoint ogrPoint, arcPoint, endPoint; //points for arc interpolation
OGRMultiLineString *ogrMultiLine = NULL; //current multi line
//tokens = ["STPT", "1111", "22222"]
ogrPoint.setX(atof(stgeom[1])); ogrPoint.setY(atof(stgeom[2]));
ogrLine = (eType == wkbPolygon) ? new OGRLinearRing() : new OGRLineString();
ogrLine->addPoint(&ogrPoint);
//Set feature geometry
if (eType == wkbMultiLineString)
{
ogrMultiLine = new OGRMultiLineString();
feature->SetGeometryDirectly(ogrMultiLine);
}
else if (eType == wkbGeometryCollection) //AREA
{
if (feature->GetGeometryRef())
ogrMultiLine = (OGRMultiLineString *)feature->GetGeometryRef();
else
{
ogrMultiLine = new OGRMultiLineString();
feature->SetGeometryDirectly(ogrMultiLine);
}
}
else if (eType == wkbPolygon)
{
if (feature->GetGeometryRef())
{
ogrPoly = (OGRPolygon *)feature->GetGeometryRef();
if (ogrPoly->getNumInteriorRings() > 0)
ogrRing = ogrPoly->getInteriorRing(ogrPoly->getNumInteriorRings()-1);
else
ogrRing = ogrPoly->getExteriorRing();
if (ogrRing && !ogrRing->get_IsClosed()) ogrLine = ogrRing; //SURFACE polygon spread over multiple OBJECTs
}
else
{
ogrPoly = new OGRPolygon();
feature->SetGeometryDirectly(ogrPoly);
}
}
else
{
feature->SetGeometryDirectly(ogrLine);
}
//Parse geometry
while (!end && (tokens = ReadParseLine()))
{
firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "LIPT"))
{
if (isArc) {
endPoint.setX(atof(tokens[1])); endPoint.setY(atof(tokens[2]));
interpolateArc(ogrLine, &ogrPoint, &arcPoint, &endPoint, arcIncr);
}
ogrPoint.setX(atof(tokens[1])); ogrPoint.setY(atof(tokens[2])); isArc = FALSE;
ogrLine->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ARCP"))
{
isArc = TRUE;
arcPoint.setX(atof(tokens[1])); arcPoint.setY(atof(tokens[2]));
}
else if (EQUAL(firsttok, "ELIN"))
{
if (ogrMultiLine)
{
ogrMultiLine->addGeometryDirectly(ogrLine);
}
if (ogrPoly && ogrLine != ogrRing)
{
ogrPoly->addRingDirectly((OGRLinearRing *)ogrLine);
}
end = TRUE;
}
else if (EQUAL(firsttok, "EEDG"))
{
end = TRUE;
}
else if (EQUAL(firsttok, "LATT"))
{
//Line Attributes (ignored)
}
else if (EQUAL(firsttok, "EFLA"))
{
end = TRUE;
}
else if (EQUAL(firsttok, "ETAB"))
{
end = TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
}
int ILI1Reader::ReadTable(const char *layername) {
char **tokens = NULL;
const char *firsttok = NULL;
int ret = TRUE;
int warned = FALSE;
int fIndex;
int geomIdx;
// curLayer is NULL if we have more than one
// point geometry column
if(curLayer == NULL) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(layername, metaFeature->GetFieldAsString(0))) {
const char *geomlayername = metaFeature->GetFieldAsString(2);
curLayer = GetLayerByName(geomlayername);
break;
}
}
}
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
// get the geometry index of the current layer
// only if the model is read
if(featureDef->GetFieldCount() != 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
geomIdx = metaFeature->GetFieldAsInteger(1);
}
}
}
long fpos = VSIFTell(fpItf);
while (ret && (tokens = ReadParseLine()))
{
firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
//Check for features spread over multiple objects
if (featureDef->GetGeomType() == wkbPolygon)
{
//Multiple polygon rings
feature = curLayer->GetFeatureRef(atol(CSLGetField(tokens, 2)));
}
else if (featureDef->GetGeomType() == wkbGeometryCollection)
{
//AREA lines spread over mutltiple objects
}
else
{
feature = NULL;
}
if (feature == NULL)
{
if (featureDef->GetFieldCount() == 0)
{
CPLDebug( "OGR_ILI", "No field definition found for table: %s", featureDef->GetName() );
//Model not read - use heuristics
for (fIndex=1; fIndex<CSLCount(tokens); fIndex++)
{
char szFieldName[32];
sprintf(szFieldName, "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
feature = new OGRFeature(featureDef);
int fieldno = 0;
for (fIndex=1; fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount(); fIndex++, fieldno++)
{
if (!EQUAL(tokens[fIndex], "@")) {
//CPLDebug( "READ TABLE OGR_ILI", "Adding Field %d: %s", fieldno, tokens[fIndex]);
feature->SetField(fieldno, tokens[fIndex]);
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal
&& featureDef->GetGeomType() == wkbPoint
/*
// if there is no ili model read,
// we have no chance to detect the
// geometry column!!
*/
&& (fieldno-2) == geomIdx) {
//add Point geometry
OGRPoint *ogrPoint = new OGRPoint(atof(tokens[fIndex-1]), atof(tokens[fIndex]));
feature->SetGeometryDirectly(ogrPoint);
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1 && !(featureDef->GetFieldCount() == CSLCount(tokens) && EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))) {
CPLDebug( "OGR_ILI", "Field count doesn't match. %d declared, %d found", featureDef->GetFieldCount(), CSLCount(tokens)-1);
warned = TRUE;
}
if (featureDef->GetGeomType() == wkbPolygon)
feature->SetFID(atol(feature->GetFieldAsString(1)));
else if (feature->GetFieldCount() > 0)
feature->SetFID(atol(feature->GetFieldAsString(0)));
curLayer->AddFeature(feature);
}
}
else if (EQUAL(firsttok, "STPT"))
{
ReadGeom(tokens, featureDef->GetGeomType(), feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos); //TODO: append multi-OBJECT geometries
}
}
else if (EQUAL(firsttok, "ELIN"))
{
//empty geom
}
else if (EQUAL(firsttok, "EDGE"))
{
tokens = ReadParseLine(); //STPT
ReadGeom(tokens, wkbMultiLineString, feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos);
}
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
if(HasMultiplePointGeom(layername) > 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
int pntCln = 1;
if(EQUAL(layername, metaFeature->GetFieldAsString(0)) && !EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
pntCln++;
OGRILI1Layer *curLayerTmp = GetLayerByName(metaFeature->GetFieldAsString(2));
OGRFeature *tmpFeature = NULL;
int geomIdxTmp = metaFeature->GetFieldAsInteger(1);
curLayer->ResetReading();
while((tmpFeature = curLayer->GetNextFeature()) != NULL ) {
OGRPoint *ogrPoint = new OGRPoint(atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln)), atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln + 1)));
tmpFeature->SetGeometryDirectly(ogrPoint);
curLayerTmp->AddFeature(tmpFeature);
}
}
}
}
CSLDestroy(tokens);
return TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
fpos = VSIFTell(fpItf);
}
return ret;
}
int ILI1Reader::ReadFeatures() {
char **tokens = NULL;
const char *firsttok = NULL;
const char *pszLine;
char *topic = NULL;
int ret = TRUE;
while (ret && (tokens = ReadParseLine()))
{
firsttok = tokens[0];
if (EQUAL(firsttok, "SCNT"))
{
//read description
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !EQUALN(pszLine, "////", 4));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MOTR"))
{
//read model
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !EQUALN(pszLine, "////", 4));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MTID"))
{
}
else if (EQUAL(firsttok, "MODL"))
{
}
else if (EQUAL(firsttok, "TOPI"))
{
CPLFree(topic);
topic = CPLStrdup(CSLGetField(tokens, 1));
}
else if (EQUAL(firsttok, "TABL"))
{
CPLDebug( "OGR_ILI", "Reading table '%s'", GetLayerNameString(topic, CSLGetField(tokens, 1)) );
const char *layername = GetLayerNameString(topic, CSLGetField(tokens, 1));
curLayer = GetLayerByName(layername);
int multiple = HasMultiplePointGeom(layername);
// create only a new layer if there is no curLayer AND
// if there are more than one point geometry columns
if (curLayer == NULL && multiple < 1) { //create one
CPLDebug( "OGR_ILI", "No model found, using default field names." );
OGRSpatialReference *poSRSIn = NULL;
int bWriterIn = 0;
OGRwkbGeometryType eReqType = wkbUnknown;
OGRILI1DataSource *poDSIn = NULL;
curLayer = new OGRILI1Layer(GetLayerNameString(topic, CSLGetField(tokens, 1)), poSRSIn, bWriterIn, eReqType, poDSIn);
AddLayer(curLayer);
}
if(curLayer != NULL) {
for (int i=0; i < curLayer->GetLayerDefn()->GetFieldCount(); i++) {
CPLDebug( "OGR_ILI", "Field %d: %s", i, curLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
}
}
ret = ReadTable(layername);
}
else if (EQUAL(firsttok, "ETOP"))
{
}
else if (EQUAL(firsttok, "EMOD"))
{
}
else if (EQUAL(firsttok, "ENDE"))
{
CSLDestroy(tokens);
CPLFree(topic);
return TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
tokens = NULL;
}
CSLDestroy(tokens);
CPLFree(topic);
return ret;
}
void ILI1Reader::ReadGeom( char **stgeom, int geomIdx, OGRwkbGeometryType eType,
OGRFeature *feature ) {
#ifdef DEBUG_VERBOSE
CPLDebug( "OGR_ILI",
"ILI1Reader::ReadGeom geomIdx: %d OGRGeometryType: %s",
geomIdx, OGRGeometryTypeToName(eType) );
#endif
if (eType == wkbNone)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Calling ILI1Reader::ReadGeom with wkbNone" );
}
// Initialize geometry.
OGRCompoundCurve *ogrCurve = new OGRCompoundCurve();
OGRCurvePolygon *ogrPoly = NULL; //current polygon
OGRMultiCurve *ogrMultiLine = NULL; //current multi line
if (eType == wkbMultiCurve || eType == wkbMultiLineString)
{
ogrMultiLine = new OGRMultiCurve();
}
else if (eType == wkbPolygon || eType == wkbCurvePolygon)
{
ogrPoly = new OGRCurvePolygon();
}
OGRPoint ogrPoint; // Current point.
ogrPoint.setX(CPLAtof(stgeom[1])); ogrPoint.setY(CPLAtof(stgeom[2]));
OGRLineString *ogrLine = new OGRLineString();
ogrLine->addPoint(&ogrPoint);
// Parse geometry.
char **tokens = NULL;
bool end = false;
OGRCircularString *arc = NULL; //current arc
while (!end && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if( firsttok == NULL )
{
// do nothing
}
else if (EQUAL(firsttok, "LIPT") && CSLCount(tokens) >= 3)
{
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
if (arc) {
arc->addPoint(&ogrPoint);
OGRErr error = ogrCurve->addCurveDirectly(arc);
if (error != OGRERR_NONE) {
char* pszJSon = arc->exportToJson();
CPLError(CE_Warning, CPLE_AppDefined, "Could not add geometry: %s",
pszJSon ? pszJSon : "(null)" );
CPLFree(pszJSon);
delete arc;
}
arc = NULL;
}
ogrLine->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ARCP") && CSLCount(tokens) >= 3)
{
//Finish line and start arc
if (ogrLine->getNumPoints() > 1) {
OGRErr error = ogrCurve->addCurveDirectly(ogrLine);
if (error != OGRERR_NONE) {
char* pszJSon = ogrLine->exportToJson();
CPLError(CE_Warning, CPLE_AppDefined, "Could not add geometry: %s",
pszJSon ? pszJSon : "(null)" );
CPLFree(pszJSon);
delete ogrLine;
}
ogrLine = new OGRLineString();
} else {
ogrLine->empty();
}
delete arc;
arc = new OGRCircularString();
arc->addPoint(&ogrPoint);
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
arc->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ELIN"))
{
if (ogrLine->getNumPoints() > 1) { // Ignore single LIPT after ARCP
OGRErr error = ogrCurve->addCurveDirectly(ogrLine);
if (error != OGRERR_NONE) {
char* pszJSon = ogrLine->exportToJson();
CPLError(CE_Warning, CPLE_AppDefined, "Could not add geometry: %s",
pszJSon ? pszJSon : "(null)" );
CPLFree(pszJSon);
delete ogrLine;
}
ogrLine = NULL;
}
if (!ogrCurve->IsEmpty()) {
if (ogrMultiLine)
{
OGRErr error = ogrMultiLine->addGeometryDirectly(ogrCurve);
if (error != OGRERR_NONE) {
char* pszJSon = ogrCurve->exportToJson();
CPLError(CE_Warning, CPLE_AppDefined, "Could not add geometry: %s",
pszJSon ? pszJSon : "(null)" );
CPLFree(pszJSon);
delete ogrCurve;
}
ogrCurve = NULL;
}
if (ogrPoly)
{
OGRErr error = ogrPoly->addRingDirectly(ogrCurve);
if (error != OGRERR_NONE) {
char* pszJSon = ogrCurve->exportToJson();
CPLError(CE_Warning, CPLE_AppDefined, "Could not add geometry: %s",
pszJSon ? pszJSon : "(null)" );
CPLFree(pszJSon);
delete ogrCurve;
}
ogrCurve = NULL;
}
}
end = true;
}
else if (EQUAL(firsttok, "EEDG"))
{
end = true;
}
else if (EQUAL(firsttok, "LATT"))
{
//Line Attributes (ignored)
}
else if (EQUAL(firsttok, "EFLA"))
{
end = true;
}
else if (EQUAL(firsttok, "ETAB"))
{
end = true;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
delete arc;
delete ogrLine;
//Set feature geometry
if (eType == wkbMultiCurve)
{
feature->SetGeomFieldDirectly(geomIdx, ogrMultiLine);
delete ogrCurve;
}
else if (eType == wkbMultiLineString)
{
feature->SetGeomFieldDirectly(geomIdx, ogrMultiLine->getLinearGeometry());
delete ogrMultiLine;
delete ogrCurve;
}
else if (eType == wkbCurvePolygon)
{
feature->SetGeomFieldDirectly(geomIdx, ogrPoly);
delete ogrCurve;
}
else if (eType == wkbPolygon)
{
feature->SetGeomFieldDirectly(geomIdx, ogrPoly->getLinearGeometry());
delete ogrPoly;
delete ogrCurve;
}
else
{
feature->SetGeomFieldDirectly(geomIdx, ogrCurve);
}
}
int ILI1Reader::ReadTable(CPL_UNUSED const char *layername) {
char **tokens = NULL;
int ret = TRUE;
int warned = FALSE;
int geomIdx = -1;
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
bool bFeatureAdded = false;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
if (featureDef->GetFieldCount() == 0 && curLayer->GetFeatureCount() == 0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No field definition found for table: %s",
featureDef->GetName() );
// Model not read - use heuristics.
for( int fIndex=1; fIndex<CSLCount(tokens); fIndex++ )
{
char szFieldName[32];
snprintf(szFieldName, sizeof(szFieldName), "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
if( !bFeatureAdded )
delete feature;
feature = new OGRFeature(featureDef);
for( int fIndex=1, fieldno = 0;
fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount();
fIndex++, fieldno++ )
{
if (!(tokens[fIndex][0] == codeUndefined && tokens[fIndex][1] == '\0')) {
#ifdef DEBUG_VERBOSE
CPLDebug( "READ TABLE OGR_ILI", "Setting Field %d (Type %d): %s",
fieldno, featureDef->GetFieldDefn(fieldno)->GetType(),
tokens[fIndex] );
#endif
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTString) {
// Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode to UTF-8
char* pszRecoded = CPLRecode(
tokens[fIndex], CPL_ENC_ISO8859_1, CPL_ENC_UTF8);
// Replace space marks
for( char* pszString = pszRecoded;
*pszString != '\0';
pszString++ ) {
if (*pszString == codeBlank) *pszString = ' ';
}
feature->SetField(fieldno, pszRecoded);
CPLFree(pszRecoded);
} else {
feature->SetField(fieldno, tokens[fIndex]);
}
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal) {
// Check for Point geometry (Coord type).
// If there is no ili model read,
// we have no chance to detect the
// geometry column.
CPLString geomfldname
= featureDef->GetFieldDefn(fieldno)->GetNameRef();
// Check if name ends with _1.
if (geomfldname.size() >= 2 && geomfldname[geomfldname.size()-2]
== '_') {
geomfldname = geomfldname.substr(0, geomfldname.size()-2);
geomIdx = featureDef->GetGeomFieldIndex(geomfldname.c_str());
if (geomIdx == -1)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No matching definition for field '%s' of "
"table %s found",
geomfldname.c_str(), featureDef->GetName() );
}
} else {
geomIdx = -1;
}
if (geomIdx >= 0) {
if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint) {
// Add Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex]));
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
} else if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint25D && fieldno > 1 &&
featureDef->GetFieldDefn(fieldno-2)->GetType() ==
OFTReal) {
// Add 3D Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-2]), CPLAtof(tokens[fIndex-1]),
CPLAtof(tokens[fIndex]) );
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
}
}
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1) {
CPLError( CE_Warning, CPLE_AppDefined,
"Field count of table %s doesn't match. %d declared, "
"%d found (e.g. ignored LINEATTR)",
featureDef->GetName(), featureDef->GetFieldCount(),
CSLCount(tokens) - 1 );
warned = TRUE;
}
if (feature->GetFieldCount() > 0) {
// USE _TID as FID. TODO: respect IDENT field from model.
feature->SetFID(feature->GetFieldAsInteger64(0));
}
curLayer->AddFeature(feature);
bFeatureAdded = true;
geomIdx = -1; //Reset
}
else if (EQUAL(firsttok, "STPT") && feature != NULL)
{
//Find next non-Point geometry
if (geomIdx < 0) geomIdx = 0;
while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint) {
geomIdx++;
}
OGRwkbGeometryType geomType
= (geomIdx < featureDef->GetGeomFieldCount()) ?
featureDef->GetGeomFieldDefn(geomIdx)->GetType() : wkbNone;
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, geomType, feature);
}
else if (EQUAL(firsttok, "ELIN"))
{
// Empty geom.
}
else if (EQUAL(firsttok, "EDGE") && feature != NULL)
{
CSLDestroy(tokens);
tokens = ReadParseLine(); //STPT
//Find next non-Point geometry
do {
geomIdx++;
} while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint);
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, wkbMultiLineString, feature);
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
CPLDebug( "OGR_ILI", "Total features: " CPL_FRMT_GIB,
curLayer->GetFeatureCount() );
CSLDestroy(tokens);
if( !bFeatureAdded )
delete feature;
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
if( !bFeatureAdded )
delete feature;
return ret;
}
int ILI1Reader::ReadFeatures() {
char **tokens = NULL;
const char *pszLine = NULL;
char *topic = CPLStrdup("(null)");
int ret = TRUE;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = tokens[0];
if (EQUAL(firsttok, "SCNT"))
{
//read description
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MOTR"))
{
//read model
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MTID"))
{
}
else if (EQUAL(firsttok, "MODL"))
{
}
else if (EQUAL(firsttok, "TOPI") && CSLCount(tokens) >= 2)
{
CPLFree(topic);
topic = CPLStrdup(CSLGetField(tokens, 1));
}
else if (EQUAL(firsttok, "TABL") && CSLCount(tokens) >= 2)
{
const char *layername
= GetLayerNameString(topic, CSLGetField(tokens, 1));
CPLDebug( "OGR_ILI", "Reading table '%s'", layername );
curLayer = GetLayerByName(layername);
if (curLayer == NULL) { //create one
CPLError( CE_Warning, CPLE_AppDefined,
"No model definition for table '%s' found, "
"using default field names.", layername );
OGRFeatureDefn* poFeatureDefn
= new OGRFeatureDefn(
GetLayerNameString(topic, CSLGetField(tokens, 1)));
poFeatureDefn->SetGeomType( wkbUnknown );
GeomFieldInfos oGeomFieldInfos;
curLayer = new OGRILI1Layer(poFeatureDefn, oGeomFieldInfos, NULL);
AddLayer(curLayer);
}
if(curLayer != NULL) {
for (int i=0; i < curLayer->GetLayerDefn()->GetFieldCount(); i++) {
CPLDebug( "OGR_ILI", "Field %d: %s", i,
curLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
}
}
ret = ReadTable(layername);
}
else if (EQUAL(firsttok, "ETOP"))
{
}
else if (EQUAL(firsttok, "EMOD"))
{
}
else if (EQUAL(firsttok, "ENDE"))
{
CSLDestroy(tokens);
CPLFree(topic);
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
tokens = NULL;
}
CSLDestroy(tokens);
CPLFree(topic);
return ret;
}
static int
PanoramaGetUOMLengthInfo( int nUOMLengthCode, char **ppszUOMName,
double * pdfInMeters )
{
char **papszUnitsRecord;
char szSearchKey[24];
int iNameField;
#define UOM_FILENAME CSVFilename( "unit_of_measure.csv" )
/* -------------------------------------------------------------------- */
/* We short cut meter to save work in the most common case. */
/* -------------------------------------------------------------------- */
if( nUOMLengthCode == 9001 )
{
if( ppszUOMName != NULL )
*ppszUOMName = CPLStrdup( "metre" );
if( pdfInMeters != NULL )
*pdfInMeters = 1.0;
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Search the units database for this unit. If we don't find */
/* it return failure. */
/* -------------------------------------------------------------------- */
sprintf( szSearchKey, "%d", nUOMLengthCode );
papszUnitsRecord =
CSVScanFileByName( UOM_FILENAME, "UOM_CODE", szSearchKey, CC_Integer );
if( papszUnitsRecord == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Get the name, if requested. */
/* -------------------------------------------------------------------- */
if( ppszUOMName != NULL )
{
iNameField = CSVGetFileFieldId( UOM_FILENAME, "UNIT_OF_MEAS_NAME" );
*ppszUOMName = CPLStrdup( CSLGetField(papszUnitsRecord, iNameField) );
}
/* -------------------------------------------------------------------- */
/* Get the A and B factor fields, and create the multiplicative */
/* factor. */
/* -------------------------------------------------------------------- */
if( pdfInMeters != NULL )
{
int iBFactorField, iCFactorField;
iBFactorField = CSVGetFileFieldId( UOM_FILENAME, "FACTOR_B" );
iCFactorField = CSVGetFileFieldId( UOM_FILENAME, "FACTOR_C" );
if( atof(CSLGetField(papszUnitsRecord, iCFactorField)) > 0.0 )
*pdfInMeters = atof(CSLGetField(papszUnitsRecord, iBFactorField))
/ atof(CSLGetField(papszUnitsRecord, iCFactorField));
else
*pdfInMeters = 0.0;
}
return( TRUE );
}
void ILI1Reader::ReadGeom(char **stgeom, int geomIdx, OGRwkbGeometryType eType, OGRFeature *feature) {
char **tokens = NULL;
const char *firsttok = NULL;
int end = FALSE;
OGRCompoundCurve *ogrCurve = NULL; //current compound curve
OGRLineString *ogrLine = NULL; //current line
OGRCircularString *arc = NULL; //current arc
OGRCurvePolygon *ogrPoly = NULL; //current polygon
OGRPoint ogrPoint; //current point
OGRMultiCurve *ogrMultiLine = NULL; //current multi line
//CPLDebug( "OGR_ILI", "ILI1Reader::ReadGeom geomIdx: %d OGRGeometryType: %s", geomIdx, OGRGeometryTypeToName(eType));
if (eType == wkbNone)
{
CPLError(CE_Warning, CPLE_AppDefined, "Calling ILI1Reader::ReadGeom with wkbNone" );
}
//Initialize geometry
ogrCurve = new OGRCompoundCurve();
if (eType == wkbMultiCurve || eType == wkbMultiLineString)
{
ogrMultiLine = new OGRMultiCurve();
}
else if (eType == wkbPolygon || eType == wkbCurvePolygon)
{
ogrPoly = new OGRCurvePolygon();
}
//tokens = ["STPT", "1111", "22222"]
ogrPoint.setX(CPLAtof(stgeom[1])); ogrPoint.setY(CPLAtof(stgeom[2]));
ogrLine = new OGRLineString();
ogrLine->addPoint(&ogrPoint);
//Parse geometry
while (!end && (tokens = ReadParseLine()))
{
firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "LIPT"))
{
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
if (arc) {
arc->addPoint(&ogrPoint);
ogrCurve->addCurveDirectly(arc);
arc = NULL;
}
ogrLine->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ARCP"))
{
//Finish line and start arc
if (ogrLine->getNumPoints() > 1) {
ogrCurve->addCurveDirectly(ogrLine);
ogrLine = new OGRLineString();
} else {
ogrLine->empty();
}
arc = new OGRCircularString();
arc->addPoint(&ogrPoint);
ogrPoint.setX(CPLAtof(tokens[1])); ogrPoint.setY(CPLAtof(tokens[2]));
arc->addPoint(&ogrPoint);
}
else if (EQUAL(firsttok, "ELIN"))
{
if (!ogrLine->IsEmpty()) {
ogrCurve->addCurveDirectly(ogrLine);
}
if (!ogrCurve->IsEmpty()) {
if (ogrMultiLine)
{
ogrMultiLine->addGeometryDirectly(ogrCurve);
}
if (ogrPoly)
{
ogrPoly->addRingDirectly(ogrCurve);
}
}
end = TRUE;
}
else if (EQUAL(firsttok, "EEDG"))
{
end = TRUE;
}
else if (EQUAL(firsttok, "LATT"))
{
//Line Attributes (ignored)
}
else if (EQUAL(firsttok, "EFLA"))
{
end = TRUE;
}
else if (EQUAL(firsttok, "ETAB"))
{
end = TRUE;
}
else
{
CPLError(CE_Warning, CPLE_AppDefined, "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
//Set feature geometry
if (eType == wkbMultiCurve)
{
feature->SetGeomFieldDirectly(geomIdx, ogrMultiLine);
}
else if (eType == wkbMultiLineString)
{
feature->SetGeomFieldDirectly(geomIdx, ogrMultiLine->getLinearGeometry());
delete ogrMultiLine;
}
else if (eType == wkbCurvePolygon)
{
feature->SetGeomFieldDirectly(geomIdx, ogrPoly);
}
else if (eType == wkbPolygon)
{
feature->SetGeomFieldDirectly(geomIdx, ogrPoly->getLinearGeometry());
delete ogrPoly;
}
else
{
feature->SetGeomFieldDirectly(geomIdx, ogrCurve);
}
}
SEXP
RGDAL_OpenDataset(SEXP filename, SEXP read_only, SEXP silent, SEXP allowedDr, SEXP sOpts) {
const char *fn = asString(filename);
#ifdef GDALV2
int i;
char **papszOpenOptions = NULL;
char **papszAllowedDrivers = NULL;
installErrorHandler();
for (i=0; i < length(sOpts); i++) papszOpenOptions = CSLAddString(
papszOpenOptions, CHAR(STRING_ELT(sOpts, i)) );
for (i=0; i < CSLCount(papszOpenOptions); i++)
Rprintf("option %d: %s\n", i, CSLGetField(papszOpenOptions, i));
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
for (i=0; i < length(allowedDr); i++) papszAllowedDrivers = CSLAddString(
papszAllowedDrivers, CHAR(STRING_ELT(allowedDr, i)) );
for (i=0; i < CSLCount(papszAllowedDrivers); i++)
Rprintf("driver %d: %s\n", i, CSLGetField(papszAllowedDrivers, i));
uninstallErrorHandlerAndTriggerError();
#endif
#ifdef GDALV2
unsigned int RWFlag;
if (asLogical(read_only))
RWFlag = GDAL_OF_RASTER | GDAL_OF_READONLY;
else
RWFlag = GDAL_OF_RASTER | GDAL_OF_UPDATE;
#else
GDALAccess RWFlag;
if (asLogical(read_only))
RWFlag = GA_ReadOnly;
else
RWFlag = GA_Update;
#endif
/* Modification suggested by Even Rouault, 2009-08-08: */
CPLErrorReset();
if (asLogical(silent))
CPLPushErrorHandler(CPLQuietErrorHandler);
else
installErrorHandler();
#ifdef GDALV2
GDALDataset *pDataset = (GDALDataset *) GDALOpenEx(fn, RWFlag,
papszAllowedDrivers, papszOpenOptions, NULL);
#else
GDALDataset *pDataset = (GDALDataset *) GDALOpen(fn, RWFlag);
#endif
if (pDataset == NULL)
error("%s\n", CPLGetLastErrorMsg());
if (asLogical(silent))
CPLPopErrorHandler();
else
uninstallErrorHandlerAndTriggerError();
#ifdef GDALV2
installErrorHandler();
CSLDestroy(papszOpenOptions);
CSLDestroy(papszAllowedDrivers);
uninstallErrorHandlerAndTriggerError();
#endif
/* 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);
}
