static void AppendCoordinateList( OGRLineString *poLine,
char **ppszText, size_t *pnLength,
size_t *pnMaxLength )
{
char szCoordinate[256]= { 0 };
const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType()));
*pnLength += strlen(*ppszText + *pnLength);
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "<coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
MakeKMLCoordinate( szCoordinate, sizeof(szCoordinate),
poLine->getX(iPoint),
poLine->getY(iPoint),
poLine->getZ(iPoint),
b3D );
_GrowBuffer( *pnLength + strlen(szCoordinate)+1,
ppszText, pnMaxLength );
if( iPoint != 0 )
strcat( *ppszText + *pnLength, " " );
strcat( *ppszText + *pnLength, szCoordinate );
*pnLength += strlen(*ppszText + *pnLength);
}
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "</coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
}
static void AppendCoumpoundCurve( OGRCompoundCurve *poCC, OGRILI1DataSource *poDS)
{
for( int iMember = 0; iMember < poCC->getNumCurves(); iMember++)
{
OGRCurve *poGeometry = poCC->getCurve( iMember );
int b3D = wkbHasZ(poGeometry->getGeometryType());
int bIsArc = (poGeometry->getGeometryType() == wkbCircularString
|| poGeometry->getGeometryType() == wkbCircularStringZ );
OGRSimpleCurve *poLine = (OGRSimpleCurve *)poGeometry;
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
//Skip last point in curve member
if (iPoint == poLine->getNumPoints()-1 && iMember < poCC->getNumCurves()-1)
continue;
if (iMember == 0 && iPoint == 0) VSIFPrintf( poDS->GetTransferFile(), "STPT" );
else if (bIsArc && iPoint == 1) VSIFPrintf( poDS->GetTransferFile(), "ARCP" );
else VSIFPrintf( poDS->GetTransferFile(), "LIPT" );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getX(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getY(iPoint)) );
if (b3D) VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getZ(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), "\n" );
}
}
VSIFPrintf( poDS->GetTransferFile(), "ELIN\n" );
}
static void AppendCoordinateList( OGRLineString *poLine, VSILFILE* fp )
{
int b3D = wkbHasZ(poLine->getGeometryType());
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
VSIFPrintfL(fp, "<COORD>");
VSIFPrintfL(fp, "<C1>%s</C1>", d2str(poLine->getX(iPoint)));
VSIFPrintfL(fp, "<C2>%s</C2>", d2str(poLine->getY(iPoint)));
if (b3D) VSIFPrintfL(fp, "<C3>%s</C3>", d2str(poLine->getZ(iPoint)));
VSIFPrintfL(fp, "</COORD>\n");
}
}
static void AppendCoordinateList( OGRLineString *poLine, OGRILI1DataSource *poDS)
{
int b3D = wkbHasZ(poLine->getGeometryType());
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
if (iPoint == 0) VSIFPrintf( poDS->GetTransferFile(), "STPT" );
else VSIFPrintf( poDS->GetTransferFile(), "LIPT" );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getX(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getY(iPoint)) );
if (b3D) VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getZ(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), "\n" );
}
VSIFPrintf( poDS->GetTransferFile(), "ELIN\n" );
}
static void AppendGML3CoordinateList( const OGRSimpleCurve *poLine, int bCoordSwap,
char **ppszText, int *pnLength,
int *pnMaxLength, int nSRSDimensionLocFlags )
{
char szCoordinate[256];
int b3D = wkbHasZ(poLine->getGeometryType());
*pnLength += strlen(*ppszText + *pnLength);
_GrowBuffer( *pnLength + 40, ppszText, pnMaxLength );
if (b3D && (nSRSDimensionLocFlags & SRSDIM_LOC_POSLIST) != 0)
strcat( *ppszText + *pnLength, "<gml:posList srsDimension=\"3\">" );
else
strcat( *ppszText + *pnLength, "<gml:posList>" );
*pnLength += strlen(*ppszText + *pnLength);
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poLine->getY(iPoint),
poLine->getX(iPoint),
poLine->getZ(iPoint),
b3D ? 3 : 2 );
else
OGRMakeWktCoordinate( szCoordinate,
poLine->getX(iPoint),
poLine->getY(iPoint),
poLine->getZ(iPoint),
b3D ? 3 : 2 );
_GrowBuffer( *pnLength + strlen(szCoordinate)+1,
ppszText, pnMaxLength );
if( iPoint != 0 )
strcat( *ppszText + *pnLength, " " );
strcat( *ppszText + *pnLength, szCoordinate );
*pnLength += strlen(*ppszText + *pnLength);
}
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "</gml:posList>" );
*pnLength += strlen(*ppszText + *pnLength);
}
static void AppendCoordinateList( OGRLineString *poLine,
char **ppszText, int *pnLength,
int *pnMaxLength )
{
char szCoordinate[256];
int b3D = wkbHasZ(poLine->getGeometryType());
*pnLength += strlen(*ppszText + *pnLength);
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "<gml:coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
MakeGMLCoordinate( szCoordinate,
poLine->getX(iPoint),
poLine->getY(iPoint),
poLine->getZ(iPoint),
b3D );
_GrowBuffer( *pnLength + strlen(szCoordinate)+1,
ppszText, pnMaxLength );
if( iPoint != 0 )
strcat( *ppszText + *pnLength, " " );
strcat( *ppszText + *pnLength, szCoordinate );
*pnLength += strlen(*ppszText + *pnLength);
}
_GrowBuffer( *pnLength + 20, ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "</gml:coordinates>" );
*pnLength += strlen(*ppszText + *pnLength);
}
OGRLayer *OGRDGNDataSource::ICreateLayer( const char *pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eGeomType,
char **papszExtraOptions )
{
const char *pszSeed, *pszMasterUnit = "m", *pszSubUnit = "cm";
const char *pszValue;
int nUORPerSU=1, nSUPerMU=100;
int nCreationFlags = 0, b3DRequested;
double dfOriginX = -21474836.0, /* default origin centered on zero */
dfOriginY = -21474836.0, /* with two decimals of precision */
dfOriginZ = -21474836.0;
/* -------------------------------------------------------------------- */
/* Ensure only one layer gets created. */
/* -------------------------------------------------------------------- */
if( nLayers > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"DGN driver only supports one layer will all the elements in it." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If the coordinate system is geographic, we should use a */
/* localized default origin and resolution. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL && poSRS->IsGeographic() )
{
dfOriginX = -200.0;
dfOriginY = -200.0;
pszMasterUnit = "d";
pszSubUnit = "s";
nSUPerMU = 3600;
nUORPerSU = 1000;
}
/* -------------------------------------------------------------------- */
/* Parse out various creation options. */
/* -------------------------------------------------------------------- */
papszOptions = CSLInsertStrings( papszOptions, 0, papszExtraOptions );
b3DRequested = CSLFetchBoolean( papszOptions, "3D",
wkbHasZ(eGeomType) );
pszSeed = CSLFetchNameValue( papszOptions, "SEED" );
if( pszSeed )
nCreationFlags |= DGNCF_USE_SEED_ORIGIN | DGNCF_USE_SEED_UNITS;
else if( b3DRequested )
pszSeed = CPLFindFile( "gdal", "seed_3d.dgn" );
else
pszSeed = CPLFindFile( "gdal", "seed_2d.dgn" );
if( pszSeed == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No seed file provided, and unable to find seed_2d.dgn." );
return NULL;
}
if( CSLFetchBoolean( papszOptions, "COPY_WHOLE_SEED_FILE", TRUE ) )
nCreationFlags |= DGNCF_COPY_WHOLE_SEED_FILE;
if( CSLFetchBoolean( papszOptions, "COPY_SEED_FILE_COLOR_TABLE", TRUE ) )
nCreationFlags |= DGNCF_COPY_SEED_FILE_COLOR_TABLE;
pszValue = CSLFetchNameValue( papszOptions, "MASTER_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszMasterUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszSubUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNITS_PER_MASTER_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nSUPerMU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "UOR_PER_SUB_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nUORPerSU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "ORIGIN" );
if( pszValue != NULL )
{
char **papszTuple = CSLTokenizeStringComplex( pszValue, " ,",
FALSE, FALSE );
nCreationFlags &= ~DGNCF_USE_SEED_ORIGIN;
if( CSLCount(papszTuple) == 3 )
{
dfOriginX = CPLAtof(papszTuple[0]);
dfOriginY = CPLAtof(papszTuple[1]);
dfOriginZ = CPLAtof(papszTuple[2]);
}
else if( CSLCount(papszTuple) == 2 )
{
dfOriginX = CPLAtof(papszTuple[0]);
dfOriginY = CPLAtof(papszTuple[1]);
dfOriginZ = 0.0;
}
else
{
CSLDestroy(papszTuple);
CPLError( CE_Failure, CPLE_AppDefined,
"ORIGIN is not a valid 2d or 3d tuple.\n"
"Separate tuple values with comma." );
return FALSE;
}
CSLDestroy(papszTuple);
}
/* -------------------------------------------------------------------- */
/* Try creating the base file. */
/* -------------------------------------------------------------------- */
hDGN = DGNCreate( pszName, pszSeed, nCreationFlags,
dfOriginX, dfOriginY, dfOriginZ,
nSUPerMU, nUORPerSU, pszMasterUnit, pszSubUnit );
if( hDGN == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRDGNLayer *poLayer;
poLayer = new OGRDGNLayer( pszLayerName, hDGN, TRUE );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRDGNLayer **)
CPLRealloc( papoLayers, sizeof(OGRDGNLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
void OGRCloudantTableLayer::WriteMetadata()
{
if (pszSpatialDDoc == nullptr)
OGRCloudantTableLayer::GetSpatialView();
if( pszSpatialDDoc == nullptr )
return;
CPLString osURI;
osURI = "/";
osURI += osEscapedName;
osURI += "/";
osURI += pszSpatialDDoc;
json_object* poDDocObj = poDS->GET(osURI);
if (poDDocObj == nullptr)
return;
if ( !json_object_is_type(poDDocObj, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined, "WriteMetadata() failed");
json_object_put(poDDocObj);
return;
}
json_object* poError = CPL_json_object_object_get(poDDocObj, "error");
const char* pszError = json_object_get_string(poError);
if (pszError && strcmp(pszError, "not_found") == 0)
{
json_object_put(poDDocObj);
return;
}
if (poDS->IsError(poDDocObj, "WriteMetadata() failed"))
{
json_object_put(poDDocObj);
return;
}
if (poSRS)
{
// epsg codes are supported in Cloudant
const char * pszEpsg = nullptr;
const char * pszAuthName = nullptr;
char szSrid[100];
if (poSRS->IsProjected())
{
pszAuthName = poSRS->GetAuthorityName("PROJCS");
if ((pszAuthName != nullptr) && (STARTS_WITH(pszAuthName, "EPSG")))
pszEpsg = poSRS->GetAuthorityCode("PROJCS");
}
else
{
pszAuthName = poSRS->GetAuthorityName("GEOGCS");
if ((pszAuthName != nullptr) && (STARTS_WITH(pszAuthName, "EPSG")))
pszEpsg = poSRS->GetAuthorityCode("GEOGCS");
}
if (pszEpsg != nullptr)
{
const char * pszUrn = "urn:ogc:def:crs:epsg::";
CPLStrlcpy(szSrid, pszUrn, sizeof(szSrid));
if (CPLStrlcpy(szSrid + sizeof(pszUrn), pszEpsg, sizeof(szSrid)) <= sizeof(szSrid))
{
json_object_object_add(poDDocObj, "srsid",
json_object_new_string(pszUrn));
}
}
}
if (eGeomType != wkbNone)
{
json_object_object_add(poDDocObj, "geomtype",
json_object_new_string(OGRToOGCGeomType(eGeomType)));
if (wkbHasZ(poFeatureDefn->GetGeomType()))
{
json_object_object_add(poDDocObj, "is_25D",
json_object_new_boolean(TRUE));
}
}
else
{
json_object_object_add(poDDocObj, "geomtype",
json_object_new_string("NONE"));
}
json_object_object_add(poDDocObj, "geojson_documents",
json_object_new_boolean(bGeoJSONDocument));
json_object* poFields = json_object_new_array();
json_object_object_add(poDDocObj, "fields", poFields);
for(int i=COUCHDB_FIRST_FIELD;i<poFeatureDefn->GetFieldCount();i++)
{
json_object* poField = json_object_new_object();
json_object_array_add(poFields, poField);
json_object_object_add(poField, "name",
json_object_new_string(poFeatureDefn->GetFieldDefn(i)->GetNameRef()));
const char* pszType = nullptr;
switch (poFeatureDefn->GetFieldDefn(i)->GetType())
{
case OFTInteger: pszType = "integer"; break;
case OFTReal: pszType = "real"; break;
case OFTString: pszType = "string"; break;
case OFTIntegerList: pszType = "integerlist"; break;
case OFTRealList: pszType = "reallist"; break;
case OFTStringList: pszType = "stringlist"; break;
default: pszType = "string"; break;
}
json_object_object_add(poField, "type",
json_object_new_string(pszType));
}
json_object* poAnswerObj = poDS->PUT(osURI,
json_object_to_json_string(poDDocObj));
json_object_put(poDDocObj);
json_object_put(poAnswerObj);
}
OGRErr OGRCurveCollection::exportToWkb( const OGRGeometry* poGeom,
OGRwkbByteOrder eByteOrder,
unsigned char * pabyData,
OGRwkbVariant eWkbVariant ) const
{
int nOffset;
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] = DB2_V72_UNFIX_BYTE_ORDER((unsigned char) eByteOrder);
/* -------------------------------------------------------------------- */
/* Set the geometry feature type, ensuring that 3D flag is */
/* preserved. */
/* -------------------------------------------------------------------- */
GUInt32 nGType = poGeom->getIsoGeometryType();
if( eWkbVariant == wkbVariantPostGIS1 )
{
int bIs3D = wkbHasZ((OGRwkbGeometryType)nGType);
nGType = wkbFlatten(nGType);
if( nGType == wkbCurvePolygon )
nGType = POSTGIS15_CURVEPOLYGON;
if( bIs3D )
nGType = (OGRwkbGeometryType)(nGType | wkb25DBitInternalUse); /* yes we explicitly set wkb25DBit */
}
if( eByteOrder == wkbNDR )
nGType = CPL_LSBWORD32( nGType );
else
nGType = CPL_MSBWORD32( nGType );
memcpy( pabyData + 1, &nGType, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
int nCount;
nCount = CPL_SWAP32( nCurveCount );
memcpy( pabyData+5, &nCount, 4 );
}
else
{
memcpy( pabyData+5, &nCurveCount, 4 );
}
nOffset = 9;
/* ==================================================================== */
/* Serialize each of the Geoms. */
/* ==================================================================== */
for( int iGeom = 0; iGeom < nCurveCount; iGeom++ )
{
papoCurves[iGeom]->exportToWkb( eByteOrder, pabyData + nOffset, eWkbVariant );
nOffset += papoCurves[iGeom]->WkbSize();
}
return OGRERR_NONE;
}
static CPLErr OGRPolygonContourWriter( double dfLevelMin, double dfLevelMax,
const OGRMultiPolygon& multipoly,
void *pInfo )
{
OGRContourWriterInfo *poInfo = static_cast<OGRContourWriterInfo *>(pInfo);
OGRFeatureDefnH hFDefn =
OGR_L_GetLayerDefn( static_cast<OGRLayerH>(poInfo->hLayer) );
OGRFeatureH hFeat = OGR_F_Create( hFDefn );
if( poInfo->nIDField != -1 )
OGR_F_SetFieldInteger( hFeat, poInfo->nIDField, poInfo->nNextID++ );
if( poInfo->nElevFieldMin != -1 )
OGR_F_SetFieldDouble( hFeat, poInfo->nElevFieldMin, dfLevelMin );
if( poInfo->nElevFieldMax != -1 )
OGR_F_SetFieldDouble( hFeat, poInfo->nElevFieldMax, dfLevelMax );
const bool bHasZ = wkbHasZ(OGR_FD_GetGeomType(hFDefn));
OGRGeometryH hGeom = OGR_G_CreateGeometry(
bHasZ ? wkbMultiPolygon25D : wkbMultiPolygon );
for ( int iPart = 0; iPart < multipoly.getNumGeometries(); iPart++ )
{
OGRPolygon* poNewPoly = new OGRPolygon();
const OGRPolygon* poPolygon = static_cast<const OGRPolygon*>(multipoly.getGeometryRef(iPart));
for ( int iRing = 0; iRing < poPolygon->getNumInteriorRings() + 1; iRing++ )
{
const OGRLinearRing* poRing = iRing == 0 ?
poPolygon->getExteriorRing()
: poPolygon->getInteriorRing(iRing - 1);
OGRLinearRing* poNewRing = new OGRLinearRing();
for ( int iPoint = 0; iPoint < poRing->getNumPoints(); iPoint++ )
{
const double dfX = poInfo->adfGeoTransform[0]
+ poInfo->adfGeoTransform[1] * poRing->getX(iPoint)
+ poInfo->adfGeoTransform[2] * poRing->getY(iPoint);
const double dfY = poInfo->adfGeoTransform[3]
+ poInfo->adfGeoTransform[4] * poRing->getX(iPoint)
+ poInfo->adfGeoTransform[5] * poRing->getY(iPoint);
if( bHasZ )
OGR_G_SetPoint( OGRGeometry::ToHandle( poNewRing ), iPoint, dfX, dfY, dfLevelMax );
else
OGR_G_SetPoint_2D( OGRGeometry::ToHandle( poNewRing ), iPoint, dfX, dfY );
}
poNewPoly->addRingDirectly( poNewRing );
}
OGR_G_AddGeometryDirectly( hGeom, OGRGeometry::ToHandle( poNewPoly ) );
}
OGR_F_SetGeometryDirectly( hFeat, hGeom );
const OGRErr eErr =
OGR_L_CreateFeature(static_cast<OGRLayerH>(poInfo->hLayer), hFeat);
OGR_F_Destroy( hFeat );
return eErr == OGRERR_NONE ? CE_None : CE_Failure;
}
static int OGR2GML3GeometryAppend( const OGRGeometry *poGeometry,
const OGRSpatialReference* poParentSRS,
char **ppszText, int *pnLength,
int *pnMaxLength,
int bIsSubGeometry,
int bLongSRS,
int bLineStringAsCurve,
const char* pszGMLId,
int nSRSDimensionLocFlags,
int bForceLineStringAsLinearRing )
{
/* -------------------------------------------------------------------- */
/* Check for Spatial Reference System attached to given geometry */
/* -------------------------------------------------------------------- */
// Buffer for srsName, srsDimension and gml:id attributes (srsName="..." gml:id="...")
char szAttributes[256];
int nAttrsLength = 0;
szAttributes[0] = 0;
const OGRSpatialReference* poSRS = NULL;
if (poParentSRS)
poSRS = poParentSRS;
else
poParentSRS = poSRS = poGeometry->getSpatialReference();
int bCoordSwap = FALSE;
if( NULL != poSRS )
{
const char* pszAuthName = NULL;
const char* pszAuthCode = NULL;
const char* pszTarget = NULL;
if (poSRS->IsProjected())
pszTarget = "PROJCS";
else
pszTarget = "GEOGCS";
pszAuthName = poSRS->GetAuthorityName( pszTarget );
if( NULL != pszAuthName )
{
if( EQUAL( pszAuthName, "EPSG" ) )
{
pszAuthCode = poSRS->GetAuthorityCode( pszTarget );
if( NULL != pszAuthCode && strlen(pszAuthCode) < 10 )
{
if (bLongSRS && !(((OGRSpatialReference*)poSRS)->EPSGTreatsAsLatLong() ||
((OGRSpatialReference*)poSRS)->EPSGTreatsAsNorthingEasting()))
{
OGRSpatialReference oSRS;
if (oSRS.importFromEPSGA(atoi(pszAuthCode)) == OGRERR_NONE)
{
if (oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting())
bCoordSwap = TRUE;
}
}
if (!bIsSubGeometry)
{
if (bLongSRS)
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"urn:ogc:def:crs:%s::%s\"",
pszAuthName, pszAuthCode );
}
else
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"%s:%s\"",
pszAuthName, pszAuthCode );
}
nAttrsLength = strlen(szAttributes);
}
}
}
}
}
if( (nSRSDimensionLocFlags & SRSDIM_LOC_GEOMETRY) != 0 &&
wkbHasZ(poGeometry->getGeometryType()) )
{
strcat(szAttributes, " srsDimension=\"3\"");
nAttrsLength = strlen(szAttributes);
nSRSDimensionLocFlags &= ~SRSDIM_LOC_GEOMETRY;
}
if (pszGMLId != NULL && nAttrsLength + 9 + strlen(pszGMLId) + 1 < sizeof(szAttributes))
{
strcat(szAttributes, " gml:id=\"");
strcat(szAttributes, pszGMLId);
strcat(szAttributes, "\"");
nAttrsLength = strlen(szAttributes);
}
OGRwkbGeometryType eType = poGeometry->getGeometryType();
OGRwkbGeometryType eFType = wkbFlatten(eType);
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( eType == wkbPoint )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), 0.0, 2 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), 0.0, 2 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 60 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( eType == wkbPoint25D )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), poPoint->getZ(), 3 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 70 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( eFType == wkbLineString )
{
int bRing = EQUAL(poGeometry->getGeometryName(),"LINEARRING") ||
bForceLineStringAsLinearRing;
if (!bRing && bLineStringAsCurve)
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:Curve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:LineStringSegment>" );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineStringSegment></gml:segments></gml:Curve>" );
}
else
{
// Buffer for tag name + srsName attribute if set
const size_t nLineTagLength = 16;
char* pszLineTagName = NULL;
pszLineTagName = (char *) CPLMalloc( nLineTagLength + nAttrsLength + 1 );
if( bRing )
{
/* LinearRing isn't supposed to have srsName attribute according to GML3 SF-0 */
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:LinearRing>" );
}
else
{
sprintf( pszLineTagName, "<gml:LineString%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszLineTagName );
}
// FREE TAG BUFFER
CPLFree( pszLineTagName );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineString>" );
}
}
/* -------------------------------------------------------------------- */
/* ArcString or Circle */
/* -------------------------------------------------------------------- */
else if( eFType == wkbCircularString )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:Curve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
OGRSimpleCurve* poSC = (OGRSimpleCurve *) poGeometry;
/* SQL MM has a unique type for arc and circle, GML not */
if( poSC->getNumPoints() == 3 &&
poSC->getX(0) == poSC->getX(2) &&
poSC->getY(0) == poSC->getY(2) )
{
double dfMidX = (poSC->getX(0) + poSC->getX(1)) / 2;
double dfMidY = (poSC->getY(0) + poSC->getY(1)) / 2;
double dfDirX = (poSC->getX(1) - poSC->getX(0)) / 2;
double dfDirY = (poSC->getY(1) - poSC->getY(0)) / 2;
double dfNormX = -dfDirY;
double dfNormY = dfDirX;
double dfNewX = dfMidX + dfNormX;
double dfNewY = dfMidY + dfNormY;
OGRLineString* poLS = new OGRLineString();
OGRPoint p;
poSC->getPoint(0, &p);
poLS->addPoint(&p);
poSC->getPoint(1, &p);
if( poSC->getCoordinateDimension() == 3 )
poLS->addPoint(dfNewX, dfNewY, p.getZ());
else
poLS->addPoint(dfNewX, dfNewY);
poLS->addPoint(&p);
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:Circle>" );
AppendGML3CoordinateList( poLS, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Circle></gml:segments></gml:Curve>" );
delete poLS;
}
else
{
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:ArcString>" );
AppendGML3CoordinateList( poSC, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:ArcString></gml:segments></gml:Curve>" );
}
}
/* -------------------------------------------------------------------- */
/* CompositeCurve */
/* -------------------------------------------------------------------- */
else if( eFType == wkbCompoundCurve )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:CompositeCurve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,">");
OGRCompoundCurve* poCC = (OGRCompoundCurve*)poGeometry;
for(int i=0;i<poCC->getNumCurves();i++)
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:curveMember>" );
if( !OGR2GML3GeometryAppend( poCC->getCurve(i), poSRS, ppszText, pnLength,
pnMaxLength, TRUE, bLongSRS,
bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, FALSE) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:curveMember>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:CompositeCurve>" );
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( eFType == wkbPolygon || eFType == wkbCurvePolygon )
{
OGRCurvePolygon *poCP = (OGRCurvePolygon *) poGeometry;
// Buffer for polygon tag name + srsName attribute if set
const size_t nPolyTagLength = 13;
char* pszPolyTagName = NULL;
pszPolyTagName = (char *) CPLMalloc( nPolyTagLength + nAttrsLength + 1 );
// Compose Polygon tag with or without srsName attribute
sprintf( pszPolyTagName, "<gml:Polygon%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszPolyTagName );
// FREE TAG BUFFER
CPLFree( pszPolyTagName );
// Don't add srsName to polygon rings
if( poCP->getExteriorRingCurve() != NULL )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:exterior>" );
if( !OGR2GML3GeometryAppend( poCP->getExteriorRingCurve(), poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, TRUE) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:exterior>" );
}
for( int iRing = 0; iRing < poCP->getNumInteriorRings(); iRing++ )
{
OGRCurve *poRing = poCP->getInteriorRingCurve(iRing);
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:interior>" );
if( !OGR2GML3GeometryAppend( poRing, poSRS, ppszText, pnLength,
pnMaxLength, TRUE, bLongSRS,
bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, TRUE) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:interior>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Polygon>" );
}
/* -------------------------------------------------------------------- */
/* MultiSurface, MultiCurve, MultiPoint, MultiGeometry */
/* -------------------------------------------------------------------- */
else if( eFType == wkbMultiPolygon
|| eFType == wkbMultiSurface
|| eFType == wkbMultiLineString
|| eFType == wkbMultiCurve
|| eFType == wkbMultiPoint
|| eFType == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
const char *pszElemClose = NULL;
const char *pszMemberElem = NULL;
// Buffer for opening tag + srsName attribute
char* pszElemOpen = NULL;
if( eFType == wkbMultiPolygon || eFType == wkbMultiSurface )
{
pszElemOpen = (char *) CPLMalloc( 13 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiSurface%s>", szAttributes );
pszElemClose = "MultiSurface>";
pszMemberElem = "surfaceMember>";
}
else if( eFType == wkbMultiLineString || eFType == wkbMultiCurve )
{
pszElemOpen = (char *) CPLMalloc( 16 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiCurve%s>", szAttributes );
pszElemClose = "MultiCurve>";
pszMemberElem = "curveMember>";
}
else if( eFType == wkbMultiPoint )
{
pszElemOpen = (char *) CPLMalloc( 11 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiPoint%s>", szAttributes );
pszElemClose = "MultiPoint>";
pszMemberElem = "pointMember>";
}
else
{
pszElemOpen = (char *) CPLMalloc( 19 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiGeometry%s>", szAttributes );
pszElemClose = "MultiGeometry>";
pszMemberElem = "geometryMember>";
}
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemOpen );
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
char* pszGMLIdSub = NULL;
if (pszGMLId != NULL)
pszGMLIdSub = CPLStrdup(CPLSPrintf("%s.%d", pszGMLId, iMember));
if( !OGR2GML3GeometryAppend( poMember, poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve,
pszGMLIdSub, nSRSDimensionLocFlags, FALSE ) )
{
CPLFree(pszGMLIdSub);
return FALSE;
}
CPLFree(pszGMLIdSub);
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemClose );
// FREE TAG BUFFER
CPLFree( pszElemOpen );
}
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Unsupported geometry type %s",
OGRGeometryTypeToName(eType));
return FALSE;
}
return TRUE;
}
OGRErr OGRGeometryCollection::exportToWkb( OGRwkbByteOrder eByteOrder,
unsigned char * pabyData,
OGRwkbVariant eWkbVariant ) const
{
if( eWkbVariant == wkbVariantOldOgc &&
(wkbFlatten(getGeometryType()) == wkbMultiCurve ||
wkbFlatten(getGeometryType()) == wkbMultiSurface) )
{
// Does not make sense for new geometries, so patch it.
eWkbVariant = wkbVariantIso;
}
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] = DB2_V72_UNFIX_BYTE_ORDER(static_cast<unsigned char>(eByteOrder));
/* -------------------------------------------------------------------- */
/* Set the geometry feature type, ensuring that 3D flag is */
/* preserved. */
/* -------------------------------------------------------------------- */
GUInt32 nGType = getGeometryType();
if( eWkbVariant == wkbVariantIso )
nGType = getIsoGeometryType();
else if( eWkbVariant == wkbVariantPostGIS1 )
{
const bool bIs3D = wkbHasZ(static_cast<OGRwkbGeometryType>(nGType));
nGType = wkbFlatten(nGType);
if( nGType == wkbMultiCurve )
nGType = POSTGIS15_MULTICURVE;
else if( nGType == wkbMultiSurface )
nGType = POSTGIS15_MULTISURFACE;
if( bIs3D )
// Yes, explicitly set wkb25DBit.
nGType = static_cast<OGRwkbGeometryType>(nGType | wkb25DBitInternalUse);
}
if( OGR_SWAP( eByteOrder ) )
{
nGType = CPL_SWAP32(nGType);
}
memcpy( pabyData + 1, &nGType, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
int nCount = CPL_SWAP32( nGeomCount );
memcpy( pabyData+5, &nCount, 4 );
}
else
{
memcpy( pabyData+5, &nGeomCount, 4 );
}
int nOffset = 9;
/* ==================================================================== */
/* Serialize each of the Geoms. */
/* ==================================================================== */
int iGeom = 0;
for( auto&& poSubGeom: *this )
{
poSubGeom->exportToWkb( eByteOrder, pabyData + nOffset,
eWkbVariant );
// Should normally not happen if everyone else does its job,
// but has happened sometimes. (#6332)
if( poSubGeom->getCoordinateDimension() !=
getCoordinateDimension() )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Sub-geometry %d has coordinate dimension %d, "
"but container has %d",
iGeom,
poSubGeom->getCoordinateDimension(),
getCoordinateDimension() );
}
nOffset += poSubGeom->WkbSize();
iGeom ++;
}
return OGRERR_NONE;
}
OGRErr OGRCARTODBTableLayer::RunDeferedCreationIfNecessary()
{
if( !bDeferedCreation )
return OGRERR_NONE;
bDeferedCreation = FALSE;
CPLString osSQL;
osSQL.Printf("CREATE TABLE %s ( %s SERIAL,",
OGRCARTODBEscapeIdentifier(osName).c_str(),
osFIDColName.c_str());
int nSRID = 0;
OGRwkbGeometryType eGType = GetGeomType();
if( eGType != wkbNone )
{
CPLString osGeomType = OGRToOGCGeomType(eGType);
if( wkbHasZ(eGType) )
osGeomType += "Z";
OGRCartoDBGeomFieldDefn *poFieldDefn =
(OGRCartoDBGeomFieldDefn *)poFeatureDefn->GetGeomFieldDefn(0);
nSRID = poFieldDefn->nSRID;
osSQL += CPLSPrintf("%s GEOMETRY(%s, %d)%s, %s GEOMETRY(%s, %d),",
"the_geom",
osGeomType.c_str(),
nSRID,
(!poFieldDefn->IsNullable()) ? " NOT NULL" : "",
"the_geom_webmercator",
osGeomType.c_str(),
3857);
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(i);
if( strcmp(poFieldDefn->GetNameRef(), osFIDColName) != 0 )
{
osSQL += OGRCARTODBEscapeIdentifier(poFieldDefn->GetNameRef());
osSQL += " ";
osSQL += OGRPGCommonLayerGetType(*poFieldDefn, FALSE, TRUE);
if( !poFieldDefn->IsNullable() )
osSQL += " NOT NULL";
if( poFieldDefn->GetDefault() != NULL && !poFieldDefn->IsDefaultDriverSpecific() )
{
osSQL += " DEFAULT ";
osSQL += poFieldDefn->GetDefault();
}
osSQL += ",";
}
}
osSQL += CPLSPrintf("PRIMARY KEY (%s) )", osFIDColName.c_str());
CPLString osSeqName(OGRCARTODBEscapeIdentifier(CPLSPrintf("%s_%s_seq",
osName.c_str(), osFIDColName.c_str())));
osSQL += ";";
osSQL += CPLSPrintf("DROP SEQUENCE IF EXISTS %s CASCADE", osSeqName.c_str());
osSQL += ";";
osSQL += CPLSPrintf("CREATE SEQUENCE %s START 1", osSeqName.c_str());
osSQL += ";";
osSQL += CPLSPrintf("ALTER TABLE %s ALTER COLUMN %s SET DEFAULT nextval('%s')",
OGRCARTODBEscapeIdentifier(osName).c_str(),
osFIDColName.c_str(), osSeqName.c_str());
json_object* poObj = poDS->RunSQL(osSQL);
if( poObj == NULL )
return OGRERR_FAILURE;
json_object_put(poObj);
if( bCartoDBify )
{
if( nSRID != 4326 )
{
if( eGType != wkbNone )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Cannot register table in dashboard with "
"cdb_cartodbfytable() since its SRS is not EPSG:4326");
}
}
else
{
if( poDS->GetCurrentSchema() == "public" )
osSQL.Printf("SELECT cdb_cartodbfytable('%s')",
OGRCARTODBEscapeLiteral(osName).c_str());
else
osSQL.Printf("SELECT cdb_cartodbfytable('%s', '%s')",
OGRCARTODBEscapeLiteral(poDS->GetCurrentSchema()).c_str(),
OGRCARTODBEscapeLiteral(osName).c_str());
poObj = poDS->RunSQL(osSQL);
if( poObj == NULL )
return OGRERR_FAILURE;
json_object_put(poObj);
}
}
return OGRERR_NONE;
}
static
int OGR2SQLITEDealWithSpatialColumn(OGRLayer* poLayer,
int iGeomCol,
const LayerDesc& oLayerDesc,
const CPLString& osTableName,
OGRSQLiteDataSource* poSQLiteDS,
sqlite3* hDB,
int bSpatialiteDB,
const std::set<LayerDesc>&
WHEN_SPATIALITE(oSetLayers),
const std::set<CPLString>&
WHEN_SPATIALITE(oSetSpatialIndex)
)
{
OGRGeomFieldDefn* poGeomField =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomCol);
CPLString osGeomColRaw;
if( iGeomCol == 0 )
osGeomColRaw = OGR2SQLITE_GetNameForGeometryColumn(poLayer);
else
osGeomColRaw = poGeomField->GetNameRef();
const char* pszGeomColRaw = osGeomColRaw.c_str();
CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw));
const char* pszGeomColEscaped = osGeomColEscaped.c_str();
CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName));
const char* pszLayerNameEscaped = osLayerNameEscaped.c_str();
CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s",
oLayerDesc.osLayerName.c_str(), pszGeomColRaw));
CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw));
/* Make sure that the SRS is injected in spatial_ref_sys */
OGRSpatialReference* poSRS = poGeomField->GetSpatialRef();
if( iGeomCol == 0 && poSRS == NULL )
poSRS = poLayer->GetSpatialRef();
int nSRSId = poSQLiteDS->GetUndefinedSRID();
if( poSRS != NULL )
nSRSId = poSQLiteDS->FetchSRSId(poSRS);
CPLString osSQL;
#ifdef HAVE_SPATIALITE
bool bCreateSpatialIndex = false;
#endif
if( !bSpatialiteDB )
{
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, geometry_format, geometry_type, "
"coord_dimension, srid) "
"VALUES ('%s','%s','SpatiaLite',%d,%d,%d)",
pszLayerNameEscaped,
pszGeomColEscaped,
(int) wkbFlatten(poLayer->GetGeomType()),
wkbHasZ( poLayer->GetGeomType() ) ? 3 : 2,
nSRSId);
}
#ifdef HAVE_SPATIALITE
else
{
/* We detect the need for creating a spatial index by 2 means : */
/* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */
/* table in the SQL --> old/traditional way of requesting spatial indices */
/* with spatialite. */
std::set<LayerDesc>::const_iterator oIter2 = oSetLayers.begin();
for(; oIter2 != oSetLayers.end(); ++oIter2)
{
const LayerDesc& oLayerDescIter = *oIter2;
if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) )
{
bCreateSpatialIndex = true;
break;
}
}
/* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */
if( !bCreateSpatialIndex )
{
std::set<CPLString>::const_iterator oIter3 = oSetSpatialIndex.begin();
for(; oIter3 != oSetSpatialIndex.end(); ++oIter3)
{
const CPLString& osNameIter = *oIter3;
if( EQUAL(osNameIter, oLayerDesc.osLayerName) )
{
bCreateSpatialIndex = true;
break;
}
}
}
if( poSQLiteDS->HasSpatialite4Layout() )
{
int nGeomType = poLayer->GetGeomType();
int nCoordDimension = 2;
if( wkbHasZ((OGRwkbGeometryType)nGeomType) )
{
nGeomType += 1000;
nCoordDimension = 3;
}
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, geometry_type, coord_dimension, "
"srid, spatial_index_enabled) "
"VALUES (Lower('%s'),Lower('%s'),%d ,%d ,%d, %d)",
pszLayerNameEscaped,
pszGeomColEscaped, nGeomType,
nCoordDimension,
nSRSId, static_cast<int>(bCreateSpatialIndex) );
}
else
{
const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType());
if (pszGeometryType[0] == '\0')
pszGeometryType = "GEOMETRY";
osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
"f_geometry_column, type, coord_dimension, "
"srid, spatial_index_enabled) "
"VALUES ('%s','%s','%s','%s',%d, %d)",
pszLayerNameEscaped,
pszGeomColEscaped, pszGeometryType,
wkbHasZ( poLayer->GetGeomType() ) ? "XYZ" : "XY",
nSRSId, static_cast<int>(bCreateSpatialIndex) );
}
}
#endif // HAVE_SPATIALITE
char* pszErrMsg = NULL;
int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, &pszErrMsg );
if( pszErrMsg != NULL )
{
CPLDebug("SQLITE", "%s -> %s", osSQL.c_str(), pszErrMsg);
sqlite3_free(pszErrMsg);
}
#ifdef HAVE_SPATIALITE
/* -------------------------------------------------------------------- */
/* Should we create a spatial index ?. */
/* -------------------------------------------------------------------- */
if( !bSpatialiteDB || !bCreateSpatialIndex )
return rc == SQLITE_OK;
CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str());
/* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */
#ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING "
"VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)",
osIdxNameEscaped.c_str(),
nExtraDS,
OGRSQLiteEscape(oLayerDesc.osLayerName).c_str());
rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
if( rc != SQLITE_OK )
{
CPLDebug( "SQLITE",
"Error occurred during spatial index creation : %s",
sqlite3_errmsg(hDB));
}
#else // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL );
osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" "
"USING rtree(pkid, xmin, xmax, ymin, ymax)",
osIdxNameEscaped.c_str());
if( rc == SQLITE_OK )
rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
sqlite3_stmt *hStmt = NULL;
if( rc == SQLITE_OK )
{
const char* pszInsertInto = CPLSPrintf(
"INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) "
"VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str());
rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL);
}
OGRFeature* poFeature;
OGREnvelope sEnvelope;
OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer);
poLayer->ResetReading();
while( rc == SQLITE_OK &&
(poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL && !poGeom->IsEmpty() )
{
poGeom->getEnvelope(&sEnvelope);
sqlite3_bind_int64(hStmt, 1,
(sqlite3_int64) poFeature->GetFID() );
sqlite3_bind_double(hStmt, 2, sEnvelope.MinX);
sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX);
sqlite3_bind_double(hStmt, 4, sEnvelope.MinY);
sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY);
rc = sqlite3_step(hStmt);
if( rc == SQLITE_OK || rc == SQLITE_DONE )
rc = sqlite3_reset(hStmt);
}
delete poFeature;
}
poLayer->SetIgnoredFields(NULL);
sqlite3_finalize(hStmt);
if( rc == SQLITE_OK )
rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL );
else
{
CPLDebug( "SQLITE",
"Error occurred during spatial index creation : %s",
sqlite3_errmsg(hDB));
rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL );
}
#endif // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
#endif // HAVE_SPATIALITE
return rc == SQLITE_OK;
}
CPLXMLNode *GMLFeatureClass::SerializeToXML()
{
CPLXMLNode *psRoot;
int iProperty;
/* -------------------------------------------------------------------- */
/* Set feature class and core information. */
/* -------------------------------------------------------------------- */
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClass" );
CPLCreateXMLElementAndValue( psRoot, "Name", GetName() );
CPLCreateXMLElementAndValue( psRoot, "ElementPath", GetElementName() );
if( m_nGeometryPropertyCount > 1 )
{
for(int i=0; i < m_nGeometryPropertyCount; i++)
{
GMLGeometryPropertyDefn* poGeomFDefn = m_papoGeometryProperty[i];
CPLXMLNode *psPDefnNode;
psPDefnNode = CPLCreateXMLNode( psRoot, CXT_Element, "GeomPropertyDefn" );
if( strlen(poGeomFDefn->GetName()) > 0 )
CPLCreateXMLElementAndValue( psPDefnNode, "Name",
poGeomFDefn->GetName() );
if( poGeomFDefn->GetSrcElement() != NULL && strlen(poGeomFDefn->GetSrcElement()) > 0 )
CPLCreateXMLElementAndValue( psPDefnNode, "ElementPath",
poGeomFDefn->GetSrcElement() );
if( poGeomFDefn->GetType() != 0 /* wkbUnknown */ )
{
char szValue[128];
OGRwkbGeometryType eType = (OGRwkbGeometryType)poGeomFDefn->GetType();
CPLString osStr(OGRToOGCGeomType(eType));
if( wkbHasZ(eType) ) osStr += "Z";
CPLCreateXMLNode( psPDefnNode, CXT_Comment, osStr.c_str() );
sprintf( szValue, "%d", eType );
CPLCreateXMLElementAndValue( psPDefnNode, "Type", szValue );
}
}
}
else if( m_nGeometryPropertyCount == 1 )
{
GMLGeometryPropertyDefn* poGeomFDefn = m_papoGeometryProperty[0];
if( strlen(poGeomFDefn->GetName()) > 0 )
CPLCreateXMLElementAndValue( psRoot, "GeometryName",
poGeomFDefn->GetName() );
if( poGeomFDefn->GetSrcElement() != NULL && strlen(poGeomFDefn->GetSrcElement()) > 0 )
CPLCreateXMLElementAndValue( psRoot, "GeometryElementPath",
poGeomFDefn->GetSrcElement() );
if( poGeomFDefn->GetType() != 0 /* wkbUnknown */ )
{
char szValue[128];
OGRwkbGeometryType eType = (OGRwkbGeometryType)poGeomFDefn->GetType();
CPLString osStr(OGRToOGCGeomType(eType));
if( wkbHasZ(eType) ) osStr += "Z";
CPLCreateXMLNode( psRoot, CXT_Comment, osStr.c_str() );
sprintf( szValue, "%d", eType );
CPLCreateXMLElementAndValue( psRoot, "GeometryType", szValue );
}
}
else
{
CPLCreateXMLElementAndValue( psRoot, "GeometryType", "100" );
}
const char* pszSRSName = GetSRSName();
if( pszSRSName )
{
CPLCreateXMLElementAndValue( psRoot, "SRSName", pszSRSName );
}
/* -------------------------------------------------------------------- */
/* Write out dataset specific information. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSI;
if( m_bHaveExtents || m_nFeatureCount != -1 || m_pszExtraInfo != NULL )
{
psDSI = CPLCreateXMLNode( psRoot, CXT_Element, "DatasetSpecificInfo" );
if( m_nFeatureCount != -1 )
{
char szValue[128];
sprintf( szValue, CPL_FRMT_GIB, m_nFeatureCount );
CPLCreateXMLElementAndValue( psDSI, "FeatureCount", szValue );
}
if( m_bHaveExtents &&
fabs(m_dfXMin) < 1e100 &&
fabs(m_dfXMax) < 1e100 &&
fabs(m_dfYMin) < 1e100 &&
fabs(m_dfYMax) < 1e100 )
{
char szValue[128];
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfXMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMin", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfXMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMax", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfYMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMin", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfYMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMax", szValue );
}
if( m_pszExtraInfo )
CPLCreateXMLElementAndValue( psDSI, "ExtraInfo", m_pszExtraInfo );
}
/* -------------------------------------------------------------------- */
/* emit property information. */
/* -------------------------------------------------------------------- */
for( iProperty = 0; iProperty < GetPropertyCount(); iProperty++ )
{
GMLPropertyDefn *poPDefn = GetProperty( iProperty );
CPLXMLNode *psPDefnNode;
const char *pszTypeName = "Unknown";
psPDefnNode = CPLCreateXMLNode( psRoot, CXT_Element, "PropertyDefn" );
CPLCreateXMLElementAndValue( psPDefnNode, "Name",
poPDefn->GetName() );
CPLCreateXMLElementAndValue( psPDefnNode, "ElementPath",
poPDefn->GetSrcElement() );
switch( poPDefn->GetType() )
{
case GMLPT_Untyped:
pszTypeName = "Untyped";
break;
case GMLPT_String:
case GMLPT_Boolean:
pszTypeName = "String";
break;
case GMLPT_Integer:
case GMLPT_Short:
case GMLPT_Integer64:
pszTypeName = "Integer";
break;
case GMLPT_Real:
case GMLPT_Float:
pszTypeName = "Real";
break;
case GMLPT_Complex:
pszTypeName = "Complex";
break;
case GMLPT_IntegerList:
case GMLPT_Integer64List:
pszTypeName = "IntegerList";
break;
case GMLPT_RealList:
pszTypeName = "RealList";
break;
case GMLPT_StringList:
case GMLPT_BooleanList:
pszTypeName = "StringList";
break;
/* should not happen in practise for now because this is not */
/* autodetected */
case GMLPT_FeatureProperty:
pszTypeName = "FeatureProperty";
break;
/* should not happen in practise for now because this is not */
/* autodetected */
case GMLPT_FeaturePropertyList:
pszTypeName = "FeaturePropertyList";
break;
}
CPLCreateXMLElementAndValue( psPDefnNode, "Type", pszTypeName );
if( poPDefn->GetType() == GMLPT_Boolean || poPDefn->GetType() == GMLPT_BooleanList )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Boolean" );
else if( poPDefn->GetType() == GMLPT_Short )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Short" );
else if( poPDefn->GetType() == GMLPT_Float )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Float" );
else if( poPDefn->GetType() == GMLPT_Integer64 ||
poPDefn->GetType() == GMLPT_Integer64List )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Integer64" );
if( EQUAL(pszTypeName,"String") )
{
char szMaxLength[48];
sprintf(szMaxLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szMaxLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Integer") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Real") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
char szPrecision[48];
sprintf(szPrecision, "%d", poPDefn->GetPrecision());
CPLCreateXMLElementAndValue ( psPDefnNode, "Precision", szPrecision );
}
}
return psRoot;
}
