void WaterDemandModel::run()
{
initmodel();
OGRFeature * p;
this->parcels.resetReading();
//Calculate outdoor demand for standard unit (100m2 roof, 100m2 garden, 1 person)
double imp_fraction = 0.2;
calculateRunoffAndDemand(500, imp_fraction, 0.8, 1);
while(p = this->parcels.getNextFeature()) {
double persons = p->GetFieldAsDouble("persons");
double garden_area = p->GetFieldAsDouble("garden_area");
double roof_area = p->GetFieldAsDouble("roof_area");
// this->stormwater_runoff = *(flow_probe_runoff->getState<std::vector<double> >("Flow"));
// this->non_potable_demand = *(nonpot_before->getState<std::vector<double> >("Flow"));
// this->potable_demand = *(pot_before->getState<std::vector<double> >("Flow"));
// this->outdoor_demand = *(flow_probe_outdoor->getState<std::vector<double> >("Flow"));
// parcels.addAttribute("non_potable_demand_daily", DM::Attribute::DOUBLE, DM::WRITE);
// parcels.addAttribute("potable_demand_daily", DM::Attribute::DOUBLE, DM::WRITE);
// parcels.addAttribute("outdoor_demand_daily", DM::Attribute::DOUBLE, DM::WRITE);
// parcels.addAttribute("run_off_roof_daily", DM::Attribute::DOUBLEVECTOR, DM::WRITE);
DM::DMFeature::SetDoubleList( p, "potable_demand_daily", this->mutiplyVector(this->potable_demand, persons));
DM::DMFeature::SetDoubleList( p, "non_potable_demand_daily", this->mutiplyVector(this->non_potable_demand, persons));
DM::DMFeature::SetDoubleList( p, "outdoor_demand_daily", this->mutiplyVector(this->outdoor_demand,garden_area/400.));
//DM::DMFeature::SetDoubleList( p, "outdoor_demand_daily", this->outdoor_demand);
DM::DMFeature::SetDoubleList( p, "run_off_roof_daily", this->mutiplyVector(this->stormwater_runoff,roof_area/100.));
}
}
CPLErr GNMGenericNetwork::LoadGraph()
{
if(m_bIsGraphLoaded)
return CE_None;
if(NULL == m_poGraphLayer)
{
CPLError( CE_Failure, CPLE_AppDefined, "Loading of graph data failed");
return CE_Failure;
}
OGRFeature *poFeature;
m_poGraphLayer->ResetReading();
GNMGFID nSrcFID, nTgtFID, nConFID;
double dfCost, dfInvCost;
while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL)
{
nSrcFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_SOURCE);
nTgtFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_TARGET);
nConFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_CONNECTOR);
dfCost = poFeature->GetFieldAsDouble(GNM_SYSFIELD_COST);
dfInvCost = poFeature->GetFieldAsDouble(GNM_SYSFIELD_INVCOST);
GNMDirection eDir = poFeature->GetFieldAsInteger(GNM_SYSFIELD_DIRECTION);
int nBlockState = poFeature->GetFieldAsInteger(GNM_SYSFIELD_BLOCKED);
bool bIsBlock = GNM_BLOCK_NONE != nBlockState;
m_oGraph.AddEdge(nConFID, nSrcFID, nTgtFID, eDir == GNM_EDGE_DIR_BOTH,
dfCost, dfInvCost);
if(bIsBlock)
{
if(nBlockState & GNM_BLOCK_SRC)
m_oGraph.ChangeBlockState(nSrcFID, bIsBlock);
if(nBlockState & GNM_BLOCK_TGT)
m_oGraph.ChangeBlockState(nTgtFID, bIsBlock);
if(nBlockState & GNM_BLOCK_CONN)
m_oGraph.ChangeBlockState(nConFID, bIsBlock);
}
if(nConFID < m_nVirtualConnectionGID)
m_nVirtualConnectionGID = nConFID;
OGRFeature::DestroyFeature(poFeature);
}
m_bIsGraphLoaded = true;
return CE_None;
}
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;
}
static swq_expr_node* OGRFeatureFetcher(swq_expr_node *op, void *pFeatureIn)
{
OGRFeature *poFeature = (OGRFeature*) pFeatureIn;
swq_expr_node *poRetNode = NULL;
switch (op->field_type)
{
case SWQ_INTEGER:
case SWQ_BOOLEAN:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsInteger(op->field_index));
break;
case SWQ_FLOAT:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsDouble(op->field_index));
break;
default:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsString(op->field_index));
break;
}
poRetNode->is_null = !(poFeature->IsFieldSet(op->field_index));
return poRetNode;
}
//---------------------------------------------------------
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 );
}
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);
}
}
SUMOReal
NIImporter_ArcView::getSpeed(OGRFeature& poFeature, const std::string& edgeid) {
if (myOptions.isSet("shapefile.type-id")) {
return myTypeCont.getSpeed(poFeature.GetFieldAsString((char*)(myOptions.getString("shapefile.type-id").c_str())));
}
// try to get definitions as to be found in SUMO-XML-definitions
// idea by John Michael Calandrino
int index = poFeature.GetDefnRef()->GetFieldIndex("speed");
if (index >= 0 && poFeature.IsFieldSet(index)) {
return (SUMOReal) poFeature.GetFieldAsDouble(index);
}
index = poFeature.GetDefnRef()->GetFieldIndex("SPEED");
if (index >= 0 && poFeature.IsFieldSet(index)) {
return (SUMOReal) poFeature.GetFieldAsDouble(index);
}
// try to get the NavTech-information
index = poFeature.GetDefnRef()->GetFieldIndex("SPEED_CAT");
if (index >= 0 && poFeature.IsFieldSet(index)) {
std::string def = poFeature.GetFieldAsString(index);
return NINavTeqHelper::getSpeed(edgeid, def);
}
return -1;
}
void DM_MicroClimate::run()
{
grid.resetReading();
OGRFeature * f;
while (f = grid.getNextFeature()) {
double tree = f->GetFieldAsDouble("tree_cover_fraction") > 0 ? f->GetFieldAsDouble("tree_cover_fraction") : 0;
double water = f->GetFieldAsDouble("water_fraction") > 0 ? f->GetFieldAsDouble("water_fraction") : 0;
double grass = f->GetFieldAsDouble("grass_fraction") > 0 ? f->GetFieldAsDouble("grass_fraction") : 0;
double irrGrass = f->GetFieldAsDouble("irrigated_grass_fraction") > 0 ? f->GetFieldAsDouble("irrigated_grass_fraction") : 0;
double roof = f->GetFieldAsDouble("roof_fraction") > 0 ? f->GetFieldAsDouble("roof_fraction") : 0;
double road = f->GetFieldAsDouble("road_fraction") > 0 ? f->GetFieldAsDouble("road_fraction") : 0;
double concrete = f->GetFieldAsDouble("concrete_fraction") > 0 ? f->GetFieldAsDouble("concrete_fraction") : 0;
double scale = tree + water + grass + irrGrass + roof + road + concrete;
f->SetField("temperature",
tree/scale * getTempForSurface(1,this->percentile) +
water/scale * getTempForSurface(2,this->percentile) +
grass/scale * getTempForSurface(3,this->percentile) +
irrGrass/scale * getTempForSurface(4,this->percentile) +
roof/scale * getTempForSurface(5,this->percentile) +
road/scale * getTempForSurface(6,this->percentile) +
concrete/scale * getTempForSurface(7,this->percentile) );
}
}
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 swq_expr_node *OGRFeatureFetcher( swq_expr_node *op, void *pFeatureIn )
{
OGRFeature *poFeature = (OGRFeature *) pFeatureIn;
swq_expr_node *poRetNode = NULL;
if( op->field_type == SWQ_GEOMETRY )
{
int iField = op->field_index - (poFeature->GetFieldCount() + SPECIAL_FIELD_COUNT);
poRetNode = new swq_expr_node( poFeature->GetGeomFieldRef(iField) );
return poRetNode;
}
switch( op->field_type )
{
case SWQ_INTEGER:
case SWQ_BOOLEAN:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsInteger(op->field_index) );
break;
case SWQ_INTEGER64:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsInteger64(op->field_index) );
break;
case SWQ_FLOAT:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsDouble(op->field_index) );
break;
default:
poRetNode = new swq_expr_node(
poFeature->GetFieldAsString(op->field_index) );
break;
}
poRetNode->is_null = !(poFeature->IsFieldSet(op->field_index));
return poRetNode;
}
wxString wxGISFeatureDataset::GetAsString(int row, int col)
{
if(m_poLayer->GetFeatureCount() <= row)
return wxString();
else
{
OGRFeature* pFeature = GetAt(row);
OGRFieldDefn* pDef = pFeature->GetFieldDefnRef(col);
switch(pDef->GetType())
{
case OFTDate:
{
int year, mon, day, hour, min, sec, flag;
pFeature->GetFieldAsDateTime(col, &year, &mon, &day, &hour, &min, &sec, &flag);
wxDateTime dt(day, wxDateTime::Month(mon - 1), year, hour, min, sec);
return dt.Format(_("%d-%m-%Y"));//wxString::Format(_("%.2u-%.2u-%.4u"), day, mon, year );
}
case OFTTime:
{
int year, mon, day, hour, min, sec, flag;
pFeature->GetFieldAsDateTime(col, &year, &mon, &day, &hour, &min, &sec, &flag);
wxDateTime dt(day, wxDateTime::Month(mon - 1), year, hour, min, sec);
return dt.Format(_("%H:%M:%S"));//wxString::Format(_("%.2u:%.2u:%.2u"), hour, min, sec);
}
case OFTDateTime:
{
int year, mon, day, hour, min, sec, flag;
pFeature->GetFieldAsDateTime(col, &year, &mon, &day, &hour, &min, &sec, &flag);
wxDateTime dt(day, wxDateTime::Month(mon - 1), year, hour, min, sec);
return dt.Format(_("%d-%m-%Y %H:%M:%S"));//wxString::Format(_("%.2u-%.2u-%.4u %.2u:%.2u:%.2u"), day, mon, year, hour, min, sec);
}
case OFTReal:
return wxString::Format(_("%.6f"), pFeature->GetFieldAsDouble(col));
default:
return wgMB2WX(pFeature->GetFieldAsString(col));
}
//return wgMB2WX(GetAt(row)->GetFieldAsString(col));
}
}
feature_ptr ogr_featureset::next()
{
OGRFeature *poFeature;
while ((poFeature = layer_.GetNextFeature()) != NULL)
{
// ogr feature ids start at 0, so add one to stay
// consistent with other mapnik datasources that start at 1
const int feature_id = (poFeature->GetFID() + 1);
feature_ptr feature(feature_factory::create(ctx_,feature_id));
OGRGeometry* geom = poFeature->GetGeometryRef();
if (geom && ! geom->IsEmpty())
{
ogr_converter::convert_geometry(geom, feature);
}
else
{
MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry="
<< poFeature->GetFID();
OGRFeature::DestroyFeature( poFeature );
continue;
}
++count_;
int fld_count = layerdef_->GetFieldCount();
for (int i = 0; i < fld_count; i++)
{
OGRFieldDefn* fld = layerdef_->GetFieldDefn(i);
const OGRFieldType type_oid = fld->GetType();
const std::string fld_name = fld->GetNameRef();
switch (type_oid)
{
case OFTInteger:
{
feature->put( fld_name, poFeature->GetFieldAsInteger(i));
break;
}
case OFTReal:
{
feature->put( fld_name, poFeature->GetFieldAsDouble(i));
break;
}
case OFTString:
case OFTWideString: // deprecated !
{
UnicodeString ustr = tr_->transcode(poFeature->GetFieldAsString(i));
feature->put( fld_name, ustr);
break;
}
case OFTIntegerList:
case OFTRealList:
case OFTStringList:
case OFTWideStringList: // deprecated !
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
break;
}
case OFTBinary:
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
//feature->put(name,feat->GetFieldAsBinary (i, size));
break;
}
case OFTDate:
case OFTTime:
case OFTDateTime: // unhandled !
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
break;
}
default: // unknown
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid;
break;
}
}
}
OGRFeature::DestroyFeature( poFeature );
return feature;
}
MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features";
return feature_ptr();
}
void CDlg_GISDataExchange::ExportDataToCSV(CString csv_file_name)
{
#ifndef _WIN64
CString message_str;
OGRRegisterAll();
OGRDataSource *poDS;
poDS = OGRSFDriverRegistrar::Open(m_GIS_ShapeFile, FALSE );
if( poDS == NULL )
{
m_MessageList.AddString("Open file failed." );
return;
}
ofstream CSVFile;
CSVFile.open (csv_file_name, ios::out);
if(CSVFile.is_open () == false)
{
AfxMessageBox("This file cannot be found or opened.\n It might be currently used and locked by EXCEL.");
return;
}else
{
CSVFile.width(15);
CSVFile.precision(6) ;
CSVFile.setf(ios::fixed);
}
int poLayers = ((OGRDataSource*)poDS)->GetLayerCount() ;
for (int i=0; i < poLayers; i++)
{
OGRLayer *poLayer;
poLayer = ((OGRDataSource*)poDS)->GetLayer(i);
if(poLayer == NULL)
{
message_str.Format("Open layer %d failed", i+1);
m_MessageList.AddString (message_str);
return;
}
OGRFeature *poFeature;
int feature_count = 0;
poLayer->ResetReading();
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
int iField;
if(feature_count == 0) // first feature point, output field name;
{
for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
CString str = poFieldDefn->GetNameRef();
str.Replace(" ", NULL); // remove space
CSVFile << str << "," ;
}
CSVFile << "geometry" << endl;
}
for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
CString str;
if( poFieldDefn->GetType() == OFTInteger )
CSVFile << poFeature->GetFieldAsInteger( iField ) << ",";
else if( poFieldDefn->GetType() == OFTReal )
CSVFile << poFeature->GetFieldAsDouble(iField) << ",";
else if( poFieldDefn->GetType() == OFTString )
{
str = poFeature->GetFieldAsString(iField);
if(str.Find(',') >=0)
CSVFile << "\"" << poFeature->GetFieldAsString(iField) << "\",";
else
CSVFile << poFeature->GetFieldAsString(iField) << ",";
}
else
{
str = poFeature->GetFieldAsString(iField);
if(str.Find(',') >=0)
CSVFile << "\"" << poFeature->GetFieldAsString(iField) << "\",";
else
CSVFile << poFeature->GetFieldAsString(iField) << ",";
}
}
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL )
{
if(wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
CSVFile << "\"<Point><coordinates>" << poPoint->getX() << "," << poPoint->getY() << ",0.0" << "</coordinates></Point>\"" ;
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString)
{
OGRLineString *poLine = (OGRLineString *) poGeometry;
CSVFile << "\"<LineString><coordinates>";
for(unsigned int si = 0; si< poLine->getNumPoints(); si++)
{
CSVFile << poLine->getX(si) << "," << poLine->getY(si) << ",0.0";
if(si!=poLine->getNumPoints()-1)
CSVFile << " ";
}
CSVFile << "</coordinates></LineString>\",";
} if (wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon )
{
OGRPolygon* polygon = (OGRPolygon*)(poGeometry);
OGRLinearRing *ring = polygon->getExteriorRing();
OGRPoint point;
CSVFile << "\"<Polygon><outerBoundaryIs><LinearRing><coordinates>";
for(int i = 0; i < ring->getNumPoints(); i++)
{
ring->getPoint(i, &point);
CSVFile << point.getX() << "," << point.getY() << ",0.0";
if(i!=ring->getNumPoints()-1)
CSVFile << " ";
}
CSVFile << "</coordinates></LinearRing></outerBoundaryIs></Polygon>\"";
}
CSVFile << endl;
}
feature_count ++;
}
OGRFeature::DestroyFeature( poFeature );
message_str.Format("Layer %d has %d features.", i+1, feature_count);
m_MessageList.AddString(message_str);
}
OGRDataSource::DestroyDataSource( poDS );
CSVFile.close();
#endif
}
OGRFeature* OGRPLScenesLayer::GetNextRawFeature()
{
if( bEOF ||
(!bFilterMustBeClientSideEvaluated && nFeatureCount >= 0 && nNextFID > nFeatureCount) )
return NULL;
if( poGeoJSONLayer == NULL )
{
if( !GetNextPage() )
return NULL;
}
#ifdef notdef
if( CSLTestBoolean(CPLGetConfigOption("OGR_LIMIT_TOO_MANY_FEATURES", "FALSE")) &&
nFeatureCount > nPageSize )
{
bEOF = TRUE;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
OGRGeometry* poGeom;
const char* pszWKT = "MULTIPOLYGON(((-180 90,180 90,180 -90,-180 -90,-180 90)))";
OGRGeometryFactory::createFromWkt((char**)&pszWKT, poSRS, &poGeom);
poFeature->SetGeometryDirectly(poGeom);
return poFeature;
}
#endif
OGRFeature* poGeoJSONFeature = poGeoJSONLayer->GetNextFeature();
if( poGeoJSONFeature == NULL )
{
osRequestURL = osNextURL;
bStillInFirstPage = FALSE;
if( !GetNextPage() )
return NULL;
poGeoJSONFeature = poGeoJSONLayer->GetNextFeature();
if( poGeoJSONFeature == NULL )
{
bEOF = TRUE;
return NULL;
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID++);
OGRGeometry* poGeom = poGeoJSONFeature->StealGeometry();
if( poGeom != NULL )
{
if( poGeom->getGeometryType() == wkbPolygon )
{
OGRMultiPolygon* poMP = new OGRMultiPolygon();
poMP->addGeometryDirectly(poGeom);
poGeom = poMP;
}
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poGeom);
}
for(int i=0;i<poFeatureDefn->GetFieldCount();i++)
{
OGRFieldDefn* poFieldDefn = poFeatureDefn->GetFieldDefn(i);
OGRFieldType eType = poFieldDefn->GetType();
int iSrcField = poGeoJSONFeature->GetFieldIndex(poFieldDefn->GetNameRef());
if( iSrcField >= 0 && poGeoJSONFeature->IsFieldSet(iSrcField) )
{
if( eType == OFTInteger )
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsInteger(iSrcField));
else if( eType == OFTReal )
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsDouble(iSrcField));
else
poFeature->SetField(i,
poGeoJSONFeature->GetFieldAsString(iSrcField));
}
}
delete poGeoJSONFeature;
return poFeature;
}
void CDlg_GISDataExchange::OnBnClickedImportGpsShapeFile()
{
#ifndef _WIN64
UpdateData(1);
if(m_GIS_ShapeFile.GetLength () == 0 )
{
AfxMessageBox("Please select a file first.");
return;
}
CWaitCursor wait;
CString message_str;
OGRRegisterAll();
OGRDataSource *poDS;
bool bFindOverlappingNode = false;
poDS = OGRSFDriverRegistrar::Open(m_GIS_ShapeFile, FALSE );
if( poDS == NULL )
{
m_MessageList.AddString("Open file failed." );
return;
}
int point_index = 0;
int poLayers = ((OGRDataSource*)poDS)->GetLayerCount() ;
for (int i=0; i < poLayers; i++)
{
OGRLayer *poLayer;
poLayer = ((OGRDataSource*)poDS)->GetLayer(i);
if(poLayer == NULL)
{
message_str.Format("Open layer %d failed", i+1);
m_MessageList.AddString (message_str);
return;
}
OGRFeature *poFeature;
int feature_count = 0;
// 0.03 miles
// 0.02: shape length / miles
double threashold = 0.02*0.001;
poLayer->ResetReading();
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
int id = feature_count;
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) // point data
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
// Create and insert the node
DTAPoint* pDTAPoint = new DTAPoint;
pDTAPoint->pt.x = poPoint->getX();
pDTAPoint->pt.y = poPoint->getY();
pDTAPoint->m_NodeNumber = id;
pDTAPoint->m_NodeID = point_index;
pDTAPoint->m_ZoneID = 0;
pDTAPoint->m_ControlType = 0;
m_pDoc->m_DTAPointSet.push_back(pDTAPoint);
point_index++;
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) // line data
{
// Create and insert the node
DTALine* pDTALine = new DTALine;
std::string name = poFeature->GetFieldAsString("Tmc");
pDTALine->TMC_code = name;
double Miles = poFeature->GetFieldAsDouble("Miles");
pDTALine->Miles = Miles;
OGRLineString *poLine = (OGRLineString *) poGeometry;
double shape_len = 0;
int step = 1;
// in case there are too many points
if(poLine->getNumPoints()>=900)
step = (int)(poLine->getNumPoints()/900)+1;
for(unsigned int si = 0; si< poLine->getNumPoints(); si+= step)
{
GDPoint pt;
pt.x = poLine->getX(si);
pt.y = poLine->getY(si);
pDTALine->m_ShapePoints .push_back(pt);
}
if(m_bCreateNodeFromLink)
{
GDPoint start_pt = pDTALine->m_ShapePoints[0];
GDPoint end_pt = pDTALine->m_ShapePoints[pDTALine->m_ShapePoints.size()-1];
//find or create from node number
int Node_Number = 0;
if( bFindOverlappingNode )
Node_Number = m_pDoc->FindCloseDTAPoint_NodeNumber(start_pt,threashold);
if(Node_Number ==0)
{
DTAPoint* pDTAPoint = new DTAPoint;
pDTAPoint->pt = start_pt;
pDTAPoint->m_NodeNumber = m_pDoc->m_DTAPointSet.size() +1;
pDTAPoint->m_NodeID = m_pDoc->m_DTAPointSet.size();
pDTAPoint->m_ZoneID = 0;
pDTAPoint->m_ControlType = 0;
m_pDoc->m_DTAPointSet.push_back(pDTAPoint);
Node_Number = pDTAPoint->m_NodeNumber;
}
pDTALine->m_FromNodeNumber = Node_Number;
//find or create to node number
Node_Number = 0;
if( bFindOverlappingNode )
Node_Number = m_pDoc->FindCloseDTAPoint_NodeNumber(end_pt,threashold);
if(Node_Number ==0)
{
DTAPoint* pDTAPoint = new DTAPoint;
pDTAPoint->pt = end_pt;
pDTAPoint->m_NodeNumber = m_pDoc->m_DTAPointSet.size() +1;
pDTAPoint->m_NodeID = m_pDoc->m_DTAPointSet.size();
pDTAPoint->m_ZoneID = 0;
pDTAPoint->m_ControlType = 0;
m_pDoc->m_DTAPointSet.push_back(pDTAPoint);
Node_Number = pDTAPoint->m_NodeNumber;
}
pDTALine->m_ToNodeNumber = Node_Number;
}
pDTALine->LineID = m_pDoc->m_DTALineSet.size()+1;
//create link
m_pDoc->m_DTALineSet.push_back(pDTALine);
if(m_pDoc->m_DTALineSet.size()%1000 ==0)
{
message_str.Format("Processing %d link records.", m_pDoc->m_DTALineSet.size());
m_MessageList.AddString(message_str);
}
}
}
// finish reading
if(m_bCreateNodeFromLink)
{
m_pDoc->m_UnitMile = 0.02;
m_pDoc->m_UnitFeet = m_pDoc->m_UnitMile/5280.0f;
for (std::list<DTAPoint*>::iterator iPoint = m_pDoc->m_DTAPointSet.begin();
iPoint != m_pDoc->m_DTAPointSet.end(); iPoint++)
{
int ThisNodeNumber = (*iPoint)->m_NodeNumber;
int Node_Number = m_pDoc->FindCloseDTAPoint_NodeNumber((*iPoint)->pt ,threashold, ThisNodeNumber );
if(Node_Number != ThisNodeNumber && Node_Number!=0)
{
// find a close node, create a dummy link
m_pDoc->AddNewLinkWithNodeNumbers (ThisNodeNumber,Node_Number);
}
if(ThisNodeNumber %1000 == 0)
{
message_str.Format("processing %d nodes.", ThisNodeNumber);
m_MessageList.AddString(message_str);
}
}
}
message_str.Format("Import %d link records from layer %d.", m_pDoc->m_DTALineSet.size(),i+1);
m_MessageList.AddString(message_str);
if(m_bCreateNodeFromLink)
{
message_str.Format("Create %d nodes from link shape points", m_pDoc->m_DTAPointSet.size());
m_MessageList.AddString(message_str);
}
OGRFeature::DestroyFeature( poFeature );
feature_count ++;
}
OGRDataSource::DestroyDataSource( poDS );
if(m_SaveInputNodeLinkFiles)
{
SaveTNPProject();
}
#endif
}
OGRFeature *OGRDODSGridLayer::GetFeature( GIntBig nFeatureId )
{
if( nFeatureId < 0 || nFeatureId >= nMaxRawIndex )
return NULL;
/* -------------------------------------------------------------------- */
/* Ensure we have the dataset. */
/* -------------------------------------------------------------------- */
if( !ProvideDataDDS() )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the feature being read. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( nFeatureId );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Establish the values for the various dimension indices. */
/* -------------------------------------------------------------------- */
int iDim;
int nRemainder = static_cast<int>(nFeatureId);
for( iDim = nDimCount-1; iDim >= 0; iDim-- )
{
paoDimensions[iDim].iLastValue =
(nRemainder % paoDimensions[iDim].nDimEntries)
* paoDimensions[iDim].nDimStride
+ paoDimensions[iDim].nDimStart;
nRemainder = nRemainder / paoDimensions[iDim].nDimEntries;
if( poTargetGrid == NULL )
poFeature->SetField( iDim, paoDimensions[iDim].iLastValue );
}
CPLAssert( nRemainder == 0 );
/* -------------------------------------------------------------------- */
/* For grids, we need to apply the values of the dimensions */
/* looked up in the corresponding map. */
/* -------------------------------------------------------------------- */
if( poTargetGrid != NULL )
{
for( iDim = 0; iDim < nDimCount; iDim++ )
{
ArrayEntryToField( paoDimensions[iDim].poMap,
paoDimensions[iDim].pRawData,
paoDimensions[iDim].iLastValue,
poFeature, iDim );
}
}
/* -------------------------------------------------------------------- */
/* Process all the regular data fields. */
/* -------------------------------------------------------------------- */
int iArray;
for( iArray = 0; iArray < nArrayRefCount; iArray++ )
{
OGRDODSArrayRef *poRef = paoArrayRefs + iArray;
ArrayEntryToField( poRef->poArray, poRef->pRawData,
static_cast<int>(nFeatureId),
poFeature, poRef->iFieldIndex );
}
/* -------------------------------------------------------------------- */
/* Do we have geometry information? */
/* -------------------------------------------------------------------- */
if( oXField.iFieldIndex >= 0 && oYField.iFieldIndex >= 0 )
{
OGRPoint *poPoint = new OGRPoint();
poPoint->setX( poFeature->GetFieldAsDouble( oXField.iFieldIndex ) );
poPoint->setY( poFeature->GetFieldAsDouble( oYField.iFieldIndex ) );
if( oZField.iFieldIndex >= 0 )
poPoint->setZ( poFeature->GetFieldAsDouble(oZField.iFieldIndex) );
poFeature->SetGeometryDirectly( poPoint );
}
return poFeature;
}
int CGouTIN::read_vector(const char* pDataSource,const char* pLayerName,char** pSpatialRefWkt,float **Sample_Array)
{
//将位置信息和属性信息存放在数组Sample_Array中
//cout<<"here4.4"<<endl;
OGRRegisterAll();
//cout<<filename<<endl;
OGRDataSource *poDS=OGRSFDriverRegistrar::Open(pDataSource,FALSE);
if( poDS == NULL )
{
printf( "[ERROR] Open failed.\n" );
exit( 1 );
}
//cout<<"here4.5"<<endl;
OGRLayer *poLayer = poDS->GetLayerByName(pLayerName);
//OGRSpatialReference * sref= poLayer->GetSpatialRef();
//sref->exportToWkt(pSpatialRefWkt);
OGRFeature *poFeature;
poLayer->ResetReading();
/*int count = 0;//统计散点数
while((poFeature=poLayer->GetNextFeature())!=NULL)
{
count++;
}
poLayer->ResetReading();*/
//不需要下面的存储空间，故注释掉
//*ptArray = annAllocPts(count, 2);
//*ptValues = new double[count];
//cout<<"here5"<<endl;
int idx = 0;
double x=0.0;
double y=0.0;
while((poFeature=poLayer->GetNextFeature())!=NULL)
{
//(*ptValues)[idx] = poFeature->GetFieldAsDouble(fieldIdx);
Sample_Array[idx][2]=poFeature->GetFieldAsDouble(2);//读取属性值
//cout<<"value:"<<Sample_Array[idx][2]<<endl;
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
OGRPoint *poPoint=(OGRPoint *)poGeometry;
x=poPoint->getX();
y=poPoint->getY();
//存储位置信息
Sample_Array[idx][0]=x;
Sample_Array[idx][1]=y;
//(*ptArray)[idx][0] = x;
//(*ptArray)[idx][1] = y;
if(idx==0)
{
//extent.minX = extent.maxX = x;
//extent.minY = extent.maxY = y;
MinX=x;
MaxX=x;
MinY=y;
MaxY=y;
}
else
{
if(x>MaxX)
MaxX = x;
if(x<MinX)
MinX = x;
if(y>MaxY)
MaxY = y;
if(y<MinY)
MinY = y;
}
}
else
{
printf( "[ERROR] No point geometry\n" );
return 1;
}
OGRFeature::DestroyFeature( poFeature );
idx++;
}
OGRDataSource::DestroyDataSource( poDS );
return 0;
}
SEXP ogrReadColumn(OGRLayer *poLayer, SEXP FIDs, int iField, int int64, int ENC_DEBUG) {
// read feature data and return something according to the type
OGRFeatureDefn *poDefn;
OGRFieldDefn *poField;
OGRFeature *poFeature;
int iRow,nRows;
SEXP ans = R_NilValue;
nRows=length(FIDs);
// get field data from layer
installErrorHandler();
poDefn = poLayer->GetLayerDefn();
poField = poDefn->GetFieldDefn(iField);
uninstallErrorHandlerAndTriggerError();
if(poField == NULL) {
error("Error getting field %d ",iField);
}
// allocate an object for the result depending on the feature type:
installErrorHandler();
switch(poField->GetType()) {
case OFTInteger:
PROTECT(ans=allocVector(INTSXP,nRows));
break;
#ifdef GDALV2
case OFTInteger64:
if (int64 ==3) {
PROTECT(ans=allocVector(STRSXP,nRows));
} else {
PROTECT(ans=allocVector(INTSXP,nRows));
}
break;
#endif
case OFTReal:
PROTECT(ans=allocVector(REALSXP,nRows));
break;
case OFTString:
PROTECT(ans=allocVector(STRSXP,nRows));
break;
case OFTDate:
PROTECT(ans=allocVector(STRSXP,nRows));
break;
case OFTDateTime:
PROTECT(ans=allocVector(STRSXP,nRows));
break;
case OFTTime:
PROTECT(ans=allocVector(STRSXP,nRows));
break;
default:
const char *desc = poField->GetFieldTypeName(poField->GetType());
uninstallErrorHandlerAndTriggerError();
error("unsupported field type: %s", desc);
break;
}
uninstallErrorHandlerAndTriggerError();
// now go over each row and retrieve data. iRow is an index in a
// vector of FIDs
/*#ifndef EJP
installErrorHandler();
for(iRow=0;iRow<nRows;iRow++){
poFeature=poLayer->GetFeature(INTEGER(FIDs)[iRow]);
if(poFeature == NULL){
error("Error getting feature FID: %d",(INTEGER(FIDs)[iRow]));
}
}
uninstallErrorHandlerAndTriggerError();
#else*/
// EJP, changed into:
installErrorHandler();
poLayer->ResetReading();
iRow = 0;
while((poFeature = poLayer->GetNextFeature()) != NULL) {
//#endif
// now get the value using the right type:
switch(poField->GetType()) {
case OFTInteger:
if (poFeature->IsFieldSet(iField))
INTEGER(ans)[iRow]=poFeature->GetFieldAsInteger(iField);
else INTEGER(ans)[iRow]=NA_INTEGER;
break;
#ifdef GDALV2
case OFTInteger64:
if (poFeature->IsFieldSet(iField)) {
if (int64 == 3) {
SET_STRING_ELT(ans, iRow,
mkChar(poFeature->GetFieldAsString(iField)));
} else {
GIntBig nVal64 = poFeature->GetFieldAsInteger64(iField);
int nVal = (nVal64 > INT_MAX) ? INT_MAX :
(nVal64 < INT_MIN) ? INT_MIN : (int) nVal64;
INTEGER(ans)[iRow]=nVal;
if (((GIntBig)nVal != nVal64) && int64 == 2) {
warning("Integer64 value clamped: feature %d", iRow);
}
}
} else {
if (int64 == 3) {
SET_STRING_ELT(ans, iRow, NA_STRING);
} else {
INTEGER(ans)[iRow]=NA_INTEGER;
}
}
break;
#endif
case OFTReal:
if (poFeature->IsFieldSet(iField))
REAL(ans)[iRow]=poFeature->GetFieldAsDouble(iField);
else REAL(ans)[iRow]=NA_REAL;
break;
case OFTString:
// ENC
char str[4096];
size_t stln;
if (poFeature->IsFieldSet(iField)) {
stln = CPLStrnlen(poFeature->GetFieldAsString(iField), 4096);
CPLStrlcpy(str, (const char *) poFeature->GetFieldAsString(iField),
4096);
SET_STRING_ELT(ans, iRow, mkChar(str));
} else SET_STRING_ELT(ans, iRow, NA_STRING);
if (ENC_DEBUG) {
Rprintf("iField: %d, iRow: %d stln %u Enc %s ", iField,
iRow, stln, CPLIsUTF8(str, (int) stln)?"UTF-8":"other");
for (int si=0; si < (int) stln; si++)
Rprintf("%x ", (unsigned char) str[si]);
Rprintf("\n");
} /* FIXME */
break;
case OFTDate:
if (poFeature->IsFieldSet(iField))
SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
else SET_STRING_ELT(ans, iRow, NA_STRING);
break;
case OFTDateTime:
if (poFeature->IsFieldSet(iField))
SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
else SET_STRING_ELT(ans, iRow, NA_STRING);
break;
case OFTTime:
if (poFeature->IsFieldSet(iField))
SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
else SET_STRING_ELT(ans, iRow, NA_STRING);
break;
default:
OGRFeature::DestroyFeature( poFeature );
// delete poFeature;
uninstallErrorHandlerAndTriggerError();
error("Unsupported field type. should have been caught before");
}
OGRFeature::DestroyFeature( poFeature );
// delete poFeature;
//#ifdef EJP
// according to tutorial: OGRFeature::DestroyFeature(poFeature);
// see comment FW in OGR tutorial: We could just "delete" it,
// but this can cause problems in windows builds where the GDAL DLL
// has a different "heap" from the main program. To be on the safe
// side we use a GDAL function to delete the feature.
iRow++;
//#endif
}
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(ans);
}
void CTLiteDoc::ImportOGRShapeFile(CString FileName)
{
#ifndef _WIN64
OGRRegisterAll();
OGRDataSource *poDS;
poDS = OGRSFDriverRegistrar::Open(FileName, FALSE );
if( poDS == NULL )
{
AfxMessageBox( "Open file failed." );
return;
}
int poLayers = ((OGRDataSource*)poDS)->GetLayerCount() ;
for (int i=0; i < poLayers; i++)
{
OGRLayer *poLayer;
poLayer = ((OGRDataSource*)poDS)->GetLayer(i);
if(poLayer == NULL)
{
AfxMessageBox( "Open layer failed." );
return;
}
OGRFeature *poFeature;
poLayer->ResetReading();
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
int iField;
for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField );
if( poFieldDefn->GetType() == OFTInteger )
TRACE( "%d,", poFeature->GetFieldAsInteger( iField ) );
else if( poFieldDefn->GetType() == OFTReal )
TRACE( "%.3f,", poFeature->GetFieldAsDouble(iField) );
else if( poFieldDefn->GetType() == OFTString )
TRACE( "%s,", poFeature->GetFieldAsString(iField) );
else
TRACE( "%s,", poFeature->GetFieldAsString(iField) );
}
OGRGeometry *poGeometry;
TRACE(" ");
poGeometry = poFeature->GetGeometryRef();
if( poGeometry != NULL
&& wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
TRACE( "x = %f ,y = %f\n", poPoint->getX(), poPoint->getY() );
}
else
{
TRACE( "no point geometry\n" );
}
OGRFeature::DestroyFeature( poFeature );
}
}
OGRDataSource::DestroyDataSource( poDS );
#else
AfxMessageBox("NEXTA 64-bit version does not support shape file exporting function. Please use NEXTA_32.exe ");
RunNEXTA_32();
#endif
}
CPLErr GDALRasterizeLayersBuf( void *pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace,
int nLayerCount, OGRLayerH *pahLayers,
const char *pszDstProjection,
double *padfDstGeoTransform,
GDALTransformerFunc pfnTransformer,
void *pTransformArg, double dfBurnValue,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressArg )
{
/* -------------------------------------------------------------------- */
/* If pixel and line spaceing are defaulted assign reasonable */
/* value assuming a packed buffer. */
/* -------------------------------------------------------------------- */
if( nPixelSpace == 0 )
nPixelSpace = GDALGetDataTypeSize( eBufType ) / 8;
if( nLineSpace == 0 )
nLineSpace = nPixelSpace * nBufXSize;
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Do some rudimentary arg checking. */
/* -------------------------------------------------------------------- */
if( nLayerCount == 0 )
return CE_None;
int bAllTouched = CSLFetchBoolean( papszOptions, "ALL_TOUCHED", FALSE );
const char *pszOpt = CSLFetchNameValue( papszOptions, "BURN_VALUE_FROM" );
GDALBurnValueSrc eBurnValueSource = GBV_UserBurnValue;
if( pszOpt )
{
if( EQUAL(pszOpt,"Z"))
eBurnValueSource = GBV_Z;
/*else if( EQUAL(pszOpt,"M"))
eBurnValueSource = GBV_M;*/
}
/* ==================================================================== */
/* Read thes pecified layers transfoming and rasterizing */
/* geometries. */
/* ==================================================================== */
CPLErr eErr = CE_None;
int iLayer;
const char *pszBurnAttribute =
CSLFetchNameValue( papszOptions, "ATTRIBUTE" );
pfnProgress( 0.0, NULL, pProgressArg );
for( iLayer = 0; iLayer < nLayerCount; iLayer++ )
{
int iBurnField = -1;
OGRLayer *poLayer = (OGRLayer *) pahLayers[iLayer];
if ( !poLayer )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Layer element number %d is NULL, skipping.\n", iLayer );
continue;
}
/* -------------------------------------------------------------------- */
/* If the layer does not contain any features just skip it. */
/* Do not force the feature count, so if driver doesn't know */
/* exact number of features, go down the normal way. */
/* -------------------------------------------------------------------- */
if ( poLayer->GetFeatureCount(FALSE) == 0 )
continue;
if ( pszBurnAttribute )
{
iBurnField =
poLayer->GetLayerDefn()->GetFieldIndex( pszBurnAttribute );
if ( iBurnField == -1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
poLayer->GetLayerDefn()->GetName() );
continue;
}
}
/* -------------------------------------------------------------------- */
/* If we have no transformer, create the one from input file */
/* projection. Note that each layer can be georefernced */
/* separately. */
/* -------------------------------------------------------------------- */
int bNeedToFreeTransformer = FALSE;
if( pfnTransformer == NULL )
{
char *pszProjection = NULL;
bNeedToFreeTransformer = TRUE;
OGRSpatialReference *poSRS = poLayer->GetSpatialRef();
if ( !poSRS )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to fetch spatial reference on layer %s "
"to build transformer, assuming matching coordinate systems.\n",
poLayer->GetLayerDefn()->GetName() );
}
else
poSRS->exportToWkt( &pszProjection );
pTransformArg =
GDALCreateGenImgProjTransformer3( pszProjection, NULL,
pszDstProjection,
padfDstGeoTransform );
pfnTransformer = GDALGenImgProjTransform;
CPLFree( pszProjection );
}
OGRFeature *poFeat;
poLayer->ResetReading();
while( (poFeat = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
if ( pszBurnAttribute )
dfBurnValue = poFeat->GetFieldAsDouble( iBurnField );
gv_rasterize_one_shape( (unsigned char *) pData, 0,
nBufXSize, nBufYSize,
1, eBufType, bAllTouched, poGeom,
&dfBurnValue, eBurnValueSource,
pfnTransformer, pTransformArg );
delete poFeat;
}
poLayer->ResetReading();
if( !pfnProgress(1, "", pProgressArg) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
if ( bNeedToFreeTransformer )
{
GDALDestroyTransformer( pTransformArg );
pTransformArg = NULL;
pfnTransformer = NULL;
}
}
return eErr;
}
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 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;
}
feature_ptr ogr_index_featureset<filterT>::next()
{
while (itr_ != ids_.end())
{
int pos = *itr_++;
layer_.SetNextByIndex (pos);
OGRFeature *poFeature = layer_.GetNextFeature();
if (poFeature == nullptr)
{
return feature_ptr();
}
// ogr feature ids start at 0, so add one to stay
// consistent with other mapnik datasources that start at 1
mapnik::value_integer feature_id = (poFeature->GetFID() + 1);
feature_ptr feature(feature_factory::create(ctx_,feature_id));
OGRGeometry* geom=poFeature->GetGeometryRef();
if (geom && !geom->IsEmpty())
{
geom->getEnvelope(&feature_envelope_);
if (!filter_.pass(mapnik::box2d<double>(feature_envelope_.MinX,feature_envelope_.MinY,
feature_envelope_.MaxX,feature_envelope_.MaxY))) continue;
feature->set_geometry(std::move(ogr_converter::convert_geometry(geom)));
}
else
{
MAPNIK_LOG_DEBUG(ogr) << "ogr_index_featureset: Feature with null geometry="
<< poFeature->GetFID();
OGRFeature::DestroyFeature( poFeature );
continue;
}
int fld_count = layerdef_->GetFieldCount();
for (int i = 0; i < fld_count; i++)
{
OGRFieldDefn* fld = layerdef_->GetFieldDefn (i);
OGRFieldType type_oid = fld->GetType ();
std::string fld_name = fld->GetNameRef ();
switch (type_oid)
{
case OFTInteger:
{
feature->put<mapnik::value_integer>(fld_name,poFeature->GetFieldAsInteger (i));
break;
}
case OFTReal:
{
feature->put(fld_name,poFeature->GetFieldAsDouble (i));
break;
}
case OFTString:
case OFTWideString: // deprecated !
{
feature->put(fld_name,tr_->transcode(poFeature->GetFieldAsString (i)));
break;
}
case OFTIntegerList:
case OFTRealList:
case OFTStringList:
case OFTWideStringList: // deprecated !
{
MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
break;
}
case OFTBinary:
{
MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
//feature->put(name,feat->GetFieldAsBinary (i, size));
break;
}
case OFTDate:
case OFTTime:
case OFTDateTime: // unhandled !
{
MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
break;
}
}
}
OGRFeature::DestroyFeature( poFeature );
return feature;
}
return feature_ptr();
}
OGRFeature *OGRHTFSoundingLayer::GetNextRawFeature()
{
const char* pszLine;
OGRLinearRing oLR;
while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL)
{
if (pszLine[0] == ';')
{
/* comment */ ;
}
else if (pszLine[0] == 0)
{
bEOF = TRUE;
return NULL;
}
else if (strcmp(pszLine, "END OF SOUNDING DATA") == 0)
{
bEOF = TRUE;
return NULL;
}
else
break;
}
if (pszLine == NULL)
{
bEOF = TRUE;
return NULL;
}
int i;
double dfEasting = 0, dfNorthing = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
char* pszStr = (char*)pszLine;
for(i=0;i<poFeatureDefn->GetFieldCount();i++)
{
if (!panFieldPresence[i])
continue;
char* pszSpace = strchr(pszStr, ' ');
if (pszSpace)
*pszSpace = '\0';
if (strcmp(pszStr, "*") != 0)
poFeature->SetField(i, pszStr);
if (i == nEastingIndex)
dfEasting = poFeature->GetFieldAsDouble(i);
else if (i == nNorthingIndex)
dfNorthing = poFeature->GetFieldAsDouble(i);
if (pszSpace == NULL)
break;
pszStr = pszSpace + 1;
}
OGRPoint* poPoint = new OGRPoint(dfEasting, dfNorthing);
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoint);
poFeature->SetFID(nNextFID++);
return poFeature;
}
feature_ptr ogr_featureset::next()
{
if (count_ == 0)
{
// Reset the layer reading on the first feature read
// this is a hack, but needed due to https://github.com/mapnik/mapnik/issues/2048
// Proper solution is to avoid storing layer state in featureset
layer_.ResetReading();
}
OGRFeature *poFeature;
while ((poFeature = layer_.GetNextFeature()) != nullptr)
{
// ogr feature ids start at 0, so add one to stay
// consistent with other mapnik datasources that start at 1
mapnik::value_integer feature_id = (poFeature->GetFID() + 1);
feature_ptr feature(feature_factory::create(ctx_,feature_id));
OGRGeometry* geom = poFeature->GetGeometryRef();
if (geom && ! geom->IsEmpty())
{
auto geom_corrected = ogr_converter::convert_geometry(geom);
mapnik::geometry::correct(geom_corrected);
feature->set_geometry(std::move(geom_corrected));
}
else
{
MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry="
<< poFeature->GetFID();
OGRFeature::DestroyFeature( poFeature );
continue;
}
++count_;
int fld_count = layerdef_->GetFieldCount();
for (int i = 0; i < fld_count; i++)
{
OGRFieldDefn* fld = layerdef_->GetFieldDefn(i);
const OGRFieldType type_oid = fld->GetType();
const std::string fld_name = fld->GetNameRef();
switch (type_oid)
{
case OFTInteger:
{
feature->put<mapnik::value_integer>( fld_name, poFeature->GetFieldAsInteger(i));
break;
}
#if GDAL_VERSION_MAJOR >= 2
case OFTInteger64:
{
feature->put<mapnik::value_integer>( fld_name, poFeature->GetFieldAsInteger64(i));
break;
}
#endif
case OFTReal:
{
feature->put( fld_name, poFeature->GetFieldAsDouble(i));
break;
}
case OFTString:
case OFTWideString: // deprecated !
{
feature->put( fld_name, tr_->transcode(poFeature->GetFieldAsString(i)));
break;
}
case OFTIntegerList:
#if GDAL_VERSION_MAJOR >= 2
case OFTInteger64List:
#endif
case OFTRealList:
case OFTStringList:
case OFTWideStringList: // deprecated !
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
break;
}
case OFTBinary:
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
//feature->put(name,feat->GetFieldAsBinary (i, size));
break;
}
case OFTDate:
case OFTTime:
case OFTDateTime: // unhandled !
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
break;
}
default: // unknown
{
MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid;
break;
}
}
}
OGRFeature::DestroyFeature( poFeature );
return feature;
}
MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features";
return feature_ptr();
}
static CPLErr ProcessLayer( OGRLayerH hSrcLayer, GDALDatasetH hDstDS,
OGRGeometry *poClipSrc,
GUInt32 nXSize, GUInt32 nYSize, int nBand,
int& bIsXExtentSet, int& bIsYExtentSet,
double& dfXMin, double& dfXMax,
double& dfYMin, double& dfYMax,
const char *pszBurnAttribute,
const double dfIncreaseBurnValue,
const double dfMultiplyBurnValue,
GDALDataType eType,
GDALGridAlgorithm eAlgorithm, void *pOptions,
int bQuiet, GDALProgressFunc pfnProgress )
{
/* -------------------------------------------------------------------- */
/* Get field index, and check. */
/* -------------------------------------------------------------------- */
int iBurnField = -1;
if ( pszBurnAttribute )
{
iBurnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hSrcLayer ),
pszBurnAttribute );
if( iBurnField == -1 )
{
printf( "Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Collect the geometries from this layer, and build list of */
/* values to be interpolated. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeat;
std::vector<double> adfX, adfY, adfZ;
OGR_L_ResetReading( hSrcLayer );
while( (poFeat = (OGRFeature *)OGR_L_GetNextFeature( hSrcLayer )) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
double dfBurnValue = 0.0;
if ( iBurnField >= 0 )
dfBurnValue = poFeat->GetFieldAsDouble( iBurnField );
ProcessCommonGeometry(poGeom, poClipSrc, iBurnField, dfBurnValue,
dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
OGRFeature::DestroyFeature( poFeat );
}
if ( adfX.size() == 0 )
{
printf( "No point geometry found on layer %s, skipping.\n",
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Compute grid geometry. */
/* -------------------------------------------------------------------- */
if ( !bIsXExtentSet || !bIsYExtentSet )
{
OGREnvelope sEnvelope;
OGR_L_GetExtent( hSrcLayer, &sEnvelope, TRUE );
if ( !bIsXExtentSet )
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
bIsXExtentSet = TRUE;
}
if ( !bIsYExtentSet )
{
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
bIsYExtentSet = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Perform gridding. */
/* -------------------------------------------------------------------- */
const double dfDeltaX = ( dfXMax - dfXMin ) / nXSize;
const double dfDeltaY = ( dfYMax - dfYMin ) / nYSize;
if ( !bQuiet )
{
printf( "Grid data type is \"%s\"\n", GDALGetDataTypeName(eType) );
printf( "Grid size = (%lu %lu).\n",
(unsigned long)nXSize, (unsigned long)nYSize );
printf( "Corner coordinates = (%f %f)-(%f %f).\n",
dfXMin - dfDeltaX / 2, dfYMax + dfDeltaY / 2,
dfXMax + dfDeltaX / 2, dfYMin - dfDeltaY / 2 );
printf( "Grid cell size = (%f %f).\n", dfDeltaX, dfDeltaY );
printf( "Source point count = %lu.\n", (unsigned long)adfX.size() );
PrintAlgorithmAndOptions( eAlgorithm, pOptions );
printf("\n");
}
GDALRasterBandH hBand = GDALGetRasterBand( hDstDS, nBand );
if (adfX.size() == 0)
{
// FIXME: Shoulda' set to nodata value instead
GDALFillRaster( hBand, 0.0 , 0.0 );
return CE_None;
}
GUInt32 nXOffset, nYOffset;
int nBlockXSize, nBlockYSize;
int nDataTypeSize = GDALGetDataTypeSize(eType) / 8;
// Try to grow the work buffer up to 16 MB if it is smaller
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
const GUInt32 nDesiredBufferSize = 16*1024*1024;
if( (GUInt32)nBlockXSize < nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockXSize < nDesiredBufferSize / (nBlockYSize * nDataTypeSize) )
{
int nNewBlockXSize = nDesiredBufferSize / (nBlockYSize * nDataTypeSize);
nBlockXSize = (nNewBlockXSize / nBlockXSize) * nBlockXSize;
if( (GUInt32)nBlockXSize > nXSize )
nBlockXSize = nXSize;
}
else if( (GUInt32)nBlockXSize == nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockYSize < nDesiredBufferSize / (nXSize * nDataTypeSize) )
{
int nNewBlockYSize = nDesiredBufferSize / (nXSize * nDataTypeSize);
nBlockYSize = (nNewBlockYSize / nBlockYSize) * nBlockYSize;
if( (GUInt32)nBlockYSize > nYSize )
nBlockYSize = nYSize;
}
CPLDebug("GDAL_GRID", "Work buffer: %d * %d", nBlockXSize, nBlockYSize);
void *pData =
VSIMalloc3( nBlockXSize, nBlockYSize, nDataTypeSize );
if( pData == NULL )
{
CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate work buffer");
return CE_Failure;
}
GUInt32 nBlock = 0;
GUInt32 nBlockCount = ((nXSize + nBlockXSize - 1) / nBlockXSize)
* ((nYSize + nBlockYSize - 1) / nBlockYSize);
CPLErr eErr = CE_None;
for ( nYOffset = 0; nYOffset < nYSize && eErr == CE_None; nYOffset += nBlockYSize )
{
for ( nXOffset = 0; nXOffset < nXSize && eErr == CE_None; nXOffset += nBlockXSize )
{
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( (double)nBlock / nBlockCount,
(double)(nBlock + 1) / nBlockCount,
pfnProgress, NULL );
nBlock ++;
int nXRequest = nBlockXSize;
if (nXOffset + nXRequest > nXSize)
nXRequest = nXSize - nXOffset;
int nYRequest = nBlockYSize;
if (nYOffset + nYRequest > nYSize)
nYRequest = nYSize - nYOffset;
eErr = GDALGridCreate( eAlgorithm, pOptions,
adfX.size(), &(adfX[0]), &(adfY[0]), &(adfZ[0]),
dfXMin + dfDeltaX * nXOffset,
dfXMin + dfDeltaX * (nXOffset + nXRequest),
dfYMin + dfDeltaY * nYOffset,
dfYMin + dfDeltaY * (nYOffset + nYRequest),
nXRequest, nYRequest, eType, pData,
GDALScaledProgress, pScaledProgress );
if( eErr == CE_None )
eErr = GDALRasterIO( hBand, GF_Write, nXOffset, nYOffset,
nXRequest, nYRequest, pData,
nXRequest, nYRequest, eType, 0, 0 );
GDALDestroyScaledProgress( pScaledProgress );
}
}
CPLFree( pData );
return eErr;
}
OGRFeature *OGRDODSSequenceLayer::GetFeature( GIntBig nFeatureId )
{
/* -------------------------------------------------------------------- */
/* Ensure we have the dataset. */
/* -------------------------------------------------------------------- */
if( !ProvideDataDDS() )
return NULL;
Sequence *seq = dynamic_cast<Sequence *>(poTargetVar);
/* -------------------------------------------------------------------- */
/* Figure out what the super and subsequence number this */
/* feature will be, and validate it. If there is not super */
/* sequence the feature id is the subsequence number. */
/* -------------------------------------------------------------------- */
int iSubSeq = -1;
if( nFeatureId < 0 || nFeatureId >= nRecordCount )
return NULL;
if( poSuperSeq == NULL )
iSubSeq = nFeatureId;
else
{
int nSeqOffset = 0, iSuperSeq;
// for now we just scan through till find find out what
// super sequence this in. In the long term we need a better (cached)
// approach that doesn't involve this quadratic cost.
for( iSuperSeq = 0;
iSuperSeq < nSuperSeqCount;
iSuperSeq++ )
{
if( nSeqOffset + panSubSeqSize[iSuperSeq] > nFeatureId )
{
iSubSeq = nFeatureId - nSeqOffset;
break;
}
nSeqOffset += panSubSeqSize[iSuperSeq];
}
CPLAssert( iSubSeq != -1 );
// Make sure we have the right target var ... the one
// corresponding to our current super sequence.
if( iSuperSeq != iLastSuperSeq )
{
iLastSuperSeq = iSuperSeq;
poTargetVar = poSuperSeq->var_value( iSuperSeq, pszSubSeqPath );
seq = dynamic_cast<Sequence *>(poTargetVar);
}
}
/* -------------------------------------------------------------------- */
/* Create the feature being read. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( nFeatureId );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Process all the regular data fields. */
/* -------------------------------------------------------------------- */
int iField;
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if( papoFields[iField]->pszPathToSequence )
continue;
BaseType *poFieldVar = GetFieldValue( papoFields[iField], iSubSeq,
NULL );
if( poFieldVar == NULL )
continue;
switch( poFieldVar->type() )
{
case dods_byte_c:
{
signed char byVal;
void *pValPtr = &byVal;
poFieldVar->buf2val( &pValPtr );
poFeature->SetField( iField, byVal );
}
break;
case dods_int16_c:
{
GInt16 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
poFeature->SetField( iField, nIntVal );
}
break;
case dods_uint16_c:
{
GUInt16 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
poFeature->SetField( iField, nIntVal );
}
break;
case dods_int32_c:
{
GInt32 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
poFeature->SetField( iField, nIntVal );
}
break;
case dods_uint32_c:
{
GUInt32 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
poFeature->SetField( iField, (int) nIntVal );
}
break;
case dods_float32_c:
poFeature->SetField( iField,
dynamic_cast<Float32 *>(poFieldVar)->value());
break;
case dods_float64_c:
poFeature->SetField( iField,
dynamic_cast<Float64 *>(poFieldVar)->value());
break;
case dods_str_c:
case dods_url_c:
{
string *poStrVal = NULL;
poFieldVar->buf2val( (void **) &poStrVal );
poFeature->SetField( iField, poStrVal->c_str() );
delete poStrVal;
}
break;
default:
break;
}
}
/* -------------------------------------------------------------------- */
/* Handle data nested in sequences. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRDODSFieldDefn *poFD = papoFields[iField];
const char *pszPathFromSubSeq;
if( poFD->pszPathToSequence == NULL )
continue;
CPLAssert( strlen(poFD->pszPathToSequence)
< strlen(poFD->pszFieldName)-1 );
if( strstr(poFD->pszFieldName,poFD->pszPathToSequence) != NULL )
pszPathFromSubSeq =
strstr(poFD->pszFieldName,poFD->pszPathToSequence)
+ strlen(poFD->pszPathToSequence) + 1;
else
continue;
/* -------------------------------------------------------------------- */
/* Get the sequence out of which this variable will be collected. */
/* -------------------------------------------------------------------- */
BaseType *poFieldVar = seq->var_value( iSubSeq,
poFD->pszPathToSequence );
Sequence *poSubSeq;
int nSubSeqCount;
if( poFieldVar == NULL )
continue;
poSubSeq = dynamic_cast<Sequence *>( poFieldVar );
if( poSubSeq == NULL )
continue;
nSubSeqCount = poSubSeq->number_of_rows();
/* -------------------------------------------------------------------- */
/* Allocate array to put values into. */
/* -------------------------------------------------------------------- */
OGRFieldDefn *poOFD = poFeature->GetFieldDefnRef( iField );
int *panIntList = NULL;
double *padfDblList = NULL;
char **papszStrList = NULL;
if( poOFD->GetType() == OFTIntegerList )
{
panIntList = (int *) CPLCalloc(sizeof(int),nSubSeqCount);
}
else if( poOFD->GetType() == OFTRealList )
{
padfDblList = (double *) CPLCalloc(sizeof(double),nSubSeqCount);
}
else if( poOFD->GetType() == OFTStringList )
{
papszStrList = (char **) CPLCalloc(sizeof(char*),nSubSeqCount+1);
}
else
continue;
/* -------------------------------------------------------------------- */
/* Loop, fetching subsequence values. */
/* -------------------------------------------------------------------- */
int iSubIndex;
for( iSubIndex = 0; iSubIndex < nSubSeqCount; iSubIndex++ )
{
poFieldVar = poSubSeq->var_value( iSubIndex, pszPathFromSubSeq );
if( poFieldVar == NULL )
continue;
switch( poFieldVar->type() )
{
case dods_byte_c:
{
signed char byVal;
void *pValPtr = &byVal;
poFieldVar->buf2val( &pValPtr );
panIntList[iSubIndex] = byVal;
}
break;
case dods_int16_c:
{
GInt16 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
panIntList[iSubIndex] = nIntVal;
}
break;
case dods_uint16_c:
{
GUInt16 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
panIntList[iSubIndex] = nIntVal;
}
break;
case dods_int32_c:
{
GInt32 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
panIntList[iSubIndex] = nIntVal;
}
break;
case dods_uint32_c:
{
GUInt32 nIntVal;
void *pValPtr = &nIntVal;
poFieldVar->buf2val( &pValPtr );
panIntList[iSubIndex] = nIntVal;
}
break;
case dods_float32_c:
padfDblList[iSubIndex] =
dynamic_cast<Float32 *>(poFieldVar)->value();
break;
case dods_float64_c:
padfDblList[iSubIndex] =
dynamic_cast<Float64 *>(poFieldVar)->value();
break;
case dods_str_c:
case dods_url_c:
{
string *poStrVal = NULL;
poFieldVar->buf2val( (void **) &poStrVal );
papszStrList[iSubIndex] = CPLStrdup( poStrVal->c_str() );
delete poStrVal;
}
break;
default:
break;
}
}
/* -------------------------------------------------------------------- */
/* Apply back to feature. */
/* -------------------------------------------------------------------- */
if( poOFD->GetType() == OFTIntegerList )
{
poFeature->SetField( iField, nSubSeqCount, panIntList );
CPLFree(panIntList);
}
else if( poOFD->GetType() == OFTRealList )
{
poFeature->SetField( iField, nSubSeqCount, padfDblList );
CPLFree(padfDblList);
}
else if( poOFD->GetType() == OFTStringList )
{
poFeature->SetField( iField, papszStrList );
CSLDestroy( papszStrList );
}
}
/* ==================================================================== */
/* Fetch the geometry. */
/* ==================================================================== */
if( oXField.bValid && oYField.bValid )
{
int iXField = poFeature->GetFieldIndex( oXField.pszFieldName );
int iYField = poFeature->GetFieldIndex( oYField.pszFieldName );
int iZField = -1;
if( oZField.bValid )
iZField = poFeature->GetFieldIndex(oZField.pszFieldName);
/* -------------------------------------------------------------------- */
/* If we can't find the values in attributes then use the more */
/* general mechanism to fetch the value. */
/* -------------------------------------------------------------------- */
if( iXField == -1 || iYField == -1
|| (oZField.bValid && iZField == -1) )
{
poFeature->SetGeometryDirectly(
new OGRPoint( GetFieldValueAsDouble( &oXField, iSubSeq ),
GetFieldValueAsDouble( &oYField, iSubSeq ),
GetFieldValueAsDouble( &oZField, iSubSeq ) ) );
}
/* -------------------------------------------------------------------- */
/* If the fields are list values, then build a linestring. */
/* -------------------------------------------------------------------- */
else if( poFeature->GetFieldDefnRef(iXField)->GetType() == OFTRealList
&& poFeature->GetFieldDefnRef(iYField)->GetType() == OFTRealList )
{
const double *padfX, *padfY, *padfZ = NULL;
int nPointCount, i;
OGRLineString *poLS = new OGRLineString();
padfX = poFeature->GetFieldAsDoubleList( iXField, &nPointCount );
padfY = poFeature->GetFieldAsDoubleList( iYField, &nPointCount );
if( iZField != -1 )
padfZ = poFeature->GetFieldAsDoubleList(iZField,&nPointCount);
poLS->setPoints( nPointCount, (double *) padfX, (double *) padfY,
(double *) padfZ );
// Make a pass clearing out NaN or Inf values.
for( i = 0; i < nPointCount; i++ )
{
double dfX = poLS->getX(i);
double dfY = poLS->getY(i);
double dfZ = poLS->getZ(i);
int bReset = FALSE;
if( OGRDODSIsDoubleInvalid( &dfX ) )
{
dfX = 0.0;
bReset = TRUE;
}
if( OGRDODSIsDoubleInvalid( &dfY ) )
{
dfY = 0.0;
bReset = TRUE;
}
if( OGRDODSIsDoubleInvalid( &dfZ ) )
{
dfZ = 0.0;
bReset = TRUE;
}
if( bReset )
poLS->setPoint( i, dfX, dfY, dfZ );
}
poFeature->SetGeometryDirectly( poLS );
}
/* -------------------------------------------------------------------- */
/* Otherwise build a point. */
/* -------------------------------------------------------------------- */
else
{
poFeature->SetGeometryDirectly(
new OGRPoint(
poFeature->GetFieldAsDouble( iXField ),
poFeature->GetFieldAsDouble( iYField ),
poFeature->GetFieldAsDouble( iZField ) ) );
}
}
return poFeature;
}
void WaterDemandModel::run()
{
station_ids = std::set<int>();
rainfalls = std::map<int, std::vector<double> >();
evaotranspirations = std::map<int, std::vector<double> >();
stormwater_runoff = std::map<int, std::vector<double> >();
non_potable_demand = std::map<int, std::vector<double> >();
potable_demand = std::map<int, std::vector<double> >();
outdoor_demand = std::map<int, std::vector<double> >();
grey_water = std::map<int, std::vector<double> >();
black_water = std::map<int, std::vector<double> >();
if (!initmodel())
return;
// init rain
if (this->from_rain_station)
initRain();
// Calculate outdoor demand for standard unit (100m2 roof, 100m2 garden, 1 person)
double imp_fraction = 0.2;
calculateRunoffAndDemand(500, imp_fraction, 0.8, 1);
if (this->to_rain_station) {
this->station.resetReading();
OGRFeature * st;
while (st = station.getNextFeature()) {
DM::DMFeature::SetDoubleList( st, "potable_demand_daily", this->mutiplyVector(this->potable_demand[st->GetFID()], 1));
DM::DMFeature::SetDoubleList( st, "non_potable_demand_daily", this->mutiplyVector(this->non_potable_demand[st->GetFID()], 1));
DM::DMFeature::SetDoubleList( st, "outdoor_demand_daily", this->mutiplyVector(this->outdoor_demand[st->GetFID()], 1./400.)); //Unit Area
DM::DMFeature::SetDoubleList( st, "run_off_roof_daily", this->mutiplyVector(this->stormwater_runoff[st->GetFID()], 1./100.)); //Unit area
DM::DMFeature::SetDoubleList( st, "grey_water_daily", this->mutiplyVector(this->grey_water[st->GetFID()], 1));
DM::DMFeature::SetDoubleList( st, "black_water_daily", this->mutiplyVector(this->black_water[st->GetFID()], 1));
}
return;
}
int counter = 0;
OGRFeature * p;
this->parcels.resetReading();
while(p = this->parcels.getNextFeature()) {
counter++;
double persons = p->GetFieldAsDouble("persons");
double garden_area = p->GetFieldAsDouble("garden_area");
double roof_area = p->GetFieldAsDouble("roof_area");
int station_id = -1;
if (this->from_rain_station)
station_id= p->GetFieldAsInteger("station_id");
DM::DMFeature::SetDoubleList( p, "potable_demand_daily", this->mutiplyVector(this->potable_demand[station_id], persons));
DM::DMFeature::SetDoubleList( p, "non_potable_demand_daily", this->mutiplyVector(this->non_potable_demand[station_id], persons));
DM::DMFeature::SetDoubleList( p, "outdoor_demand_daily", this->mutiplyVector(this->outdoor_demand[station_id], garden_area/400.)); //Unit Area
DM::DMFeature::SetDoubleList( p, "run_off_roof_daily", this->mutiplyVector(this->stormwater_runoff[station_id], roof_area/100.)); //Unit area
DM::DMFeature::SetDoubleList( p, "grey_water_daily", this->mutiplyVector(this->grey_water[station_id], 1));
DM::DMFeature::SetDoubleList( p, "black_water_daily", this->mutiplyVector(this->black_water[station_id], 1));
if (counter % 1000 == 0){
this->parcels.syncAlteredFeatures();
this->parcels.setNextByIndex(counter);
}
}
}
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;
}
}
CPLErr GDALRasterizeLayers( GDALDatasetH hDS,
int nBandCount, int *panBandList,
int nLayerCount, OGRLayerH *pahLayers,
GDALTransformerFunc pfnTransformer,
void *pTransformArg,
double *padfLayerBurnValues,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressArg )
{
GDALDataType eType;
unsigned char *pabyChunkBuf;
GDALDataset *poDS = (GDALDataset *) hDS;
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Do some rudimentary arg checking. */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 || nLayerCount == 0 )
return CE_None;
// prototype band.
GDALRasterBand *poBand = poDS->GetRasterBand( panBandList[0] );
if (poBand == NULL)
return CE_Failure;
int bAllTouched = CSLFetchBoolean( papszOptions, "ALL_TOUCHED", FALSE );
const char *pszOpt = CSLFetchNameValue( papszOptions, "BURN_VALUE_FROM" );
GDALBurnValueSrc eBurnValueSource = GBV_UserBurnValue;
if( pszOpt )
{
if( EQUAL(pszOpt,"Z"))
eBurnValueSource = GBV_Z;
/*else if( EQUAL(pszOpt,"M"))
eBurnValueSource = GBV_M;*/
}
/* -------------------------------------------------------------------- */
/* Establish a chunksize to operate on. The larger the chunk */
/* size the less times we need to make a pass through all the */
/* shapes. */
/* -------------------------------------------------------------------- */
int nYChunkSize, nScanlineBytes;
const char *pszYChunkSize =
CSLFetchNameValue( papszOptions, "CHUNKYSIZE" );
if( poBand->GetRasterDataType() == GDT_Byte )
eType = GDT_Byte;
else
eType = GDT_Float32;
nScanlineBytes = nBandCount * poDS->GetRasterXSize()
* (GDALGetDataTypeSize(eType)/8);
if ( pszYChunkSize && (nYChunkSize = atoi(pszYChunkSize)) )
;
else
nYChunkSize = GDALGetCacheMax() / nScanlineBytes;
if( nYChunkSize < 1 )
nYChunkSize = 1;
if( nYChunkSize > poDS->GetRasterYSize() )
nYChunkSize = poDS->GetRasterYSize();
pabyChunkBuf = (unsigned char *) VSIMalloc(nYChunkSize * nScanlineBytes);
if( pabyChunkBuf == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to allocate rasterization buffer." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the image once for all layers if user requested to render */
/* the whole raster in single chunk. */
/* -------------------------------------------------------------------- */
if ( nYChunkSize == poDS->GetRasterYSize() )
{
if ( poDS->RasterIO( GF_Read, 0, 0, poDS->GetRasterXSize(),
nYChunkSize, pabyChunkBuf,
poDS->GetRasterXSize(), nYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 )
!= CE_None )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to read buffer." );
CPLFree( pabyChunkBuf );
return CE_Failure;
}
}
/* ==================================================================== */
/* Read the specified layers transfoming and rasterizing */
/* geometries. */
/* ==================================================================== */
CPLErr eErr = CE_None;
int iLayer;
const char *pszBurnAttribute =
CSLFetchNameValue( papszOptions, "ATTRIBUTE" );
pfnProgress( 0.0, NULL, pProgressArg );
for( iLayer = 0; iLayer < nLayerCount; iLayer++ )
{
int iBurnField = -1;
double *padfBurnValues = NULL;
OGRLayer *poLayer = (OGRLayer *) pahLayers[iLayer];
if ( !poLayer )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Layer element number %d is NULL, skipping.\n", iLayer );
continue;
}
/* -------------------------------------------------------------------- */
/* If the layer does not contain any features just skip it. */
/* Do not force the feature count, so if driver doesn't know */
/* exact number of features, go down the normal way. */
/* -------------------------------------------------------------------- */
if ( poLayer->GetFeatureCount(FALSE) == 0 )
continue;
if ( pszBurnAttribute )
{
iBurnField =
poLayer->GetLayerDefn()->GetFieldIndex( pszBurnAttribute );
if ( iBurnField == -1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
poLayer->GetLayerDefn()->GetName() );
continue;
}
}
else
padfBurnValues = padfLayerBurnValues + iLayer * nBandCount;
/* -------------------------------------------------------------------- */
/* If we have no transformer, create the one from input file */
/* projection. Note that each layer can be georefernced */
/* separately. */
/* -------------------------------------------------------------------- */
int bNeedToFreeTransformer = FALSE;
if( pfnTransformer == NULL )
{
char *pszProjection = NULL;
bNeedToFreeTransformer = TRUE;
OGRSpatialReference *poSRS = poLayer->GetSpatialRef();
if ( !poSRS )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to fetch spatial reference on layer %s "
"to build transformer, assuming matching coordinate systems.\n",
poLayer->GetLayerDefn()->GetName() );
}
else
poSRS->exportToWkt( &pszProjection );
pTransformArg =
GDALCreateGenImgProjTransformer( NULL, pszProjection,
hDS, NULL, FALSE, 0.0, 0 );
pfnTransformer = GDALGenImgProjTransform;
CPLFree( pszProjection );
}
OGRFeature *poFeat;
poLayer->ResetReading();
/* -------------------------------------------------------------------- */
/* Loop over image in designated chunks. */
/* -------------------------------------------------------------------- */
int iY;
for( iY = 0;
iY < poDS->GetRasterYSize() && eErr == CE_None;
iY += nYChunkSize )
{
int nThisYChunkSize;
nThisYChunkSize = nYChunkSize;
if( nThisYChunkSize + iY > poDS->GetRasterYSize() )
nThisYChunkSize = poDS->GetRasterYSize() - iY;
// Only re-read image if not a single chunk is being rendered
if ( nYChunkSize < poDS->GetRasterYSize() )
{
eErr =
poDS->RasterIO( GF_Read, 0, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nThisYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
if( eErr != CE_None )
break;
}
double *padfAttrValues = (double *) VSIMalloc(sizeof(double) * nBandCount);
while( (poFeat = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
if ( pszBurnAttribute )
{
int iBand;
double dfAttrValue;
dfAttrValue = poFeat->GetFieldAsDouble( iBurnField );
for (iBand = 0 ; iBand < nBandCount ; iBand++)
padfAttrValues[iBand] = dfAttrValue;
padfBurnValues = padfAttrValues;
}
gv_rasterize_one_shape( pabyChunkBuf, iY,
poDS->GetRasterXSize(),
nThisYChunkSize,
nBandCount, eType, bAllTouched, poGeom,
padfBurnValues, eBurnValueSource,
pfnTransformer, pTransformArg );
delete poFeat;
}
VSIFree( padfAttrValues );
// Only write image if not a single chunk is being rendered
if ( nYChunkSize < poDS->GetRasterYSize() )
{
eErr =
poDS->RasterIO( GF_Write, 0, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nThisYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
}
poLayer->ResetReading();
if( !pfnProgress((iY+nThisYChunkSize)/((double)poDS->GetRasterYSize()),
"", pProgressArg) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
if ( bNeedToFreeTransformer )
{
GDALDestroyTransformer( pTransformArg );
pTransformArg = NULL;
pfnTransformer = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Write out the image once for all layers if user requested */
/* to render the whole raster in single chunk. */
/* -------------------------------------------------------------------- */
if ( nYChunkSize == poDS->GetRasterYSize() )
{
poDS->RasterIO( GF_Write, 0, 0,
poDS->GetRasterXSize(), nYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
}
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
VSIFree( pabyChunkBuf );
return eErr;
}
