void OGRILI1Layer::JoinGeomLayers()
{
bGeomsJoined = TRUE;
int bResetConfigOption = FALSE;
if (EQUAL(CPLGetConfigOption("OGR_ARC_STEPSIZE", ""), ""))
{
bResetConfigOption = TRUE;
CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", "0.96");
}
for (GeomFieldInfos::const_iterator it = oGeomFieldInfos.begin(); it != oGeomFieldInfos.end(); ++it)
{
OGRFeatureDefn* geomFeatureDefn = it->second.geomTable;
if (geomFeatureDefn)
{
CPLDebug( "OGR_ILI", "Join geometry table %s of field '%s'", geomFeatureDefn->GetName(), it->first.c_str() );
OGRILI1Layer* poGeomLayer = poDS->GetLayerByName(geomFeatureDefn->GetName());
int nGeomFieldIndex = GetLayerDefn()->GetGeomFieldIndex(it->first.c_str());
if (it->second.iliGeomType == "Surface")
{
JoinSurfaceLayer(poGeomLayer, nGeomFieldIndex);
}
else if (it->second.iliGeomType == "Area")
{
CPLString pointField = it->first + "__Point";
int nPointFieldIndex = GetLayerDefn()->GetGeomFieldIndex(pointField.c_str());
PolygonizeAreaLayer(poGeomLayer, nGeomFieldIndex, nPointFieldIndex);
}
}
}
if( bResetConfigOption )
CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", NULL);
}
void OGRILI1Layer::JoinSurfaceLayer( OGRILI1Layer* poSurfaceLineLayer, int nSurfaceFieldIndex )
{
CPLDebug( "OGR_ILI", "Joining surface layer %s with geometries", GetLayerDefn()->GetName());
OGRwkbGeometryType geomType = GetLayerDefn()->GetGeomFieldDefn(nSurfaceFieldIndex)->GetType();
poSurfaceLineLayer->ResetReading();
while (OGRFeature *linefeature = poSurfaceLineLayer->GetNextFeatureRef()) {
//OBJE entries with same _RefTID are polygon rings of same feature
//TODO: non-numeric _RefTID/FID is not supported yet!
GIntBig reftid = linefeature->GetFieldAsInteger64(1); //_RefTID
OGRFeature *feature = GetFeatureRef((int)reftid);
if (feature) {
OGRCurvePolygon *poly;
if (feature->GetGeomFieldRef(nSurfaceFieldIndex)) {
CPLDebug( "OGR_ILI", "Adding ring to FID " CPL_FRMT_GIB, reftid );
poly = (OGRCurvePolygon *)feature->GetGeomFieldRef(nSurfaceFieldIndex);
} else {
poly = (geomType == wkbPolygon) ? new OGRPolygon() : new OGRCurvePolygon();
feature->SetGeomFieldDirectly(nSurfaceFieldIndex, poly);
}
OGRMultiCurve *lines = (OGRMultiCurve*)linefeature->GetGeomFieldRef(0);
for( int i = 0; i < lines->getNumGeometries(); i++ ) {
OGRCurve *line = (OGRCurve*)lines->getGeometryRef(i);
OGRCurve *ring = (geomType == wkbPolygon) ?
OGRCurve::CastToLinearRing((OGRCurve*)line->clone()) :
(OGRCurve*)line->clone();
poly->addRingDirectly(ring);
}
} else {
CPLError(CE_Warning, CPLE_AppDefined, "Couldn't join feature FID " CPL_FRMT_GIB, reftid );
}
}
ResetReading();
poSurfaceLineLayer = 0;
}
void OGRPGResultLayer::SetSpatialFilter( int iGeomField, OGRGeometry * poGeomIn )
{
if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||
GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone )
{
if( iGeomField != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid geometry field index : %d", iGeomField);
}
return;
}
m_iGeomFieldFilter = iGeomField;
OGRPGGeomFieldDefn* poGeomFieldDefn =
poFeatureDefn->myGetGeomFieldDefn(m_iGeomFieldFilter);
if( InstallFilter( poGeomIn ) )
{
if ( poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOMETRY ||
poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOGRAPHY )
{
if( m_poFilterGeom != NULL)
{
char szBox3D_1[128];
char szBox3D_2[128];
OGREnvelope sEnvelope;
m_poFilterGeom->getEnvelope( &sEnvelope );
if( poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOGRAPHY )
{
if( sEnvelope.MinX < -180.0 )
sEnvelope.MinX = -180.0;
if( sEnvelope.MinY < -90.0 )
sEnvelope.MinY = -90.0;
if( sEnvelope.MaxX > 180.0 )
sEnvelope.MaxX = 180.0;
if( sEnvelope.MaxY > 90.0 )
sEnvelope.MaxY = 90.0;
}
CPLsnprintf(szBox3D_1, sizeof(szBox3D_1), "%.18g %.18g", sEnvelope.MinX, sEnvelope.MinY);
CPLsnprintf(szBox3D_2, sizeof(szBox3D_2), "%.18g %.18g", sEnvelope.MaxX, sEnvelope.MaxY);
osWHERE.Printf("WHERE %s && %s('BOX3D(%s, %s)'::box3d,%d) ",
OGRPGEscapeColumnName(poGeomFieldDefn->GetNameRef()).c_str(),
(poDS->sPostGISVersion.nMajor >= 2) ? "ST_SetSRID" : "SetSRID",
szBox3D_1, szBox3D_2, poGeomFieldDefn->nSRSId );
}
else
{
osWHERE = "";
}
BuildFullQueryStatement();
}
ResetReading();
}
}
void OGRUnionLayer::AutoWarpLayerIfNecessary(int iLayer)
{
if( !pabCheckIfAutoWrap[iLayer] )
{
pabCheckIfAutoWrap[iLayer] = TRUE;
for(int i=0; i<GetLayerDefn()->GetGeomFieldCount();i++)
{
OGRSpatialReference* poSRS = GetLayerDefn()->GetGeomFieldDefn(i)->GetSpatialRef();
if( poSRS != NULL )
poSRS->Reference();
OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn();
int iSrcGeomField = poSrcFeatureDefn->GetGeomFieldIndex(
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef());
if( iSrcGeomField >= 0 )
{
OGRSpatialReference* poSRS2 =
poSrcFeatureDefn->GetGeomFieldDefn(iSrcGeomField)->GetSpatialRef();
if( (poSRS == NULL && poSRS2 != NULL) ||
(poSRS != NULL && poSRS2 == NULL) )
{
CPLError(CE_Warning, CPLE_AppDefined,
"SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS",
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),
papoSrcLayers[iLayer]->GetName());
}
else if (poSRS != NULL && poSRS2 != NULL &&
poSRS != poSRS2 && !poSRS->IsSame(poSRS2))
{
CPLDebug("VRT", "SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS. "
"Trying auto warping",
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),
papoSrcLayers[iLayer]->GetName());
OGRCoordinateTransformation* poCT =
OGRCreateCoordinateTransformation( poSRS2, poSRS );
OGRCoordinateTransformation* poReversedCT = (poCT != NULL) ?
OGRCreateCoordinateTransformation( poSRS, poSRS2 ) : NULL;
if( poReversedCT != NULL )
papoSrcLayers[iLayer] = new OGRWarpedLayer(
papoSrcLayers[iLayer], iSrcGeomField, TRUE, poCT, poReversedCT);
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"AutoWarpLayerIfNecessary failed to create "
"poCT or poReversedCT.");
if ( poCT != NULL )
delete poCT;
}
}
}
if( poSRS != NULL )
poSRS->Release();
}
}
}
OGRFeature *OGRGFTLayer::GetNextFeature()
{
GetLayerDefn();
while( true )
{
if (nNextInSeq < nOffset ||
nNextInSeq >= nOffset + static_cast<int>(aosRows.size()))
{
if (bEOF)
return nullptr;
nOffset += static_cast<int>(aosRows.size());
if (!FetchNextRows())
return nullptr;
}
OGRFeature *poFeature = GetNextRawFeature();
if (poFeature == nullptr)
return nullptr;
if((m_poFilterGeom == nullptr
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == nullptr
|| m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
else
delete poFeature;
}
}
OGRErr OGRUnionLayer::SetAttributeFilter( const char * pszAttributeFilterIn )
{
if( pszAttributeFilterIn == NULL && pszAttributeFilter == NULL)
return OGRERR_NONE;
if( pszAttributeFilterIn != NULL && pszAttributeFilter != NULL &&
strcmp(pszAttributeFilterIn, pszAttributeFilter) == 0)
return OGRERR_NONE;
if( poFeatureDefn == NULL ) GetLayerDefn();
bAttrFilterPassThroughValue = -1;
OGRErr eErr = OGRLayer::SetAttributeFilter(pszAttributeFilterIn);
if( eErr != OGRERR_NONE )
return eErr;
CPLFree(pszAttributeFilter);
pszAttributeFilter = pszAttributeFilterIn ?
CPLStrdup(pszAttributeFilterIn) : NULL;
if( iCurLayer >= 0 && iCurLayer < nSrcLayers)
ApplyAttributeFilterToSrcLayer(iCurLayer);
return OGRERR_NONE;
}
OGRFeature* OGRCARTODBTableLayer::GetFeature( GIntBig nFeatureId )
{
if( bDeferedCreation && RunDeferedCreationIfNecessary() != OGRERR_NONE )
return NULL;
FlushDeferedInsert();
GetLayerDefn();
if( osFIDColName.size() == 0 )
return OGRCARTODBLayer::GetFeature(nFeatureId);
CPLString osSQL = osSELECTWithoutWHERE;
osSQL += " WHERE ";
osSQL += OGRCARTODBEscapeIdentifier(osFIDColName).c_str();
osSQL += " = ";
osSQL += CPLSPrintf(CPL_FRMT_GIB, nFeatureId);
json_object* poObj = poDS->RunSQL(osSQL);
json_object* poRowObj = OGRCARTODBGetSingleRow(poObj);
if( poRowObj == NULL )
{
if( poObj != NULL )
json_object_put(poObj);
return OGRCARTODBLayer::GetFeature(nFeatureId);
}
OGRFeature* poFeature = BuildFeature(poRowObj);
json_object_put(poObj);
return poFeature;
}
OGRFeature *OGRGFTLayer::GetNextFeature()
{
OGRFeature *poFeature;
GetLayerDefn();
while(TRUE)
{
if (nNextInSeq < nOffset ||
nNextInSeq >= nOffset + (int)aosRows.size())
{
if (bEOF)
return NULL;
nOffset += aosRows.size();
if (!FetchNextRows())
return NULL;
}
poFeature = GetNextRawFeature();
if (poFeature == NULL)
return NULL;
if((m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
else
delete poFeature;
}
}
void OGRGeoJSONLayer::AddFeature( OGRFeature* poFeature )
{
CPLAssert( NULL != poFeature );
// NOTE - mloskot:
// Features may not be sorted according to FID values.
// TODO: Should we check if feature already exists?
// TODO: Think about sync operation, upload, etc.
OGRFeature* poNewFeature = NULL;
poNewFeature = poFeature->Clone();
if( -1 == poNewFeature->GetFID() )
{
int nFID = static_cast<int>(seqFeatures_.size());
poNewFeature->SetFID( nFID );
// TODO - mlokot: We need to redesign creation of FID column
int nField = poNewFeature->GetFieldIndex( DefaultFIDColumn );
if( -1 != nField && GetLayerDefn()->GetFieldDefn(nField)->GetType() == OFTInteger )
{
poNewFeature->SetField( nField, nFID );
}
}
seqFeatures_.push_back( poNewFeature );
}
OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce )
{
OGRFeature *poFeature;
OGREnvelope oEnv;
GBool bExtentSet = FALSE;
/* -------------------------------------------------------------------- */
/* If this layer has a none geometry type, then we can */
/* reasonably assume there are not extents available. */
/* -------------------------------------------------------------------- */
if( GetLayerDefn()->GetGeomType() == wkbNone )
{
psExtent->MinX = 0.0;
psExtent->MaxX = 0.0;
psExtent->MinY = 0.0;
psExtent->MaxY = 0.0;
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* If not forced, we should avoid having to scan all the */
/* features and just return a failure. */
/* -------------------------------------------------------------------- */
if( !bForce )
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* OK, we hate to do this, but go ahead and read through all */
/* the features to collect geometries and build extents. */
/* -------------------------------------------------------------------- */
ResetReading();
while( (poFeature = GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if (poGeom && !bExtentSet)
{
poGeom->getEnvelope(psExtent);
bExtentSet = TRUE;
}
else if (poGeom)
{
poGeom->getEnvelope(&oEnv);
if (oEnv.MinX < psExtent->MinX)
psExtent->MinX = oEnv.MinX;
if (oEnv.MinY < psExtent->MinY)
psExtent->MinY = oEnv.MinY;
if (oEnv.MaxX > psExtent->MaxX)
psExtent->MaxX = oEnv.MaxX;
if (oEnv.MaxY > psExtent->MaxY)
psExtent->MaxY = oEnv.MaxY;
}
delete poFeature;
}
ResetReading();
return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE);
}
GIntBig OGRSVGLayer::GetFeatureCount( int bForce )
{
if (m_poAttrQuery != NULL || m_poFilterGeom != NULL)
return OGRLayer::GetFeatureCount(bForce);
GetLayerDefn();
return nTotalFeatures;
}
void OGRILI1Layer::JoinSurfaceLayer()
{
if (poSurfacePolyLayer == 0) return;
CPLDebug( "OGR_ILI", "Joining surface layer %s with geometries", GetLayerDefn()->GetName());
GetLayerDefn()->SetGeomType(poSurfacePolyLayer->GetLayerDefn()->GetGeomType());
ResetReading();
while (OGRFeature *feature = GetNextFeatureRef())
{
OGRFeature *polyfeature = poSurfacePolyLayer->GetFeatureRef(feature->GetFID());
if (polyfeature) {
feature->SetGeometry(polyfeature->GetGeometryRef());
}
}
ResetReading();
poSurfacePolyLayer = 0;
}
OGRErr OGRGFTTableLayer::DeleteFeature( long nFID )
{
GetLayerDefn();
if (!poDS->IsReadWrite())
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if (osTableId.size() == 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot delete feature in non-created table");
return OGRERR_FAILURE;
}
if (poDS->GetAuth().size() == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in unauthenticated mode");
return OGRERR_FAILURE;
}
CPLString osCommand;
osCommand += "DELETE FROM ";
osCommand += osTableId;
osCommand += " WHERE ROWID = '";
osCommand += CPLSPrintf("%ld", nFID);
osCommand += "'";
//CPLDebug("GFT", "%s", osCommand.c_str());
CPLHTTPResult * psResult = poDS->RunSQL(osCommand);
if (psResult == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature deletion failed");
return OGRERR_FAILURE;
}
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL ||
strncmp(pszLine, "OK", 2) != 0 ||
psResult->pszErrBuf != NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature deletion failed");
CPLHTTPDestroyResult(psResult);
return OGRERR_FAILURE;
}
CPLHTTPDestroyResult(psResult);
return OGRERR_NONE;
}
const char *OGRDB2Layer::GetFIDColumn()
{
GetLayerDefn();
if( pszFIDColumn != nullptr )
return pszFIDColumn;
else
return "";
}
int OGROCIWritableLayer::FindFieldIndex( const char *pszFieldName, int bExactMatch )
{
int iField = GetLayerDefn()->GetFieldIndex( pszFieldName );
if( !bExactMatch && iField < 0 )
{
// try laundered version
OGROCISession *poSession = poDS->GetSession();
char *pszSafeName = CPLStrdup( pszFieldName );
poSession->CleanName( pszSafeName );
iField = GetLayerDefn()->GetFieldIndex( pszSafeName );
CPLFree( pszSafeName );
}
return iField;
}
const char *OGRDB2Layer::GetGeometryColumn()
{
GetLayerDefn();
if( pszGeomColumn != nullptr )
return pszGeomColumn;
else
return "";
}
const char *OGRMSSQLSpatialLayer::GetGeometryColumn()
{
GetLayerDefn();
if( pszGeomColumn != NULL )
return pszGeomColumn;
else
return "";
}
const char *OGRMSSQLSpatialLayer::GetFIDColumn()
{
GetLayerDefn();
if( pszFIDColumn != NULL )
return pszFIDColumn;
else
return "";
}
void OGRWarpedLayer::SetSpatialFilter( int iGeomField, OGRGeometry *poGeom )
{
if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid geometry field index : %d", iGeomField);
return;
}
m_iGeomFieldFilter = iGeomField;
if( InstallFilter( poGeom ) )
ResetReading();
if( m_iGeomFieldFilter == m_iGeomField )
{
if( poGeom == NULL || m_poReversedCT == NULL )
{
m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,
NULL);
}
else
{
OGREnvelope sEnvelope;
poGeom->getEnvelope(&sEnvelope);
if( CPLIsInf(sEnvelope.MinX) && CPLIsInf(sEnvelope.MinY) &&
CPLIsInf(sEnvelope.MaxX) && CPLIsInf(sEnvelope.MaxY) )
{
m_poDecoratedLayer->SetSpatialFilterRect(m_iGeomFieldFilter,
sEnvelope.MinX,
sEnvelope.MinY,
sEnvelope.MaxX,
sEnvelope.MaxY);
}
else if( ReprojectEnvelope(&sEnvelope, m_poReversedCT) )
{
m_poDecoratedLayer->SetSpatialFilterRect(m_iGeomFieldFilter,
sEnvelope.MinX,
sEnvelope.MinY,
sEnvelope.MaxX,
sEnvelope.MaxY);
}
else
{
m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,
NULL);
}
}
}
else
{
m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,
poGeom);
}
}
OGRFeature * OGRGFTTableLayer::GetFeature( GIntBig nFID )
{
GetLayerDefn();
CPLString osSQL("SELECT ROWID");
for(int i=0;i<poFeatureDefn->GetFieldCount();i++)
{
osSQL += ",";
const char* pszFieldName =
poFeatureDefn->GetFieldDefn(i)->GetNameRef();
osSQL += EscapeAndQuote(pszFieldName);
}
if (bHiddenGeometryField)
{
osSQL += ",";
osSQL += EscapeAndQuote(GetGeometryColumn());
}
osSQL += " FROM ";
osSQL += osTableId;
osSQL += CPLSPrintf(" WHERE ROWID='" CPL_FRMT_GIB "'", nFID);
CPLPushErrorHandler(CPLQuietErrorHandler);
CPLHTTPResult * psResult = poDS->RunSQL(osSQL);
CPLPopErrorHandler();
if (psResult == NULL)
return NULL;
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL || psResult->pszErrBuf != NULL)
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
/* skip header line */
pszLine = OGRGFTGotoNextLine(pszLine);
if (pszLine == NULL || pszLine[0] == 0)
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
int nLen = (int)strlen(pszLine);
if (nLen > 0 && pszLine[nLen-1] == '\n')
pszLine[nLen-1] = '\0';
OGRFeature* poFeature = BuildFeatureFromSQL(pszLine);
CPLHTTPDestroyResult(psResult);
return poFeature;
}
OGRErr OGRGFTTableLayer::CommitTransaction()
{
GetLayerDefn();
if (!bInTransaction)
{
CPLError(CE_Failure, CPLE_AppDefined, "Should be in transaction");
return OGRERR_FAILURE;
}
bInTransaction = FALSE;
if (nFeaturesInTransaction > 0)
{
if (nFeaturesInTransaction > 1)
osTransaction += ";";
CPLHTTPResult * psResult = poDS->RunSQL(osTransaction);
osTransaction.resize(0);
nFeaturesInTransaction = 0;
if (psResult == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "CommitTransaction failed");
return OGRERR_FAILURE;
}
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL ||
strncmp(pszLine, "rowid", 5) != 0 ||
psResult->pszErrBuf != NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "CommitTransaction failed : %s",
pszLine ? pszLine : psResult->pszErrBuf);
CPLHTTPDestroyResult(psResult);
return OGRERR_FAILURE;
}
pszLine = OGRGFTGotoNextLine(pszLine);
while(pszLine && *pszLine != 0)
{
char* pszNextLine = OGRGFTGotoNextLine(pszLine);
if (pszNextLine)
pszNextLine[-1] = 0;
//CPLDebug("GFT", "Feature id = %s", pszLine);
pszLine = pszNextLine;
}
CPLHTTPDestroyResult(psResult);
}
return OGRERR_NONE;
}
OGRErr OGRUnionLayer::GetExtent(int iGeomField, OGREnvelope *psExtent, int bForce)
{
if( iGeomField >= 0 && iGeomField < nGeomFields &&
papoGeomFields[iGeomField]->sStaticEnvelope.IsInit() )
{
memcpy(psExtent, &papoGeomFields[iGeomField]->sStaticEnvelope, sizeof(OGREnvelope));
return OGRERR_NONE;
}
if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid geometry field index : %d", iGeomField);
return OGRERR_FAILURE;
}
int bInit = FALSE;
for(int i = 0; i < nSrcLayers; i++)
{
AutoWarpLayerIfNecessary(i);
int iSrcGeomField = papoSrcLayers[i]->GetLayerDefn()->GetGeomFieldIndex(
GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetNameRef());
if( iSrcGeomField >= 0 )
{
if( !bInit )
{
if( papoSrcLayers[i]->GetExtent(iSrcGeomField, psExtent, bForce) == OGRERR_NONE )
bInit = TRUE;
}
else
{
OGREnvelope sExtent;
if( papoSrcLayers[i]->GetExtent(iSrcGeomField, &sExtent, bForce) == OGRERR_NONE )
{
psExtent->Merge(sExtent);
}
}
}
}
return (bInit) ? OGRERR_NONE : OGRERR_FAILURE;
}
void OGRGFTTableLayer::SetSpatialFilter( OGRGeometry * poGeomIn )
{
GetLayerDefn();
if( InstallFilter( poGeomIn ) )
{
BuildWhere();
ResetReading();
}
}
void OGRUnionLayer::SetSpatialFilterToSourceLayer(OGRLayer* poSrcLayer)
{
if( m_iGeomFieldFilter >= 0 &&
m_iGeomFieldFilter < GetLayerDefn()->GetGeomFieldCount() )
{
int iSrcGeomField = poSrcLayer->GetLayerDefn()->GetGeomFieldIndex(
GetLayerDefn()->GetGeomFieldDefn(m_iGeomFieldFilter)->GetNameRef());
if( iSrcGeomField >= 0 )
{
poSrcLayer->SetSpatialFilter(iSrcGeomField, m_poFilterGeom);
}
else
{
poSrcLayer->SetSpatialFilter(NULL);
}
}
else
{
poSrcLayer->SetSpatialFilter(NULL);
}
}
OGRFeature * OGRLayerWithTransaction::GetFeature( GIntBig nFID )
{
if( !m_poDecoratedLayer ) return NULL;
OGRFeature* poSrcFeature = m_poDecoratedLayer->GetFeature(nFID);
if( !poSrcFeature )
return NULL;
OGRFeature* poFeature = new OGRFeature(GetLayerDefn());
poFeature->SetFrom(poSrcFeature);
poFeature->SetFID(poSrcFeature->GetFID());
delete poSrcFeature;
return poFeature;
}
OGRErr OGRLayer::ReorderField( int iOldFieldPos, int iNewFieldPos )
{
OGRErr eErr;
int nFieldCount = GetLayerDefn()->GetFieldCount();
if (iOldFieldPos < 0 || iOldFieldPos >= nFieldCount)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid field index");
return OGRERR_FAILURE;
}
if (iNewFieldPos < 0 || iNewFieldPos >= nFieldCount)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid field index");
return OGRERR_FAILURE;
}
if (iNewFieldPos == iOldFieldPos)
return OGRERR_NONE;
int* panMap = (int*) CPLMalloc(sizeof(int) * nFieldCount);
int i;
if (iOldFieldPos < iNewFieldPos)
{
/* "0","1","2","3","4" (1,3) -> "0","2","3","1","4" */
for(i=0;i<iOldFieldPos;i++)
panMap[i] = i;
for(;i<iNewFieldPos;i++)
panMap[i] = i + 1;
panMap[iNewFieldPos] = iOldFieldPos;
for(i=iNewFieldPos+1;i<nFieldCount;i++)
panMap[i] = i;
}
else
{
/* "0","1","2","3","4" (3,1) -> "0","3","1","2","4" */
for(i=0;i<iNewFieldPos;i++)
panMap[i] = i;
panMap[iNewFieldPos] = iOldFieldPos;
for(i=iNewFieldPos+1;i<=iOldFieldPos;i++)
panMap[i] = i - 1;
for(;i<nFieldCount;i++)
panMap[i] = i;
}
eErr = ReorderFields(panMap);
CPLFree(panMap);
return eErr;
}
void OGRCARTODBTableLayer::SetSpatialFilter( int iGeomField, OGRGeometry * poGeomIn )
{
if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||
GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone )
{
if( iGeomField != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid geometry field index : %d", iGeomField);
}
return;
}
m_iGeomFieldFilter = iGeomField;
if( InstallFilter( poGeomIn ) )
{
BuildWhere();
ResetReading();
}
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature
\return NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(VFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {
if (poVFKFeature->GetProperty(iField)->IsNull())
continue;
OGRFieldType fType = poOGRFeature->GetDefnRef()->GetFieldDefn(iField)->GetType();
if (fType == OFTInteger)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueI());
else if (fType == OFTReal)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueD());
else
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueS());
}
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
OGRErr OGRGFTTableLayer::RollbackTransaction()
{
GetLayerDefn();
if (!bInTransaction)
{
CPLError(CE_Failure, CPLE_AppDefined, "Should be in transaction");
return OGRERR_FAILURE;
}
bInTransaction = FALSE;
nFeaturesInTransaction = 0;
osTransaction.resize(0);
return OGRERR_NONE;
}
GIntBig OGRXLSLayer::GetFeatureCount( int bForce )
{
if( m_poAttrQuery == nullptr /* && m_poFilterGeom == NULL */ )
{
const char* pszXLSHeaders = CPLGetConfigOption("OGR_XLS_HEADERS", "");
if(EQUAL(pszXLSHeaders, "DISABLE"))
return nRows;
GetLayerDefn();
return bFirstLineIsHeaders ? nRows - 1 : nRows;
}
return OGRLayer::GetFeatureCount(bForce);
}
