OGRErr OGRSQLiteSelectLayerCommonBehaviour::GetExtent(int iGeomField, OGREnvelope *psExtent, int bForce) { if( iGeomField < 0 || iGeomField >= poLayer->GetLayerDefn()->GetGeomFieldCount() || poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone ) { if( iGeomField != 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid geometry field index : %d", iGeomField); } return OGRERR_FAILURE; } /* Caching of extent by SQL string is interesting to speed-up the */ /* establishment of the WFS GetCapabilities document for a MapServer mapfile */ /* which has several layers, only differing by scale rules */ if( iGeomField == 0 ) { const OGREnvelope* psCachedExtent = poDS->GetEnvelopeFromSQL(osSQLBase); if (psCachedExtent) { memcpy(psExtent, psCachedExtent, sizeof(*psCachedExtent)); return OGRERR_NONE; } } CPLString osSQLCommand = osSQLBase; /* ORDER BY are costly to evaluate and are not necessary to establish */ /* the layer extent. */ size_t nOrderByPos = osSQLCommand.ifind(" ORDER BY "); if( osSQLCommand.ifind("SELECT ") == 0 && osSQLCommand.ifind("SELECT ", 1) == std::string::npos && /* Ensure there's no sub SELECT that could confuse our heuristics */ nOrderByPos != std::string::npos && osSQLCommand.ifind(" LIMIT ") == std::string::npos && osSQLCommand.ifind(" UNION ") == std::string::npos && osSQLCommand.ifind(" INTERSECT ") == std::string::npos && osSQLCommand.ifind(" EXCEPT ") == std::string::npos) { osSQLCommand.resize(nOrderByPos); OGRLayer* poTmpLayer = poDS->ExecuteSQL(osSQLCommand.c_str(), NULL, NULL); if (poTmpLayer) { OGRErr eErr = poTmpLayer->GetExtent(iGeomField, psExtent, bForce); poDS->ReleaseResultSet(poTmpLayer); return eErr; } } OGRErr eErr; if( iGeomField == 0 ) eErr = poLayer->BaseGetExtent(psExtent, bForce); else eErr = poLayer->BaseGetExtent(iGeomField, psExtent, bForce); if (iGeomField == 0 && eErr == OGRERR_NONE && poDS->GetUpdate() == FALSE) poDS->SetEnvelopeForSQL(osSQLBase, *psExtent); return eErr; }
int Raster::VectortoRaster(const char * sVectorSourcePath, const char * sRasterOutputPath, double dCellWidth, const char * psFieldName){ OGRRegisterAll(); OGRDataSource * pDSVectorInput; pDSVectorInput = OGRSFDriverRegistrar::Open( sVectorSourcePath, FALSE ); if (pDSVectorInput == NULL) return INPUT_FILE_ERROR; // Get the extents of the file before passing it off to the function that actually burns // the geometries // ------------------------------------------------------- // Note: we're just grabbing the first layer here. If we get into needing multiple layers // Then we'll need to re-think this. OGRLayer * poLayer = pDSVectorInput->GetLayer(0); if (poLayer == NULL) return VECTOR_LAYER_NOT_FOUND; OGREnvelope psExtent; poLayer->GetExtent(&psExtent, TRUE); double dMaxY, dMaxX, dMinY, dMinX; double cellWidth = fabs(dCellWidth); dMaxY = ceil(psExtent.MaxY / cellWidth) * cellWidth; dMaxX = ceil(psExtent.MaxX / cellWidth) * cellWidth; dMinY = floor(psExtent.MinY / cellWidth) * cellWidth; dMinX = floor(psExtent.MinX / cellWidth) * cellWidth; int nRows = (int)((dMaxY - dMinY) / cellWidth); int nCols = (int)((dMaxX - dMinX) / cellWidth); \ // We're going to create them without projections. The projections get set later. double fNoDataValue = (double) -std::numeric_limits<float>::max(); GDALDataType nDType = GDT_Float32; double dCellHeight = -dCellWidth; RasterMeta TemplateRaster(psExtent.MaxY, psExtent.MinX, nRows, nCols, &dCellHeight, &dCellWidth, &fNoDataValue, "GTiff", &nDType, ""); pDSVectorInput->Release(); return VectortoRaster(sVectorSourcePath, sRasterOutputPath, psFieldName, &TemplateRaster); }
OGRErr OGRSQLiteSelectLayer::GetExtent(OGREnvelope *psExtent, int bForce) { if (GetGeomType() == wkbNone) return OGRERR_FAILURE; /* Caching of extent by SQL string is interesting to speed-up the */ /* establishment of the WFS GetCapabilities document for a MapServer mapfile */ /* which has several layers, only differing by scale rules */ const OGREnvelope* psCachedExtent = poDS->GetEnvelopeFromSQL(osSQLBase); if (psCachedExtent) { memcpy(psExtent, psCachedExtent, sizeof(*psCachedExtent)); return OGRERR_NONE; } CPLString osSQLCommand = osSQLBase; /* ORDER BY are costly to evaluate and are not necessary to establish */ /* the layer extent. */ size_t nOrderByPos = osSQLCommand.ifind(" ORDER BY "); if( osSQLCommand.ifind("SELECT ") == 0 && nOrderByPos != std::string::npos && osSQLCommand.ifind(" LIMIT ") == std::string::npos && osSQLCommand.ifind(" UNION ") == std::string::npos && osSQLCommand.ifind(" INTERSECT ") == std::string::npos && osSQLCommand.ifind(" EXCEPT ") == std::string::npos) { osSQLCommand.resize(nOrderByPos); OGRLayer* poTmpLayer = poDS->ExecuteSQL(osSQLCommand.c_str(), NULL, NULL); if (poTmpLayer) { OGRErr eErr = poTmpLayer->GetExtent(psExtent, bForce); poDS->ReleaseResultSet(poTmpLayer); return eErr; } } OGRErr eErr = OGRSQLiteLayer::GetExtent(psExtent, bForce); if (eErr == OGRERR_NONE && poDS->GetUpdate() == FALSE) poDS->SetEnvelopeForSQL(osSQLBase, *psExtent); return eErr; }
bool rspfOgrVectorTileSource::open() { const char* MODULE = "rspfOgrVectorTileSource::open"; if (isOgrVectorDataSource() == false) { close(); return false; } if(isOpen()) { close(); } theDataSource = OGRSFDriverRegistrar::Open(theImageFile, false); if (theDataSource) { int layerCount = theDataSource->GetLayerCount(); theLayerVector.resize(layerCount); if(layerCount) { for(int i = 0; i < layerCount; ++i) { OGRLayer* layer = theDataSource->GetLayer(i); if(layer) { OGRSpatialReference* spatialReference = layer->GetSpatialRef(); if(!spatialReference) { if(traceDebug()) { rspfNotify(rspfNotifyLevel_NOTICE) << MODULE << " No spatial reference given, assuming geographic" << endl; } } } else { if(traceDebug()) { rspfNotify(rspfNotifyLevel_NOTICE) << MODULE << " layer " << i << " is null." << endl; } } if (layer) { layer->GetExtent(&theBoundingExtent, true); rspfRefPtr<rspfProjection> proj = createProjFromReference(layer->GetSpatialRef()); rspfRefPtr<rspfImageGeometry> imageGeometry = 0; bool isDefaultProjection = false; if(proj.valid()) { imageGeometry = new rspfImageGeometry(0, proj.get()); } rspfMapProjection* mapProj = 0; if(imageGeometry.valid()) { mapProj = PTR_CAST(rspfMapProjection, imageGeometry->getProjection()); } else { mapProj = createDefaultProj(); imageGeometry = new rspfImageGeometry(0, mapProj); isDefaultProjection = true; } if(mapProj) { rspfDrect rect(theBoundingExtent.MinX, theBoundingExtent.MaxY, theBoundingExtent.MaxX, theBoundingExtent.MinY, RSPF_RIGHT_HANDED); std::vector<rspfGpt> points; if (isDefaultProjection || mapProj->isGeographic()) { rspfGpt g1(rect.ul().y, rect.ul().x); rspfGpt g2(rect.ur().y, rect.ur().x); rspfGpt g3(rect.lr().y, rect.lr().x); rspfGpt g4(rect.ll().y, rect.ll().x); points.push_back(g1); points.push_back(g2); points.push_back(g3); points.push_back(g4); } else { rspfGpt g1 = mapProj->inverse(rect.ul()); rspfGpt g2 = mapProj->inverse(rect.ur()); rspfGpt g3 = mapProj->inverse(rect.lr()); rspfGpt g4 = mapProj->inverse(rect.ll()); points.push_back(g1); points.push_back(g2); points.push_back(g3); points.push_back(g4); } std::vector<rspfDpt> rectTmp; rectTmp.resize(4); for(std::vector<rspfGpt>::size_type index=0; index < 4; ++index) { imageGeometry->worldToLocal(points[(int)index], rectTmp[(int)index]); } rspfDrect rect2 = rspfDrect(rectTmp[0], rectTmp[1], rectTmp[2], rectTmp[3]); theLayerVector[i] = new rspfOgrVectorLayerNode(rect2); theLayerVector[i]->setGeoImage(imageGeometry); if (i == 0) theImageGeometry = imageGeometry; } } } } } else { delete theDataSource; theDataSource = 0; return false; } return (theDataSource!=0); }
int main( int nArgc, char ** papszArgv ) { int nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg; const char *pszFormat = "ESRI Shapefile"; const char *pszTileIndexField = "LOCATION"; const char *pszOutputName = NULL; int write_absolute_path = FALSE; int skip_different_projection = FALSE; char* current_path = NULL; int accept_different_schemas = FALSE; int bFirstWarningForNonMatchingAttributes = TRUE; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(papszArgv[0])) exit(1); /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ OGRRegisterAll(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ for( iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 ) { pszFormat = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-write_absolute_path")) { write_absolute_path = TRUE; } else if( EQUAL(papszArgv[iArg],"-skip_different_projection")) { skip_different_projection = TRUE; } else if( EQUAL(papszArgv[iArg],"-accept_different_schemas")) { accept_different_schemas = TRUE; } else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 ) { pszTileIndexField = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-lnum") || EQUAL(papszArgv[iArg],"-lname") ) { iArg++; bLayersWildcarded = FALSE; } else if( papszArgv[iArg][0] == '-' ) Usage(); else if( pszOutputName == NULL ) pszOutputName = papszArgv[iArg]; else if( nFirstSourceDataset == -1 ) nFirstSourceDataset = iArg; } if( pszOutputName == NULL || nFirstSourceDataset == -1 ) Usage(); /* -------------------------------------------------------------------- */ /* Try to open as an existing dataset for update access. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDstDS; OGRLayer *poDstLayer = NULL; poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE ); /* -------------------------------------------------------------------- */ /* If that failed, find the driver so we can create the tile index.*/ /* -------------------------------------------------------------------- */ if( poDstDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); OGRSFDriver *poDriver = NULL; int iDriver; for( iDriver = 0; iDriver < poR->GetDriverCount() && poDriver == NULL; iDriver++ ) { if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) ) { poDriver = poR->GetDriver(iDriver); } } if( poDriver == NULL ) { fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat ); fprintf( stderr, "The following drivers are available:\n" ); for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } if( !poDriver->TestCapability( ODrCCreateDataSource ) ) { fprintf( stderr, "%s driver does not support data source creation.\n", pszFormat ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Now create it. */ /* -------------------------------------------------------------------- */ poDstDS = poDriver->CreateDataSource( pszOutputName, NULL ); if( poDstDS == NULL ) { fprintf( stderr, "%s driver failed to create %s\n", pszFormat, pszOutputName ); exit( 1 ); } if( poDstDS->GetLayerCount() == 0 ) { OGRFieldDefn oLocation( pszTileIndexField, OFTString ); oLocation.SetWidth( 200 ); if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; } OGRSpatialReference* poSrcSpatialRef = NULL; /* Fetches the SRS of the first layer and use it when creating the tileindex layer */ if (nFirstSourceDataset < nArgc) { OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if (poDS) { int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; if ( poLayer->GetSpatialRef() ) poSrcSpatialRef = poLayer->GetSpatialRef()->Clone(); break; } } OGRDataSource::DestroyDataSource( poDS ); } poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef ); poDstLayer->CreateField( &oLocation, OFTString ); OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef ); } } /* -------------------------------------------------------------------- */ /* Identify target layer and field. */ /* -------------------------------------------------------------------- */ int iTileIndexField; poDstLayer = poDstDS->GetLayer(0); if( poDstLayer == NULL ) { fprintf( stderr, "Can't find any layer in output tileindex!\n" ); exit( 1 ); } iTileIndexField = poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField ); if( iTileIndexField == -1 ) { fprintf( stderr, "Can't find %s field in tile index dataset.\n", pszTileIndexField ); exit( 1 ); } OGRFeatureDefn* poFeatureDefn = NULL; /* Load in memory existing file names in SHP */ int nExistingLayers = 0; char** existingLayersTab = NULL; OGRSpatialReference* alreadyExistingSpatialRef = NULL; int alreadyExistingSpatialRefValid = FALSE; nExistingLayers = poDstLayer->GetFeatureCount(); if (nExistingLayers) { int i; existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*)); for(i=0;i<nExistingLayers;i++) { OGRFeature* feature = poDstLayer->GetNextFeature(); existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField)); if (i == 0) { OGRDataSource *poDS; char* filename = CPLStrdup(existingLayersTab[i]); int j; for(j=strlen(filename)-1;j>=0;j--) { if (filename[j] == ',') break; } if (j >= 0) { int iLayer = atoi(filename + j + 1); filename[j] = 0; poDS = OGRSFDriverRegistrar::Open(filename, FALSE ); if (poDS) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if (poLayer) { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL; if (poFeatureDefn == NULL) poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } OGRDataSource::DestroyDataSource( poDS ); } } } } } if (write_absolute_path) { current_path = CPLGetCurrentDir(); if (current_path == NULL) { fprintf( stderr, "This system does not support the CPLGetCurrentDir call. " "The option -write_absolute_path will have no effect\n"); write_absolute_path = FALSE; } } /* ==================================================================== */ /* Process each input datasource in turn. */ /* ==================================================================== */ for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ ) { int i; OGRDataSource *poDS; if( papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; continue; } char* fileNameToWrite; VSIStatBuf sStatBuf; if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) && VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0) { fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset])); } else { fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]); } poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if( poDS == NULL ) { fprintf( stderr, "Failed to open dataset %s, skipping.\n", papszArgv[nFirstSourceDataset] ); CPLFree(fileNameToWrite); continue; } /* -------------------------------------------------------------------- */ /* Check all layers, and see if they match requests. */ /* -------------------------------------------------------------------- */ int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; /* Checks that the layer is not already in tileindex */ for(i=0;i<nExistingLayers;i++) { char szLocation[5000]; sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); if (EQUAL(szLocation, existingLayersTab[i])) { fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n", iLayer, papszArgv[nFirstSourceDataset]); break; } } if (i != nExistingLayers) { continue; } OGRSpatialReference* spatialRef = poLayer->GetSpatialRef(); if (alreadyExistingSpatialRefValid) { if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL && spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) || ((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL))) { fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as " "other files in the tileindex. This may cause problems when " "using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset], (skip_different_projection) ? " Skipping it" : ""); if (skip_different_projection) { continue; } } } else { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL; } /* -------------------------------------------------------------------- */ /* Check if all layers in dataset have the same attributes schema. */ /* -------------------------------------------------------------------- */ if( poFeatureDefn == NULL ) { poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } else if ( !accept_different_schemas ) { OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn(); assert(NULL != poFeatureDefnCur); int fieldCount = poFeatureDefnCur->GetFieldCount(); if( fieldCount != poFeatureDefn->GetFieldCount()) { fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } continue; } int bSkip = FALSE; for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ ) { OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn); OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn); /* XXX - Should those pointers be checked against NULL? */ assert(NULL != poField); assert(NULL != poFieldCur); if( poField->GetType() != poFieldCur->GetType() || poField->GetWidth() != poFieldCur->GetWidth() || poField->GetPrecision() != poFieldCur->GetPrecision() || !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) ) { fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } bSkip = TRUE; break; } } if (bSkip) continue; } /* -------------------------------------------------------------------- */ /* Get layer extents, and create a corresponding polygon */ /* geometry. */ /* -------------------------------------------------------------------- */ OGREnvelope sExtents; OGRPolygon oRegion; OGRLinearRing oRing; if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE ) { fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset] ); continue; } oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRegion.addRing( &oRing ); /* -------------------------------------------------------------------- */ /* Add layer to tileindex. */ /* -------------------------------------------------------------------- */ char szLocation[5000]; OGRFeature oTileFeat( poDstLayer->GetLayerDefn() ); sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); oTileFeat.SetGeometry( &oRegion ); oTileFeat.SetField( iTileIndexField, szLocation ); if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE ) { fprintf( stderr, "Failed to create feature on tile index ... terminating." ); OGRDataSource::DestroyDataSource( poDstDS ); exit( 1 ); } } /* -------------------------------------------------------------------- */ /* Cleanup this data source. */ /* -------------------------------------------------------------------- */ CPLFree(fileNameToWrite); OGRDataSource::DestroyDataSource( poDS ); } /* -------------------------------------------------------------------- */ /* Close tile index and clear buffers. */ /* -------------------------------------------------------------------- */ OGRDataSource::DestroyDataSource( poDstDS ); OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn ); if (alreadyExistingSpatialRef != NULL) OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef ); CPLFree(current_path); if (nExistingLayers) { int i; for(i=0;i<nExistingLayers;i++) { CPLFree(existingLayersTab[i]); } CPLFree(existingLayersTab); } return 0; }
void ShpReader::VectorMetaDataInfo(OGRDataSource* OGRDataset, StudyControllerPtr studyController, VectorMapControllerPtr vectorMapController) { vFileMetaData* vHeader = vectorMapController->GetVectorMapModel()->GetVectorMetaData(); OGRLayer *poLayer = OGRDataset->GetLayer( 0 ); char *originalWkt = NULL; char *destinationWkt = NULL; OGREnvelope psEnvelope; poLayer->GetExtent( &psEnvelope ); vHeader->originalExtents.x = psEnvelope.MinX; vHeader->originalExtents.dx = psEnvelope.MaxX; vHeader->originalExtents.y = psEnvelope.MinY; vHeader->originalExtents.dy = psEnvelope.MaxY; Log::Inst().Write("Original Extents: "); Log::Inst().Write(_T("Lower, Left (x,y): ") +wxString(StringTools::ToStringW(vHeader->originalExtents.x, 2).c_str()) + _T(", ") + wxString(StringTools::ToStringW(vHeader->originalExtents.y, 2).c_str())); Log::Inst().Write(_T("Upper, Right (x,y): ") +wxString(StringTools::ToStringW(vHeader->originalExtents.dx, 2).c_str()) + _T(", ") + wxString(StringTools::ToStringW(vHeader->originalExtents.dy, 2).c_str())); vHeader->numFeatures= poLayer->GetFeatureCount(); Log::Inst().Write("Number of Features: " + StringTools::ToString(vHeader->numFeatures)); std::string type; OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); if ( wkbFlatten( poFDefn->GetGeomType() ) == wkbPoint || wkbFlatten( poFDefn->GetGeomType() ) == wkbMultiPoint ) type="Point"; else if ( wkbFlatten(poFDefn->GetGeomType() ) == wkbLineString || wkbFlatten(poFDefn->GetGeomType() ) == wkbMultiLineString ) type="Polyline"; else if ( wkbFlatten( poFDefn->GetGeomType() ) == wkbPolygon || wkbFlatten( poFDefn->GetGeomType() ) == wkbMultiPolygon ) type="Polygon"; else type="Unknown"; vHeader->geometryType=type; Log::Inst().Write("Geometry Type: "+ type); OGRSpatialReference* originalShpSR = poLayer->GetSpatialRef(); if (originalShpSR != NULL) { originalShpSR->exportToWkt(&originalWkt); vHeader->originalProjection = std::string(originalWkt); } Log::Inst().Write("Original Projection: " + vHeader->originalProjection); Log::Inst().Write(""); ProjectionToolPtr projTool = studyController->GetProjectionTool(); if (projTool != NULL) { OGRSpatialReference *destinationCS= projTool->GetTargetCS (); destinationCS->exportToWkt(&destinationWkt); vHeader->destinationProjection = std::string(destinationWkt); } vHeader->currentExtents.x = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MinX(); vHeader->currentExtents.y = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MinY(); vHeader->currentExtents.dx = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MaxX(); vHeader->currentExtents.dy = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MaxY(); //Log::Inst().Write("Upper, Right (x,y): " + // StringTools::ToString(vHeader->currentExtents.dx) + ", " + //StringTools::ToString(vHeader->currentExtents.dy)); }
bool ShpReader::Open(std::wstring fullPath, StudyControllerPtr studyController, VectorMapControllerPtr vectorMapController, ProgressDlgPtr progressDlg) { // Registers all format drivers built into GDAL/OGR. OGRRegisterAll(); OGRDataSource *OGRDataset; // Open vector file path std::string tempStr( fullPath.begin(), fullPath.end() ); OGRDataset = OGRSFDriverRegistrar::Open( tempStr.c_str(), FALSE ); // Return if no vector files are found if( OGRDataset == NULL ) { Log::Inst().Warning("(Warning) Failed to open file at " + tempStr + "."); return false; } if ( App::Inst().GetLayerTreeController()->GetNumMapLayers() >0 ) MapControllerPtr mapController= App::Inst().GetLayerTreeController()->GetLayerTreeModel()->GetStudy(0)->GetMapLayer(0)->GetMapController(); // It appears that shapefiles (*.SHP) only support up to one layer per file // This will need to be further investigated for other vector filetypes (e.g., KML) // For now just grab layer at position 0 OGRLayer *poLayer = OGRDataset->GetLayer( 0 ); // Determine the XY boundaries for the entire vector dataset OGREnvelope psEnvelope; VectorMapModelPtr vectorMapModel = vectorMapController->GetVectorMapModel(); poLayer->GetExtent( &psEnvelope ); vectorMapModel->SetVectorBoundary(psEnvelope); if(!SetupVectorProjection(OGRDataset,studyController,poLayer,vectorMapController )) { OGRDataset->DestroyDataSource(OGRDataset); return false; } if(progressDlg) { if(!progressDlg->Update(0, _T("Reading Vector Map Information..."))) { OGRDataset->DestroyDataSource(OGRDataset); return false; } } GLdouble minX, minY, maxX, maxY; minX = minY = std::numeric_limits<float>::max(); maxX = maxY = -std::numeric_limits<float>::max(); // Retrieve features from the dataset OGRFeature *poFeature; poLayer->ResetReading(); int numFeatures = poLayer->GetFeatureCount(); int count=0; //Log::Inst().Write("Loading shapefile with the following meta data:"); while ( ( poFeature = poLayer->GetNextFeature() ) != NULL ) { ///////////////////////////////////////////////// // PHASE 1: Retrieve METADATA from the dataset // ///////////////////////////////////////////////// OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); int iField; for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); //if( poFieldDefn->GetType() == OFTInteger ) // printf( "%d,", poFeature->GetFieldAsInteger( iField ) ); //else if( poFieldDefn->GetType() == OFTReal ) // printf( "%.3f,", poFeature->GetFieldAsDouble(iField) ); //else if( poFieldDefn->GetType() == OFTString ) // printf( "%s,", poFeature->GetFieldAsString(iField) ); //else // printf( "%s,", poFeature->GetFieldAsString(iField) ); //ofs << poFeature->GetFieldAsString(iField) << ","; std::string metaData = poFeature->GetFieldAsString(iField); // do something with the meta data... //Log::Inst().Write(metaData); } count++; if(progressDlg) { if(!progressDlg->Update(int(50 + (float(count)/numFeatures)*50))) return false; } /////////////////////////////////////////////////// // PHASE 2: Retrieve GEOMETRIES from the dataset // /////////////////////////////////////////////////// OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); // Move to the next feature in the set if no geometry present if( poGeometry == NULL ) { OGRFeature::DestroyFeature( poFeature ); continue; } OGRwkbGeometryType whatisit = poGeometry->getGeometryType(); // Handle POINTS if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPoint ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = (OGRPoint *) poGeometry; geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } //Handle MultiPoint else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPoint ) { OGRMultiPoint *poMultiPoint = (OGRMultiPoint *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPoint->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = ( OGRPoint* )poMultiPoint->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } //Handle Polylines else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbLineString ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = (OGRLineString *) poGeometry; geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); // Convert and store the points for ( int currentPoint = 0; currentPoint < poLine->getNumPoints(); currentPoint++ ) { // Convert and store the points if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MultiPolyLine else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiLineString ) { OGRMultiLineString *poMultiLine = (OGRMultiLineString *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiLine->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = ( OGRLineString* )poMultiLine->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLine ->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } // Handle POLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPolygon ) { GeoVector* geoVector = new GeoVector(); OGRPolygon *poPolygon = ( OGRPolygon* )poGeometry; OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MULTIPOLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPolygon ) { OGRMultiPolygon *poMultiPolygon = (OGRMultiPolygon *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPolygon->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); // OGRPolygon http://www.gdal.org/ogr/classOGRPolygon.html OGRPolygon *poPolygon = ( OGRPolygon* )poMultiPolygon->getGeometryRef( currGeometry ); // Retrieve the EXTERNAL ring of the multipolygon OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); // Retrieve all the INTERNAL rings of the multipolygon for ( int currentRing = 0; currentRing < poPolygon->getNumInteriorRings(); currentRing++ ) { GeoVector* geoVector2 = new GeoVector(); poLinearRing = poPolygon->getInteriorRing( currentRing ); geoVector2->SetGeometryType( wkbLinearRing ); geoVector2->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector2->pointX[currentPoint] = x; geoVector2->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector2->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector2->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector2 ); } } } // Report a warning message for unhandled geometries else { Log::Inst().Warning("(Warning) Could not load vector data: unsupported geometry."); } OGRFeature::DestroyFeature( poFeature ); } if (float(minX) == float(maxX) && float(minY) == float(maxY)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } if(needProjection) { vectorMapModel->SetVectorBoundary_MinX(minX); vectorMapModel->SetVectorBoundary_MaxX(maxX); vectorMapModel->SetVectorBoundary_MinY(minY); vectorMapModel->SetVectorBoundary_MaxY(maxY); } if(!SetupVectorScaling(vectorMapModel,progressDlg)) { OGRDataset->DestroyDataSource(OGRDataset); return false; } VectorMetaDataInfo(OGRDataset, studyController, vectorMapController); OGRDataSource::DestroyDataSource( OGRDataset ); return true; }
void ogr_datasource::bind() const { if (is_bound_) return; // initialize ogr formats OGRRegisterAll(); std::string driver = *params_.get<std::string>("driver",""); if (! driver.empty()) { OGRSFDriver * ogr_driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver.c_str()); if (ogr_driver && ogr_driver != NULL) { dataset_ = ogr_driver->Open((dataset_name_).c_str(), FALSE); } } else { // open ogr driver dataset_ = OGRSFDriverRegistrar::Open((dataset_name_).c_str(), FALSE); } if (! dataset_) { const std::string err = CPLGetLastErrorMsg(); if (err.size() == 0) { throw datasource_exception("OGR Plugin: connection failed: " + dataset_name_ + " was not found or is not a supported format"); } else { throw datasource_exception("OGR Plugin: " + err); } } // initialize layer boost::optional<std::string> layer_by_name = params_.get<std::string>("layer"); boost::optional<unsigned> layer_by_index = params_.get<unsigned>("layer_by_index"); boost::optional<std::string> layer_by_sql = params_.get<std::string>("layer_by_sql"); int passed_parameters = 0; passed_parameters += layer_by_name ? 1 : 0; passed_parameters += layer_by_index ? 1 : 0; passed_parameters += layer_by_sql ? 1 : 0; if (passed_parameters > 1) { throw datasource_exception("OGR Plugin: you can only select an ogr layer by name " "('layer' parameter), by number ('layer_by_index' parameter), " "or by sql ('layer_by_sql' parameter), " "do not supply 2 or more of them at the same time" ); } if (layer_by_name) { layer_name_ = *layer_by_name; layer_.layer_by_name(dataset_, layer_name_); } else if (layer_by_index) { const unsigned num_layers = dataset_->GetLayerCount(); if (*layer_by_index >= num_layers) { std::ostringstream s; s << "OGR Plugin: only "; s << num_layers; s << " layer(s) exist, cannot find layer by index '" << *layer_by_index << "'"; throw datasource_exception(s.str()); } layer_.layer_by_index(dataset_, *layer_by_index); layer_name_ = layer_.layer_name(); } else if (layer_by_sql) { layer_.layer_by_sql(dataset_, *layer_by_sql); layer_name_ = layer_.layer_name(); } else { std::ostringstream s; s << "OGR Plugin: missing <layer> or <layer_by_index> or <layer_by_sql> " << "parameter, available layers are: "; unsigned num_layers = dataset_->GetLayerCount(); bool layer_found = false; for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer* ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* ogr_layer_def = ogr_layer->GetLayerDefn(); if (ogr_layer_def != 0) { layer_found = true; s << " '" << ogr_layer_def->GetName() << "' "; } } if (! layer_found) { s << "None (no layers were found in dataset)"; } throw datasource_exception(s.str()); } if (! layer_.is_valid()) { std::string s("OGR Plugin: "); if (layer_by_name) { s += "cannot find layer by name '" + *layer_by_name; } else if (layer_by_index) { s += "cannot find layer by index number '" + *layer_by_index; } else if (layer_by_sql) { s += "cannot find layer by sql query '" + *layer_by_sql; } s += "' in dataset '" + dataset_name_ + "'"; throw datasource_exception(s); } // work with real OGR layer OGRLayer* layer = layer_.layer(); // initialize envelope OGREnvelope envelope; layer->GetExtent(&envelope); extent_.init(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY); // scan for index file // TODO - layer names don't match dataset name, so this will break for // any layer types of ogr than shapefiles, etc // fix here and in ogrindex size_t breakpoint = dataset_name_.find_last_of("."); if (breakpoint == std::string::npos) { breakpoint = dataset_name_.length(); } index_name_ = dataset_name_.substr(0, breakpoint) + ".ogrindex"; std::ifstream index_file(index_name_.c_str(), std::ios::in | std::ios::binary); if (index_file) { indexed_ = true; index_file.close(); } #if 0 // TODO - enable this warning once the ogrindex tool is a bit more stable/mature else { std::clog << "### Notice: no ogrindex file found for " << dataset_name_ << ", use the 'ogrindex' program to build an index for faster rendering" << std::endl; } #endif // deal with attributes descriptions OGRFeatureDefn* def = layer->GetLayerDefn(); if (def != 0) { const int fld_count = def->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn(i); const std::string fld_name = fld->GetNameRef(); const OGRFieldType type_oid = fld->GetType(); switch (type_oid) { case OFTInteger: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Integer)); break; case OFTReal: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Double)); break; case OFTString: case OFTWideString: // deprecated desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String)); break; case OFTBinary: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; case OFTIntegerList: case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif break; case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; default: // unknown #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unknown type_oid=" << type_oid << std::endl; #endif break; } } } is_bound_ = true; }
void ogr_datasource::init(mapnik::parameters const& params) { #ifdef MAPNIK_STATS mapnik::progress_timer __stats__(std::clog, "ogr_datasource::init"); #endif boost::optional<std::string> file = params.get<std::string>("file"); boost::optional<std::string> string = params.get<std::string>("string"); if (!string) string = params.get<std::string>("inline"); if (! file && ! string) { throw datasource_exception("missing <file> or <string> parameter"); } if (string) { dataset_name_ = *string; } else { boost::optional<std::string> base = params.get<std::string>("base"); if (base) { dataset_name_ = *base + "/" + *file; } else { dataset_name_ = *file; } } std::string driver = *params.get<std::string>("driver",""); if (! driver.empty()) { #if GDAL_VERSION_MAJOR >= 2 unsigned int nOpenFlags = GDAL_OF_READONLY | GDAL_OF_VECTOR; const char* papszAllowedDrivers[] = { driver.c_str(), nullptr }; dataset_ = reinterpret_cast<gdal_dataset_type>(GDALOpenEx(dataset_name_.c_str(),nOpenFlags,papszAllowedDrivers, nullptr, nullptr)); #else OGRSFDriver * ogr_driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver.c_str()); if (ogr_driver && ogr_driver != nullptr) { dataset_ = ogr_driver->Open((dataset_name_).c_str(), false); } #endif } else { // open ogr driver #if GDAL_VERSION_MAJOR >= 2 dataset_ = reinterpret_cast<gdal_dataset_type>(OGROpen(dataset_name_.c_str(), false, nullptr)); #else dataset_ = OGRSFDriverRegistrar::Open(dataset_name_.c_str(), false); #endif } if (! dataset_) { const std::string err = CPLGetLastErrorMsg(); if (err.size() == 0) { throw datasource_exception("OGR Plugin: connection failed: " + dataset_name_ + " was not found or is not a supported format"); } else { throw datasource_exception("OGR Plugin: " + err); } } // initialize layer boost::optional<std::string> layer_by_name = params.get<std::string>("layer"); boost::optional<mapnik::value_integer> layer_by_index = params.get<mapnik::value_integer>("layer_by_index"); boost::optional<std::string> layer_by_sql = params.get<std::string>("layer_by_sql"); int passed_parameters = 0; passed_parameters += layer_by_name ? 1 : 0; passed_parameters += layer_by_index ? 1 : 0; passed_parameters += layer_by_sql ? 1 : 0; if (passed_parameters > 1) { throw datasource_exception("OGR Plugin: you can only select an ogr layer by name " "('layer' parameter), by number ('layer_by_index' parameter), " "or by sql ('layer_by_sql' parameter), " "do not supply 2 or more of them at the same time" ); } if (layer_by_name) { layer_name_ = *layer_by_name; layer_.layer_by_name(dataset_, layer_name_); } else if (layer_by_index) { int num_layers = dataset_->GetLayerCount(); if (*layer_by_index >= num_layers) { std::ostringstream s; s << "OGR Plugin: only " << num_layers << " layer(s) exist, cannot find layer by index '" << *layer_by_index << "'"; throw datasource_exception(s.str()); } layer_.layer_by_index(dataset_, *layer_by_index); layer_name_ = layer_.layer_name(); } else if (layer_by_sql) { #ifdef MAPNIK_STATS mapnik::progress_timer __stats_sql__(std::clog, "ogr_datasource::init(layer_by_sql)"); #endif layer_.layer_by_sql(dataset_, *layer_by_sql); layer_name_ = layer_.layer_name(); } else { std::string s("OGR Plugin: missing <layer> or <layer_by_index> or <layer_by_sql> parameter, available layers are: "); unsigned num_layers = dataset_->GetLayerCount(); bool layer_found = false; std::vector<std::string> layer_names; for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer* ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* ogr_layer_def = ogr_layer->GetLayerDefn(); if (ogr_layer_def != 0) { layer_found = true; layer_names.push_back(std::string("'") + ogr_layer_def->GetName() + std::string("'")); } } if (! layer_found) { s += "None (no layers were found in dataset)"; } else { s += boost::algorithm::join(layer_names,", "); } throw datasource_exception(s); } if (! layer_.is_valid()) { std::ostringstream s; s << "OGR Plugin: "; if (layer_by_name) { s << "cannot find layer by name '" << *layer_by_name; } else if (layer_by_index) { s << "cannot find layer by index number '" << *layer_by_index; } else if (layer_by_sql) { s << "cannot find layer by sql query '" << *layer_by_sql; } s << "' in dataset '" << dataset_name_ << "'"; throw datasource_exception(s.str()); } // work with real OGR layer OGRLayer* layer = layer_.layer(); // initialize envelope boost::optional<std::string> ext = params.get<std::string>("extent"); if (ext && !ext->empty()) { extent_.from_string(*ext); } else { OGREnvelope envelope; OGRErr e = layer->GetExtent(&envelope); if (e == OGRERR_FAILURE) { if (layer->GetFeatureCount() == 0) { MAPNIK_LOG_ERROR(ogr) << "could not determine extent, layer '" << layer->GetLayerDefn()->GetName() << "' appears to have no features"; } else { std::ostringstream s; s << "OGR Plugin: Cannot determine extent for layer '" << layer->GetLayerDefn()->GetName() << "'. Please provide a manual extent string (minx,miny,maxx,maxy)."; throw datasource_exception(s.str()); } } extent_.init(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY); } // scan for index file // TODO - layer names don't match dataset name, so this will break for // any layer types of ogr than shapefiles, etc // fix here and in ogrindex size_t breakpoint = dataset_name_.find_last_of("."); if (breakpoint == std::string::npos) { breakpoint = dataset_name_.length(); } index_name_ = dataset_name_.substr(0, breakpoint) + ".ogrindex"; #if defined (_WINDOWS) std::ifstream index_file(mapnik::utf8_to_utf16(index_name_), std::ios::in | std::ios::binary); #else std::ifstream index_file(index_name_.c_str(), std::ios::in | std::ios::binary); #endif if (index_file) { indexed_ = true; index_file.close(); } #if 0 // TODO - enable this warning once the ogrindex tool is a bit more stable/mature else { MAPNIK_LOG_DEBUG(ogr) << "ogr_datasource: no ogrindex file found for " << dataset_name_ << ", use the 'ogrindex' program to build an index for faster rendering"; } #endif #ifdef MAPNIK_STATS mapnik::progress_timer __stats2__(std::clog, "ogr_datasource::init(get_column_description)"); #endif // deal with attributes descriptions OGRFeatureDefn* def = layer->GetLayerDefn(); if (def != 0) { const int fld_count = def->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn(i); const std::string fld_name = fld->GetNameRef(); const OGRFieldType type_oid = fld->GetType(); switch (type_oid) { case OFTInteger: #if GDAL_VERSION_MAJOR >= 2 case OFTInteger64: #endif desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Integer)); break; case OFTReal: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Double)); break; case OFTString: case OFTWideString: // deprecated desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String)); break; case OFTBinary: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; case OFTIntegerList: #if GDAL_VERSION_MAJOR >= 2 case OFTInteger64List: #endif case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! MAPNIK_LOG_WARN(ogr) << "ogr_datasource: Unhandled type_oid=" << type_oid; break; case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); MAPNIK_LOG_WARN(ogr) << "ogr_datasource: Unhandled type_oid=" << type_oid; break; } } } mapnik::parameters & extra_params = desc_.get_extra_parameters(); OGRSpatialReference * srs_ref = layer->GetSpatialRef(); char * srs_output = nullptr; if (srs_ref && srs_ref->exportToProj4( &srs_output ) == OGRERR_NONE ) { extra_params["proj4"] = mapnik::util::trim_copy(srs_output); } CPLFree(srs_output); }
virtual OGRErr GetExtent( OGREnvelope *psExtent, int bForce ) { return poBaseLayer->GetExtent(psExtent, bForce); }
// extern "C" { SEXP ogrInfo(SEXP ogrsourcename, SEXP Layer) { // return FIDs, nFields, fieldInfo SEXP ans, vec1, vec2, vec3,/*mat,*/drv, dvec; SEXP itemlist, itemnames, itemwidth, itemtype, itemTypeNames; SEXP itemlistmaxcount; #ifdef GDALV2 SEXP dFIDs; #endif /*SEXP geotype;*/ int nFIDs, nFields, iField, *nCount, pc=0; #ifdef GDALV2 GDALDriver *poDriver; GDALDataset *poDS; #else OGRDataSource *poDS; OGRSFDriver *poDriver; #endif OGRLayer *poLayer; OGRFeature *poFeature; OGRFeatureDefn *poDefn; /* OGRGeometry *poGeom;*/ installErrorHandler(); #ifdef GDALV2 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrsourcename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL); if(poDS==NULL) { uninstallErrorHandlerAndTriggerError(); error("Cannot open data source"); } poDriver = poDS->GetDriver(); #else poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrsourcename, 0)), FALSE, &poDriver); #endif uninstallErrorHandlerAndTriggerError(); if(poDS==NULL) { installErrorHandler(); #ifdef GDALV2 GDALClose( poDS ); #else OGRDataSource::DestroyDataSource( poDS ); #endif uninstallErrorHandlerAndTriggerError(); // delete poDS; error("Cannot open file"); } installErrorHandler(); poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0))); uninstallErrorHandlerAndTriggerError(); if(poLayer == NULL) { installErrorHandler(); #ifdef GDALV2 GDALClose( poDS ); #else OGRDataSource::DestroyDataSource( poDS ); #endif uninstallErrorHandlerAndTriggerError(); // delete poDS; error("Cannot open layer"); } // allocate a list for return values PROTECT(ans=allocVector(VECSXP,6)); pc++; PROTECT(drv=allocVector(STRSXP,1)); pc++; installErrorHandler(); #ifdef GDALV2 SET_STRING_ELT(drv, 0, mkChar(poDriver->GetDescription())); #else SET_STRING_ELT(drv, 0, mkChar(poDriver->GetName())); #endif uninstallErrorHandlerAndTriggerError(); SET_VECTOR_ELT(ans,3,drv); PROTECT(vec1=allocVector(INTSXP,1)); pc++; installErrorHandler(); #ifdef GDALV2 GIntBig nFIDs64 = poLayer->GetFeatureCount(); nFIDs = (nFIDs64 > INT_MAX) ? INT_MAX : (nFIDs64 < INT_MIN) ? INT_MIN : (int) nFIDs64; if ((GIntBig) nFIDs != nFIDs64) { warning("ogrInfo: feature count overflow"); INTEGER(vec1)[0]=NA_INTEGER; PROTECT(dFIDs=NEW_NUMERIC(1)); pc++; NUMERIC_POINTER(dFIDs)[0] = (double) nFIDs64; setAttrib(vec1, install("dFIDs"), dFIDs); } else { // store number of FIDs INTEGER(vec1)[0]=nFIDs; } #else nFIDs = poLayer->GetFeatureCount(); // store number of FIDs INTEGER(vec1)[0]=nFIDs; #endif uninstallErrorHandlerAndTriggerError(); if (nFIDs == -1) { int i=0; installErrorHandler(); while( ((poFeature = poLayer->GetNextFeature()) != NULL) && i <= INT_MAX) { i++; OGRFeature::DestroyFeature( poFeature ); // delete poFeature; } uninstallErrorHandlerAndTriggerError(); if (i == INT_MAX) { error("ogrInfo: undeclared feature count overflow"); } else { nFIDs = i; warning("ogrInfo: feature count not given; %d counted", nFIDs); } installErrorHandler(); poLayer->ResetReading(); uninstallErrorHandlerAndTriggerError(); INTEGER(vec1)[0]=nFIDs; } SET_VECTOR_ELT(ans,0,vec1); // store other stuff.... installErrorHandler(); poDefn = poLayer->GetLayerDefn(); nFields = poDefn->GetFieldCount(); uninstallErrorHandlerAndTriggerError(); // store number of fields PROTECT(vec2=allocVector(INTSXP,1)); pc++; INTEGER(vec2)[0]=nFields; SET_VECTOR_ELT(ans,1,vec2); installErrorHandler(); OGREnvelope oExt; if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { PROTECT(dvec=allocVector(REALSXP,4)); pc++; REAL(dvec)[0] = oExt.MinX; REAL(dvec)[1] = oExt.MinY; REAL(dvec)[2] = oExt.MaxX; REAL(dvec)[3] = oExt.MaxY; SET_VECTOR_ELT(ans,4,dvec); } uninstallErrorHandlerAndTriggerError(); PROTECT(itemnames=allocVector(STRSXP,nFields)); pc++; PROTECT(itemtype=allocVector(INTSXP,nFields)); pc++; PROTECT(itemwidth=allocVector(INTSXP,nFields)); pc++; // try List types PROTECT(itemlistmaxcount=allocVector(INTSXP,nFields)); pc++; PROTECT(itemTypeNames=allocVector(STRSXP,nFields)); pc++; int listFieldCount=0; installErrorHandler(); for(iField=0; iField<nFields; iField++) { OGRFieldDefn *poField = poDefn->GetFieldDefn(iField); SET_STRING_ELT(itemnames,iField,mkChar(poField->GetNameRef())); INTEGER(itemtype)[iField]=poField->GetType(); if (INTEGER(itemtype)[iField] == OFTIntegerList || INTEGER(itemtype)[iField] == OFTRealList || INTEGER(itemtype)[iField] == OFTStringList) listFieldCount++; INTEGER(itemwidth)[iField]=poField->GetWidth(); SET_STRING_ELT(itemTypeNames,iField,mkChar(poField->GetFieldTypeName( poField->GetType()))); INTEGER(itemlistmaxcount)[iField] = 0; } uninstallErrorHandlerAndTriggerError(); PROTECT(vec3=allocVector(INTSXP,1)); pc++; INTEGER(vec3)[0]=listFieldCount; SET_VECTOR_ELT(ans,5,vec3); PROTECT(itemlist=allocVector(VECSXP,5)); pc++; SET_VECTOR_ELT(itemlist,0,itemnames); SET_VECTOR_ELT(itemlist,1,itemtype); SET_VECTOR_ELT(itemlist,2,itemwidth); SET_VECTOR_ELT(itemlist,3,itemTypeNames); // try List types if (listFieldCount > 0) { poLayer->ResetReading(); OGRFeature* poFeature; nCount = (int *) R_alloc((size_t) nFields, sizeof(int)); for (iField=0; iField<nFields; iField++) nCount[iField] = 0; installErrorHandler(); OGRField* psField; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { for(iField=0; iField<nFields; iField++) { psField = poFeature->GetRawFieldRef(iField); if (INTEGER(itemtype)[iField] == OFTIntegerList) { nCount[iField] = psField->IntegerList.nCount; if (nCount[iField] > INTEGER(itemlistmaxcount)[iField]) INTEGER(itemlistmaxcount)[iField] = nCount[iField]; } else if (INTEGER(itemtype)[iField] == OFTRealList) { nCount[iField] = psField->RealList.nCount; if (nCount[iField] > INTEGER(itemlistmaxcount)[iField]) INTEGER(itemlistmaxcount)[iField] = nCount[iField]; } else if (INTEGER(itemtype)[iField] == OFTStringList) { nCount[iField] = psField->StringList.nCount; if (nCount[iField] > INTEGER(itemlistmaxcount)[iField]) INTEGER(itemlistmaxcount)[iField] = nCount[iField]; } } OGRFeature::DestroyFeature( poFeature ); // delete poFeature; } uninstallErrorHandlerAndTriggerError(); } SET_VECTOR_ELT(itemlist,4,itemlistmaxcount); SET_VECTOR_ELT(ans,2,itemlist); UNPROTECT(pc); installErrorHandler(); #ifdef GDALV2 GDALClose( poDS ); #else OGRDataSource::DestroyDataSource( poDS ); #endif uninstallErrorHandlerAndTriggerError(); // delete poDS; return(ans); }
void DrawShape::featuredetect(int XPoint,int YPoint) { if(!sfile.empty() && XPoint>=(x_pos_shift-increase_width/2)*6.40 && XPoint<=(x_pos_shift-increase_width/2)*6.40+(100+increase_width)*6.4 && YPoint>=(y_pos_shift-increase_height/2)*4.8 && YPoint<=(y_pos_shift-increase_height/2)*4.8+(100+increase_height)*4.8 )//check if point is inside the view area { OGRDataSource *poDS; string dfile = sfile + ".shp"; string shp = "g_4326/" + sfile + ".shp"; poDS = OGRSFDriverRegistrar::Open(shp.c_str(), FALSE ); //comment till here if( poDS == NULL ) { WApplication::instance()->doJavaScript("alert('Open failed')"); cout << "Open failed"; } OGRLayer *poLayer; poLayer = poDS->GetLayerByName( sfile.c_str() ); // comment here OGRFeature *poFeature; OGREnvelope * psExtent = new OGREnvelope(); poLayer->GetExtent(psExtent); double xMin = psExtent->MinX; double yMin = psExtent->MinY; double xMax = psExtent->MaxX; double yMax = psExtent->MaxY; stringstream strm; strm << xMin; string exp; double scaleFactor; string bound_string = strm.str(); int size = bound_string.size(); size_t found=bound_string.find("+"); if (found!=string::npos) { exp = bound_string.substr(found+1,size); } if(exp.empty()) { stringstream strExtent; strExtent << yMin; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << xMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << yMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(!exp.empty()) { int exponent = boost::lexical_cast<int>(exp); exponent-=3; scaleFactor = pow (10,exponent); } else { scaleFactor = 1; } xMin/=scaleFactor; xMax/=scaleFactor; yMin/=scaleFactor; yMax/=scaleFactor; double gWidth = xMax - xMin; double gHeight = yMax - yMin; double widthFactor = 1; double pwidth = abs(gWidth-gHeight); double s = gWidth - gHeight; if(s<0.16) gWidth = gHeight + 0.16; double scaledX=(XPoint*(gWidth* widthFactor*(100-increase_width)/100)/640 + (xMin+(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor))*scaleFactor; double scaledY=(YPoint*(gHeight*widthFactor*(-1+increase_height/100))/480 + (yMax+(y_pos_shift-increase_height/2)/100*gHeight*widthFactor))*scaleFactor; OGRPoint *poPoint =new OGRPoint(); poPoint->setX(scaledX); poPoint->setY(scaledY); poLayer->ResetReading(); int index=0;bool flagFeature=false; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); if(poGeometry->Distance(poPoint)/scaleFactor<=0.01*gWidth*widthFactor) { flagFeature=true; //std::cerr<<index<<" " <<flagFeature<<" "<<poGeometry->Distance(poPoint); break; } index++; } if(flagFeature) DBFDialog *attrtable =new DBFDialog(cfile,sfile,flagFeature,index); } }
void DrawShape::paintMap(WPaintDevice *paintDevice) { WPainter painter(paintDevice); painter.setRenderHint(WPainter::LowQualityShadows); painter.save(); if(!sfile.empty()) { vector<LABELS> label_list; OGRDataSource *poDS,*PointDS; string dfile = sfile + ".shp"; string shp = "g_4326/" + sfile + ".shp"; poDS = OGRSFDriverRegistrar::Open(shp.c_str(), FALSE ); //comment till here if(poDS==NULL) { printf( "Open failed.\n" ); exit( 1 ); } OGRLayer *poLayer; poLayer = poDS->GetLayerByName( sfile.c_str() ); // comment here OGRFeature *poFeature; OGREnvelope * psExtent = new OGREnvelope(); poLayer->GetExtent(psExtent); double xMin = psExtent->MinX; double yMin = psExtent->MinY; double xMax = psExtent->MaxX; double yMax = psExtent->MaxY; stringstream strm; strm << xMin; string exp; double scaleFactor; string bound_string = strm.str(); int size = bound_string.size(); size_t found=bound_string.find("+"); if (found!=string::npos) { exp = bound_string.substr(found+1,size); } if(exp.empty()) { stringstream strExtent; strExtent << yMin; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << xMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << yMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } //cout << "EXXP: " << exp << endl; if(!exp.empty()) { int exponent = boost::lexical_cast<int>(exp); exponent-=3; scaleFactor = pow (10,exponent); } else { //cout << "EXXP is empty " << exp << endl; scaleFactor = 1; } xMin/=scaleFactor; xMax/=scaleFactor; yMin/=scaleFactor; yMax/=scaleFactor; double gWidth = xMax - xMin; double gHeight = yMax - yMin; double widthFactor = 1; double pwidth = abs(gWidth-gHeight); double s = gWidth - gHeight; if(s<0.16) gWidth = gHeight + 0.16; double ratio=gWidth/gHeight; //for zoom n pan if(increase_width<100 && increase_height<100){ painter.setWindow(xMin +(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor, yMax+(y_pos_shift-increase_height/2)/100*gHeight * widthFactor, gWidth* widthFactor*(100-increase_width)/100, gHeight * widthFactor*(-1+increase_height/100)); brush.setStyle(SolidPattern); brush.setColor(backcolor); painter.setBrush(brush); painter.drawRect(xMin +(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor, yMax+(y_pos_shift-increase_height/2)/100*gHeight * widthFactor, gWidth* widthFactor*(100-increase_width)/100, gHeight * widthFactor*(-1+increase_height/100)); } else{ painter.setWindow(xMin +x_pos_shift, yMax-y_pos_shift, 0, 0); } // for normal picture //painter.setWindow(xMin , yMax, gWidth* widthFactor, -gHeight * widthFactor); pwidth/=480; pwidth*=4; //if(iwidth<0.06) // iwidth=0.06; if(iwidth == 0.0015){ pen.setWidth(pwidth); } else { pen.setWidth(iwidth); } //std::cerr<<pwidth<<" "<<iwidth<<"\n"; pen.setColor(bordercolor); brush.setStyle(SolidPattern); brush.setColor(fillcolor); font= new WFont(); font->setSize(WLength(labelpercentage*gWidth*widthFactor)); painter.setFont(*font); painter.setPen(pen); painter.setBrush(brush); WPainterPath path; poLayer->ResetReading(); OGRPoint *centroid = new OGRPoint(); char label[100]; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { centroid->empty(); label[0]=0; if(labelindex>0) { OGRFeatureDefn *PointFDefn = poLayer->GetLayerDefn(); OGRFieldDefn *PointFieldDefn = PointFDefn->GetFieldDefn(labelindex-1); if( PointFieldDefn->GetType() == OFTInteger ) sprintf(label, "%d", poFeature->GetFieldAsInteger(labelindex-1) ); else if( PointFieldDefn->GetType() == OFTReal ) sprintf(label, "%.3f", poFeature->GetFieldAsDouble(labelindex-1) ); else if( PointFieldDefn->GetType() == OFTString ) sprintf(label, "%s", poFeature->GetFieldAsString(labelindex-1) ); else sprintf(label, "%s", poFeature->GetFieldAsString(labelindex-1) ); } OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); if( poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; double x = poPoint->getX(); double y = poPoint->getY(); //painter.drawPoint(x/scaleFactor,y/scaleFactor); painter.drawEllipse(x/scaleFactor-0.005*gWidth*widthFactor,y/scaleFactor-0.005*gWidth*widthFactor,0.01*gWidth*widthFactor,0.01*gWidth*widthFactor); poGeometry->Centroid(centroid); } //end wkbpoint else if( poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbLineString ) { OGRLineString *poPoint = (OGRLineString *) poGeometry; for(int i=0;i<poPoint->getNumPoints();i++) { double x=poPoint->getX(i) ; double y = poPoint->getY(i); x/=scaleFactor; y/=scaleFactor; if(i==0) path = WPainterPath( WPointF(x, y)); else path.lineTo( x , y); } painter.drawPath(path); poGeometry->Centroid(centroid); } else if( (poGeometry != NULL) && wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) { OGRPolygon *poPoint = (OGRPolygon *) poGeometry; OGRLinearRing *extring = poPoint->getExteriorRing(); int n = extring->getNumPoints(); double x, y; for(int i=0;i<n;i++) { x = extring->getX(i); y = extring->getY(i); x/=scaleFactor; y/=scaleFactor; if(i==0) path = WPainterPath( WPointF(x , y)); else path.lineTo( x , y); } painter.drawPath(path); poGeometry->Centroid(centroid); } else if( (poGeometry != NULL) && wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon) { double x, y; OGRMultiPolygon *poPoint = (OGRMultiPolygon *) poGeometry; int p = poPoint->getNumGeometries(); for(int k=0;k<p;k++) { OGRGeometry* geom = poPoint->getGeometryRef(k); OGRPolygon *poly = (OGRPolygon *) geom; OGRLinearRing *ring = poly->getExteriorRing(); for(int i=0;i<ring->getNumPoints();i++) { x = ring->getX(i); y = ring->getY(i); x/=scaleFactor; y/=scaleFactor; if(i==0) path = WPainterPath( WPointF(x , y)); else path.lineTo( x , y); } painter.drawPath(path); poGeometry->Centroid(centroid); } } if(labelindex>0 && !centroid->IsEmpty()){ LABELS l={centroid->getX(),centroid->getY(),label}; label_list.push_back(l); } } painter.restore(); //labelling the contents if(increase_width<100 && increase_height<100){ painter.setWindow(0.0, 0.0, (paintDevice->width()).value(),(paintDevice->height()).value()); font= new WFont(WFont::SansSerif); font->setSize(WLength(10*labelpercentage)); painter.setFont(*font); pen.setColor(labelcolor); painter.setPen(pen); std::vector<LABELS>::iterator the_iterator = label_list.begin(); double x, y, minx=(xMin+(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor),miny=(yMax+(y_pos_shift-increase_height/2)/100*gHeight*widthFactor); double multx=(paintDevice->width().value())/(gWidth* widthFactor*(100-increase_width)/100); double multy=(paintDevice->height().value())/(gHeight*widthFactor*(-1+increase_height/100)); while( the_iterator != label_list.end() ) { x=((*the_iterator).x/scaleFactor-minx)*multx; y=((*the_iterator).y/scaleFactor-miny)*multy; painter.drawText(WRectF( x-(*the_iterator).label.size()*5*labelpercentage, y-5*labelpercentage, (*the_iterator).label.size() *10*labelpercentage,10*labelpercentage),AlignCenter,(*the_iterator).label); ++the_iterator; } pen.setColor(red); painter.setPen(pen); painter.setFont(*font); //painter.drawText(WRectF(paintDevice->width().value()-dfile.size()*10*labelpercentage,paintDevice->height().value()-10*labelpercentage*(paintDevice->height()).value(), dfile.size()*10*labelpercentage,10*labelpercentage ),AlignCenter,dfile); //this text is not seen in the picture when painted. } } }