pktools  2.6.5
Processing Kernel for geospatial data
ImgReaderOgr.h
1 /**********************************************************************
2 ImgReaderOgr.h: class to read 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 #ifndef _IMGREADEROGR_H_
21 #define _IMGREADEROGR_H_
22 
23 #include <assert.h>
24 #include <fstream>
25 #include <string>
26 #include <sstream>
27 #include <map>
28 #include <vector>
29 #include <iostream>
30 #include "ogrsf_frmts.h"
31 #include "base/Vector2d.h"
32 #include "ImgReaderGdal.h"
33 
34 //--------------------------------------------------------------------------
36 {
37 public:
38  ImgReaderOgr(void);
39  ImgReaderOgr(const std::string& filename);
40  ~ImgReaderOgr(void);
41  void open(const std::string& filename);
42  void close(void);
43  // int readData(Vector2d<double>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, int layer=0, bool pos=false);//default layer 0 and no pos information in data
44  template <typename T> int readXY(std::vector<T>& xVector, std::vector<T>& yVector, int layer=0, bool verbose=false);
45  template <typename T> int readY(std::vector<T>& yVector, int layer=0, bool verbose=false);
46  template <typename T> int readData(std::vector<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, OGRFeature *poFeature, int layer=0, bool pos=false, bool verbose=false);
47  template <typename T> int readData(std::vector<T>& data, const OGRFieldType& fieldType, const std::string& theField, int layer=0, bool verbose=false);
48  template <typename T> int readData(Vector2d<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, int layer=0, bool pos=false, bool verbose=false);//default layer 0 and no pos information in data
49  template <typename T> int readData(std::map<int,Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, int layer=0, bool pos=false, bool verbose=false);//default layer 0 and no pos information in data
50  template <typename T> int readData(std::map<std::string,Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, int layer=0, bool pos=false, bool verbose=false);//default layer 0 and no pos information in data
51  unsigned int readDataImageOgr(std::map<std::string,Vector2d<float> > &mapPixels, //[classNr][pixelNr][bandNr],
52  std::vector<std::string>& fields,
53  const std::vector<unsigned short>& bands,
54  const std::string& label,
55  const std::vector<std::string>& layers,
56  int verbose=false);
57 
58  unsigned int readDataImageOgr(std::map<std::string,Vector2d<float> > &mapPixels, //[classNr][pixelNr][bandNr],
59  std::vector<std::string>& fields,
60  double start,
61  double end,
62  const std::string& label,
63  const std::vector<std::string>& layers,
64  int verbose=false);
65 
66  // void shape2ascii(std::ostream& theOstream, const std::string& pointname, int layer=0, bool verbose=false);
67  unsigned long int getFeatureCount(int layer=0) const;
68  int getFieldCount(int layer=0) const;
69  OGRLayer* getLayer(int layer=0){return m_datasource->GetLayer(layer);};
70  std::string getProjection(int layer=0) const;
71  OGRwkbGeometryType getGeometryType(int layer=0) const;
72  std::string getLayerName(int layer=0){return m_datasource->GetLayer(layer)->GetLayerDefn()->GetName();};
73  // int getLayer(int layer=0) const;
74  int getFields(std::vector<std::string>& fields, int layer=0) const;
75  int getFields(std::vector<OGRFieldDefn*>& fields, int layer=0) const;
76  OGRDataSource* getDataSource(void) {return m_datasource;};
77  OGRSFDriver* getDriver(void) const {return m_datasource->GetDriver();};
78  int getLayerCount(void) const {return m_datasource->GetLayerCount();};
79 // OGRLayer *executeSql(const std::string& output,const std::string& sqlStatement, OGRGeometry* spatialFilter=NULL);
80  template<typename T> int readSql(Vector2d<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& sqlStatement, OGRGeometry* spatialFilter=NULL, int layer=0, bool pos=false, bool verbose=false);
81  template<typename T> int readSql(std::map<int,Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, const std::string& sqlStatement, OGRGeometry* spatialFilter, int layer=0, bool pos=false, bool verbose=false);
82  bool getExtent(double& ulx, double& uly, double& lrx, double& lry, int layer);
83  bool getExtent(double& ulx, double& uly, double& lrx, double& lry);
84 
85  void setFieldSeparator(const char fs){ m_fs=fs;};
86  char getFieldSeparator() const { return m_fs;};
87  friend std::ostream& operator<<(std::ostream& theOstream, ImgReaderOgr& theImageReader);
88 
89 protected:
90  void setCodec(void);
91 
92  std::string m_filename;
93  OGRDataSource *m_datasource;
94  char m_fs;
95 };
96 
97 //read data from all features in a map, organized by classes
98 template <typename T> int ImgReaderOgr::readData(std::map<int,Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, int layer, bool pos, bool verbose)
99 {
100  assert(m_datasource->GetLayerCount()>layer);
101  OGRLayer *poLayer;
102  if(verbose)
103  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
104  poLayer = m_datasource->GetLayer(layer);
105  if(poLayer!=NULL){
106  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
107  if(fields.empty()){
108  fields.resize(poFDefn->GetFieldCount());
109  if(verbose)
110  std::cout << "resized fields to " << fields.size() << std::endl;
111  }
112  //start reading features from the layer
113  OGRFeature *poFeature;
114  if(verbose)
115  std::cout << "reset reading" << std::endl;
116  poLayer->ResetReading();
117  unsigned long int ifeature=0;
118  int posOffset=(pos)?2:0;
119  if(verbose)
120  std::cout << "going through features" << std::endl << std::flush;
121  int theClass=0;
122  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
123  std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
124  if(verbose)
125  std::cout << "reading feature " << ifeature << std::endl << std::flush;
126  OGRGeometry *poGeometry;
127  poGeometry = poFeature->GetGeometryRef();
128  if(verbose){
129  if(poGeometry == NULL)
130  std::cerr << "no geometry defined" << std::endl << std::flush;
131  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
132  std::cerr << "Warning: poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
133  }
134  assert(poGeometry != NULL );
135  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
136  if(pos){
137  if(wkbFlatten(poGeometry->getGeometryType()) == wkbPoint){
138  OGRPoint *poPoint;
139  poPoint = (OGRPoint *) poGeometry;
140  theFeature.push_back(poPoint->getX());
141  theFeature.push_back(poPoint->getY());
142  }
143  else if(wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon){
144  OGRPoint thePoint;
145  OGRPolygon * poPolygon = (OGRPolygon *) poGeometry;
146  poPolygon->Centroid(&thePoint);
147  theFeature.push_back(thePoint.getX());
148  theFeature.push_back(thePoint.getY());
149  }
150  else{
151  //Centroid for non polygon geometry not supported until OGR 1.8.0, comment out if version < 1.8.0 is installed...";
152  OGRPoint thePoint;
153  poGeometry->Centroid(&thePoint);
154  theFeature.push_back(thePoint.getX());
155  theFeature.push_back(thePoint.getY());
156  }
157  }
158  // OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
159  std::string featurename;
160  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
161  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
162  std::string fieldname=poFieldDefn->GetNameRef();
163  if(fieldname==label)
164  theClass=poFeature->GetFieldAsInteger(iField);
165  else{
166  switch(fieldType){
167  case(OFTReal):
168  if(fields.size()<poFDefn->GetFieldCount()){
169  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
170  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
171  }
172  else{
173  fields[iField]=fieldname;
174  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
175  }
176  break;
177  case(OFTInteger):
178  if(fields.size()<poFDefn->GetFieldCount()){
179  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
180  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
181  }
182  else{
183  fields[iField]=fieldname;
184  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
185  }
186  break;
187  default:
188  {
189  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
190  throw(errorstring);
191  }
192  break;
193  }
194  }
195  }
196  data[theClass].push_back(theFeature);
197  ++ifeature;
198  ++ifeature;
199  }
200  if(verbose)
201  std::cout << "number of features read: " << ifeature << std::endl << std::flush;
202  typename std::map<int,Vector2d<T> >::const_iterator mit=data.begin();
203  int nband=0;
204  if(verbose)
205  std::cout << "read classes: " << std::flush;
206  while(mit!=data.end()){
207  if(verbose)
208  std::cout << mit->first << " " << std::flush;
209  if(!nband)
210  nband=fields.size();
211  if(pos)
212  assert((mit->second)[0].size()==nband+2);
213  else
214  assert((mit->second)[0].size()==nband);
215  ++mit;
216  }
217  if(verbose)
218  std::cout << std::endl << std::flush;
219  return(nband);
220  }
221  else{
222  std::ostringstream ess;
223  ess << "no layer in " << m_filename;
224  throw(ess.str());
225  }
226 }
227 
228 //read data from all features in a map, organized by class names
229 template <typename T> int ImgReaderOgr::readData(std::map<std::string,Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, int layer, bool pos, bool verbose)
230 {
231  assert(m_datasource->GetLayerCount()>layer);
232  OGRLayer *poLayer;
233  if(verbose)
234  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
235  poLayer = m_datasource->GetLayer(layer);
236  if(poLayer!=NULL){
237  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
238  assert(poFDefn!=NULL);
239 
240  if(fields.empty()){
241  fields.resize(poFDefn->GetFieldCount());
242  if(verbose)
243  std::cout << "resized fields to " << fields.size() << std::endl;
244  }
245 
246  //start reading features from the layer
247  OGRFeature *poFeature;
248  if(verbose)
249  std::cout << "reset reading" << std::endl;
250  poLayer->ResetReading();
251  unsigned long int ifeature=0;
252  int posOffset=(pos)?2:0;
253  if(verbose)
254  std::cout << "going through features to fill in string map" << std::endl << std::flush;
255  std::string theClass;
256  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
257  std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
258  if(verbose)
259  std::cout << "reading feature " << ifeature << std::endl << std::flush;
260  OGRGeometry *poGeometry;
261  poGeometry = poFeature->GetGeometryRef();
262  if(verbose){
263  if(poGeometry == NULL)
264  std::cerr << "no geometry defined" << std::endl << std::flush;
265  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
266  std::cerr << "Warning: poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
267  }
268  assert(poGeometry != NULL );
269  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
270  if(pos){
271  if(wkbFlatten(poGeometry->getGeometryType()) == wkbPoint){
272  OGRPoint *poPoint;
273  poPoint = (OGRPoint *) poGeometry;
274  theFeature.push_back(poPoint->getX());
275  theFeature.push_back(poPoint->getY());
276  }
277  else if(wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon){
278  OGRPoint thePoint;
279  poGeometry->Centroid(&thePoint);
280  theFeature.push_back(thePoint.getX());
281  theFeature.push_back(thePoint.getY());
282  }
283  else{
284  //Centroid for non polygon geometry not supported until OGR 1.8.0, comment out if version < 1.8.0 is installed...";
285  OGRPoint thePoint;
286  poGeometry->Centroid(&thePoint);
287  theFeature.push_back(thePoint.getX());
288  theFeature.push_back(thePoint.getY());
289  }
290  }
291  // OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();//got LayerDefn already...
292  std::string featurename;
293  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
294  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
295  std::string fieldname=poFieldDefn->GetNameRef();
296  if(fieldname==label){
297  theClass=poFeature->GetFieldAsString(iField);
298  if(verbose)
299  std::cout << "read feature for " << theClass << std::endl;
300  }
301  else{
302  switch(fieldType){
303  case(OFTReal):
304  if(fields.size()<poFDefn->GetFieldCount()){
305  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
306  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
307  }
308  else{
309  fields[iField]=fieldname;
310  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
311  }
312  break;
313  case(OFTInteger):
314  if(fields.size()<poFDefn->GetFieldCount()){
315  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
316  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
317  }
318  else{
319  fields[iField]=fieldname;
320  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
321  }
322  break;
323  default:
324  {
325  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
326  throw(errorstring);
327  }
328  break;
329  }
330  }
331  assert(poFDefn!=NULL);
332  }
333  data[theClass].push_back(theFeature);
334  ++ifeature;
335  }
336  if(verbose)
337  std::cout << "number of features read: " << ifeature << std::endl << std::flush;
338  typename std::map<std::string,Vector2d<T> >::const_iterator mit=data.begin();
339  int nband=0;
340  if(verbose)
341  std::cout << "read classes: " << std::flush;
342  while(mit!=data.end()){
343  if(verbose)
344  std::cout << mit->first << " " << std::flush;
345  if(!nband)
346  nband=fields.size();
347  if(pos)
348  assert((mit->second)[0].size()==nband+2);
349  else
350  assert((mit->second)[0].size()==nband);
351  ++mit;
352  }
353  if(verbose)
354  std::cout << std::endl << std::flush;
355  return(nband);
356  }
357  else{
358  std::ostringstream ess;
359  ess << "no layer in " << m_filename;
360  throw(ess.str());
361  }
362 }
363 
364 //read x positions
365 template <typename T> int ImgReaderOgr::readXY(std::vector<T>& xVector, std::vector<T>& yVector, int layer, bool verbose){
366  assert(m_datasource->GetLayerCount()>layer);
367  OGRLayer *poLayer;
368  if(verbose)
369  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
370  poLayer = m_datasource->GetLayer(layer);
371  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
372  //start reading features from the layer
373  OGRFeature *poFeature;
374  if(verbose)
375  std::cout << "reset reading" << std::endl;
376  poLayer->ResetReading();
377  unsigned long int ifeature=0;
378  if(verbose)
379  std::cout << "going through features" << std::endl << std::flush;
380  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
381  if(verbose)
382  std::cout << "reading feature " << ifeature << std::endl << std::flush;
383  OGRGeometry *poGeometry;
384  poGeometry = poFeature->GetGeometryRef();
385  if(verbose){
386  if(poGeometry == NULL)
387  std::cerr << "no geometry defined" << std::endl << std::flush;
388  else// if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
389  std::cout << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl;
390  }
391  // assert(poGeometry != NULL
392  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
393  OGRPoint *poPoint = (OGRPoint *) poGeometry;
394  xVector.push_back(poPoint->getX());
395  yVector.push_back(poPoint->getY());
396  ++ifeature;
397  }
398  assert(xVector.size()==yVector.size());
399  if(xVector.size()){
400  return xVector.size();
401  }
402  else{
403  std::ostringstream ess;
404  ess << "no layer in " << m_filename;
405  throw(ess.str());
406  }
407 }
408 
409 //read data from a single feature
410 template <typename T> int ImgReaderOgr::readData(std::vector<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, OGRFeature *poFeature, int layer, bool pos, bool verbose)
411 {
412  assert(m_datasource->GetLayerCount()>layer);
413  OGRLayer *poLayer;
414  if(verbose)
415  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
416  poLayer = m_datasource->GetLayer(layer);
417  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
418  if(fields.empty()){
419  fields.resize(poFDefn->GetFieldCount());
420  if(verbose)
421  std::cout << "resized fields to " << fields.size() << std::endl;
422  }
423  OGRGeometry *poGeometry;
424  poGeometry = poFeature->GetGeometryRef();
425  if(verbose){
426  if(poGeometry == NULL)
427  std::cerr << "no geometry defined" << std::endl << std::flush;
428  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
429  std::cerr << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
430  }
431  assert(poGeometry != NULL);
432  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
433  OGRPoint *poPoint = (OGRPoint *) poGeometry;
434  if(pos){
435  if(wkbFlatten(poGeometry->getGeometryType()) == wkbPoint){
436  OGRPoint *poPoint;
437  poPoint = (OGRPoint *) poGeometry;
438  data.push_back(poPoint->getX());
439  data.push_back(poPoint->getY());
440  }
441  else if(wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon){
442  OGRPoint thePoint;
443  poGeometry->Centroid(&thePoint);
444  data.push_back(thePoint.getX());
445  data.push_back(thePoint.getY());
446  }
447  else{
448  //Centroid for non polygon geometry not supported until OGR 1.8.0, comment out if version < 1.8.0 is installed...";
449  OGRPoint thePoint;
450  poGeometry->Centroid(&thePoint);
451  data.push_back(thePoint.getX());
452  data.push_back(thePoint.getY());
453  }
454 
455  }
456  std::string featurename;
457  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
458  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
459  std::string fieldname=poFieldDefn->GetNameRef();
460  switch(fieldType){
461  case(OFTReal):
462  if(fields.size()<poFDefn->GetFieldCount()){
463  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
464  data.push_back(poFeature->GetFieldAsDouble(iField));
465  }
466  else{
467  fields[iField]=fieldname;
468  data.push_back(poFeature->GetFieldAsDouble(iField));
469  }
470  break;
471  case(OFTInteger):
472  if(fields.size()<poFDefn->GetFieldCount()){
473  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
474  data.push_back(poFeature->GetFieldAsDouble(iField));
475  }
476  else{
477  fields[iField]=fieldname;
478  data.push_back(poFeature->GetFieldAsDouble(iField));
479  }
480  break;
481  default:
482  {
483  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
484  throw(errorstring);
485  }
486  break;
487  }
488  }
489  // assert(data.size()==ifeature);
490  if(data.size()){
491  if(pos)
492  assert(data.size()==fields.size()+2);
493  else
494  assert(data.size()==fields.size());
495  return fields.size();
496  }
497  else{
498  std::ostringstream ess;
499  ess << "no layer in " << m_filename;
500  throw(ess.str());
501  }
502 }
503 
504 //read one field from all features
505 template <typename T> inline int ImgReaderOgr::readData(std::vector<T>& data, const OGRFieldType& fieldType, const std::string& theField, int layer, bool verbose)
506 {
507  assert(m_datasource->GetLayerCount()>layer);
508  OGRLayer *poLayer;
509  if(verbose)
510  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
511  poLayer = m_datasource->GetLayer(layer);
512  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
513  int nfield=(theField!="")? poFDefn->GetFieldCount() : 1;
514  if(theField==""){
515  //read first field available
516  if(verbose)
517  std::cout << "read first field from total of " << nfield << std::endl;
518  }
519 
520  //start reading features from the layer
521  OGRFeature *poFeature;
522  if(verbose)
523  std::cout << "reset reading" << std::endl;
524  poLayer->ResetReading();
525  unsigned long int ifeature=0;
526  if(verbose)
527  std::cout << "going through features" << std::endl << std::flush;
528  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
529  // std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
530  T theFeature;
531  if(verbose)
532  std::cout << "reading feature " << ifeature << std::endl << std::flush;
533  OGRGeometry *poGeometry;
534  poGeometry = poFeature->GetGeometryRef();
535  if(verbose){
536  if(poGeometry == NULL)
537  std::cerr << "no geometry defined" << std::endl << std::flush;
538  else// if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
539  std::cout << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl;
540  }
541  // assert(poGeometry != NULL
542  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
543  OGRPoint *poPoint = (OGRPoint *) poGeometry;
544 
545  for(int iField=0;iField<nfield;++iField){
546  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
547  std::string fieldname=poFieldDefn->GetNameRef();
548  if(fieldname!=theField)
549  continue;
550  switch(fieldType){
551  case(OFTInteger):
552  case(OFTReal):
553  theFeature=poFeature->GetFieldAsDouble(iField);
554  break;
555  default:
556  {
557  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
558  throw(errorstring);
559  }
560  break;
561  }
562  }
563  data.push_back(theFeature);
564  if(verbose)
565  std::cout << "feature is: " << theFeature << std::endl;
566  ++ifeature;
567  }
568  if(data.size()){
569  return data.size();
570  }
571  else{
572  std::ostringstream ess;
573  ess << "no layer in " << m_filename;
574  throw(ess.str());
575  }
576 }
577 
578 //specialization for string: read one field from all features
579 template <> inline int ImgReaderOgr::readData(std::vector<std::string>& data, const OGRFieldType& fieldType, const std::string& theField, int layer, bool verbose)
580 {
581  assert(m_datasource->GetLayerCount()>layer);
582  OGRLayer *poLayer;
583  if(verbose)
584  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
585  poLayer = m_datasource->GetLayer(layer);
586  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
587  int nfield=(theField!="")? poFDefn->GetFieldCount() : 1;
588  if(theField==""){
589  //read first field available
590  if(verbose)
591  std::cout << "read first field from total of " << nfield << std::endl;
592  }
593 
594  //start reading features from the layer
595  OGRFeature *poFeature;
596  if(verbose)
597  std::cout << "reset reading" << std::endl;
598  poLayer->ResetReading();
599  unsigned long int ifeature=0;
600  if(verbose)
601  std::cout << "going through features" << std::endl << std::flush;
602  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
603  std::string theFeature;
604  if(verbose)
605  std::cout << "reading feature " << ifeature << std::endl << std::flush;
606  OGRGeometry *poGeometry;
607  poGeometry = poFeature->GetGeometryRef();
608  if(verbose){
609  if(poGeometry == NULL)
610  std::cerr << "no geometry defined" << std::endl << std::flush;
611  else// if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
612  std::cout << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl;
613  }
614  // assert(poGeometry != NULL
615  // && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
616  OGRPoint *poPoint = (OGRPoint *) poGeometry;
617 
618  for(int iField=0;iField<nfield;++iField){
619  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
620  std::string fieldname=poFieldDefn->GetNameRef();
621  if(fieldname!=theField)
622  continue;
623  switch(fieldType){
624  case(OFTInteger):
625  case(OFTReal):
626  case(OFTString):
627  theFeature=poFeature->GetFieldAsString(iField);
628  break;
629  default:
630  {
631  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
632  throw(errorstring);
633  }
634  break;
635  }
636  }
637  data.push_back(theFeature);
638  if(verbose)
639  std::cout << "feature is: " << theFeature << std::endl;
640  ++ifeature;
641  }
642  if(data.size()){
643  return data.size();
644  }
645  else{
646  std::ostringstream ess;
647  ess << "no layer in " << m_filename;
648  throw(ess.str());
649  }
650 }
651 
652 //read data from all features
653 template <typename T> int ImgReaderOgr::readData(Vector2d<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, int layer, bool pos, bool verbose)
654 {
655  assert(m_datasource->GetLayerCount()>layer);
656  OGRLayer *poLayer;
657  if(verbose)
658  std::cout << "number of layers: " << m_datasource->GetLayerCount() << std::endl;
659  poLayer = m_datasource->GetLayer(layer);
660  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
661  if(fields.empty()){
662  fields.resize(poFDefn->GetFieldCount());
663  if(verbose)
664  std::cout << "resized fields to " << fields.size() << std::endl;
665  }
666  //start reading features from the layer
667  OGRFeature *poFeature;
668  if(verbose)
669  std::cout << "reset reading" << std::endl;
670  poLayer->ResetReading();
671  unsigned long int ifeature=0;
672  int posOffset=(pos)?2:0;
673  if(verbose)
674  std::cout << "going through features" << std::endl << std::flush;
675  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
676  std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
677  if(verbose)
678  std::cout << "reading feature " << ifeature << std::endl << std::flush;
679  OGRGeometry *poGeometry;
680  poGeometry = poFeature->GetGeometryRef();
681  if(verbose){
682  if(poGeometry == NULL)
683  std::cerr << "no geometry defined" << std::endl << std::flush;
684  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
685  std::cerr << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
686  }
687  assert(poGeometry != NULL
688  && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
689  OGRPoint *poPoint = (OGRPoint *) poGeometry;
690  if(pos){
691  theFeature.push_back(poPoint->getX());
692  theFeature.push_back(poPoint->getY());
693  }
694  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
695  std::string featurename;
696  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
697  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
698  std::string fieldname=poFieldDefn->GetNameRef();
699  switch(fieldType){
700  case(OFTReal):
701  if(fields.size()<poFDefn->GetFieldCount()){
702  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
703  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
704  }
705  else{
706  fields[iField]=fieldname;
707  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
708  }
709  break;
710  case(OFTInteger):
711  if(fields.size()<poFDefn->GetFieldCount()){
712  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
713  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
714  }
715  else{
716  fields[iField]=fieldname;
717  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
718  }
719  break;
720  default:
721  {
722  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
723  throw(errorstring);
724  }
725  break;
726  }
727  }
728  data.push_back(theFeature);
729  ++ifeature;
730  }
731 // assert(data.size()==ifeature);
732  if(data.size()){
733  if(pos)
734  assert(data[0].size()==fields.size()+2);
735  else
736  assert(data[0].size()==fields.size());
737  return fields.size();
738  }
739  else{
740  std::ostringstream ess;
741  ess << "no layer in " << m_filename;
742  throw(ess.str());
743  }
744 }
745 
746 template<typename T> int ImgReaderOgr::readSql(std::map<int, Vector2d<T> >& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& label, const std::string& sqlStatement, OGRGeometry* spatialFilter, int layer, bool pos, bool verbose)
747 {
748  assert(m_datasource->GetLayerCount()>layer);
749  OGRLayer *poLayer;
750  poLayer = m_datasource->ExecuteSQL(sqlStatement.c_str(), spatialFilter,NULL );
751  if(poLayer!=NULL){
752  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
753  if(fields.empty()){
754  fields.resize(poFDefn->GetFieldCount());
755  if(verbose)
756  std::cout << "resized fields to " << fields.size() << std::endl;
757  }
758  //start reading features from the layer
759  OGRFeature *poFeature;
760  if(verbose)
761  std::cout << "reset reading" << std::endl;
762  poLayer->ResetReading();
763  unsigned long int ifeature=0;
764  int posOffset=(pos)?2:0;
765  if(verbose)
766  std::cout << "going through features" << std::endl << std::flush;
767  int theClass=0;
768  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
769  std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
770  if(verbose)
771  std::cout << "reading feature " << ifeature << std::endl << std::flush;
772  OGRGeometry *poGeometry;
773  poGeometry = poFeature->GetGeometryRef();
774  if(verbose){
775  if(poGeometry == NULL)
776  std::cerr << "no geometry defined" << std::endl << std::flush;
777  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
778  std::cerr << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
779  }
780  assert(poGeometry != NULL
781  && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
782  OGRPoint *poPoint = (OGRPoint *) poGeometry;
783  if(pos){
784  theFeature.push_back(poPoint->getX());
785  theFeature.push_back(poPoint->getY());
786  }
787  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
788  std::string featurename;
789  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
790  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
791  std::string fieldname=poFieldDefn->GetNameRef();
792  if(fieldname==label)
793  theClass=poFeature->GetFieldAsInteger(iField);
794  else{
795  switch(fieldType){
796  case(OFTReal):
797  if(fields.size()<poFDefn->GetFieldCount()){
798  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
799  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
800  }
801  else{
802  fields[iField]=fieldname;
803  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
804  }
805  break;
806  case(OFTInteger):
807  if(fields.size()<poFDefn->GetFieldCount()){
808  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
809  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
810  }
811  else{
812  fields[iField]=fieldname;
813  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
814  }
815  break;
816  default:
817  {
818  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
819  throw(errorstring);
820  }
821  break;
822  }
823  }
824  }
825  data[theClass].push_back(theFeature);
826  ++ifeature;
827  }
828  if(verbose)
829  std::cout << "number of features read: " << ifeature << std::endl << std::flush;
830  typename std::map<int,Vector2d<T> >::const_iterator mit=data.begin();
831  int nband=0;
832  if(verbose)
833  std::cout << "read classes: " << std::flush;
834  while(mit!=data.end()){
835  if(verbose)
836  std::cout << mit->first << " " << std::flush;
837  if(!nband)
838  nband=fields.size();
839  if(pos)
840  assert((mit->second)[0].size()==nband+2);
841  else
842  assert((mit->second)[0].size()==nband);
843  ++mit;
844  }
845  if(verbose)
846  std::cout << std::endl << std::flush;
847  return(nband);
848  }
849  else{
850  std::ostringstream ess;
851  ess << "no layer in " << m_filename;
852  throw(ess.str());
853  }
854 }
855 
856 template<typename T> int ImgReaderOgr::readSql(Vector2d<T>& data, const OGRFieldType& fieldType, std::vector<std::string>& fields, const std::string& sqlStatement, OGRGeometry* spatialFilter, int layer, bool pos, bool verbose)
857 {
858  assert(m_datasource->GetLayerCount()>layer);
859  OGRLayer *poLayer;
860  poLayer = m_datasource->ExecuteSQL(sqlStatement.c_str(), spatialFilter,NULL );
861  if(poLayer!=NULL){
862  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
863  if(fields.empty()){
864  fields.resize(poFDefn->GetFieldCount());
865  if(verbose)
866  std::cout << "resized fields to " << fields.size() << std::endl;
867  }
868  //start reading features from the layer
869  OGRFeature *poFeature;
870  if(verbose)
871  std::cout << "reset reading" << std::endl;
872  poLayer->ResetReading();
873  unsigned long int ifeature=0;
874  int posOffset=(pos)?2:0;
875  if(verbose)
876  std::cout << "going through features" << std::endl << std::flush;
877  while( (poFeature = poLayer->GetNextFeature()) != NULL ){
878  std::vector<T> theFeature;//(fields.size()+posOffset);//x,y+selectedfields
879  if(verbose)
880  std::cout << "reading feature " << ifeature << std::endl << std::flush;
881  OGRGeometry *poGeometry;
882  poGeometry = poFeature->GetGeometryRef();
883  if(verbose){
884  if(poGeometry == NULL)
885  std::cerr << "no geometry defined" << std::endl << std::flush;
886  else if(wkbFlatten(poGeometry->getGeometryType()) != wkbPoint)
887  std::cerr << "poGeometry type: " << wkbFlatten(poGeometry->getGeometryType()) << std::endl << std::flush;
888  }
889  assert(poGeometry != NULL
890  && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint);
891  OGRPoint *poPoint = (OGRPoint *) poGeometry;
892  if(pos){
893  theFeature.push_back(poPoint->getX());
894  theFeature.push_back(poPoint->getY());
895  }
896  OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
897  std::string featurename;
898  for(int iField=0;iField<poFDefn->GetFieldCount();++iField){
899  OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
900  std::string fieldname=poFieldDefn->GetNameRef();
901  switch(fieldType){
902  case(OFTReal):
903  if(fields.size()<poFDefn->GetFieldCount()){
904  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
905  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
906  }
907  else{
908  fields[iField]=fieldname;
909  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
910  }
911  break;
912  case(OFTInteger):
913  if(fields.size()<poFDefn->GetFieldCount()){
914  if(find(fields.begin(),fields.end(),fieldname)!=fields.end())
915  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
916  }
917  else{
918  fields[iField]=fieldname;
919  theFeature.push_back(poFeature->GetFieldAsDouble(iField));
920  }
921  break;
922  default:
923  {
924  std::string errorstring="field type not supported in ImgReaderOgr::ReadData";
925  throw(errorstring);
926  }
927  break;
928  }
929  }
930  data.push_back(theFeature);
931  ++ifeature;
932  }
933  m_datasource->ReleaseResultSet( poLayer );
934  // assert(data.size()==ifeature);
935  if(data.size()){
936  if(pos)
937  assert(data[0].size()==fields.size()+2);
938  else
939  assert(data[0].size()==fields.size());
940  return fields.size();
941  }
942  else
943  return(0);
944  }
945  else{
946  std::ostringstream ess;
947  ess << "no layer in " << m_filename;
948  throw(ess.str());
949  }
950 }
951 
952 #endif // _IMGREADEROGR_H_