OGRErr OGRCreateFromGeomedia( GByte *pabyGeom,
OGRGeometry **ppoGeom,
int nBytes )
{
*ppoGeom = NULL;
if( nBytes < 16 )
return OGRERR_FAILURE;
if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) )
return OGRERR_FAILURE;
int nGeomType = pabyGeom[0];
pabyGeom += 16;
nBytes -= 16;
if( nGeomType == GEOMEDIA_POINT ||
nGeomType == GEOMEDIA_ORIENTED_POINT )
{
if (nBytes < 3 * 8)
return OGRERR_FAILURE;
double dfX, dfY, dfZ;
memcpy(&dfX, pabyGeom, 8);
CPL_LSBPTR64(&dfX);
memcpy(&dfY, pabyGeom + 8, 8);
CPL_LSBPTR64(&dfY);
memcpy(&dfZ, pabyGeom + 16, 8);
CPL_LSBPTR64(&dfZ);
*ppoGeom = new OGRPoint( dfX, dfY, dfZ );
return OGRERR_NONE;
}
else if ( nGeomType == GEOMEDIA_POLYLINE )
{
if (nBytes < 4)
return OGRERR_FAILURE;
int nPoints;
memcpy(&nPoints, pabyGeom, 4);
CPL_LSBPTR32(&nPoints);
pabyGeom += 4;
nBytes -= 4;
if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24)
return OGRERR_FAILURE;
OGRLineString* poLS = new OGRLineString();
poLS->setNumPoints(nPoints);
int i;
for(i=0;i<nPoints;i++)
{
double dfX, dfY, dfZ;
memcpy(&dfX, pabyGeom, 8);
CPL_LSBPTR64(&dfX);
memcpy(&dfY, pabyGeom + 8, 8);
CPL_LSBPTR64(&dfY);
memcpy(&dfZ, pabyGeom + 16, 8);
CPL_LSBPTR64(&dfZ);
poLS->setPoint(i, dfX, dfY, dfZ);
pabyGeom += 24;
}
*ppoGeom = poLS;
return OGRERR_NONE;
}
else if ( nGeomType == GEOMEDIA_POLYGON )
{
if (nBytes < 4)
return OGRERR_FAILURE;
int nPoints;
memcpy(&nPoints, pabyGeom, 4);
CPL_LSBPTR32(&nPoints);
pabyGeom += 4;
nBytes -= 4;
if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24)
return OGRERR_FAILURE;
OGRLinearRing* poRing = new OGRLinearRing();
poRing->setNumPoints(nPoints);
int i;
for(i=0;i<nPoints;i++)
{
double dfX, dfY, dfZ;
memcpy(&dfX, pabyGeom, 8);
CPL_LSBPTR64(&dfX);
memcpy(&dfY, pabyGeom + 8, 8);
CPL_LSBPTR64(&dfY);
memcpy(&dfZ, pabyGeom + 16, 8);
CPL_LSBPTR64(&dfZ);
poRing->setPoint(i, dfX, dfY, dfZ);
pabyGeom += 24;
}
OGRPolygon* poPoly = new OGRPolygon();
poPoly->addRingDirectly(poRing);
*ppoGeom = poPoly;
return OGRERR_NONE;
}
else if ( nGeomType == GEOMEDIA_BOUNDARY )
{
if (nBytes < 4)
return OGRERR_FAILURE;
int nExteriorSize;
memcpy(&nExteriorSize, pabyGeom, 4);
CPL_LSBPTR32(&nExteriorSize);
pabyGeom += 4;
nBytes -= 4;
if (nBytes < nExteriorSize)
return OGRERR_FAILURE;
OGRGeometry* poExteriorGeom = NULL;
if (OGRCreateFromGeomedia( pabyGeom, &poExteriorGeom, nExteriorSize ) != OGRERR_NONE)
return OGRERR_FAILURE;
if ( wkbFlatten( poExteriorGeom->getGeometryType() ) != wkbPolygon )
{
delete poExteriorGeom;
return OGRERR_FAILURE;
}
pabyGeom += nExteriorSize;
nBytes -= nExteriorSize;
if (nBytes < 4)
{
delete poExteriorGeom;
return OGRERR_FAILURE;
}
int nInteriorSize;
memcpy(&nInteriorSize, pabyGeom, 4);
CPL_LSBPTR32(&nInteriorSize);
pabyGeom += 4;
nBytes -= 4;
if (nBytes < nInteriorSize)
{
delete poExteriorGeom;
return OGRERR_FAILURE;
}
OGRGeometry* poInteriorGeom = NULL;
if (OGRCreateFromGeomedia( pabyGeom, &poInteriorGeom, nInteriorSize ) != OGRERR_NONE)
{
delete poExteriorGeom;
return OGRERR_FAILURE;
}
OGRwkbGeometryType interiorGeomType = wkbFlatten( poInteriorGeom->getGeometryType() );
if ( interiorGeomType == wkbPolygon )
{
((OGRPolygon*)poExteriorGeom)->addRing(((OGRPolygon*)poInteriorGeom)->getExteriorRing());
}
else if ( interiorGeomType == wkbMultiPolygon )
{
int numGeom = ((OGRMultiPolygon*)poInteriorGeom)->getNumGeometries();
for ( int i = 0; i < numGeom; ++i )
{
OGRPolygon* poInteriorPolygon =
(OGRPolygon*)((OGRMultiPolygon*)poInteriorGeom)->getGeometryRef(i);
((OGRPolygon*)poExteriorGeom)->addRing( poInteriorPolygon->getExteriorRing() );
}
}
else
{
delete poExteriorGeom;
delete poInteriorGeom;
return OGRERR_FAILURE;
}
delete poInteriorGeom;
*ppoGeom = poExteriorGeom;
return OGRERR_NONE;
}
else if ( nGeomType == GEOMEDIA_COLLECTION ||
nGeomType == GEOMEDIA_MULTILINE ||
nGeomType == GEOMEDIA_MULTIPOLYGON )
{
if (nBytes < 4)
return OGRERR_FAILURE;
int i;
int nParts;
memcpy(&nParts, pabyGeom, 4);
CPL_LSBPTR32(&nParts);
pabyGeom += 4;
nBytes -= 4;
if (nParts < 0 || nParts > INT_MAX / (4 + 16) || nBytes < nParts * (4 + 16))
return OGRERR_FAILURE;
/* Can this collection be considered as a multipolyline or multipolygon ? */
if ( nGeomType == GEOMEDIA_COLLECTION )
{
GByte* pabyGeomBackup = pabyGeom;
int nBytesBackup = nBytes;
int bAllPolyline = TRUE;
int bAllPolygon = TRUE;
for(i=0;i<nParts;i++)
{
if (nBytes < 4)
return OGRERR_FAILURE;
int nSubBytes;
memcpy(&nSubBytes, pabyGeom, 4);
CPL_LSBPTR32(&nSubBytes);
if (nSubBytes < 0)
{
return OGRERR_FAILURE;
}
pabyGeom += 4;
nBytes -= 4;
if (nBytes < nSubBytes)
{
return OGRERR_FAILURE;
}
if( nSubBytes < 16 )
return OGRERR_FAILURE;
if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) )
return OGRERR_FAILURE;
int nSubGeomType = pabyGeom[0];
if ( nSubGeomType != GEOMEDIA_POLYLINE )
bAllPolyline = FALSE;
if ( nSubGeomType != GEOMEDIA_POLYGON )
bAllPolygon = FALSE;
pabyGeom += nSubBytes;
nBytes -= nSubBytes;
}
pabyGeom = pabyGeomBackup;
nBytes = nBytesBackup;
if (bAllPolyline)
nGeomType = GEOMEDIA_MULTILINE;
else if (bAllPolygon)
nGeomType = GEOMEDIA_MULTIPOLYGON;
}
OGRGeometryCollection* poColl = (nGeomType == GEOMEDIA_MULTILINE) ? new OGRMultiLineString() :
(nGeomType == GEOMEDIA_MULTIPOLYGON) ? new OGRMultiPolygon() :
new OGRGeometryCollection();
for(i=0;i<nParts;i++)
{
if (nBytes < 4)
return OGRERR_FAILURE;
int nSubBytes;
memcpy(&nSubBytes, pabyGeom, 4);
CPL_LSBPTR32(&nSubBytes);
if (nSubBytes < 0)
{
delete poColl;
return OGRERR_FAILURE;
}
pabyGeom += 4;
nBytes -= 4;
if (nBytes < nSubBytes)
{
delete poColl;
return OGRERR_FAILURE;
}
OGRGeometry* poSubGeom = NULL;
if (OGRCreateFromGeomedia( pabyGeom, &poSubGeom, nSubBytes ) == OGRERR_NONE)
{
if (wkbFlatten(poColl->getGeometryType()) == wkbMultiPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbLineString)
{
OGRPolygon* poPoly = new OGRPolygon();
OGRLinearRing* poRing = new OGRLinearRing();
poRing->addSubLineString((OGRLineString*)poSubGeom);
poPoly->addRingDirectly(poRing);
delete poSubGeom;
poSubGeom = poPoly;
}
if (poColl->addGeometryDirectly(poSubGeom) != OGRERR_NONE)
{
//printf("%d %d\n", poColl->getGeometryType() & ~wkb25DBit, poSubGeom->getGeometryType() & ~wkb25DBit);
delete poSubGeom;
}
}
pabyGeom += nSubBytes;
nBytes -= nSubBytes;
}
*ppoGeom = poColl;
return OGRERR_NONE;
}
else
{
CPLDebug("GEOMEDIA", "Unhandled type %d", nGeomType);
}
return OGRERR_FAILURE;
}
OGRFeature *OGRMDBLayer::GetNextRawFeature()
{
OGRErr err = OGRERR_NONE;
if( !poMDBTable->GetNextRow() )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poMDBTable->GetColumnIndex(pszFIDColumn) > -1 )
poFeature->SetFID(
poMDBTable->GetColumnAsInt(poMDBTable->GetColumnIndex(pszFIDColumn)) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
int iSrcField = panFieldOrdinals[iField]-1;
char *pszValue = poMDBTable->GetColumnAsString( iSrcField );
OGRFieldType eType = poFeature->GetFieldDefnRef(iField)->GetType();
if( pszValue == NULL )
/* no value */;
else if( eType == OFTBinary )
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iSrcField, &nBytes);
poFeature->SetField( iField,
nBytes,
pData );
CPLFree(pData);
}
else if ( eType == OFTInteger && EQUAL(pszValue, "true"))
{
poFeature->SetField( iField, 1 );
}
else
{
poFeature->SetField( iField, pszValue );
}
CPLFree(pszValue);
}
if( !(m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( eGeometryType == MDB_GEOM_PGEO && iGeomColumn >= 0)
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes);
OGRGeometry *poGeom = NULL;
if( pData != NULL )
{
err = OGRCreateFromShapeBin( pData, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "MDB",
"Translation shape binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
CPLFree(pData);
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
else if( eGeometryType == MDB_GEOM_GEOMEDIA && iGeomColumn >= 0)
{
int nBytes = 0;
GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes);
OGRGeometry *poGeom = NULL;
if( pData != NULL )
{
err = OGRCreateFromGeomedia( pData, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "MDB",
"Translation geomedia binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
CPLFree(pData);
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
OGRFeature *OGRGeomediaLayer::GetNextRawFeature()
{
OGRErr err = OGRERR_NONE;
if( GetStatement() == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !poStmt->Fetch() )
{
delete poStmt;
poStmt = NULL;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
int iSrcField = panFieldOrdinals[iField]-1;
const char *pszValue = poStmt->GetColData( iSrcField );
if( pszValue == NULL )
/* no value */;
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iField = poStmt->GetColId( pszGeomColumn );
GByte *pabyShape = (GByte *) poStmt->GetColData( iField );
int nBytes = poStmt->GetColDataLength(iField);
OGRGeometry *poGeom = NULL;
if( pabyShape != NULL )
{
err = OGRCreateFromGeomedia( pabyShape, &poGeom, nBytes );
if( OGRERR_NONE != err )
{
CPLDebug( "Geomedia",
"Translation geomedia binary to OGR geometry failed (FID=%ld)",
(long)poFeature->GetFID() );
}
}
if( poGeom != NULL && OGRERR_NONE == err )
{
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
