Ticket #1735: gdal_svn_bna.patch

ogr/ogrsf_frmts/ogr_formats.html

@@ -20 +20 @@
-</td><td> Yes
-</td></tr>
-
+<tr><td> <a href="drv_bna.html">Atlas BNA</a>
+</td><td> Yes
+</td><td> No
+</td></tr>
+
-<tr><td> <a href="drv_csv.html">Comma Separated Value (.csv)</a>
-</td><td> Yes
-</td><td> No

ogr/ogrsf_frmts/bna/makefile.vc

@@ -2 +2 @@
-OBJ     =       ogrbnadriver.obj ogrbnadatasource.obj ogrbnalayer.obj \
-                ogrbnaparser.obj
-
-
+ $(GEOS_CFLAGS)
-
-GDAL_ROOT       =       ..\..\..
-

ogr/ogrsf_frmts/bna/ogrbnadatasource.cpp

@@ -42 +42 @@
-{
-    papoLayers = NULL;
-    nLayers = 0;
+    
+    fpOutput = NULL;
-
-    pszName = NULL;
+    
+    pszCoordinateSeparator = NULL;
-
-    bUpdate = FALSE;
-}
@@ -55 +59 @@
-OGRBNADataSource::~OGRBNADataSource()
-
-{
+    if ( fpOutput != NULL )
+    {
+        VSIFClose( fpOutput);
+    }
+
-    for( int i = 0; i < nLayers; i++ )
-        delete papoLayers[i];
-    CPLFree( papoLayers );
+    
+    CPLFree( pszCoordinateSeparator );
-
-    CPLFree( pszName );
-}
@@ -70 +81 @@
-
-{
-    if( EQUAL(pszCap,ODsCCreateLayer) )
-FALS
+TRU
-    else if( EQUAL(pszCap,ODsCDeleteLayer) )
-        return FALSE;
-    else
@@ -91 +102 @@
-}
-
-/************************************************************************/
+/*                            CreateLayer()                             */
+/************************************************************************/
+
+OGRLayer * OGRBNADataSource::CreateLayer( const char * pszLayerName,
+                                          OGRSpatialReference *poSRS,
+                                          OGRwkbGeometryType eType,
+                                          char ** papszOptions )
+
+{
+    BNAFeatureType bnaFeatureType;
+    
+    switch(eType)
+    {
+        case wkbPolygon:
+        case wkbPolygon25D:
+        case wkbMultiPolygon:
+        case wkbMultiPolygon25D:
+            bnaFeatureType = BNA_POLYGON;
+            break;
+        
+        case wkbPoint:
+        case wkbPoint25D:
+            bnaFeatureType = BNA_POINT;
+            break;
+            
+        case wkbLineString:
+        case wkbLineString25D:
+            bnaFeatureType = BNA_POLYLINE;
+            break;
+            
+        default:
+            CPLError( CE_Failure, CPLE_NotSupported,
+                    "Geometry type of `%s' not supported in BNAs.\n",
+                    OGRGeometryTypeToName(eType) );
+            return NULL;
+    }
+    
+    nLayers++;
+    papoLayers = (OGRBNALayer **) CPLRealloc(papoLayers, nLayers * sizeof(OGRBNALayer*));
+    papoLayers[nLayers-1] = new OGRBNALayer( pszName, pszLayerName, bnaFeatureType, eType, TRUE, this );
+    
+    return papoLayers[nLayers-1];
+}
+
+/************************************************************************/
-/*                                Open()                                */
-/************************************************************************/
-
@@ -115 +171 @@
-// --------------------------------------------------------------------
-    if( !EQUAL( CPLGetExtension(pszFilename), "bna" ) )
-        return FALSE;
-
- = VSIFOpen(pszFilename, "rb
-
+
+p = VSIFOpen(pszFilename, "r
+p
-    {
-        BNARecord* record;
-        int curLine = 0;
-
+
+
+
+
+
-        BNA_FreeRecord(record);
-
-        if (ok)
@@ -129 +189 @@
-            nLayers = 4;
-
-            papoLayers = (OGRBNALayer **) CPLMalloc(nLayers * sizeof(OGRBNALayer*));
-papoLayers[0] = new OGRBNALayer( pszFilename, "points", BNA_POINT, wkbPoint );
-papoLayers[1] = new OGRBNALayer( pszFilename, "lines", BNA_POLYLINE, wkbLineString );
-papoLayers[2] = new OGRBNALayer( pszFilename, "polygons", BNA_POLYGON, wkbMultiPolygon );
-papoLayers[3] = new OGRBNALayer( pszFilename, "ellipses", BNA_ELLIPSE, wkbPolygon
+for(i=0;i<4;i++)
+    papoLayers[i] = new OGRBNALayer( pszFilename,
+                                     layerRadixName[i],
+                                     (BNAFeatureType)i, wkbGeomTypes[i], FALSE, this
-        }
+#else
+        int nFeatures[4] = { 0, 0, 0, 0 };
+        OffsetAndLine* offsetAndLineFeaturesTable[4] = { NULL, NULL, NULL, NULL };
+        int nIDs[4] = {0, 0, 0, 0};
+        int partialIndexTable = TRUE;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-    return ok;
-}
-
+
+/************************************************************************/
+/*                               Create()                               */
+/************************************************************************/
+
+int OGRBNADataSource::Create( const char *pszFilename, 
+                              char **papszOptions )
+{
+    if( fpOutput != NULL)
+    {
+        CPLAssert( FALSE );
+        return FALSE;
+    }
+
+/* -------------------------------------------------------------------- */
+/*     Do not override exiting file.                                    */
+/* -------------------------------------------------------------------- */
+    VSIStatBufL sStatBuf;
+
+    if( VSIStatL( pszFilename, &sStatBuf ) == 0 )
+        return FALSE;
+    
+/* -------------------------------------------------------------------- */
+/*      Create the output file.                                         */
+/* -------------------------------------------------------------------- */
+    pszName = CPLStrdup( pszFilename );
+
+    if( EQUAL(pszFilename,"stdout") )
+        fpOutput = stdout;
+    else
+        fpOutput = VSIFOpen( pszFilename, "w" );
+    if( fpOutput == NULL )
+    {
+        CPLError( CE_Failure, CPLE_OpenFailed, 
+                  "Failed to create BNA file %s.", 
+                  pszFilename );
+        return FALSE;
+    }
+    
+    /* EOL token */
+    const char *pszCRLFFormat = CSLFetchNameValue( papszOptions, "LINEFORMAT");
+
+    if( pszCRLFFormat == NULL )
+    {
+#ifdef WIN32
+        bUseCRLF = TRUE;
+#else
+        bUseCRLF = FALSE;
+#endif
+    }
+    else if( EQUAL(pszCRLFFormat,"CRLF") )
+        bUseCRLF = TRUE;
+    else if( EQUAL(pszCRLFFormat,"LF") )
+        bUseCRLF = FALSE;
+    else
+    {
+        CPLError( CE_Warning, CPLE_AppDefined, 
+                  "LINEFORMAT=%s not understood, use one of CRLF or LF.",
+                  pszCRLFFormat );
+#ifdef WIN32
+        bUseCRLF = TRUE;
+#else
+        bUseCRLF = FALSE;
+#endif
+    }
+
+    /* Multi line or single line format ? */
+    bMultiLine = CSLFetchBoolean( papszOptions, "MULTILINE", TRUE);
+    
+    /* Number of identifiers per record */
+    const char* pszNbOutID = CSLFetchNameValue ( papszOptions, "NB_IDS");
+    if (pszNbOutID == NULL)
+    {
+        nbOutID = NB_MIN_BNA_IDS;
+    }
+    else if (EQUAL(pszNbOutID, "NB_SOURCE_FIELDS"))
+    {
+        nbOutID = -1;
+    }
+    else
+    {
+        nbOutID = atoi(pszNbOutID);
+        if (nbOutID <= 0)
+        {
+            CPLError( CE_Warning, CPLE_AppDefined, 
+                  "NB_ID=%s not understood. Must be >=%d and <=%d or equal to NB_SOURCE_FIELDS",
+                  pszNbOutID, NB_MIN_BNA_IDS, NB_MAX_BNA_IDS );
+            nbOutID = NB_MIN_BNA_IDS;
+        }
+        if (nbOutID > NB_MAX_BNA_IDS)
+        {
+            CPLError( CE_Warning, CPLE_AppDefined, 
+                  "NB_ID=%s not understood. Must be >=%d and <=%d or equal to NB_SOURCE_FIELDS",
+                  pszNbOutID, NB_MIN_BNA_IDS, NB_MAX_BNA_IDS );
+            nbOutID = NB_MAX_BNA_IDS;
+        }
+    }
+    
+    /* Ellipses export as ellipses or polygons ? */
+    bEllipsesAsEllipses = CSLFetchBoolean( papszOptions, "ELLIPSES_AS_ELLIPSES", TRUE);
+    
+    /* Number of coordinate pairs per line */
+    const char* pszNbPairPerLine = CSLFetchNameValue( papszOptions, "NB_PAIRS_PER_LINE");
+    if (pszNbPairPerLine)
+    {
+        nbPairPerLine = atoi(pszNbPairPerLine);
+        if (nbPairPerLine <= 0)
+            nbPairPerLine = (bMultiLine == FALSE) ? 1000000000 : 1;
+        if (bMultiLine == FALSE)
+        {
+            CPLError( CE_Warning, CPLE_AppDefined, "NB_PAIR_PER_LINE option is ignored when MULTILINE=NO");
+        }
+    }
+    else
+    {
+        nbPairPerLine = (bMultiLine == FALSE) ? 1000000000 : 1;
+    }
+    
+    /* Coordinate precision */
+    const char* pszCoordinatePrecision = CSLFetchNameValue( papszOptions, "COORDINATE_PRECISION");
+    if (pszCoordinatePrecision)
+    {
+        coordinatePrecision = atoi(pszCoordinatePrecision);
+        if (coordinatePrecision <= 0)
+            coordinatePrecision = 0;
+        else if (coordinatePrecision >= 20)
+            coordinatePrecision = 20;
+    }
+    else
+    {
+        coordinatePrecision = 10;
+    }
+    
+    pszCoordinateSeparator = (char*)CSLFetchNameValue( papszOptions, "COORDINATE_SEPARATOR");
+    if (pszCoordinateSeparator == NULL)
+        pszCoordinateSeparator = CPLStrdup(",");
+    else
+        pszCoordinateSeparator = CPLStrdup(pszCoordinateSeparator);
+
+    return TRUE;
+}

ogr/ogrsf_frmts/bna/ogrbnadriver.cpp

@@ -68 +68 @@
-}
-
-/************************************************************************/
+/*                          CreateDataSource()                          */
+/************************************************************************/
+
+OGRDataSource *OGRBNADriver::CreateDataSource( const char * pszName,
+                                                 char **papszOptions )
+
+{
+    OGRBNADataSource   *poDS = new OGRBNADataSource();
+
+    if( !poDS->Create( pszName, papszOptions ) )
+    {
+        delete poDS;
+        poDS = NULL;
+    }
+
+    return poDS;
+}
+
+/************************************************************************/
+/*                          DeleteDataSource()                          */
+/************************************************************************/
+
+OGRErr OGRBNADriver::DeleteDataSource( const char *pszFilename )
+
+{
+    if( VSIUnlink( pszFilename ) == 0 )
+        return OGRERR_NONE;
+    else
+        return OGRERR_FAILURE;
+}
+
+/************************************************************************/
-/*                           TestCapability()                           */
-/************************************************************************/
-
@@ -75 +107 @@
-
-{
-    if( EQUAL(pszCap,ODrCCreateDataSource) )
-FALS
+TRU
-    else if( EQUAL(pszCap,ODrCDeleteDataSource) )
-FALS
+TRU
-    else
-        return FALSE;
-}

ogr/ogrsf_frmts/bna/ogrbnalayer.cpp

@@ -1 +1 @@
-/******************************************************************************
- 10646 2007-01-18 02:38:10Z warmerdam $
+
- *
- * Project:  BNA Translator
- * Purpose:  Implements OGRBNALayer class.
@@ -46 +46 @@
-OGRBNALayer::OGRBNALayer( const char *pszFilename,
-                          const char* layerName,
-                          BNAFeatureType bnaFeatureType,
-
+
+
+
+
-
-{
-    eof = FALSE;
-    failed = FALSE;
-    curLine = 0;
-    nNextFID = 0;
+    
+    this->bWriter = bWriter;
+    this->poDS = poDS;
+    this->nIDs = nIDs;
-
-    nFeatures = 0;
-    partialIndexTable = TRUE;
@@ -68 +75 @@
-    poFeatureDefn->SetGeomType( eLayerGeomType );
-    this->bnaFeatureType = bnaFeatureType;
-
-
-
+
-    {
-
+
+
-        {
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-
+
+
-        {
-
-
-
+
+
+
+
+
-        }
+
+        fpBNA = VSIFOpen( pszFilename, "r" );
+        if( fpBNA == NULL )
+            return;
-    }
-
-
+
-    {
-
-
-
-
-
+
-    }
-
-    fpBNA = VSIFOpen( pszFilename, "rb" );
-    if( fpBNA == NULL )
-        return;
-}
-
-/************************************************************************/
@@ -115 +129 @@
-}
-
-/************************************************************************/
+/*                         SetFeatureIndexTable()                       */
+/************************************************************************/
+void  OGRBNALayer::SetFeatureIndexTable(int nFeatures, OffsetAndLine* offsetAndLineFeaturesTable, int partialIndexTable)
+{
+    this->nFeatures = nFeatures;
+    this->offsetAndLineFeaturesTable = offsetAndLineFeaturesTable;
+    this->partialIndexTable = partialIndexTable;
+}
+
+/************************************************************************/
-/*                            ResetReading()                            */
-/************************************************************************/
-
@@ -154 +178 @@
-        record =  BNA_GetNextRecord(fpBNA, &ok, &curLine, TRUE, bnaFeatureType);
-        if (ok == FALSE)
-        {
+            BNA_FreeRecord(record);
-            failed = TRUE;
-            return NULL;
-        }
@@ -161 +186 @@
-        {
-            /* end of file */
-            eof = TRUE;
-
+
-            /* and we have finally build the whole index table */
-            partialIndexTable = FALSE;
-            return NULL;
@@ -169 +194 @@
-
-        if (record->featureType == bnaFeatureType)
-        {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-        else
-        {
-            BNA_FreeRecord(record);
-        }
-    }
+}
+
+
+void OGRBNALayer::WriteFeatureAttributes(FILE* fp, OGRFeature *poFeature )
+{
+    int i;
+    OGRFieldDefn *poField;
+    int nbOutID = poDS->GetNbOutId();
+    if (nbOutID < 0)
+        nbOutID = poFeatureDefn->GetFieldCount();
+    for(i=0;i<nbOutID;i++)
+    { 
+        if (i < poFeatureDefn->GetFieldCount())
+        {
+            poField = poFeatureDefn->GetFieldDefn( i );
+            if( poFeature->IsFieldSet( i ) )
+            {
+                const char *pszRaw = poFeature->GetFieldAsString( i );
+                VSIFPrintf( fp, "\"%s\",", pszRaw);
+            }
+            else
+            {
+                VSIFPrintf( fp, "\"\",");
+            }
+        }
+        else
+        {
+            VSIFPrintf( fp, "\"\",");
+        }
+    }
+}
+
+/************************************************************************/
+/*                           CreateFeature()                            */
+/************************************************************************/
+
+OGRErr OGRBNALayer::CreateFeature( OGRFeature *poFeature )
+
+{
+    int i,j,k,n;
+    OGRGeometry     *poGeom = poFeature->GetGeometryRef();
+    char eol[3];
+    const char* partialEol = (poDS->GetMultiLine()) ? eol : poDS->GetCoordinateSeparator();
-    
-nNextFID >= nFeatures
+poDS->GetUseCRLF()
-    {
-
-
-
-
-
+
+
+
-    }
+    else
+    {
+        eol[0] = 10;
+        eol[1] = 0;
+    }
+    
+    if ( ! bWriter )
+    {
+        return OGRERR_FAILURE;
+    }
+    
+    if( poFeature->GetFID() == OGRNullFID )
+        poFeature->SetFID( nFeatures++ );
+    
+    FILE* fp = poDS->GetOutputFP();
+    int nbPairPerLine = poDS->GetNbPairPerLine();
+    char formatCoordinates[32];
+    sprintf(formatCoordinates, "%%s%%.%df%s%%.%df",
+            poDS->GetCoordinatePrecision(), poDS->GetCoordinateSeparator(), poDS->GetCoordinatePrecision());
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
+
+
-/************************************************************************/
-BuildFeatureFromBNARecord()
+ CreateField()   
-/************************************************************************/
+
+OGRErr OGRBNALayer::CreateField( OGRFieldDefn *poField, int bApproxOK )
+
+{
+    if( !bWriter || nFeatures != 0)
+        return OGRERR_FAILURE;
+
+    poFeatureDefn->AddFieldDefn( poField );
+
+    return OGRERR_NONE;
+}
+
+/************************************************************************/
+/*                           MakeMultiPolygon()                         */
+/************************************************************************/
+
+/* This is indeed of general use and may relate really closely with bug #1217 */
+/* If it works correctly, maybe a candidate for upper level exposition */ 
+
+enum
+{
+    CONTAINS,
+    IS_CONTAINED_BY,
+    NOT_RELATED
+};
+
+static OGRMultiPolygon *  MakeMultiPolygon (OGRPolygon** polygons,
+                                            int nbPolygons,
+                                            int* pIsValidGeometry)
+{
+    int i, j;
+    OGRMultiPolygon* multipolygon = new OGRMultiPolygon();
+    
+    if (nbPolygons == 1)
+    {
+        multipolygon->addGeometry(polygons[0]);
+    }
+    else
+    {
+#ifndef HAVE_GEOS
+        static int firstTime = 1;
+        if (firstTime)
+        {
+            CPLError(CE_Warning, CPLE_AppDefined, 
+                     "GDAL should be built with GEOS support enabled in order the "
+                     "BNA driver to provide reliable results on complex polygons.");
+            firstTime = 0;
+        }
+#endif
+
+        OGREnvelope* envelopes = new OGREnvelope[nbPolygons];
+        int** relations = new int*[nbPolygons];
+        double* areas = new double[nbPolygons];
+        int go_on = 1;
+        for(i=0;i<nbPolygons;i++)
+        {
+            relations[i] = new int[nbPolygons];
+            polygons[i]->getEnvelope(&envelopes[i]);
+            areas[i] = polygons[i]->get_Area();
+        }
+        
+        /* This a several step algorithm :
+           1) Compute in a matrix how polygons relate to each other
+              (this is the moment for detecting pathological intersections and exiting)
+           2) For each polygon, find the smallest enclosing polygon
+           3) For each polygon, compute its inclusion depth (0 means toplevel)
+           4) For each polygon of odd depth (= inner ring), add it to its outer ring
+        
+           Complexity : O(nbPolygons^2)
+        */
+        
+        /* Compute how each polygon relate to the other ones
+           To save a bit of computation we always begin the computation by a test on the
+           enveloppe. We also take into account the areas to avoid some useless tests.
+           (A contains B implies envelop(A) contains envelop(B) and area(A) > area(B))
+           In practise, we can hope that few full geometry intersection of inclusion test is done:
+             * if the polygons are well separated geographically
+                (a set of islands for example), no full geometry intersection or inclusion
+                test is done. (the envelopes don't intersect each other)
+             * if the polygons are 'lake inside an island inside a lake inside an area' and
+               that each polygon is much smaller than its enclosing one, their bounding boxes
+               are stricly contained into each oter, and thus, no full geometry intersection or inclusion
+               test is done
+        */
+        for(i=0;go_on && i<nbPolygons;i++)
+        {
+            for(j=i+1;go_on && j<nbPolygons;j++)
+            {
+                if (envelopes[i].Contains(envelopes[j])
+                    && areas[i] > areas[j]
+#ifdef HAVE_GEOS
+                    && polygons[i]->Contains(polygons[j])
+#endif
+                   )
+                {
+                    relations[i][j] = CONTAINS;
+                    relations[j][i] = IS_CONTAINED_BY;
+                }
+                else if (envelopes[j].Contains(envelopes[i])
+                         && areas[j] > areas[i]
+#ifdef HAVE_GEOS
+                         && polygons[j]->Contains(polygons[i])
+#endif
+                        )
+                {
+                    relations[j][i] = CONTAINS;
+                    rela