| pktools 2.6.7 Processing Kernel for geospatial data

ImgWriterOgr.cc
1/**********************************************************************
2 ImgWriterOgr.cc: class to write vector files using OGR API library
3 Copyright (C) 2008-2012 Pieter Kempeneers
4
5 This file is part of pktools
6
7 pktools is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
11
12 pktools is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with pktools. If not, see <http://www.gnu.org/licenses/>.
19***********************************************************************/
20#include <iostream>
21#include <fstream>
22#include <sstream>
23#include "ImgReaderOgr.h"
24#include "ImgWriterOgr.h"
25#include "ImgReaderGdal.h"
26#include "cpl_string.h"
27//---------------------------------------------------------------------------
28ImgWriterOgr::ImgWriterOgr(void)
29{}
30
31ImgWriterOgr::~ImgWriterOgr(void)
32{
33}
34
35ImgWriterOgr::ImgWriterOgr(const std::string& filename, const std::string& imageType)
36{
37 open(filename,imageType);
38}
39
40ImgWriterOgr::ImgWriterOgr(const std::string& filename, ImgReaderOgr& imgReaderOgr)
41{
42 m_filename=filename;
43 setCodec(imgReaderOgr.getDriver());
44 int nlayer=imgReaderOgr.getDataSource()->GetLayerCount();
45 for(int ilayer=0;ilayer<nlayer;++ilayer){
46 std::string layername = imgReaderOgr.getLayer(ilayer)->GetName();
47 createLayer(layername,imgReaderOgr.getProjection(),imgReaderOgr.getGeometryType(),NULL);
48 copyFields(imgReaderOgr,ilayer,ilayer);
49 }
50}
51
52ImgWriterOgr::ImgWriterOgr(const std::string& filename, ImgReaderOgr& imgReaderOgr, bool copyData)
53{
54 CPLErrorReset();
55 m_filename=filename;
56 setCodec(imgReaderOgr.getDriver());
57 int nlayer=imgReaderOgr.getDataSource()->GetLayerCount();
58 for(int ilayer=0;ilayer<nlayer;++ilayer){
59 std::string layername = imgReaderOgr.getLayer(ilayer)->GetName();
60 createLayer(layername,imgReaderOgr.getProjection(),imgReaderOgr.getGeometryType(),NULL);
61 copyFields(imgReaderOgr,ilayer,ilayer);
62 if(copyData){
63 OGRFeature *poFeature;
64 while(true){// (poFeature = imgReaderOgr.getLayer()->GetNextFeature()) != NULL ){
65 poFeature = imgReaderOgr.getLayer(ilayer)->GetNextFeature();
66 if( poFeature == NULL )
67 break;
68 OGRFeature *poDstFeature = NULL;
69
70 poDstFeature=createFeature(ilayer);
71 //todo: check here if SetFrom works (experienced segmentation fault)
72 if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ){
73 const char* fmt;
74 std::string errorString="Unable to translate feature %d from layer %s.\n";
75 fmt=errorString.c_str();
76 CPLError( CE_Failure, CPLE_AppDefined,
77 fmt,
78 poFeature->GetFID(), getLayerName().c_str() );
79 // CPLError( CE_Failure, CPLE_AppDefined,
80 // "Unable to translate feature %d from layer %s.\n",
81 // poFeature->GetFID(), getLayerName().c_str() );
82
83 OGRFeature::DestroyFeature( poFeature );
84 OGRFeature::DestroyFeature( poDstFeature );
85 }
86 poDstFeature->SetFID( poFeature->GetFID() );
87 OGRFeature::DestroyFeature( poFeature );
88
89 CPLErrorReset();
90 if(createFeature( poDstFeature,ilayer ) != OGRERR_NONE){
91 const char* fmt;
92 std::string errorString="Unable to translate feature %d from layer %s.\n";
93 fmt=errorString.c_str();
94 CPLError( CE_Failure, CPLE_AppDefined,
95 fmt,
96 poFeature->GetFID(), getLayerName().c_str() );
97 OGRFeature::DestroyFeature( poDstFeature );
98 }
99 OGRFeature::DestroyFeature( poDstFeature );
100 }
101 }
102 }
103}
104
105//---------------------------------------------------------------------------
106
107 void ImgWriterOgr::open(const std::string& filename, ImgReaderOgr& imgReaderOgr)
108{
109 m_filename=filename;
110 setCodec(imgReaderOgr.getDriver());
111 int nlayer=imgReaderOgr.getDataSource()->GetLayerCount();
112 for(int ilayer=0;ilayer<nlayer;++ilayer){
113 std::string layername = imgReaderOgr.getLayer(ilayer)->GetName();
114 createLayer(layername,imgReaderOgr.getProjection(),imgReaderOgr.getGeometryType(),NULL);
115 copyFields(imgReaderOgr,ilayer,ilayer);
116 }
117}
118
119 void ImgWriterOgr::open(const std::string& filename, const std::string& imageType)
120{
121 m_filename = filename;
122 setCodec(imageType);
123}
124
125//---------------------------------------------------------------------------
126 void ImgWriterOgr::close(void)
127{
128#if GDAL_VERSION_MAJOR < 2
129 OGRDataSource::DestroyDataSource(m_datasource);
130#else
131 GDALClose(m_datasource);
132#endif
133}
134
135//---------------------------------------------------------------------------
136 void ImgWriterOgr::setCodec(const std::string& imageType){
137#if GDAL_VERSION_MAJOR < 2
138 //register the drivers
139 OGRRegisterAll();
140 //fetch the OGR file driver
141 OGRSFDriver *poDriver;
142 poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(imageType.c_str());
143#else
144 //register the drivers
145 GDALAllRegister();
146 GDALDriver *poDriver;
147 poDriver = GetGDALDriverManager()->GetDriverByName(imageType.c_str());
148#endif
149 if( poDriver == NULL ){
150 std::string errorString="FileOpenError";
151 throw(errorString);
152 }
153#if GDAL_VERSION_MAJOR < 2
154 m_datasource = OGRSFDriverRegistrar::Open( m_filename.c_str(), TRUE );
155#else
156 m_datasource = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_UPDATE||GDAL_OF_VECTOR, NULL, NULL, NULL);
157#endif
158 if( m_datasource == NULL ){
159#if GDAL_VERSION_MAJOR < 2
160 m_datasource = OGRSFDriverRegistrar::Open( m_filename.c_str(), FALSE );
161#else
162 m_datasource = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_READONLY||GDAL_OF_VECTOR, NULL, NULL, NULL);
163#endif
164 if ( m_datasource != NULL){// we can only open in not update mode
165 std::string errorString="Update mode not supported, delete output dataset first";
166 throw(errorString);
167#if GDAL_VERSION_MAJOR < 2
168 OGRDataSource::DestroyDataSource(m_datasource);
169#else
170 GDALClose(m_datasource);
171#endif
172 m_datasource = NULL;
173 }
174 else //create the data source
175#if GDAL_VERSION_MAJOR < 2
176 m_datasource=poDriver->CreateDataSource(m_filename.c_str(),NULL);
177#else
178 m_datasource=poDriver->Create(m_filename.c_str(),0,0,0,GDT_Unknown,NULL);
179#endif
180 }
181 else{//datasets exists, always overwrite all layers (no update append for now)
182 int nLayerCount = m_datasource->GetLayerCount();
183 for(int iLayer = 0; iLayer < nLayerCount; ++iLayer){
184 if(m_datasource->DeleteLayer(iLayer)!=OGRERR_NONE){
185 std::string errorstring="DeleteLayer() failed when overwrite requested";
186 throw(errorstring);
187 }
188 }
189 }
190 if(m_datasource==NULL){
191 std::string errorString="Creation of output file failed";
192 throw(errorString);
193 }
194}
195
196#if GDAL_VERSION_MAJOR < 2
197 void ImgWriterOgr::setCodec(OGRSFDriver *poDriver){
198 OGRRegisterAll();
199#else
200 void ImgWriterOgr::setCodec(GDALDriver *poDriver){
201 GDALAllRegister();
202#endif
203 if( poDriver == NULL ){
204 std::string errorString="FileOpenError";
205 throw(errorString);
206 }
207#if GDAL_VERSION_MAJOR < 2
208 m_datasource = OGRSFDriverRegistrar::Open( m_filename.c_str(), TRUE );
209#else
210 m_datasource = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_UPDATE||GDAL_OF_VECTOR, NULL, NULL, NULL);
211#endif
212 if( m_datasource == NULL ){
213#if GDAL_VERSION_MAJOR < 2
214 m_datasource = OGRSFDriverRegistrar::Open( m_filename.c_str(), FALSE );
215#else
216 m_datasource = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_READONLY||GDAL_OF_VECTOR, NULL, NULL, NULL);
217#endif
218 if ( m_datasource != NULL){// we can only open in not update mode
219 std::string errorString="Update mode not supported, delete output dataset first";
220 throw(errorString);
221#if GDAL_VERSION_MAJOR < 2
222 OGRDataSource::DestroyDataSource(m_datasource);
223#else
224 GDALClose(m_datasource);
225#endif
226 m_datasource = NULL;
227 }
228 else //create the data source
229#if GDAL_VERSION_MAJOR < 2
230 m_datasource=poDriver->CreateDataSource(m_filename.c_str(),NULL);
231#else
232 m_datasource=poDriver->Create(m_filename.c_str(),0,0,0,GDT_Unknown,NULL);
233#endif
234 }
235 else{//datasets exists, always overwrite all layers (no update append for now)
236 int nLayerCount = m_datasource->GetLayerCount();
237 for(int iLayer = 0; iLayer < nLayerCount; ++iLayer){
238 if(m_datasource->DeleteLayer(iLayer)!=OGRERR_NONE){
239 std::string errorstring="DeleteLayer() failed when overwrite requested";
240 throw(errorstring);
241 }
242 }
243 }
244 if(m_datasource==NULL){
245 std::string errorString="Creation of output file failed";
246 throw(errorString);
247 }
248}
249
250// OGRLayer* ImgWriterOgr::copyLayer(OGRLayer* poSrcLayer, const std::string& layername, char** papszOptions)
251// {
252// return(m_datasource->CopyLayer(poSrcLayer, layername.c_str(),papszOptions));
253// }
254
255OGRLayer* ImgWriterOgr::createLayer(const std::string& layername, const std::string& theProjection, const OGRwkbGeometryType& eGType, char** papszOptions)
256{
257 if( !m_datasource->TestCapability( ODsCCreateLayer ) ){
258 std::string errorString="Test capability to create layer failed";
259 throw(errorString);
260 }
261 //papszOptions = CSLSetNameValue( papszOptions, "DIM", "1" );
262 //if points: use wkbPoint
263 //if no constraints on the types geometry to be written: use wkbUnknown
264 OGRLayer* poLayer;
265
266 OGRSpatialReference oSRS;
267
268 if(theProjection!=""){
269 oSRS.SetFromUserInput(theProjection.c_str());
270 poLayer=m_datasource->CreateLayer( layername.c_str(), &oSRS, eGType,papszOptions );
271 // if(theProjection.find("EPSPG:")!=std::string::npos){
272 // int epsg_code=atoi(theProjection.substr(theProjection.find_first_not_of("EPSG:")).c_str());
273 // OGRSpatialReference oSRS;
274 // oSRS.importFromEPSG(epsg_code);
275 // poLayer=m_datasource->CreateLayer( layername.c_str(), &oSRS, eGType,papszOptions );
276 // }
277 // else{
278 // OGRSpatialReference oSRS(theProjection.c_str());
279 // poLayer=m_datasource->CreateLayer( layername.c_str(), &oSRS, eGType,papszOptions );
280 // }
281 // }
282 // oSRS.importFromProj4(theProjection);
283 }
284 else
285 poLayer=m_datasource->CreateLayer( layername.c_str(), NULL, eGType,papszOptions );
286 //check if destroy is needed?!
287 CSLDestroy( papszOptions );
288 if( poLayer == NULL ){
289 std::string errorstring="Layer creation failed";
290 throw(errorstring);
291 }
292 // OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
293 return poLayer;
294}
295
296 void ImgWriterOgr::createField(const std::string& fieldname, const OGRFieldType& fieldType, int theLayer)
297{
298 OGRFieldDefn oField( fieldname.c_str(), fieldType );
299 if(fieldType==OFTString)
300 oField.SetWidth(32);
301 if(theLayer<0)
302 theLayer=m_datasource->GetLayerCount()-1;//get back layer
303 if(m_datasource->GetLayer(theLayer)->CreateField( &oField ) != OGRERR_NONE ){
304 std::ostringstream es;
305 es << "Creating field " << fieldname << " failed";
306 std::string errorString=es.str();
307 throw(errorString);
308 }
309}
310
311 int ImgWriterOgr::getFields(std::vector<std::string>& fields, int layer) const
312{
313 if(layer<0)
314 layer=m_datasource->GetLayerCount()-1;
315 assert(m_datasource->GetLayerCount()>layer);
316 OGRLayer *poLayer;
317 if((poLayer = m_datasource->GetLayer(layer))==NULL){
318 std::string errorstring="Could not get layer";
319 throw(errorstring);
320 }
321 OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
322 fields.clear();
323 fields.resize(poFDefn->GetFieldCount());
324 for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
325 OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
326 fields[iField]=poFieldDefn->GetNameRef();
327 }
328 return(fields.size());
329}
330
331 int ImgWriterOgr::getFields(std::vector<OGRFieldDefn*>& fields, int layer) const
332{
333 if(layer<0)
334 layer=m_datasource->GetLayerCount()-1;
335 assert(m_datasource->GetLayerCount()>layer);
336 OGRLayer *poLayer;
337 if((poLayer = m_datasource->GetLayer(layer))==NULL){
338 std::string errorstring="Could not get layer";
339 throw(errorstring);
340 }
341 OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
342 fields.clear();
343 fields.resize(poFDefn->GetFieldCount());
344 for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
345 OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
346 fields[iField]=poFDefn->GetFieldDefn(iField);
347 }
348 assert(fields.size()==getFieldCount(layer));
349 return(fields.size());
350}
351
352 void ImgWriterOgr::copyFields(const ImgReaderOgr& imgReaderOgr, int srcLayer, int targetLayer){
353 if(targetLayer<0)
354 targetLayer=m_datasource->GetLayerCount()-1;//get back layer
355 //get fields from imgReaderOgr
356 std::vector<OGRFieldDefn*> fields;
357
358 imgReaderOgr.getFields(fields,srcLayer);
359 for(int iField=0;iField<fields.size();++iField){
360 if(m_datasource->GetLayer(targetLayer)->CreateField(fields[iField]) != OGRERR_NONE ){
361 std::ostringstream es;
362 es << "Creating field " << fields[iField]->GetNameRef() << " failed";
363 std::string errorString=es.str();
364 throw(errorString);
365 }
366 }
367}
368
369 void ImgWriterOgr::addPoint(double x, double y, const std::map<std::string,double>& pointAttributes, std::string fieldName, const std::string& theId, int layer){
370 OGRFeature *poFeature;
371 poFeature=createFeature(layer);
372 OGRPoint pt;
373 poFeature->SetField( fieldName.c_str(), theId.c_str());
374 for(std::map<std::string,double>::const_iterator mit=pointAttributes.begin();mit!=pointAttributes.end();++mit){
375 poFeature->SetField((mit->first).c_str(), mit->second);
376 }
377 pt.setX(x);
378 pt.setY(y);
379 poFeature->SetGeometry( &pt );
380 if(createFeature(poFeature,layer)!=OGRERR_NONE){
381 std::string errorString="Failed to create feature";
382 throw(errorString);
383 }
384 OGRFeature::DestroyFeature( poFeature );
385}
386
387 void ImgWriterOgr::addPoint(double x, double y, const std::map<std::string,double>& pointAttributes, std::string fieldName, int theId, int layer){
388 OGRFeature *poFeature;
389 poFeature = createFeature(layer);
390 OGRPoint pt;
391 if(pointAttributes.size()+1!=poFeature->GetFieldCount()){
392 std::ostringstream ess;
393 ess << "Failed to add feature: " << pointAttributes.size() << " !=" << poFeature->GetFieldCount() << std::endl;
394 throw(ess.str());
395 }
396 assert(pointAttributes.size()+1==poFeature->GetFieldCount());
397 poFeature->SetField( fieldName.c_str(), theId);
398 int fid=0;
399 for(std::map<std::string,double>::const_iterator mit=pointAttributes.begin();mit!=pointAttributes.end();++mit){
400 poFeature->SetField((mit->first).c_str(),mit->second);
401 }
402 pt.setX(x);
403 pt.setY(y);
404 poFeature->SetGeometry( &pt );
405 if(createFeature(poFeature,layer)!=OGRERR_NONE){
406 std::string errorString="Failed to create feature";
407 throw(errorString);
408 }
409 OGRFeature::DestroyFeature( poFeature );
410}
411
412//add a line std::string (polygon), caller is responsible to close the line (end point=start point)
413 void ImgWriterOgr::addLineString(std::vector<OGRPoint*>& points, const std::string& fieldName, int theId, int layer){
414 OGRFeature *poFeature;
415 poFeature = createFeature(layer);
416 poFeature->SetStyleString("PEN(c:#FF0000,w:5px)");//see also http://www.gdal.org/ogr/ogr_feature_style.html
417 poFeature->SetField( fieldName.c_str(), theId);
418 OGRLineString theLineString;
419 theLineString.setNumPoints(points.size());
420 for(int ip=0;ip<points.size();++ip)
421 theLineString.setPoint(ip,points[ip]);
422 if(poFeature->SetGeometry( &theLineString )!=OGRERR_NONE){
423 std::string errorString="Failed to set line OGRLineString as feature geometry";
424 throw(errorString);
425 }
426 if(createFeature(poFeature,layer)!=OGRERR_NONE){
427 std::string errorString="Failed to create feature";
428 throw(errorString);
429 }
430 OGRFeature::DestroyFeature( poFeature );
431}
432
433//add a ring (polygon), caller is responsible to close the line (end point=start point)?
434 void ImgWriterOgr::addRing(std::vector<OGRPoint*>& points, const std::string& fieldName, int theId, int layer){
435 OGRFeature *poFeature;
436 poFeature = createFeature(layer);
437 poFeature->SetStyleString("PEN(c:#FF0000,w:5px)");//see also http://www.gdal.org/ogr/ogr_feature_style.html
438 poFeature->SetField( fieldName.c_str(), theId);
439 // OGRLineString theLineString;
440 // theLineString.setNumPoints(points.size());
441 OGRPolygon thePolygon;
442 OGRLinearRing theRing;
443 for(int ip=0;ip<points.size();++ip)
444 theRing.addPoint(points[ip]);
445 // theRing.addPoint(points[0]);//close the ring
446 theRing.closeRings();//redundent with previous line?
447 thePolygon.addRing(&theRing);
448 // SetSpatialFilter(&thePolygon)
449 poFeature->SetGeometry( &thePolygon );
450 if(createFeature(poFeature,layer)!=OGRERR_NONE){
451 std::string errorString="Failed to create feature";
452 throw(errorString);
453 OGRFeature::DestroyFeature( poFeature );
454 }
455 if(poFeature->SetGeometry( &thePolygon )!=OGRERR_NONE){
456 std::string errorString="Failed to set polygon as feature geometry";
457 throw(errorString);
458 }
459 OGRFeature::DestroyFeature( poFeature );
460}
461
462//add a line string (polygon), caller is responsible to close the line (end point=start point)
463 void ImgWriterOgr::addLineString(std::vector<OGRPoint*>& points, const std::string& fieldName, const std::string& theId, int layer){
464 OGRFeature *poFeature;
465 poFeature = createFeature(layer);
466 poFeature->SetField( fieldName.c_str(), theId.c_str());
467 OGRLineString theLineString;
468 theLineString.setNumPoints(points.size());
469 for(int ip=0;ip<points.size();++ip)
470 theLineString.setPoint(ip,points[ip]);
471 if(poFeature->SetGeometry( &theLineString )!=OGRERR_NONE){
472 std::string errorString="Failed to set line OGRLineString as feature geometry";
473 throw(errorString);
474 }
475 if(createFeature(poFeature,layer)!=OGRERR_NONE){
476 std::string errorString="Failed to create feature";
477 throw(errorString);
478 }
479 OGRFeature::DestroyFeature( poFeature );
480}
481
482OGRFeature* ImgWriterOgr::createFeature(int layer){
483 return(OGRFeature::CreateFeature(m_datasource->GetLayer(layer)->GetLayerDefn()));
484}
485
486OGRErr ImgWriterOgr::createFeature(OGRFeature *theFeature,int layer){
487 return m_datasource->GetLayer(layer)->CreateFeature(theFeature);
488}
489
490 int ImgWriterOgr::getFieldCount(int layer) const
491{
492 assert(m_datasource->GetLayerCount()>layer);
493 OGRLayer *poLayer;
494 if((poLayer = m_datasource->GetLayer(layer))==NULL){
495 std::string errorstring="Could not get layer";
496 throw(errorstring);
497 }
498 OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
499 return(poFDefn->GetFieldCount());
500}
501
502 int ImgWriterOgr::getFeatureCount(int layer) const
503{
504 return(getLayer(layer)->GetFeatureCount());
505}
506
507 int ImgWriterOgr::ascii2ogr(const std::string& filename, const std::string &layername, const std::vector<std::string>& fieldName, const std::vector<OGRFieldType>& fieldType, short colX, short colY, const std::string& theProjection, const OGRwkbGeometryType& eGType, const char fs)
508{
509 char **papszOptions=NULL;
510 createLayer(layername, theProjection, eGType, papszOptions);
511 //create attribute fields that should appear on the layer. Fields must be added to the layer before any features are written. To create a field we initialize an OGRField object with the information about the field. In the case of Shapefiles, the field width and precision is significant in the creation of the output .dbf file, so we set it specifically, though generally the defaults are OK
512 int ncol=fieldName.size();
513 assert(colX>=0);
514 assert(colY>=0);
515 assert(colX<ncol+2);
516 assert(colY<ncol+2);
517 for(int ifield=0;ifield<ncol;++ifield)
518 createField(fieldName[ifield],fieldType[ifield]);
519 //create a local OGRFeature, set attributes and attach geometry before trying to write it to the layer. It is imperative that this feature be instantiated from the OGRFeatureDefn associated with the layer it will be written to.
520 //todo: try to open and catch if failure...
521 std::ifstream fpoints(filename.c_str(),std::ios::in);
522 std::string line;
523 OGRPolygon thePolygon;
524 OGRLinearRing theRing;
525 OGRPoint firstPoint;
526 OGRFeature *polyFeature;
527 if(eGType!=wkbPoint)
528 polyFeature=createFeature();
529
530
531 if(fs>' '&&fs<='~'){//field separator is a regular character (minimum ASCII code is space, maximum ASCII code is tilde)
532 std::string csvRecord;
533 while(getline(fpoints,csvRecord)){//read a line
534 OGRFeature *pointFeature;
535 if(eGType==wkbPoint)
536 pointFeature=createFeature();
537 OGRPoint thePoint;
538 bool skip=false;
539 std::istringstream csvstream(csvRecord);
540 std::string value;
541 int colId=0;
542 int fieldId=0;
543 while(getline(csvstream,value,fs)){//read a column
544 if(colId==colX)
545 thePoint.setX(atof(value.c_str()));
546 else if(colId==colY)
547 thePoint.setY(atof(value.c_str()));
548 else{
549 switch(fieldType[fieldId]){
550 case(OFTReal):
551 if(eGType==wkbPoint)
552 pointFeature->SetField(fieldId,atof(value.c_str()));
553 else if(firstPoint.IsEmpty())
554 polyFeature->SetField(fieldId,atof(value.c_str()));
555 break;
556 case(OFTInteger):
557 if(eGType==wkbPoint)
558 pointFeature->SetField(fieldId,atoi(value.c_str()));
559 else if(firstPoint.IsEmpty())
560 polyFeature->SetField(fieldId,atoi(value.c_str()));
561 break;
562 case(OFTString):
563 if(eGType==wkbPoint)
564 pointFeature->SetField(fieldId,value.c_str());
565 else if(firstPoint.IsEmpty())
566 polyFeature->SetField(fieldId,value.c_str());
567 break;
568 default:
569 break;
570 }
571 ++fieldId;
572 }
573 ++colId;
574 }
575 if(colId!=fieldId+2){
576 std::ostringstream ess;
577 ess << "Error: colId = " << colId << " is different from fieldId+2 = " << fieldId;
578 throw(ess.str());
579 }
580 if(eGType==wkbPoint){
581 pointFeature->SetGeometry( &thePoint );
582 if(createFeature(pointFeature)!=OGRERR_NONE){
583 std::string errorString="Failed to create feature";
584 throw(errorString);
585 OGRFeature::DestroyFeature( pointFeature );
586 }
587 }
588 else{
589 if(firstPoint.IsEmpty()){
590 firstPoint=thePoint;
591 }
592 theRing.addPoint(&thePoint);
593 }
594 }
595 }
596 else{//space or tab delimited fields
597 while(getline(fpoints,line)){
598 OGRFeature *pointFeature;
599 if(eGType==wkbPoint)
600 pointFeature=createFeature();
601 OGRPoint thePoint;
602 bool skip=false;
603 std::istringstream ist(line);
604 std::string value;
605 int colId=0;
606 int fieldId=0;
607 while(ist >> value){
608 if(colId==colX)
609 thePoint.setX(atof(value.c_str()));
610 else if(colId==colY)
611 thePoint.setY(atof(value.c_str()));
612 else{
613 switch(fieldType[fieldId]){
614 case(OFTReal):
615 if(eGType==wkbPoint)
616 pointFeature->SetField(fieldId,atof(value.c_str()));
617 else if(firstPoint.IsEmpty())
618 polyFeature->SetField(fieldId,atof(value.c_str()));
619 break;
620 case(OFTInteger):
621 if(eGType==wkbPoint)
622 pointFeature->SetField(fieldId,atoi(value.c_str()));
623 else if(firstPoint.IsEmpty())
624 polyFeature->SetField(fieldId,atoi(value.c_str()));
625 break;
626 case(OFTString):
627 if(eGType==wkbPoint)
628 pointFeature->SetField(fieldId,value.c_str());
629 else if(firstPoint.IsEmpty())
630 polyFeature->SetField(fieldId,value.c_str());
631 break;
632 default:
633 break;
634 }
635 ++fieldId;
636 }
637 ++colId;
638 }
639 if(colId!=fieldId+2){
640 std::ostringstream ess;
641 ess << "Error: colId = " << colId << " is different from fieldId+2 = " << fieldId;
642 throw(ess.str());
643 }
644 if(eGType==wkbPoint){
645 pointFeature->SetGeometry( &thePoint );
646 if(createFeature(pointFeature)!=OGRERR_NONE){
647 std::string errorString="Failed to create feature";
648 throw(errorString);
649 OGRFeature::DestroyFeature( pointFeature );
650 }
651 }
652 else{
653 if(firstPoint.IsEmpty()){
654 firstPoint=thePoint;
655 }
656 theRing.addPoint(&thePoint);
657 }
658 }
659 }
660 if(eGType!=wkbPoint){
661 theRing.addPoint(&firstPoint);//close the ring
662 thePolygon.addRing(&theRing);
663 // SetSpatialFilter(&thePolygon)
664 polyFeature->SetGeometry( &thePolygon );
665 if(createFeature(polyFeature)!=OGRERR_NONE){
666 std::string errorString="Failed to create feature";
667 throw(errorString);
668 OGRFeature::DestroyFeature( polyFeature );
669 }
670 }
671 return getFeatureCount();
672}
673
674 int ImgWriterOgr::addData(ImgReaderGdal& imgReader, int theLayer, bool verbose)
675{
676 OGRLayer *poLayer;
677 assert(m_datasource->GetLayerCount()>theLayer);
678 if(verbose)
679 std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
680 if(verbose)
681 std::cout << "get layer " << theLayer << std::endl;
682 poLayer = m_datasource->GetLayer(theLayer);
683 //start reading features from the layer
684 OGRFeature *poFeature;
685 if(verbose)
686 std::cout << "reset reading" << std::endl;
687 poLayer->ResetReading();
688 for(int iband=0;iband<imgReader.nrOfBand();++iband){
689 std::ostringstream fs;
690 fs << "band" << iband;
691 createField(fs.str(),OFTReal,theLayer);
692 }
693 OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
694 int nfield=poFDefn->GetFieldCount();
695 if(verbose)
696 std::cout << "new number of fields: " << nfield << std::endl;
697 while( (poFeature = poLayer->GetNextFeature()) != NULL ){
698 OGRGeometry *poGeometry;
699 poGeometry = poFeature->GetGeometryRef();
700 assert(poGeometry != NULL
701 && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
702 OGRPoint *poPoint = (OGRPoint *) poGeometry;
703 double x=poPoint->getX();
704 double y=poPoint->getY();
705 for(int iband=0;iband<imgReader.nrOfBand();++iband){
706 double imgData;
707 imgReader.readData(imgData,x,y,iband);
708 //todo: put imgdata in field
709 std::ostringstream fs;
710 fs << "band" << iband;
711 poFeature->SetField(fs.str().c_str(),imgData);
712 }
713 }
714 return(nfield);
715}
716
ImgRasterGdal::nrOfBand
int nrOfBand(void) const
Get the number of bands of this dataset.
Definition: ImgRasterGdal.h:102
ImgReaderGdal
Definition: ImgReaderGdal.h:37
ImgReaderGdal::readData
void readData(T &value, int col, int row, int band=0)
Read a single pixel cell value at a specific column and row for a specific band (all indices start co...
Definition: ImgReaderGdal.h:95
ImgReaderOgr
Definition: ImgReaderOgr.h:36