/*!
\brief Update VFK_DB_TABLE table
\param nGeometries number of geometries to update
*/
void VFKDataBlockDB::UpdateVfkBlocks(int nGeometries) {
int nFeatCount;
CPLString osSQL;
VFKReaderDB *poReader;
poReader = (VFKReaderDB*) m_poReader;
/* update number of features in VFK_DB_TABLE table */
nFeatCount = (int)GetFeatureCount();
if (nFeatCount > 0) {
osSQL.Printf("UPDATE %s SET num_features = %d WHERE table_name = '%s'",
VFK_DB_TABLE, nFeatCount, m_pszName);
poReader->ExecuteSQL(osSQL.c_str());
}
/* update number of geometries in VFK_DB_TABLE table */
if (nGeometries > 0) {
CPLDebug("OGR-VFK",
"VFKDataBlockDB::UpdateVfkBlocks(): name=%s -> "
"%d geometries saved to internal DB", m_pszName, nGeometries);
osSQL.Printf("UPDATE %s SET num_geometries = %d WHERE table_name = '%s'",
VFK_DB_TABLE, nGeometries, m_pszName);
poReader->ExecuteSQL(osSQL.c_str());
}
}
OGRFeature *OGRNTFFeatureClassLayer::GetNextFeature()
{
if( iCurrentFC >= GetFeatureCount() )
return NULL;
return GetFeature( (long) iCurrentFC++ );
}
OGRErr OGRPLScenesLayer::GetExtent( OGREnvelope *psExtent, int bForce )
{
GetFeatureCount();
if( nFeatureCount > 0 && nFeatureCount < nPageSize )
return OGRLayer::GetExtentInternal(0, psExtent, bForce);
psExtent->MinX = -180;
psExtent->MinY = -90;
psExtent->MaxX = 180;
psExtent->MaxY = 90;
return OGRERR_NONE;
}
int TigerCompleteChain::GetShapeRecordId( int nChainId, int nTLID )
{
CPLAssert( nChainId >= 0 && nChainId < GetFeatureCount() );
if( fpShape == NULL || panShapeRecordId == NULL )
return -1;
/* -------------------------------------------------------------------- */
/* Do we already have the answer? */
/* -------------------------------------------------------------------- */
if( panShapeRecordId[nChainId] != 0 )
return panShapeRecordId[nChainId];
/* -------------------------------------------------------------------- */
/* If we don't already have this value, then search from the */
/* previous known record. */
/* -------------------------------------------------------------------- */
int iTestChain, nWorkingRecId;
for( iTestChain = nChainId-1;
iTestChain >= 0 && panShapeRecordId[iTestChain] <= 0;
iTestChain-- ) {}
if( iTestChain < 0 )
{
iTestChain = -1;
nWorkingRecId = 1;
}
else
{
nWorkingRecId = panShapeRecordId[iTestChain]+1;
}
/* -------------------------------------------------------------------- */
/* If we have non existent records following (-1's) we can */
/* narrow our search a bit. */
/* -------------------------------------------------------------------- */
while( panShapeRecordId[iTestChain+1] == -1 )
{
iTestChain++;
}
/* -------------------------------------------------------------------- */
/* Read records up to the maximum distance that is possibly */
/* required, looking for our target TLID. */
/* -------------------------------------------------------------------- */
int nMaxChainToRead = nChainId - iTestChain;
int nChainsRead = 0;
char achShapeRec[OGR_TIGER_RECBUF_LEN];
int nShapeRecLen = psRT2Info->nRecordLength + nRecordLength - psRT1Info->nRecordLength;
while( nChainsRead < nMaxChainToRead )
{
if( VSIFSeekL( fpShape, (nWorkingRecId-1) * nShapeRecLen,
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s2",
(nWorkingRecId-1) * nShapeRecLen, pszModule );
return -2;
}
if( VSIFReadL( achShapeRec, psRT2Info->nRecordLength, 1, fpShape ) != 1 )
{
if( !VSIFEofL( fpShape ) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %s2",
nWorkingRecId-1, pszModule );
return -2;
}
else
return -1;
}
if( atoi(GetField(achShapeRec,6,15)) == nTLID )
{
panShapeRecordId[nChainId] = nWorkingRecId;
return nWorkingRecId;
}
if( atoi(GetField(achShapeRec,16,18)) == 1 )
{
nChainsRead++;
}
nWorkingRecId++;
}
panShapeRecordId[nChainId] = -1;
return -1;
}
int TigerCompleteChain::SetModule( const char * pszModule )
{
if( !OpenFile( pszModule, "1" ) )
return FALSE;
EstablishFeatureCount();
/* -------------------------------------------------------------------- */
/* Is this a copyright record inserted at the beginning of the */
/* RT1 file by the folks at GDT? If so, setup to ignore the */
/* first record. */
/* -------------------------------------------------------------------- */
nRT1RecOffset = 0;
if( pszModule )
{
char achHeader[10];
VSIFSeekL( fpPrimary, 0, SEEK_SET );
VSIFReadL( achHeader, sizeof(achHeader), 1, fpPrimary );
if( EQUALN(achHeader,"Copyright",8) )
{
nRT1RecOffset = 1;
nFeatures--;
}
}
/* -------------------------------------------------------------------- */
/* Open the RT3 file */
/* -------------------------------------------------------------------- */
if( bUsingRT3 )
{
if( fpRT3 != NULL )
{
VSIFCloseL( fpRT3 );
fpRT3 = NULL;
}
if( pszModule )
{
char *pszFilename;
pszFilename = poDS->BuildFilename( pszModule, "3" );
fpRT3 = VSIFOpenL( pszFilename, "rb" );
CPLFree( pszFilename );
}
}
/* -------------------------------------------------------------------- */
/* Close the shape point file, if open and free the list of */
/* record ids. */
/* -------------------------------------------------------------------- */
if( fpShape != NULL )
{
VSIFCloseL( fpShape );
fpShape = NULL;
}
CPLFree( panShapeRecordId );
panShapeRecordId = NULL;
/* -------------------------------------------------------------------- */
/* Try to open the RT2 file corresponding to this RT1 file. */
/* -------------------------------------------------------------------- */
if( pszModule != NULL )
{
char *pszFilename;
pszFilename = poDS->BuildFilename( pszModule, "2" );
fpShape = VSIFOpenL( pszFilename, "rb" );
if( fpShape == NULL )
{
if( nRT1RecOffset == 0 )
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, intermediate shape arcs will not be available.\n",
pszFilename );
}
else
panShapeRecordId = (int *)CPLCalloc(sizeof(int),GetFeatureCount());
CPLFree( pszFilename );
}
return TRUE;
}
void OGRILI1Layer::PolygonizeAreaLayer()
{
if (poAreaLineLayer == 0) return;
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != poAreaReferenceLayer->GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", poAreaReferenceLayer->GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),polys->getNumGeometries());
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS();
if (!GEOSisValid(ahInGeoms[i])) ahInGeoms[i] = NULL;
}
poAreaReferenceLayer->ResetReading();
while (OGRFeature *feature = poAreaReferenceLayer->GetNextFeatureRef())
{
GEOSGeom point = (GEOSGeom)feature->GetGeometryRef()->exportToGEOS();
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin(point, ahInGeoms[i]))
{
OGRFeature* areaFeature = feature->Clone();
areaFeature->SetGeometry( polys->getGeometryRef(i) );
AddFeature(areaFeature);
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy( point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy( ahInGeoms[i] );
CPLFree( ahInGeoms );
#endif
poAreaReferenceLayer = 0;
poAreaLineLayer = 0;
}
OGRErr OGRGeoconceptLayer::CreateField( OGRFieldDefn *poField, int bApproxOK )
{
if( GetGCMode_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature))==vReadAccess_GCIO )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create fields on a read-only Geoconcept layer.\n");
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Add field to layer */
/* -------------------------------------------------------------------- */
{
/* check whether field exists ... */
GCField* theField;
char* pszName = OGRGeoconceptLayer_GetCompatibleFieldName(poField->GetNameRef());
if( !(theField= FindFeatureField_GCIO(_gcFeature,pszName)) )
{
if( GetFeatureCount(TRUE) > 0 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create field '%s' on existing Geoconcept layer '%s.%s'.\n",
pszName,
GetSubTypeName_GCIO(_gcFeature),
GetTypeName_GCIO(GetSubTypeType_GCIO(_gcFeature)) );
CPLFree(pszName);
return OGRERR_FAILURE;
}
if( GetSubTypeNbFields_GCIO(_gcFeature)==-1)
SetSubTypeNbFields_GCIO(_gcFeature, 0L);
if( !(theField= AddSubTypeField_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature),
GetTypeName_GCIO(GetSubTypeType_GCIO(_gcFeature)),
GetSubTypeName_GCIO(_gcFeature),
FindFeatureFieldIndex_GCIO(_gcFeature,kNbFields_GCIO)
+GetSubTypeNbFields_GCIO(_gcFeature)+1L,
pszName,
GetSubTypeNbFields_GCIO(_gcFeature)-999L,
vUnknownItemType_GCIO, NULL, NULL)) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Field '%s' could not be created for Feature %s.%s.\n",
pszName,
GetSubTypeName_GCIO(_gcFeature),
GetTypeName_GCIO(GetSubTypeType_GCIO(_gcFeature))
);
CPLFree(pszName);
return OGRERR_FAILURE;
}
SetSubTypeNbFields_GCIO(_gcFeature, GetSubTypeNbFields_GCIO(_gcFeature)+1L);
_poFeatureDefn->AddFieldDefn(poField);
}
else
{
if( _poFeatureDefn->GetFieldIndex(GetFieldName_GCIO(theField))==-1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Field %s not found for Feature %s.%s.\n",
GetFieldName_GCIO(theField),
GetSubTypeName_GCIO(_gcFeature),
GetTypeName_GCIO(GetSubTypeType_GCIO(_gcFeature))
);
CPLFree(pszName);
return OGRERR_FAILURE;
}
}
CPLFree(pszName);
pszName = NULL;
/* check/update type ? */
if( GetFieldKind_GCIO(theField)==vUnknownItemType_GCIO )
{
switch(poField->GetType()) {
case OFTInteger :
SetFieldKind_GCIO(theField,vIntFld_GCIO);
break;
case OFTReal :
SetFieldKind_GCIO(theField,vRealFld_GCIO);
break;
case OFTDate :
SetFieldKind_GCIO(theField,vDateFld_GCIO);
break;
case OFTTime :
case OFTDateTime :
SetFieldKind_GCIO(theField,vTimeFld_GCIO);
break;
case OFTString :
SetFieldKind_GCIO(theField,vMemoFld_GCIO);
break;
case OFTIntegerList :
case OFTRealList :
case OFTStringList :
case OFTBinary :
default :
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create fields of type %s on Geoconcept feature %s.\n",
OGRFieldDefn::GetFieldTypeName(poField->GetType()),
_poFeatureDefn->GetName() );
return OGRERR_FAILURE;
}
}
}
return OGRERR_NONE;
}
OGRErr OGRGeoconceptLayer::CreateFeature( OGRFeature* poFeature )
{
OGRwkbGeometryType eGt;
OGRGeometry* poGeom;
int nextField, iGeom, nbGeom, isSingle;
poGeom= poFeature->GetGeometryRef();
if (poGeom == NULL)
{
CPLError( CE_Warning, CPLE_NotSupported,
"NULL geometry not supported in Geoconcept, feature skipped.\n");
return OGRERR_NONE;
}
eGt= poGeom->getGeometryType();
switch( eGt ) {
case wkbPoint :
case wkbPoint25D :
case wkbMultiPoint :
case wkbMultiPoint25D :
if( GetSubTypeKind_GCIO(_gcFeature)==vUnknownItemType_GCIO )
{
SetSubTypeKind_GCIO(_gcFeature,vPoint_GCIO);
}
else if( GetSubTypeKind_GCIO(_gcFeature)!=vPoint_GCIO )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't write non ponctual feature in a ponctual Geoconcept layer %s.\n",
_poFeatureDefn->GetName());
return OGRERR_FAILURE;
}
break;
case wkbLineString :
case wkbLineString25D :
case wkbMultiLineString :
case wkbMultiLineString25D :
if( GetSubTypeKind_GCIO(_gcFeature)==vUnknownItemType_GCIO )
{
SetSubTypeKind_GCIO(_gcFeature,vLine_GCIO);
}
else if( GetSubTypeKind_GCIO(_gcFeature)!=vLine_GCIO )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't write non linear feature in a linear Geoconcept layer %s.\n",
_poFeatureDefn->GetName());
return OGRERR_FAILURE;
}
break;
case wkbPolygon :
case wkbPolygon25D :
case wkbMultiPolygon :
case wkbMultiPolygon25D :
if( GetSubTypeKind_GCIO(_gcFeature)==vUnknownItemType_GCIO )
{
SetSubTypeKind_GCIO(_gcFeature,vPoly_GCIO);
}
else if( GetSubTypeKind_GCIO(_gcFeature)!=vPoly_GCIO )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't write non polygonal feature in a polygonal Geoconcept layer %s.\n",
_poFeatureDefn->GetName());
return OGRERR_FAILURE;
}
break;
case wkbUnknown :
case wkbGeometryCollection :
case wkbGeometryCollection25D :
case wkbNone :
case wkbLinearRing :
default :
CPLError( CE_Warning, CPLE_AppDefined,
"Geometry type %s not supported in Geoconcept, feature skipped.\n",
OGRGeometryTypeToName(eGt) );
return OGRERR_NONE;
}
if( GetSubTypeDim_GCIO(_gcFeature)==vUnknown3D_GCIO )
{
if( poGeom->getCoordinateDimension()==3 )
{
SetSubTypeDim_GCIO(_gcFeature,v3D_GCIO);
}
else
{
SetSubTypeDim_GCIO(_gcFeature,v2D_GCIO);
}
}
switch( eGt ) {
case wkbPoint :
case wkbPoint25D :
nbGeom= 1;
isSingle= TRUE;
break;
case wkbMultiPoint :
case wkbMultiPoint25D :
nbGeom= ((OGRGeometryCollection*)poGeom)->getNumGeometries();
isSingle= FALSE;
break;
case wkbLineString :
case wkbLineString25D :
nbGeom= 1;
isSingle= TRUE;
break;
case wkbMultiLineString :
case wkbMultiLineString25D :
nbGeom= ((OGRGeometryCollection*)poGeom)->getNumGeometries();
isSingle= FALSE;
break;
case wkbPolygon :
case wkbPolygon25D :
nbGeom= 1;
isSingle= TRUE;
break;
case wkbMultiPolygon :
case wkbMultiPolygon25D :
nbGeom= ((OGRGeometryCollection*)poGeom)->getNumGeometries();
isSingle= FALSE;
break;
case wkbUnknown :
case wkbGeometryCollection :
case wkbGeometryCollection25D :
case wkbNone :
case wkbLinearRing :
default :
nbGeom= 0;
isSingle= FALSE;
break;
}
/* 1st feature, let's write header : */
if( GetGCMode_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature)) == vWriteAccess_GCIO &&
GetFeatureCount(TRUE) == 0 )
if( WriteHeader_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature))==NULL )
{
return OGRERR_FAILURE;
}
if( nbGeom>0 )
{
for( iGeom= 0; iGeom<nbGeom; iGeom++ )
{
nextField= StartWritingFeature_GCIO(_gcFeature,
isSingle? poFeature->GetFID():OGRNullFID);
while (nextField!=WRITECOMPLETED_GCIO)
{
if( nextField==WRITEERROR_GCIO )
{
return OGRERR_FAILURE;
}
if( nextField==GEOMETRYEXPECTED_GCIO )
{
OGRGeometry* poGeomPart=
isSingle? poGeom:((OGRGeometryCollection*)poGeom)->getGeometryRef(iGeom);
nextField= WriteFeatureGeometry_GCIO(_gcFeature,
(OGRGeometryH)poGeomPart);
}
else
{
int iF, nF;
OGRFieldDefn *poField;
GCField* theField= GetSubTypeField_GCIO(_gcFeature,nextField);
/* for each field, find out its mapping ... */
if( (nF= poFeature->GetFieldCount())>0 )
{
for( iF= 0; iF<nF; iF++ )
{
poField= poFeature->GetFieldDefnRef(iF);
char* pszName = OGRGeoconceptLayer_GetCompatibleFieldName(poField->GetNameRef());
if( EQUAL(pszName, GetFieldName_GCIO(theField)) )
{
CPLFree(pszName);
nextField= WriteFeatureFieldAsString_GCIO(_gcFeature,
nextField,
poFeature->IsFieldSet(iF)?
poFeature->GetFieldAsString(iF)
:
NULL);
break;
}
CPLFree(pszName);
}
if( iF==nF )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Can't find a field attached to %s on Geoconcept layer %s.\n",
GetFieldName_GCIO(theField), _poFeatureDefn->GetName());
return OGRERR_FAILURE;
}
}
else
{
nextField= WRITECOMPLETED_GCIO;
}
}
}
StopWritingFeature_GCIO(_gcFeature);
}
}
return OGRERR_NONE;
}
void OGRILI1Layer::PolygonizeAreaLayer( OGRILI1Layer* poAreaLineLayer, int nAreaFieldIndex, int nPointFieldIndex )
{
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
poAreaLineLayer = 0;
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: " CPL_FRMT_GIB, GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*), polys->getNumGeometries());
GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext();
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(hGEOSCtxt);
if (!GEOSisValid_r(hGEOSCtxt, ahInGeoms[i])) ahInGeoms[i] = NULL;
}
for ( int nFidx = 0; nFidx < nFeatures; nFidx++)
{
OGRFeature *feature = papoFeatures[nFidx];
OGRGeometry* geomRef = feature->GetGeomFieldRef(nPointFieldIndex);
if( !geomRef )
{
continue;
}
GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS(hGEOSCtxt));
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin_r(hGEOSCtxt, point, ahInGeoms[i]))
{
feature->SetGeomField(nAreaFieldIndex, polys->getGeometryRef(i));
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy_r( hGEOSCtxt, point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] );
CPLFree( ahInGeoms );
OGRGeometry::freeGEOSContext( hGEOSCtxt );
#endif
poAreaLineLayer = 0;
delete polys;
}
