GNMGFID GNMGenericNetwork::FindNearestPoint(const OGRPoint* poPoint,
const std::vector<OGRLayer*>& paPointLayers,
double dfTolerance)
{
VALIDATE_POINTER1(poPoint, "GNMGenericNetwork::FindNearestPoint", -1);
double dfMinX = poPoint->getX() - dfTolerance;
double dfMinY = poPoint->getY() - dfTolerance;
double dfMaxX = poPoint->getX() + dfTolerance;
double dfMaxY = poPoint->getY() + dfTolerance;
OGRFeature *poFeature;
for(size_t i = 0; i < paPointLayers.size(); ++i)
{
OGRLayer *poLayer = paPointLayers[i];
poLayer->SetSpatialFilterRect(dfMinX, dfMinY,
dfMaxX, dfMaxY);
poLayer->ResetReading();
while((poFeature = poLayer->GetNextFeature()) != NULL)
{
GNMGFID nRetFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID);
OGRFeature::DestroyFeature(poFeature);
return nRetFID;
}
}
return -1;
}
OGRSpatialReference* OGRGeomediaDataSource::GetGeomediaSRS(const char* pszGCoordSystemTable,
const char* pszGCoordSystemGUID)
{
if (pszGCoordSystemTable == NULL || pszGCoordSystemGUID == NULL)
return NULL;
OGRLayer* poGCoordSystemTable = GetLayerByName(pszGCoordSystemTable);
if (poGCoordSystemTable == NULL)
return NULL;
poGCoordSystemTable->ResetReading();
OGRFeature* poFeature;
while((poFeature = poGCoordSystemTable->GetNextFeature()) != NULL)
{
const char* pszCSGUID = poFeature->GetFieldAsString("CSGUID");
if (pszCSGUID && strcmp(pszCSGUID, pszGCoordSystemGUID) == 0)
{
OGRSpatialReference* poSRS = OGRGetGeomediaSRS(poFeature);
delete poFeature;
return poSRS;
}
delete poFeature;
}
return NULL;
}
//本函数返回矢量点的数目
int CGouTIN::read_samplenum(const char* pDataSource,const char* pLayerName,char** pSpatialRefWkt)
{
//将类CIDW做参数
OGRRegisterAll();
OGRDataSource *poDS=OGRSFDriverRegistrar::Open(pDataSource,FALSE);
//OGRDataSource *poDS=OGRSFDriverRegistrar::Open("point.shp",FALSE);
if( poDS == NULL )
{
printf( "[ERROR] zmw Open failed.\n" );
exit( 1 );
}
OGRLayer *poLayer = poDS->GetLayerByName(pLayerName);
//cout<<f3.c_str()<<endl;
//cout<<"here2"<<endl;
//OGRSpatialReference * sref= poLayer->GetSpatialRef();
//sref->exportToWkt(pSpatialRefWkt);
//cout<<"here3"<<endl;
OGRFeature *poFeature;
poLayer->ResetReading();
//cout<<"here4"<<endl;
int count = 0;//统计散点数
while((poFeature=poLayer->GetNextFeature())!=NULL)
{
count++;
}
OGRDataSource::DestroyDataSource( poDS );
return count;
}
int FGdbDataSource::FixIndexes()
{
int bRet = TRUE;
if( m_pConnection && m_pConnection->IsFIDHackInProgress() )
{
m_pConnection->CloseGeodatabase();
char* apszDrivers[2];
apszDrivers[0] = (char*) "OpenFileGDB";
apszDrivers[1] = NULL;
const char* pszSystemCatalog = CPLFormFilename(m_osFSName, "a00000001.gdbtable", NULL);
GDALDataset* poOpenFileGDBDS = (GDALDataset*)
GDALOpenEx(pszSystemCatalog, GDAL_OF_VECTOR,
apszDrivers, NULL, NULL);
if( poOpenFileGDBDS == NULL || poOpenFileGDBDS->GetLayer(0) == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open %s with OpenFileGDB driver. "
"Should not happen. Some layers will be corrupted",
pszSystemCatalog);
bRet = FALSE;
}
else
{
OGRLayer* poLayer = poOpenFileGDBDS->GetLayer(0);
size_t count = m_layers.size();
for(size_t i = 0; i < count; ++i )
{
if( m_layers[i]->m_oMapOGRFIDToFGDBFID.size() == 0)
continue;
CPLString osFilter = "name = '";
osFilter += m_layers[i]->GetName();
osFilter += "'";
poLayer->SetAttributeFilter(osFilter);
poLayer->ResetReading();
OGRFeature* poF = poLayer->GetNextFeature();
if( poF == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find filename for layer %s",
m_layers[i]->GetName());
bRet = FALSE;
}
else
{
if( !m_layers[i]->EditIndexesForFIDHack(CPLFormFilename(m_osFSName,
CPLSPrintf("a%08x", (int)poF->GetFID()), NULL)) )
{
bRet = FALSE;
}
}
delete poF;
}
}
GDALClose(poOpenFileGDBDS);
m_pConnection->SetFIDHackInProgress(FALSE);
}
return bRet;
}
//---------------------------------------------------------
CSG_Shapes * COGR_DataSource::Read_Shapes(int iLayer)
{
OGRLayer *pLayer = Get_Layer(iLayer);
//-----------------------------------------------------
if( pLayer && Get_Type(iLayer) != SHAPE_TYPE_Undefined )
{
int iField;
OGRFeature *pFeature;
OGRFeatureDefn *pDef = pLayer->GetLayerDefn();
CSG_Shapes *pShapes = SG_Create_Shapes(Get_Type(iLayer), CSG_String(pDef->GetName()));
for(iField=0; iField<pDef->GetFieldCount(); iField++)
{
OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField);
pShapes->Add_Field(pDefField->GetNameRef(), COGR_Driver::Get_Type(pDefField->GetType()));
}
pLayer->ResetReading();
//-------------------------------------------------
while( (pFeature = pLayer->GetNextFeature()) != NULL && SG_UI_Process_Get_Okay(false) )
{
OGRGeometry *pGeometry = pFeature->GetGeometryRef();
if( pGeometry != NULL )
{
CSG_Shape *pShape = pShapes->Add_Shape();
for(iField=0; iField<pDef->GetFieldCount(); iField++)
{
OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField);
switch( pDefField->GetType() )
{
default: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break;
case OFTString: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break;
case OFTInteger: pShape->Set_Value(iField, pFeature->GetFieldAsInteger(iField)); break;
case OFTReal: pShape->Set_Value(iField, pFeature->GetFieldAsDouble (iField)); break;
}
}
//-----------------------------------------
if( _Read_Geometry(pShape, pGeometry) == false )
{
pShapes->Del_Shape(pShape);
}
}
OGRFeature::DestroyFeature(pFeature);
}
return( pShapes );
}
//-----------------------------------------------------
return( NULL );
}
void MSN_Helper::LoadSamples(Config &config, Matrix &mat)
{
if(config.bShapefile)
{
OGRRegisterAll();
string pLayerName = StringGetFileName(config.sSamples);
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(config.sSamples.c_str(),FALSE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
config.nSamples = poLayer->GetFeatureCount();
mat.Resize(config.nSamples, 4);
OGRPoint *poPoint;
OGRFeature * pFeature =poLayer->GetNextFeature();
for(unsigned long i=1; i<=config.nSamples; i++)
{
//样本取值字段名为value，double型
poPoint = (OGRPoint *)pFeature->GetGeometryRef();
mat[i][1] = poPoint->getX();
mat[i][2] = poPoint->getY();
mat[i][3] = pFeature->GetFieldAsInteger("stratum");
mat[i][4] = pFeature->GetFieldAsDouble("value");
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
}
else
{
double x, y, v, stratum;
string sline;
ifstream infile(config.sSamples.c_str());
infile >> config.nSamples;
mat.Resize(config.nSamples, 4);
for(unsigned long i=1; i<=config.nSamples; i++)
{
infile >> x >> y >> stratum >> v;
mat[i][1] = x;
mat[i][2] = y;
mat[i][3] = stratum;
mat[i][4] = v;
}
infile.close();
}
}
static
void OGR2SQLITE_ogr_geocode_set_result(sqlite3_context* pContext,
OGRLayerH hLayer,
const char* pszField)
{
if( hLayer == NULL )
sqlite3_result_null (pContext);
else
{
OGRLayer* poLayer = (OGRLayer*)hLayer;
OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn();
OGRFeature* poFeature = poLayer->GetNextFeature();
int nIdx = -1;
if( poFeature == NULL )
sqlite3_result_null (pContext);
else if( strcmp(pszField, "geometry") == 0 &&
poFeature->GetGeometryRef() != NULL )
{
GByte* pabyGeomBLOB = NULL;
int nGeomBLOBLen = 0;
if( OGRSQLiteLayer::ExportSpatiaLiteGeometry(
poFeature->GetGeometryRef(), 4326, wkbNDR, FALSE, FALSE, FALSE,
&pabyGeomBLOB,
&nGeomBLOBLen ) != CE_None )
{
sqlite3_result_null (pContext);
}
else
{
sqlite3_result_blob (pContext, pabyGeomBLOB, nGeomBLOBLen, CPLFree);
}
}
else if( (nIdx = poFDefn->GetFieldIndex(pszField)) >= 0 &&
poFeature->IsFieldSet(nIdx) )
{
OGRFieldType eType = poFDefn->GetFieldDefn(nIdx)->GetType();
if( eType == OFTInteger )
sqlite3_result_int(pContext,
poFeature->GetFieldAsInteger(nIdx));
else if( eType == OFTInteger64 )
sqlite3_result_int64(pContext,
poFeature->GetFieldAsInteger64(nIdx));
else if( eType == OFTReal )
sqlite3_result_double(pContext,
poFeature->GetFieldAsDouble(nIdx));
else
sqlite3_result_text(pContext,
poFeature->GetFieldAsString(nIdx),
-1, SQLITE_TRANSIENT);
}
else
sqlite3_result_null (pContext);
delete poFeature;
OGRGeocodeFreeResult(hLayer);
}
}
bool AoIIntersection::compareIntersectionResults( OGRDataSource *resultData, IntersectionSummary *origSummary )
{
bool success = true;
IntersectionSummary resultSummary;
OGRLayer *resultLayer;
resultSummary.numLayers = resultData->GetLayerCount();
if ( resultSummary.numLayers != origSummary->numLayers )
{
printf( "Test results: Layer count mismatch.\n" );
success = false;
}
for (int layerCt = 0; layerCt < resultSummary.numLayers; ++layerCt)
{
resultLayer = resultData->GetLayer( layerCt );
if ( resultLayer == NULL )
{
printf( "Test results: Layer count mismatch.\n" );
success = false;
}
// get field indices for the fields we wrote
int acreIndex = resultLayer->GetLayerDefn()->GetFieldIndex( "Acres in AoI" );
int areaIndex = resultLayer->GetLayerDefn()->GetFieldIndex( "Percent of AOI" );
resultLayer->ResetReading();
OGRFeature *resultFeature;
while( (resultFeature = resultLayer->GetNextFeature()) != NULL )
{
double acres = resultFeature->GetFieldAsDouble( acreIndex );
double area = resultFeature->GetFieldAsDouble( areaIndex );
resultSummary.totalPercentOfAoI += area;
resultSummary.totalIntersectionAcres += acres;
}
}
if ( resultSummary.totalPercentOfAoI != origSummary->totalPercentOfAoI )
{
printf( "Test results: Percent of AoI mismatch.\n" );
success = false;
}
if ( resultSummary.totalIntersectionAcres != origSummary->totalIntersectionAcres )
{
printf( "Test results: Acreage mismatch.\n" );
success = false;
}
return success;
}
int main() {
// Read in raster data for night time lights
int band_number = 1; // only one band, starts with one
Raster* raster = import_raster("raster.tif", band_number);
// Read in shapefile data containing municipality administrative regions
int layer_number = 0; // only one layer, starts with zero
OGRLayer* shapelayer = import_shapefile("MEX_adm2.shp", layer_number);
shapelayer->SetAttributeFilter("ID_1 = 1834"); // Filter for Yucatan
const int idx_of_number_field = 5; // Column number of municipality number
const int idx_of_name_field = 6; // Column number of municipality name
OGRFeature* poFeature;
int feature_ctr = 0;
while( (poFeature = shapelayer->GetNextFeature()) != NULL ) {
cerr << "Feature: " << feature_ctr++ << "\t";
int feature_num = poFeature->GetFieldAsInteger(idx_of_number_field);
string feature_name = poFeature->GetFieldAsString(idx_of_name_field);
OGRFeatureDefn *poFDefn = shapelayer->GetLayerDefn();
for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) {
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
if( poFieldDefn->GetType() == OFTString ) cerr << poFeature->GetFieldAsString(iField) << ",";
}
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL) {
// For contiguous regions
if ( wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon ) {
cerr << " polygon" << endl;
report_raster_data_within_polygon(raster, (OGRPolygon *) poGeometry, feature_num, feature_name);
// For disjoint regions
} else if ( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon ) {
cerr << " multipolygon" << endl;
OGRMultiPolygon *multipolygon = (OGRMultiPolygon *) poGeometry;
for (int i = 0; i<multipolygon->getNumGeometries(); i++) {
report_raster_data_within_polygon(raster, (OGRPolygon*) multipolygon->getGeometryRef(i), feature_num, feature_name);
}
// Is this really the right shapefile?
} else {
cerr << "No polygon or multipolygon geometry for this feature: " << poGeometry->getGeometryName() << endl;
}
} else {
cerr << "No geometry for this feature" << endl;
}
}
OGRFeature::DestroyFeature( poFeature );
}
bool LoadShapes(GDALDataset* dataset, QueryIntermediateData& qid)
{
OGRLayer* waterLayer = dataset->GetLayerByName("water");
if (!waterLayer) return true; // requested layer may not be present in requested dataset
waterLayer->ResetReading();
OGRFeature* feature;
while ((feature = waterLayer->GetNextFeature()) != NULL)
{
auto geo = feature->GetGeometryRef();
auto featureId = feature->GetFID();
if (qid.transform)
{
if (geo->transform(qid.transform) != OGRERR_NONE)
{
continue;
}
}
if (geo->getGeometryType() == wkbMultiPolygon)
{
auto mp = (OGRMultiPolygon*)geo;
const int numPolys = mp->getNumGeometries();
for (int p = 0; p < numPolys; p++)
{
auto poly = new Polygon((OGRPolygon*)mp->getGeometryRef(p), featureId);
qid.waterPolyQuadtree.Insert(poly);
qid.waterPolygons.push_back(poly);
}
}
else if (geo->getGeometryType() == wkbPolygon)
{
auto poly = new Polygon((OGRPolygon*)geo, featureId);
qid.waterPolyQuadtree.Insert(poly);
qid.waterPolygons.push_back(poly);
}
OGRFeature::DestroyFeature(feature);
}
return true;
}
/** @brief Get list of shapes from file, optional search by name
*
* read in shape file, extract shapes return as list
* optional string argument returns only matching shapes (by string.find)
* (!case sensitive!)
*/
void getAvailShapes(vector<OGRFeature*>* availShapes_p, const string selected = "")
{
OGRRegisterAll();
OGRDataSource * poDS;
string path = "../admin_level_6/shape_al6/admin_level_6.shp";
if (exists(path))
{
poDS = OGRSFDriverRegistrar::Open(path.c_str());
if (poDS == NULL)
{
cout << "Data read error" << endl;
exit (1);
}
}
else
{
cout << "File not found" << endl;
exit(1);
}
// cout << "Found " << poDS->GetLayerCount() << "Layers in File" << endl;
OGRLayer *poLayer;
OGRFeature *poFeature;
poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
while ( (poFeature = poLayer->GetNextFeature()) != NULL)
{
if (selected.empty())
{
availShapes_p->push_back(poFeature);
}
else
{
if (string(poFeature->GetFieldAsString(1)).find(selected) != string::npos)
availShapes_p->push_back(poFeature);
else
OGRFeature::DestroyFeature(poFeature);
}
}
OGRDataSource::DestroyDataSource(poDS);
}
MapExtruder::MapExtruder(const char* map2dFile,double height)
{
_map2dFile = map2dFile;
_height = height;
OGRRegisterAll();
OGRDataSource *poDS = OGRSFDriverRegistrar::Open(_map2dFile,FALSE);
if( poDS == NULL)
{
printf("Open failed.\n");
exit(1);
}
_map2d = new OGRMultiPolygon();
OGRLayer *poLayer;
poLayer = poDS->GetLayer(0);
OGRFeature *poFeature;
poLayer->ResetReading();
while((poFeature = poLayer->GetNextFeature())!=NULL)
{
OGRGeometry *poGeometry;
poGeometry = poFeature ->GetGeometryRef();
if(poGeometry!=NULL)
{
if(poGeometry ->getGeometryType()==wkbPolygon)
_map2d->addGeometry((OGRPolygon*) poGeometry);
if(poGeometry ->getGeometryType()==wkbMultiPolygon)
{
int nPolygons = ((OGRMultiPolygon*)poGeometry)->getNumGeometries();
for(int i=0;i<nPolygons;i++)
_map2d->addGeometry((OGRPolygon*)(((OGRMultiPolygon*)poGeometry)->getGeometryRef(i)));
}
}
}
extrusion();
}
// *************************************************************
// LoadStyle()
// *************************************************************
CStringW OgrStyleHelper::LoadStyle(GDALDataset* dataset, CStringW styleTableName, CStringW layerName, CStringW styleName)
{
USES_CONVERSION;
CStringW sql;
sql.Format(L"SELECT style FROM %s WHERE layername = '%s' AND stylename = '%s'", styleTableName, layerName, styleName);
CStringW xml = L"";
bool found = false;
CPLErrorReset();
OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL);
if (layer) {
OGRFeature* ft = layer->GetNextFeature();
if (ft) {
const char* s = ft->GetFieldAsString(0);
if (s) {
xml = OgrHelper::OgrString2Unicode(s);
}
OGRFeature::DestroyFeature(ft);
}
dataset->ReleaseResultSet(layer);
}
return xml;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjectId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjectId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing project id");
return FALSE;
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
if (osAPIKey.empty())
{
osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY");
}
if (osAPIKey.empty())
{
CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n");
return FALSE;
}
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.empty() )
return FALSE;
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
if (!osDatasets.empty())
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
// If OVERWRITE: YES, truncate the layer.
if( nLayers==1 &&
CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) )
{
TruncateDataset(papoLayers[0]->GetTableName());
}
return TRUE;
} else {
// If 'datasets' word is in the filename, but no dataset id specified,
// print the list of available datasets
if(std::string(pszFilename).find("datasets") != std::string::npos)
ListDatasets();
}
return TRUE;
}
CPLErr GNMGenericNetwork::ChangeAllBlockState(bool bIsBlock)
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return CE_Failure;
}
OGRFeature *poFeature;
m_poGraphLayer->ResetReading();
while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL)
{
if(bIsBlock)
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_ALL );
}
else
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE );
}
if( m_poGraphLayer->SetFeature( poFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." );
return CE_Failure;
}
OGRFeature::DestroyFeature( poFeature );
}
// change all network layers
for(size_t i = 0; i < m_apoLayers.size(); ++i)
{
OGRLayer* poLayer = m_apoLayers[i];
if(NULL == poLayer)
continue;
while ((poFeature = poLayer->GetNextFeature()) != NULL)
{
if(bIsBlock)
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_ALL );
}
else
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE );
}
if( poLayer->SetFeature( poFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." );
return CE_Failure;
}
OGRFeature::DestroyFeature( poFeature );
}
}
m_oGraph.ChangeAllBlockState(bIsBlock);
return CE_None;
}
CPLErr GNMGenericNetwork::ConnectPointsByLines(char **papszLayerList,
double dfTolerance, double dfCost,
double dfInvCost, GNMDirection eDir)
{
if( CSLCount(papszLayerList) < 2 )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Minimum 2 layers needed to connect" );
return CE_Failure;
}
std::vector<OGRLayer*> paLineLayers;
std::vector<OGRLayer*> paPointLayers;
int eType;
int iLayer;
OGRLayer* poLayer;
for(iLayer = 0; papszLayerList[iLayer] != NULL; ++iLayer)
{
poLayer = GetLayerByName(papszLayerList[iLayer]);
if(NULL == poLayer)
continue;
eType = wkbFlatten(poLayer->GetGeomType());
if(eType == wkbLineString || eType == wkbMultiLineString)
{
paLineLayers.push_back(poLayer);
}
else if(eType == wkbPoint)
{
paPointLayers.push_back(poLayer);
}
}
if (paLineLayers.empty() || paPointLayers.empty() )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Need at least one line (or "
"multiline) layer and one point layer to connect" );
return CE_Failure;
}
// now walk through all lines and find nearest points for line start and end
OGRFeature* poFeature;
for(size_t i = 0; i < paLineLayers.size(); ++i)
{
poLayer = paLineLayers[i];
eType = wkbFlatten(poLayer->GetGeomType());
poLayer->ResetReading();
while((poFeature = poLayer->GetNextFeature()) != NULL)
{
const OGRGeometry* poGeom = poFeature->GetGeometryRef();
if(NULL != poGeom)
{
if(eType == wkbLineString)
{
const OGRLineString* poLineString =
(const OGRLineString*) poGeom;
ConnectPointsByLine(poFeature->GetFID(), poLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
else if( eType == wkbMultiLineString)
{
const OGRMultiLineString* poMultiLineString =
(const OGRMultiLineString*) poGeom;
ConnectPointsByMultiline(poFeature->GetFID(), poMultiLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
}
OGRFeature::DestroyFeature(poFeature);
}
}
return CE_None;
}
bool MapWidget::loadCountyShapes()
{
OGRRegisterAll();
std::string filename = g_dataDirectory + "/counties/tl_2009_48_county00.shp";
OGRDataSource * dataSource = OGRSFDriverRegistrar::Open(filename.c_str(), false);
if(dataSource == NULL)
{
put_flog(LOG_ERROR, "could not open %s", filename.c_str());
return false;
}
OGRLayer * layer = dataSource->GetLayerByName("tl_2009_48_county00");
layer->ResetReading();
OGRFeature * feature;
while((feature = layer->GetNextFeature()) != NULL)
{
// get county FIPS code
int nodeId = feature->GetFieldAsInteger("COUNTYFP00");
if(nodeId == 0)
{
put_flog(LOG_WARN, "invalid county");
}
// add a new county to the counties map corresponding to this nodeId
boost::shared_ptr<MapShape> county(new MapShape());
counties_[nodeId] = county;
OGRGeometry * geometry = feature->GetGeometryRef();
if(geometry != NULL && geometry->getGeometryType() == wkbPolygon)
{
OGRPolygon * polygon = (OGRPolygon *)geometry;
OGRLinearRing * ring = polygon->getExteriorRing();
for(int i=0; i<ring->getNumPoints(); i++)
{
// x is longitude, y latitude
county->addVertex(ring->getY(i), ring->getX(i));
}
// set the centroid
OGRPoint centroidPoint;
if(polygon->Centroid(¢roidPoint) == OGRERR_NONE)
{
county->setCentroid(centroidPoint.getY(), centroidPoint.getX());
}
else
{
put_flog(LOG_WARN, "no polygon centroid");
}
}
else
{
put_flog(LOG_WARN, "no polygon geometry");
}
OGRFeature::DestroyFeature(feature);
}
OGRDataSource::DestroyDataSource(dataSource);
return true;
}
boost::optional<mapnik::datasource_geometry_t> ogr_datasource::get_geometry_type() const
{
boost::optional<mapnik::datasource_geometry_t> result;
if (dataset_ && layer_.is_valid())
{
OGRLayer* layer = layer_.layer();
// NOTE: wkbFlatten macro in ogr flattens 2.5d types into base 2d type
#if GDAL_VERSION_NUM < 1800
switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType()))
#else
switch (wkbFlatten(layer->GetGeomType()))
#endif
{
case wkbPoint:
case wkbMultiPoint:
result.reset(mapnik::datasource_geometry_t::Point);
break;
case wkbLinearRing:
case wkbLineString:
case wkbMultiLineString:
result.reset(mapnik::datasource_geometry_t::LineString);
break;
case wkbPolygon:
case wkbMultiPolygon:
result.reset(mapnik::datasource_geometry_t::Polygon);
break;
case wkbGeometryCollection:
result.reset(mapnik::datasource_geometry_t::Collection);
break;
case wkbNone:
case wkbUnknown:
{
// fallback to inspecting first actual geometry
// TODO - csv and shapefile inspect first 4 features
if (dataset_ && layer_.is_valid())
{
layer = layer_.layer();
// only new either reset of setNext
//layer->ResetReading();
layer->SetNextByIndex(0);
OGRFeature *poFeature;
while ((poFeature = layer->GetNextFeature()) != nullptr)
{
OGRGeometry* geom = poFeature->GetGeometryRef();
if (geom && ! geom->IsEmpty())
{
switch (wkbFlatten(geom->getGeometryType()))
{
case wkbPoint:
case wkbMultiPoint:
result.reset(mapnik::datasource_geometry_t::Point);
break;
case wkbLinearRing:
case wkbLineString:
case wkbMultiLineString:
result.reset(mapnik::datasource_geometry_t::LineString);
break;
case wkbPolygon:
case wkbMultiPolygon:
result.reset(mapnik::datasource_geometry_t::Polygon);
break;
case wkbGeometryCollection:
result.reset(mapnik::datasource_geometry_t::Collection);
break;
default:
break;
}
}
OGRFeature::DestroyFeature( poFeature );
break;
}
}
break;
}
default:
break;
}
}
return result;
}
bool ShortNavigation::createObstaclesTables()
{
// OGRLayer* layer;
status = true;
if ( !status==false ) {
qDebug()<<"bool ShortNavigation::createObstaclesTables()";
/// POINT_OFFSET is the area around the obstacle,
/// so is it's value is 5, it will draw 10 m^2
//float POINT_OFFSET = settingsManager->getPOffset();
float POINT_OFFSET = 5; //test values, above comment from old code
//float NOT_ALLOWED_DEPTH = settingsManager->getMinDepth();
float NOT_ALLOWED_DEPTH = 2; //test values, above comment from old code
/// signsound with depth from 0 to this value are
/// taken in consideration for the obstacles layer
//float SIGNSOUND_THRESHOLD = settingsManager->getSignsound();
float SIGNSOUND_THRESHOLD = 1; //test values, above comment from old code
// ##################################################
// list of polygon layers considered obstacles
QList<QString> polygon_layers;
polygon_layers.append("generarea_r");
// list of point layers to be considered as obstacles
QList<QString> point_layers;
point_layers.append("rock_p");
point_layers.append("wreck_p");
point_layers.append("navaid_p");
point_layers.append("signsound_p");
// line layers to be considered as obstacles
QList<QString> line_layers;
line_layers.append("depthcont_l");
//####################################################
for (int i = 0 ; i < this->chartObjects.size(); i++) {
// qDebug() << "chartObjects size" << chartObjects.size();
if(this->chartObjects.at(i)->getTableName() == "generarea_r") {
for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) {
this->polyObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j));
}
}
if(this->chartObjects.at(i)->getTableName() == "depthcont_l") {
for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { //TODO: parse line from polygon
//this->lineObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j)); //Not used in Shortnavigation -> can be removed!
}
}
if(this->chartObjects.at(i)->getTableName() == "rock_p") {
for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { //need to check how vectors are written from DB. is getfeaturecount = polygonvector.size ?
for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) {
this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k));
}
}
}
if(this->chartObjects.at(i)->getTableName() == "wreck_p") {
for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) {
for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) {
this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k));
}
}
}
if(this->chartObjects.at(i)->getTableName() == "navaid_p") {
for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) {
for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) {
this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k));
}
}
}
if(this->chartObjects.at(i)->getTableName() == "signsound_p") {
QVector<QPolygonF> qpoint;
QList<QPointF> listqpoint;
OGRLayer* layer;
OGRFeatureDefn *poFDefn;
OGRFeature *poFeature;
qpoint = this->chartObjects.at(i)->getCoordinateGeometry();
for(int n = 0; n < qpoint.size(); n++){
listqpoint = qpoint.value(n).toList();
}
layer = this->chartObjects.at(i)->getFeatureData();
layer->ResetReading();
QString /*sql("SELECT * FROM *"); //FIX THIS! //*/ sql("SELECT * FROM ( SELECT DISTINCT Intersects( wkb_geometry, ");
for(int m= 0; m < layer->GetFeatureCount();m++ ) {
poFDefn = layer->GetLayerDefn();
poFeature = layer->GetNextFeature();
for(int j = 0; j < poFDefn->GetFieldCount(); j++ ){
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( j );
QString str = poFieldDefn->GetNameRef();
if(str.contains("depth") == true) {
if (poFeature->GetFieldAsDouble(j) < SIGNSOUND_THRESHOLD) { //parse out depths above signsound threshold since they are not obstacles
pointObstacles.append(listqpoint.at(m));
}
}
}
}
// // CREATE NEW TABLES
sql = "CREATE TABLE obstacles_r (ogc_fid serial);";
sql.append( "CREATE TABLE obstacles_l (ogc_fid serial);" );
sql.append( "SELECT AddGeometryColumn ('obstacles_r','wkb_geometry',-1,'POLYGON',2);" );
sql.append( "SELECT AddGeometryColumn ('obstacles_l','wkb_geometry',-1,'LINESTRING',2);" );
sql.append( "ALTER TABLE obstacles_r ADD COLUMN source_table char(11);" );
sql.append( "ALTER TABLE obstacles_l ADD COLUMN source_table char(11);" );
res = PQexec(conn, sql.toAscii() );
PQclear(res);
// INSERT POLYGON LAYERS
sql.clear();
// DIRECT VERSION, WITHOUT ADDING THE OFFSET
for ( int i = 0; i < polygon_layers.size(); i++ ) {
sql.append( "INSERT INTO obstacles_r( wkb_geometry, source_table) SELECT wkb_geometry, '");
sql.append( polygon_layers[i] );
sql.append( "' AS source_table FROM " );
sql.append( polygon_layers[i] );
sql.append( ";" );
if (debug) qDebug() << QString("UwShort: Adding obstacles of %1").arg( polygon_layers[i]);
}
// WARNING: very long string:
res = PQexec(conn, sql.toAscii() );
PQclear(res);
qDebug() << "for in 1"; // INSERT POINT LAYERS WITH OFFSET
for ( int i = 0; i < point_layers.size(); i++ ) {
bool signsound = ( point_layers[i] == "signsound_p" );
sql = "SELECT X(wkb_geometry),Y(wkb_geometry)";
if ( signsound)
sql.append( ",depth");
sql.append( " FROM ");
sql.append( point_layers[i] );
if ( signsound)
sql.append( QString(" WHERE depth < %1 ").arg( QString::number( SIGNSOUND_THRESHOLD)));
sql.append( ";");
res = PQexec(conn, sql.toAscii() );
if (debug) qDebug() << QString("UwShort: Adding obstacles of %1 (%2/%3): %4 obstacles").arg( point_layers[i], QString::number(i+1), QString::number(point_layers.size()), QString::number(PQntuples(res)));
sql.clear();
for ( int j = 0; j < PQntuples(res); j++ ) {
QPointF point( QString( PQgetvalue( res, j, 0)).toDouble(), QString( PQgetvalue( res, j, 1)).toDouble()); //forms a qpoint double precision
sql.append( "INSERT INTO obstacles_r ( wkb_geometry, source_table) VALUES ( ");
if ( point_layers[i] == "rock_p")
sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET * POINT_OFFSET_FACTOR_ROCK ));
else if ( point_layers[i] == "wreck_p" )
sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET * POINT_OFFSET_FACTOR_ROCK ));
else if ( signsound)
// for signsound POINT_OFFSET = POINT_OFFSET / ( depth of signsound / factor )
// the bigger the signsound is, the bigger the point offset gets
sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET / ( QString( PQgetvalue( res, j, 2)).toDouble() / POINT_OFFSET_FACTOR_SIGNSOUND ) ));
else
sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET));
sql.append( ", '");
sql.append( point_layers[i]);
sql.append( "'); ");
}
PQclear(res);
res = PQexec( conn, sql.toAscii());
PQclear(res);
//INSERT LINE LAYERS
sql.clear();
for ( int i = 0; i < line_layers.size(); i++ ) {
sql.append( "INSERT INTO obstacles_l( wkb_geometry, source_table) SELECT wkb_geometry, '");
sql.append( line_layers[i]);
sql.append( "' AS source_table FROM " );
sql.append( line_layers[i] );
if ( line_layers[i] == "depthcont_l" ) {
sql.append( " WHERE valdco<=" );
sql.append( QString::number( NOT_ALLOWED_DEPTH));
}
sql.append( ";");
if (debug) {
// WARNING: very long string:
qDebug() << QString("UwShort: Adding obstacles of ").append( line_layers[i]);
}
res = PQexec(conn, sql.toAscii() );
PQclear(res);
}
// for loop for testing
// for (int s=0; s<pointObstacles.size();s++){
// qDebug() << " index: " << s << "point x" << pointObstacles.at(s).x() << "y" << pointObstacles.at(s).y();
// }
// tables are done
this->obstaclesTablesCreated = true;
qDebug("createObstaclesTables() returns = true");
return true;
}
}
}
}else {
// tables are not done
this->obstaclesTablesCreated = false;
return false;
}
}
void DataCvt_Log::CalAsShp()
{
double ptmptime_start = MPI_Wtime();
OGRRegisterAll();
//create a new shp to caculate
CBaseOperate pbaseOperate;
if(rankid==0)
{
pbaseOperate.CreateCopyShp(m_DatasourceConStr.c_str(),m_PathOrTableName.c_str(),m_ResultPathOrTableName.c_str());
}
MPI_Barrier(MPI_COMM_WORLD);
string pLayerName = m_ResultPathOrTableName;
if(strcmp(m_DatasourceConStr.c_str(),"")==0)//input is shp file
{
m_DatasourceConStr = m_ResultPathOrTableName;
string pShpPath = m_ResultPathOrTableName;
string p_LayerName = GetFileNameOnly(pShpPath.c_str());
int pindex = p_LayerName.find_first_of('.');
pLayerName = p_LayerName.erase(pindex,p_LayerName.size()-1);
}
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(m_DatasourceConStr.c_str(),TRUE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
OGRFeature * pFeature =poLayer->GetNextFeature();
m_RowNum = poLayer->GetFeatureCount();
//if -c argv is null, all field will be used
m_ColNum= pFeature->GetFieldCount();
if(c_CaculateCols.size()==0)
{
if(rankid==0)
cout<<"!!!!!!! No input columns ids, all fields in the input file will be used..."<<endl<<endl;
for(int i=0;i<m_ColNum;i++)
{
c_CaculateCols.push_back(i);
}
}
double ptmptime_end = MPI_Wtime();
m_GdalIOInCal_Time=m_GdalIOInCal_Time+ptmptime_end-ptmptime_start;
//assign number to each process
int pnum_start,pnum_end;
int pMyProcessNum=0; int pRemainder=m_RowNum%numproc;
if(rankid<pRemainder)
{
pMyProcessNum = m_RowNum/numproc+1;
pnum_start = rankid*pMyProcessNum;
pnum_end = pnum_start+pMyProcessNum-1;
}
else
{
pMyProcessNum = m_RowNum/numproc;
pnum_start = pRemainder*(pMyProcessNum+1)+(rankid-pRemainder)*pMyProcessNum;
pnum_end = pnum_start+pMyProcessNum-1;
}
//postgis: fid begins from 1, not 0
string pwhere="";
if(strcmp(m_DatasourceConStr.substr(0,3).c_str(),"PG:")==0)//input is postgis
{
pwhere = "gid>="+toString(pnum_start+1)+" and gid<="+toString(pnum_end+1);
}
else//shpfile: fid begins from 0, not 1
{
pwhere = "fid>="+toString(pnum_start)+" and fid<="+toString(pnum_end);
}
poLayer->SetAttributeFilter(pwhere.c_str());
pFeature = poLayer->GetNextFeature();
while(pFeature!=NULL)
{
for(int i=0;i<c_CaculateCols.size();i++)
{
double tmp = pFeature->GetFieldAsDouble(c_CaculateCols[i]);
if(tmp!=0)
tmp = log(fabs(tmp));
else
tmp=0;
double pstart = MPI_Wtime();
pFeature->SetField(c_CaculateCols[i],tmp);
poLayer->SetFeature(pFeature);
double pend = MPI_Wtime();
m_GdalIOInCal_Time = m_GdalIOInCal_Time+pend-pstart;
}
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
double ptmptime_endall = MPI_Wtime();
Mpi_Caculate_Time = ptmptime_endall-ptmptime_start-m_GdalIOInCal_Time;
double tmp=Mpi_Caculate_Time;
MPI_Reduce(&Mpi_Caculate_Time,&tmp,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD);
Mpi_Caculate_Time = tmp;
}
static OGRGeometryCollection* LoadGeometry( const char* pszDS,
const char* pszSQL,
const char* pszLyr,
const char* pszWhere )
{
OGRDataSource *poDS;
OGRLayer *poLyr;
OGRFeature *poFeat;
OGRGeometryCollection *poGeom = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDS, FALSE );
if ( poDS == NULL )
return NULL;
if ( pszSQL != NULL )
poLyr = poDS->ExecuteSQL( pszSQL, NULL, NULL );
else if ( pszLyr != NULL )
poLyr = poDS->GetLayerByName( pszLyr );
else
poLyr = poDS->GetLayer(0);
if ( poLyr == NULL )
{
fprintf( stderr,
"FAILURE: Failed to identify source layer from datasource.\n" );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
if ( pszWhere )
poLyr->SetAttributeFilter( pszWhere );
while ( (poFeat = poLyr->GetNextFeature()) != NULL )
{
OGRGeometry* poSrcGeom = poFeat->GetGeometryRef();
if ( poSrcGeom )
{
OGRwkbGeometryType eType =
wkbFlatten( poSrcGeom->getGeometryType() );
if ( poGeom == NULL )
poGeom = new OGRMultiPolygon();
if ( eType == wkbPolygon )
poGeom->addGeometry( poSrcGeom );
else if ( eType == wkbMultiPolygon )
{
int iGeom;
int nGeomCount =
((OGRMultiPolygon *)poSrcGeom)->getNumGeometries();
for ( iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
poGeom->addGeometry(
((OGRMultiPolygon *)poSrcGeom)->getGeometryRef(iGeom) );
}
}
else
{
fprintf( stderr, "FAILURE: Geometry not of polygon type.\n" );
OGRGeometryFactory::destroyGeometry( poGeom );
OGRFeature::DestroyFeature( poFeat );
if ( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
}
OGRFeature::DestroyFeature( poFeat );
}
if( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return poGeom;
}
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;
}
int Raster::VectortoRaster(const char * sVectorSourcePath,
const char * sRasterOutputPath,
const char * psFieldName,
RasterMeta * p_rastermeta ){
OGRRegisterAll();
OGRDataSource * pDSVectorInput;
pDSVectorInput = OGRSFDriverRegistrar::Open( sVectorSourcePath, FALSE );
if (pDSVectorInput == NULL)
return INPUT_FILE_ERROR;
OGRLayer * poLayer = pDSVectorInput->GetLayer(0);
// The type of the field.
OGRFeature * feat1 = poLayer->GetFeature(0);
int fieldindex = feat1->GetFieldIndex(psFieldName);
OGRFieldType fieldType = feat1->GetFieldDefnRef(fieldindex)->GetType();
OGRFeature::DestroyFeature( feat1 );
// The data type we're going to use for the file
GDALDataType OutputDataType = GDT_Byte;
// Handle field types according to their type:
switch (fieldType) {
case OFTString:
CSVWriteVectorValues(poLayer, psFieldName, sRasterOutputPath);
break;
case OFTInteger:
break;
case OFTReal:
OutputDataType = GDT_Float64;
default:
throw RasterManagerException(VECTOR_FIELD_NOT_VALID, "Type of field not recognized.");
break;
}
// Get our projection and set the rastermeta accordingly.
// -------------------------------------------------------
char *pszWKT = NULL;
OGRSpatialReference* poSRS = poLayer->GetSpatialRef();
poSRS->exportToWkt(&pszWKT);
p_rastermeta->SetProjectionRef(pszWKT);
CPLFree(pszWKT);
OSRDestroySpatialReference(poSRS);
// Create the output dataset for writing
GDALDataset * pDSOutput = CreateOutputDS(sRasterOutputPath, p_rastermeta);
// Create a list of burn-in values
// -------------------------------------------------------
std::vector<OGRGeometryH> ogrBurnGeometries;
std::vector<double> dBurnValues;
poLayer->ResetReading();
OGRFeature * ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory
while( ogrFeat != NULL ){
OGRGeometry * ogrGeom = ogrFeat->GetGeometryRef();
// No geometry found. Move along.
if( ogrGeom == NULL )
{
OGRFeature::DestroyFeature( ogrFeat );
continue;
}
OGRGeometry * geoClone = ogrGeom->clone(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory AND LEAK 20 direct bytes
// Push a clone of this geometry onto the list of shapes to burn
ogrBurnGeometries.push_back( (OGRGeometryH) geoClone );
if (fieldType == OFTString){
// If it's a string type we burn the FID. The value is then placed in a CSV file
dBurnValues.push_back( ogrFeat->GetFID() );
}
else {
// If it's a float type or a byte type we write it directly.
dBurnValues.push_back( ogrFeat->GetFieldAsDouble(psFieldName) );
}
// GetNextFeature() creates a clone so we must delete it.
OGRFeature::DestroyFeature( ogrFeat ); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds:
ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory
}
// Do the Actual Burning of Geometries.
// -------------------------------------------------------
int band = 1;
char **papszRasterizeOptions = NULL;
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
CPLErr err = GDALRasterizeGeometries( pDSOutput, 1, &band,
ogrBurnGeometries.size(),
&(ogrBurnGeometries[0]),
NULL, NULL,
&(dBurnValues[0]),
NULL,
NULL, NULL );
if (err) { }
ogrBurnGeometries.clear();
dBurnValues.clear();
// Done. Calculate stats and close file
CalculateStats(pDSOutput->GetRasterBand(1));
CSLDestroy(papszRasterizeOptions);
GDALClose(pDSOutput);
pDSVectorInput->Release(); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds:
//This is where the implementation actually goes
return PROCESS_OK;
}
void
NIImporter_ArcView::load() {
#ifdef HAVE_GDAL
PROGRESS_BEGIN_MESSAGE("Loading data from '" + mySHPName + "'");
#if GDAL_VERSION_MAJOR < 2
OGRRegisterAll();
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(mySHPName.c_str(), FALSE);
#else
GDALAllRegister();
GDALDataset* poDS = (GDALDataset*)GDALOpenEx(mySHPName.c_str(), GDAL_OF_VECTOR | GA_ReadOnly, NULL, NULL, NULL);
#endif
if (poDS == NULL) {
WRITE_ERROR("Could not open shape description '" + mySHPName + "'.");
return;
}
// begin file parsing
OGRLayer* poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
// build coordinate transformation
OGRSpatialReference* origTransf = poLayer->GetSpatialRef();
OGRSpatialReference destTransf;
// use wgs84 as destination
destTransf.SetWellKnownGeogCS("WGS84");
OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf);
if (poCT == NULL) {
if (myOptions.isSet("shapefile.guess-projection")) {
OGRSpatialReference origTransf2;
origTransf2.SetWellKnownGeogCS("WGS84");
poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf);
}
if (poCT == 0) {
WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed.");
}
}
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// read in edge attributes
std::string id, name, from_node, to_node;
if (!getStringEntry(poFeature, "shapefile.street-id", "LINK_ID", true, id)) {
WRITE_ERROR("Needed field '" + id + "' (from node id) is missing.");
}
if (id == "") {
WRITE_ERROR("Could not obtain edge id.");
return;
}
getStringEntry(poFeature, "shapefile.street-id", "ST_NAME", true, name);
name = StringUtils::replace(name, "&", "&");
if (!getStringEntry(poFeature, "shapefile.from-id", "REF_IN_ID", true, from_node)) {
WRITE_ERROR("Needed field '" + from_node + "' (from node id) is missing.");
}
if (!getStringEntry(poFeature, "shapefile.to-id", "NREF_IN_ID", true, to_node)) {
WRITE_ERROR("Needed field '" + to_node + "' (to node id) is missing.");
}
if (from_node == "" || to_node == "") {
from_node = toString(myRunningNodeID++);
to_node = toString(myRunningNodeID++);
}
std::string type;
if (myOptions.isSet("shapefile.type-id") && poFeature->GetFieldIndex(myOptions.getString("shapefile.type-id").c_str()) >= 0) {
type = poFeature->GetFieldAsString(myOptions.getString("shapefile.type-id").c_str());
} else if (poFeature->GetFieldIndex("ST_TYP_AFT") >= 0) {
type = poFeature->GetFieldAsString("ST_TYP_AFT");
}
SUMOReal width = myTypeCont.getWidth(type);
SUMOReal speed = getSpeed(*poFeature, id);
int nolanes = getLaneNo(*poFeature, id, speed);
int priority = getPriority(*poFeature, id);
if (nolanes == 0 || speed == 0) {
if (myOptions.getBool("shapefile.use-defaults-on-failure")) {
nolanes = myTypeCont.getNumLanes("");
speed = myTypeCont.getSpeed("");
} else {
OGRFeature::DestroyFeature(poFeature);
WRITE_ERROR("The description seems to be invalid. Please recheck usage of types.");
return;
}
}
if (mySpeedInKMH) {
speed = speed / (SUMOReal) 3.6;
}
// read in the geometry
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
OGRwkbGeometryType gtype = poGeometry->getGeometryType();
assert(gtype == wkbLineString);
UNUSED_PARAMETER(gtype); // ony used for assertion
OGRLineString* cgeom = (OGRLineString*) poGeometry;
if (poCT != 0) {
// try transform to wgs84
cgeom->transform(poCT);
}
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!NBNetBuilder::transformCoordinate(pos)) {
WRITE_WARNING("Unable to project coordinates for edge '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
// build from-node
NBNode* from = myNodeCont.retrieve(from_node);
if (from == 0) {
Position from_pos = shape[0];
from = myNodeCont.retrieve(from_pos);
if (from == 0) {
from = new NBNode(from_node, from_pos);
if (!myNodeCont.insert(from)) {
WRITE_ERROR("Node '" + from_node + "' could not be added");
delete from;
continue;
}
}
}
// build to-node
NBNode* to = myNodeCont.retrieve(to_node);
if (to == 0) {
Position to_pos = shape[-1];
to = myNodeCont.retrieve(to_pos);
if (to == 0) {
to = new NBNode(to_node, to_pos);
if (!myNodeCont.insert(to)) {
WRITE_ERROR("Node '" + to_node + "' could not be added");
delete to;
continue;
}
}
}
if (from == to) {
WRITE_WARNING("Edge '" + id + "' connects identical nodes, skipping.");
continue;
}
// retrieve the information whether the street is bi-directional
std::string dir;
int index = poFeature->GetDefnRef()->GetFieldIndex("DIR_TRAVEL");
if (index >= 0 && poFeature->IsFieldSet(index)) {
dir = poFeature->GetFieldAsString(index);
}
// add positive direction if wanted
if (dir == "B" || dir == "F" || dir == "" || myOptions.getBool("shapefile.all-bidirectional")) {
if (myEdgeCont.retrieve(id) == 0) {
LaneSpreadFunction spread = dir == "B" || dir == "FALSE" ? LANESPREAD_RIGHT : LANESPREAD_CENTER;
NBEdge* edge = new NBEdge(id, from, to, type, speed, nolanes, priority, width, NBEdge::UNSPECIFIED_OFFSET, shape, name, id, spread);
myEdgeCont.insert(edge);
checkSpread(edge);
}
}
// add negative direction if wanted
if (dir == "B" || dir == "T" || myOptions.getBool("shapefile.all-bidirectional")) {
if (myEdgeCont.retrieve("-" + id) == 0) {
LaneSpreadFunction spread = dir == "B" || dir == "FALSE" ? LANESPREAD_RIGHT : LANESPREAD_CENTER;
NBEdge* edge = new NBEdge("-" + id, to, from, type, speed, nolanes, priority, width, NBEdge::UNSPECIFIED_OFFSET, shape.reverse(), name, id, spread);
myEdgeCont.insert(edge);
checkSpread(edge);
}
}
//
OGRFeature::DestroyFeature(poFeature);
}
#if GDAL_VERSION_MAJOR < 2
OGRDataSource::DestroyDataSource(poDS);
#else
GDALClose(poDS);
#endif
PROGRESS_DONE_MESSAGE();
#else
WRITE_ERROR("SUMO was compiled without GDAL support.");
#endif
}
void Dust::MakeGrid(WindNinjaInputs &input, AsciiGrid<double> &grid)
{
/*------------------------------------------*/
/* Open grid as a GDAL dataset */
/*------------------------------------------*/
int nXSize = grid.get_nCols();
int nYSize = grid.get_nRows();
GDALDriverH hDriver = GDALGetDriverByName( "MEM" );
GDALDatasetH hMemDS = GDALCreate(hDriver, "", nXSize, nYSize, 1, GDT_Float64, NULL);
double *padfScanline;
padfScanline = new double[nXSize];
double adfGeoTransform[6];
adfGeoTransform[0] = grid.get_xllCorner();
adfGeoTransform[1] = grid.get_cellSize();
adfGeoTransform[2] = 0;
adfGeoTransform[3] = grid.get_yllCorner()+(grid.get_nRows()*grid.get_cellSize());
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -grid.get_cellSize();
char* pszDstWKT = (char*)grid.prjString.c_str();
GDALSetProjection(hMemDS, pszDstWKT);
GDALSetGeoTransform(hMemDS, adfGeoTransform);
GDALRasterBandH hBand = GDALGetRasterBand( hMemDS, 1 );
GDALSetRasterNoDataValue(hBand, -9999.0);
for(int i=nYSize-1; i>=0; i--)
{
for(int j=0; j<nXSize; j++)
{
padfScanline[j] = grid.get_cellValue(nYSize-1-i, j);
}
GDALRasterIO(hBand, GF_Write, 0, i, nXSize, 1, padfScanline, nXSize,
1, GDT_Float64, 0, 0);
}
/*------------------------------------------*/
/* Get the geometry info */
/*------------------------------------------*/
OGRDataSourceH hOGRDS = 0;
hOGRDS = OGROpen(input.dustFilename.c_str(), FALSE, 0);
if(hOGRDS == NULL)
{
throw std::runtime_error("Could not open the fire perimeter file '" +
input.dustFilename + "' for reading.");
}
OGRLayer *poLayer;
OGRFeature *poFeature;
OGRGeometry *poGeo;
poLayer = (OGRLayer*)OGR_DS_GetLayer(hOGRDS, 0);
poLayer->ResetReading();
poFeature = poLayer->GetNextFeature();
poGeo = poFeature->GetGeometryRef();
OGRGeometryH hPolygon = (OGRGeometryH) poGeo;
/* -------------------------------------------------------------------- */
/* Check for same CRS in fire perimeter and DEM files */
/* -------------------------------------------------------------------- */
char *pszSrcWKT;
OGRSpatialReference *poSrcSRS, oDstSRS;
poSrcSRS = poLayer->GetSpatialRef(); //shapefile CRS
poSrcSRS->exportToWkt( &pszSrcWKT );
//printf("CRS of DEM is:\n %s\n", pszDstWKT);
//printf("WKT CRS of .shp is:\n %s\n", pszSrcWKT);
oDstSRS.importFromWkt( &pszDstWKT );
char *pszDstProj4, *pszSrcProj4;
oDstSRS.exportToProj4( &pszDstProj4 );
poSrcSRS->exportToProj4( &pszSrcProj4 );
//printf("proj4 of .shp is:\n %s\n", pszSrcProj4);
//printf("proj4 of dem is:\n %s\n", pszDstProj4);
/* -------------------------------------------------------------------- */
/* If the CRSs are not equal, convert shapefile CRS to DEM CRS */
/* -------------------------------------------------------------------- */
GDALTransformerFunc pfnTransformer = NULL;
if( !EQUAL( pszSrcProj4, pszDstProj4 ) ){ //tranform shp CRS to DEM CRS
poGeo->transformTo(&oDstSRS);
}
/* -------------------------------------------------------------------- */
/* Rasterize the shapefile */
/* -------------------------------------------------------------------- */
int nTargetBand = 1;
double BurnValue = 1.0;
CPLErr eErr;
eErr = GDALRasterizeGeometries(hMemDS, 1, &nTargetBand, 1, &hPolygon, pfnTransformer, NULL, &BurnValue, NULL, NULL, NULL);
if(eErr != CE_None)
{
throw std::runtime_error("Error in GDALRasterizeGeometies in Dust:MakeGrid().");
}
GDAL2AsciiGrid((GDALDataset*)hMemDS, 1, grid);
/* -------------------------------------------------------------------- */
/* clean up */
/* -------------------------------------------------------------------- */
if( hMemDS != NULL ){
GDALClose( hMemDS );
hMemDS = NULL;
}
OGR_DS_Destroy(hOGRDS);
}
//coordinate;//(double x, double y);
//contains the baseline/collection of baselines for the shoreline
void ShoreLine::getShapePoints(string filename){
RegisterOGRShape(); // OGR Drivers for reading shapefiles only
OGRDataSource *poDS;
cout<<"Reading in file shapefile"<<filename<<endl;
poDS = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE );
if ( poDS == NULL ){
printf("Open fail");
exit(1);
}
OGRLayer *poLayer;
poLayer = poDS->GetLayer(0);
OGRGeometry *poGeometry;
//poGeometry = poLayer->
OGRFeature *poFeature;
poFeature= poLayer->GetNextFeature();
poLayer->ResetReading();
if (poGeometry==NULL){
return;
}
switch(wkbFlatten(poGeometry->getGeometryType()))
{
case wkbPoint:
{ ((OGRPoint*)poGeometry);/////////////////////////
break;
}
case wkbLineString:
case wkbLinearRing:
{
OGRLineString* poLS = (OGRLineString*) poGeometry;
for(int i=0;i<poLS->getNumPoints();i++)
shoreLinePoints.push_back(coordinate(poLS->getX(i),poLS->getY(i)));
break;
}
case wkbPolygon:
{
int i;
OGRPolygon* poPoly = (OGRPolygon*) poGeometry;
//SetZ(poPoly->getExteriorRing(), dfZ);
for(i=0;i<poPoly->getNumInteriorRings();i++)
// SetZ(poPoly->getInteriorRing(i), dfZ);
break;
}
case wkbMultiPoint:
case wkbMultiLineString:
case wkbMultiPolygon:
case wkbGeometryCollection:
{
int i;
OGRGeometryCollection* poGeometryColl = (OGRGeometryCollection*) poGeometry;
for(i=0;i<poGeometryColl->getNumGeometries();i++)
// SetZ(poGeometryColl->getGeometryRef(i), dfZ);
break;
}
default:
printf( "no readable geometry\n" );
break;
}
OGRFeature::DestroyFeature( poFeature );
OGRDataSource::DestroyDataSource( poDS );
return;
}
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;
}
bool shape::load(string filename)
{
OGRRegisterAll();
// First open the shape file
ds = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE );
// Now to load in the points .....
points = vector<vector<glm::vec2>>();
// Grab the first layer
OGRLayer* layer = ds->GetLayer(0);
// Grab the spatial reference and create a coordinate transform function
sr = layer->GetSpatialRef();
// Taking from http://www.compsci.wm.edu/SciClone/documentation/software/geo/gdal-1.9.0/html/ogr/ogr_apitut.html
OGRFeature *poFeature;
layer->ResetReading();
while( (poFeature = layer->GetNextFeature()) != NULL )
{
OGRFeatureDefn *poFDefn = layer->GetLayerDefn();
int iField;
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
//printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() );
}
else if (poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbLineString)
{
//cout << "LINES!!!!" << endl;
OGRLineString* ls= (OGRLineString*)poGeometry;
points.push_back(vector<glm::vec2>());
for(int i = 0; i < ls->getNumPoints(); i++ )
{
OGRPoint p;
ls->getPoint(i,&p);
// This function can transform a larget set of points.....
double x = p.getX();
double y = p.getY();
points[points.size()-1].push_back(glm::vec2(x,y));
//poTransform->Transform (1, &x, &y);
//cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl;
}
}
else if (poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon)
{
OGRLineString* ls= (OGRLineString*)poGeometry->getBoundary();
points.push_back(vector<glm::vec2>());
cout << "POLYGON" << ls->getNumPoints() << endl;
//exit(0);
for(int i = 0; i < ls->getNumPoints(); i++ )
{
OGRPoint p;
ls->getPoint(i,&p);
// This function can transform a larget set of points.....
double x = p.getX();
double y = p.getY();
points[points.size()-1].push_back(glm::vec2(x,y));
//poTransform->Transform (1, &x, &y);
//cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl;
}
}
OGRFeature::DestroyFeature( poFeature );
}
return true;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") )
pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID"));
else
{
pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjetctId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjetctId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id");
return FALSE;
}
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES"));
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.size() == 0 )
return FALSE;
if (osDatasets.size() != 0)
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
return TRUE;
}
return TRUE;
}
void
PCLoaderArcView::load(const std::string& file, OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap&) {
#ifdef HAVE_GDAL
GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing();
// get defaults
std::string prefix = oc.getString("prefix");
std::string type = oc.getString("type");
RGBColor color = RGBColor::parseColor(oc.getString("color"));
int layer = oc.getInt("layer");
std::string idField = oc.getString("shapefile.id-column");
bool useRunningID = oc.getBool("shapefile.use-running-id");
// start parsing
std::string shpName = file + ".shp";
OGRRegisterAll();
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(shpName.c_str(), FALSE);
if (poDS == NULL) {
throw ProcessError("Could not open shape description '" + shpName + "'.");
}
// begin file parsing
OGRLayer* poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
// build coordinate transformation
OGRSpatialReference* origTransf = poLayer->GetSpatialRef();
OGRSpatialReference destTransf;
// use wgs84 as destination
destTransf.SetWellKnownGeogCS("WGS84");
OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf);
if (poCT == NULL) {
if (oc.isSet("shapefile.guess-projection")) {
OGRSpatialReference origTransf2;
origTransf2.SetWellKnownGeogCS("WGS84");
poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf);
}
if (poCT == 0) {
WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed.");
}
}
OGRFeature* poFeature;
poLayer->ResetReading();
unsigned int runningID = 0;
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// read in edge attributes
std::string id = useRunningID ? toString(runningID) : poFeature->GetFieldAsString(idField.c_str());
++runningID;
id = StringUtils::prune(id);
if (id == "") {
throw ProcessError("Missing id under '" + idField + "'");
}
id = prefix + id;
// read in the geometry
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry == 0) {
OGRFeature::DestroyFeature(poFeature);
continue;
}
// try transform to wgs84
poGeometry->transform(poCT);
OGRwkbGeometryType gtype = poGeometry->getGeometryType();
switch (gtype) {
case wkbPoint: {
OGRPoint* cgeom = (OGRPoint*) poGeometry;
Position pos((SUMOReal) cgeom->getX(), (SUMOReal) cgeom->getY());
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + id + "'.");
}
PointOfInterest* poi = new PointOfInterest(id, type, color, pos, (SUMOReal)layer);
if (!toFill.insert(id, poi, layer)) {
WRITE_ERROR("POI '" + id + "' could not be added.");
delete poi;
}
}
break;
case wkbLineString: {
OGRLineString* cgeom = (OGRLineString*) poGeometry;
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, false, (SUMOReal)layer);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not be added.");
delete poly;
}
}
break;
case wkbPolygon: {
OGRLinearRing* cgeom = ((OGRPolygon*) poGeometry)->getExteriorRing();
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, true, (SUMOReal)layer);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not be added.");
delete poly;
}
}
break;
case wkbMultiPoint: {
OGRMultiPoint* cgeom = (OGRMultiPoint*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRPoint* cgeom2 = (OGRPoint*) cgeom->getGeometryRef(i);
Position pos((SUMOReal) cgeom2->getX(), (SUMOReal) cgeom2->getY());
std::string tid = id + "#" + toString(i);
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + tid + "'.");
}
PointOfInterest* poi = new PointOfInterest(tid, type, color, pos, (SUMOReal)layer);
if (!toFill.insert(tid, poi, layer)) {
WRITE_ERROR("POI '" + tid + "' could not be added.");
delete poi;
}
}
}
break;
case wkbMultiLineString: {
OGRMultiLineString* cgeom = (OGRMultiLineString*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLineString* cgeom2 = (OGRLineString*) cgeom->getGeometryRef(i);
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, false, (SUMOReal)layer);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not be added.");
delete poly;
}
}
}
break;
case wkbMultiPolygon: {
OGRMultiPolygon* cgeom = (OGRMultiPolygon*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLinearRing* cgeom2 = ((OGRPolygon*) cgeom->getGeometryRef(i))->getExteriorRing();
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, true, (SUMOReal)layer);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not be added.");
delete poly;
}
}
}
break;
default:
WRITE_WARNING("Unsupported shape type occured (id='" + id + "').");
break;
}
OGRFeature::DestroyFeature(poFeature);
}
PROGRESS_DONE_MESSAGE();
#else
WRITE_ERROR("SUMO was compiled without GDAL support.");
#endif
}
