1 // Copyright 2003 (c) Barry Rowlingson
2 // Modified 2006 Roger Bivand
3 // OGR data source interface
4 //
5 // note: the following objects must be deleted or memory leaks:
6 // OGRDataSource
7 // OGRFeature
8 //
9 // the following objects are owned by their parents, and so
10 // shouldnt be deleted (they get cleaned up when their parent is deleted)
11 // OGRLayer
12 // OGRGeometry
13 // OGRFeatureDefn
14 // OGRSpatialReference
15 //
16 // see ogrsf_frmts.dox for authoritative notes!
17
18 #include "ogrsf_frmts.h"
19
20 // R headers moved outside extern "C" 070808 RSB re. note from BDR
21 //extern "C" {
22 #include <R.h>
23 #include <Rinternals.h>
24 #include <Rdefines.h>
25 //}
26 #include "rgdal.h"
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 //#define EJP
33
34 // extern "C" {
RGDAL_ogrInfo(SEXP ogrsourcename,SEXP Layer)35 SEXP RGDAL_ogrInfo(SEXP ogrsourcename, SEXP Layer){
36 // return FIDs, nFields, fieldInfo
37
38 SEXP ans, vec1, vec2, vec3,/*mat,*/drv, dvec;
39 SEXP itemlist, itemnames, itemwidth, itemtype, itemTypeNames;
40 SEXP itemlistmaxcount;
41 #ifdef GDALV2
42 SEXP dFIDs;
43 #endif
44 /*SEXP geotype;*/
45
46 int nFIDs, nFields, iField, *nCount, pc=0;
47
48 #ifdef GDALV2
49 GDALDriver *poDriver;
50 GDALDataset *poDS;
51 #else
52 OGRDataSource *poDS;
53 OGRSFDriver *poDriver;
54 #endif
55 OGRLayer *poLayer;
56 OGRFeature *poFeature;
57 OGRFeatureDefn *poDefn;
58 /* OGRGeometry *poGeom;*/
59
60 installErrorHandler();
61 #ifdef GDALV2
62 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrsourcename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
63 if(poDS==NULL){
64 uninstallErrorHandlerAndTriggerError();
65 error("Cannot open data source");
66 }
67 poDriver = poDS->GetDriver();
68 #else
69 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrsourcename, 0)),
70 FALSE, &poDriver);
71 #endif
72 uninstallErrorHandlerAndTriggerError();
73
74 if(poDS==NULL){
75 installErrorHandler();
76 #ifdef GDALV2
77 GDALClose( poDS );
78 #else
79 OGRDataSource::DestroyDataSource( poDS );
80 #endif
81 uninstallErrorHandlerAndTriggerError();
82 // delete poDS;
83 error("Cannot open file");
84 }
85
86 installErrorHandler();
87 poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
88 uninstallErrorHandlerAndTriggerError();
89
90 if(poLayer == NULL){
91 installErrorHandler();
92 #ifdef GDALV2
93 GDALClose( poDS );
94 #else
95 OGRDataSource::DestroyDataSource( poDS );
96 #endif
97 uninstallErrorHandlerAndTriggerError();
98 // delete poDS;
99 error("Cannot open layer");
100 }
101
102 // allocate a list for return values
103 PROTECT(ans=allocVector(VECSXP,6)); pc++;
104
105 PROTECT(drv=allocVector(STRSXP,1)); pc++;
106 installErrorHandler();
107 #ifdef GDALV2
108 SET_STRING_ELT(drv, 0, mkChar(poDriver->GetDescription()));
109 #else
110 SET_STRING_ELT(drv, 0, mkChar(poDriver->GetName()));
111 #endif
112 uninstallErrorHandlerAndTriggerError();
113 SET_VECTOR_ELT(ans,3,drv);
114
115 PROTECT(vec1=allocVector(INTSXP,1)); pc++;
116 installErrorHandler();
117 #ifdef GDALV2
118 GIntBig nFIDs64 = poLayer->GetFeatureCount();
119 nFIDs = (nFIDs64 > INT_MAX) ? INT_MAX :
120 (nFIDs64 < INT_MIN) ? INT_MIN : (int) nFIDs64;
121 if ((GIntBig) nFIDs != nFIDs64){
122 warning("ogrInfo: feature count overflow");
123 INTEGER(vec1)[0]=NA_INTEGER;
124 PROTECT(dFIDs=NEW_NUMERIC(1)); pc++;
125 NUMERIC_POINTER(dFIDs)[0] = (double) nFIDs64;
126 setAttrib(vec1, install("dFIDs"), dFIDs);
127 } else {
128 // store number of FIDs
129 INTEGER(vec1)[0]=nFIDs;
130 }
131 #else
132 nFIDs = poLayer->GetFeatureCount();
133 // store number of FIDs
134 INTEGER(vec1)[0]=nFIDs;
135 #endif
136 uninstallErrorHandlerAndTriggerError();
137
138 if (nFIDs == -1) {
139 int i=0;
140 installErrorHandler();
141 while( ((poFeature = poLayer->GetNextFeature()) != NULL) && i <= INT_MAX){
142 i++;
143 OGRFeature::DestroyFeature( poFeature );
144 // delete poFeature;
145 }
146 uninstallErrorHandlerAndTriggerError();
147 if (i == INT_MAX) {
148 error("ogrInfo: undeclared feature count overflow");
149 } else {
150 nFIDs = i;
151 warning("ogrInfo: feature count not given; %d counted", nFIDs);
152 }
153 installErrorHandler();
154 poLayer->ResetReading();
155 uninstallErrorHandlerAndTriggerError();
156
157 INTEGER(vec1)[0]=nFIDs;
158 }
159
160 SET_VECTOR_ELT(ans,0,vec1);
161
162
163
164 // store other stuff....
165 installErrorHandler();
166 poDefn = poLayer->GetLayerDefn();
167 nFields = poDefn->GetFieldCount();
168 uninstallErrorHandlerAndTriggerError();
169
170 // store number of fields
171 PROTECT(vec2=allocVector(INTSXP,1)); pc++;
172 INTEGER(vec2)[0]=nFields;
173 SET_VECTOR_ELT(ans,1,vec2);
174 installErrorHandler();
175 OGREnvelope oExt;
176 if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) {
177 PROTECT(dvec=allocVector(REALSXP,4)); pc++;
178 REAL(dvec)[0] = oExt.MinX;
179 REAL(dvec)[1] = oExt.MinY;
180 REAL(dvec)[2] = oExt.MaxX;
181 REAL(dvec)[3] = oExt.MaxY;
182 SET_VECTOR_ELT(ans,4,dvec);
183 }
184 uninstallErrorHandlerAndTriggerError();
185
186 PROTECT(itemnames=allocVector(STRSXP,nFields)); pc++;
187 PROTECT(itemtype=allocVector(INTSXP,nFields)); pc++;
188 PROTECT(itemwidth=allocVector(INTSXP,nFields)); pc++;
189 // try List types
190 PROTECT(itemlistmaxcount=allocVector(INTSXP,nFields)); pc++;
191 PROTECT(itemTypeNames=allocVector(STRSXP,nFields)); pc++;
192 int listFieldCount=0;
193
194 installErrorHandler();
195 for(iField=0;iField<nFields;iField++){
196 OGRFieldDefn *poField = poDefn->GetFieldDefn(iField);
197 SET_STRING_ELT(itemnames,iField,mkChar(poField->GetNameRef()));
198 INTEGER(itemtype)[iField]=poField->GetType();
199 if (INTEGER(itemtype)[iField] == OFTIntegerList ||
200 #ifdef GDALV2
201 INTEGER(itemtype)[iField] == OFTInteger64List ||
202 #endif
203 INTEGER(itemtype)[iField] == OFTRealList ||
204 INTEGER(itemtype)[iField] == OFTStringList) listFieldCount++;
205 INTEGER(itemwidth)[iField]=poField->GetWidth();
206 SET_STRING_ELT(itemTypeNames,iField,mkChar(poField->GetFieldTypeName(
207 poField->GetType())));
208 INTEGER(itemlistmaxcount)[iField] = 0;
209 }
210 uninstallErrorHandlerAndTriggerError();
211
212 PROTECT(vec3=allocVector(INTSXP,1)); pc++;
213 INTEGER(vec3)[0]=listFieldCount;
214 SET_VECTOR_ELT(ans,5,vec3);
215 PROTECT(itemlist=allocVector(VECSXP,5)); pc++;
216 SET_VECTOR_ELT(itemlist,0,itemnames);
217 SET_VECTOR_ELT(itemlist,1,itemtype);
218 SET_VECTOR_ELT(itemlist,2,itemwidth);
219 SET_VECTOR_ELT(itemlist,3,itemTypeNames);
220 // try List types
221 if (listFieldCount > 0) {
222
223 poLayer->ResetReading();
224 OGRFeature* poFeature;
225
226 nCount = (int *) R_alloc((size_t) nFields, sizeof(int));
227 for (iField=0; iField<nFields; iField++) nCount[iField] = 0;
228 installErrorHandler();
229 OGRField* psField;
230 while( (poFeature = poLayer->GetNextFeature()) != NULL ){
231 for(iField=0; iField<nFields; iField++){
232 psField = poFeature->GetRawFieldRef(iField);
233 if (INTEGER(itemtype)[iField] == OFTIntegerList) {
234 nCount[iField] = psField->IntegerList.nCount;
235 if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
236 INTEGER(itemlistmaxcount)[iField] = nCount[iField];
237 } else if (INTEGER(itemtype)[iField] == OFTRealList) {
238 nCount[iField] = psField->RealList.nCount;
239 if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
240 INTEGER(itemlistmaxcount)[iField] = nCount[iField];
241 } else if (INTEGER(itemtype)[iField] == OFTStringList) {
242 nCount[iField] = psField->StringList.nCount;
243 if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
244 INTEGER(itemlistmaxcount)[iField] = nCount[iField];
245 #ifdef GDALV2
246 } else if (INTEGER(itemtype)[iField] == OFTInteger64List) {
247 nCount[iField] = psField->StringList.nCount;
248 if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
249 INTEGER(itemlistmaxcount)[iField] = nCount[iField];
250 #endif
251 }
252 }
253 OGRFeature::DestroyFeature( poFeature );
254 // delete poFeature;
255 }
256 uninstallErrorHandlerAndTriggerError();
257
258 }
259 SET_VECTOR_ELT(itemlist,4,itemlistmaxcount);
260 SET_VECTOR_ELT(ans,2,itemlist);
261
262
263 installErrorHandler();
264 #ifdef GDALV2
265 GDALClose( poDS );
266 #else
267 OGRDataSource::DestroyDataSource( poDS );
268 #endif
269 uninstallErrorHandlerAndTriggerError();
270 // delete poDS;
271 UNPROTECT(pc);
272 return(ans);
273
274 }
275 // }
276 #ifdef __cplusplus
277 }
278 #endif
279
280
281 #ifdef __cplusplus
282 extern "C" {
283 #endif
284 //extern "C" {
RGDAL_ogrFIDs(SEXP filename,SEXP layer)285 SEXP RGDAL_ogrFIDs(SEXP filename, SEXP layer){
286 SEXP fids, nf, ii;
287 int /*layerNum,*/i;
288 int nFeatures, pc=0;
289 OGRLayer *poLayer;
290 OGRFeature *poFeature;
291 #ifdef GDALV2
292 GDALDataset *poDS;
293 #else
294 OGRDataSource *poDS;
295 OGRSFDriver *poDriver;
296 #endif
297
298 installErrorHandler();
299 #ifdef GDALV2
300 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(filename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
301 #else
302 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(filename, 0)),
303 FALSE, &poDriver);
304 #endif
305 uninstallErrorHandlerAndTriggerError();
306
307 if(poDS==NULL){
308 error("Cannot open file");
309 }
310
311 installErrorHandler();
312 poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(layer, 0)));
313 uninstallErrorHandlerAndTriggerError();
314
315 if(poLayer == NULL){
316 error("Cannot open layer");
317 }
318 installErrorHandler();
319 #ifdef GDALV2
320 GIntBig nFIDs64 = poLayer->GetFeatureCount();
321 nFeatures = (nFIDs64 > INT_MAX) ? INT_MAX :
322 (nFIDs64 < INT_MIN) ? INT_MIN : (int) nFIDs64;
323 if ((GIntBig) nFeatures != nFIDs64){
324 uninstallErrorHandlerAndTriggerError();
325 error("ogrFIDs: feature count overflow");
326 }
327 #else
328 nFeatures=poLayer->GetFeatureCount();
329 #endif
330 uninstallErrorHandlerAndTriggerError();
331
332 if (nFeatures == -1) {
333 i=0;
334 installErrorHandler();
335 while( ((poFeature = poLayer->GetNextFeature()) != NULL) && i <= INT_MAX){
336 i++;
337 OGRFeature::DestroyFeature( poFeature );
338 // delete poFeature;
339 }
340 uninstallErrorHandlerAndTriggerError();
341 installErrorHandler();
342 poLayer->ResetReading();
343 uninstallErrorHandlerAndTriggerError();
344 if (i == INT_MAX) {
345 error("ogrFIDs: feature count overflow");
346 } else {
347 nFeatures = i;
348 }
349 }
350
351 PROTECT(fids=allocVector(INTSXP,nFeatures)); pc++;
352 PROTECT(nf = NEW_INTEGER(1)); pc++;
353 INTEGER_POINTER(nf)[0] = nFeatures;
354 PROTECT(ii = NEW_INTEGER(1)); pc++;
355
356 installErrorHandler();
357 poLayer->ResetReading();
358 uninstallErrorHandlerAndTriggerError();
359
360
361 i=0;
362 installErrorHandler();
363 while( (poFeature = poLayer->GetNextFeature()) != NULL ){
364 INTEGER(fids)[i]= (int) poFeature->GetFID();
365 i++;
366 OGRFeature::DestroyFeature( poFeature );
367 // delete poFeature;
368 }
369 uninstallErrorHandlerAndTriggerError();
370
371 INTEGER_POINTER(ii)[0] = i;
372 setAttrib(fids, install("nf"), nf);
373 setAttrib(fids, install("i"), ii);
374
375 installErrorHandler();
376 #ifdef GDALV2
377 GDALClose( poDS );
378 #else
379 OGRDataSource::DestroyDataSource( poDS );
380 #endif
381 uninstallErrorHandlerAndTriggerError();
382 // delete poDS;
383
384 UNPROTECT(pc);
385 return(fids);
386
387 }
388 // }
389 #ifdef __cplusplus
390 }
391 #endif
392
393 #ifdef __cplusplus
394 extern "C" {
395 #endif
396 // extern "C" {
397
ogrReadColumn(OGRLayer * poLayer,SEXP FIDs,int iField,int int64)398 SEXP ogrReadColumn(OGRLayer *poLayer, SEXP FIDs, int iField, int int64){
399 // read feature data and return something according to the type
400 OGRFeatureDefn *poDefn;
401 OGRFieldDefn *poField;
402 OGRFeature *poFeature;
403 int iRow, nRows, warn_int64=0;
404 double dbl_max_int64 = pow(2.0, 53);
405 SEXP ans = R_NilValue;
406
407 nRows=length(FIDs);
408 // get field data from layer
409 installErrorHandler();
410 poDefn = poLayer->GetLayerDefn();
411 poField = poDefn->GetFieldDefn(iField);
412 uninstallErrorHandlerAndTriggerError();
413 if(poField == NULL){
414 error("Error getting field %d ",iField);
415 }
416 // allocate an object for the result depending on the feature type:
417 installErrorHandler();
418 switch(poField->GetType()){
419 case OFTInteger:
420 PROTECT(ans=allocVector(INTSXP,nRows));
421 break;
422 #ifdef GDALV2
423 case OFTInteger64:
424 if (int64 == 4) {
425 PROTECT(ans=allocVector(REALSXP,nRows));
426 } else if (int64 ==3) {
427 PROTECT(ans=allocVector(STRSXP,nRows));
428 } else {
429 PROTECT(ans=allocVector(INTSXP,nRows));
430 }
431 break;
432 #endif
433 case OFTReal:
434 PROTECT(ans=allocVector(REALSXP,nRows));
435 break;
436 case OFTString:
437 PROTECT(ans=allocVector(STRSXP,nRows));
438 break;
439 case OFTDate:
440 PROTECT(ans=allocVector(STRSXP,nRows));
441 break;
442 case OFTDateTime:
443 PROTECT(ans=allocVector(STRSXP,nRows));
444 break;
445 case OFTTime:
446 PROTECT(ans=allocVector(STRSXP,nRows));
447 break;
448 default:
449 const char *desc = poField->GetFieldTypeName(poField->GetType());
450 uninstallErrorHandlerAndTriggerError();
451 error("unsupported field type: %s", desc);
452 break;
453 }
454 uninstallErrorHandlerAndTriggerError();
455
456 // now go over each row and retrieve data. iRow is an index in a
457 // vector of FIDs
458 /*#ifndef EJP
459 installErrorHandler();
460 for(iRow=0;iRow<nRows;iRow++){
461 poFeature=poLayer->GetFeature(INTEGER(FIDs)[iRow]);
462 if(poFeature == NULL){
463 error("Error getting feature FID: %d",(INTEGER(FIDs)[iRow]));
464 }
465 }
466 uninstallErrorHandlerAndTriggerError();
467 #else*/
468 // EJP, changed into:
469 installErrorHandler();
470 poLayer->ResetReading();
471 iRow = 0;
472 while((poFeature = poLayer->GetNextFeature()) != NULL) {
473 //#endif
474 // now get the value using the right type:
475 switch(poField->GetType()){
476 case OFTInteger:
477 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
478 if (poFeature->IsFieldSetAndNotNull(iField))
479 #else
480 if (poFeature->IsFieldSet(iField))
481 #endif
482 INTEGER(ans)[iRow]=poFeature->GetFieldAsInteger(iField);
483 else INTEGER(ans)[iRow]=NA_INTEGER;
484 break;
485 #ifdef GDALV2
486 case OFTInteger64:
487 #if (GDAL_VERSION_MINOR >= 2 || GDAL_VERSION_MAJOR > 2)
488 if (poFeature->IsFieldSetAndNotNull(iField)) {
489 #else
490 if (poFeature->IsFieldSet(iField)) {
491 #endif
492 if (int64 == 4) {
493 REAL(ans)[iRow] = poFeature->GetFieldAsDouble(iField);
494 if (REAL(ans)[iRow] > dbl_max_int64) warn_int64 = 1;
495 } else if (int64 == 3) {
496 SET_STRING_ELT(ans, iRow,
497 mkChar(poFeature->GetFieldAsString(iField)));
498 } else {
499 GIntBig nVal64 = poFeature->GetFieldAsInteger64(iField);
500 int nVal = (nVal64 > INT_MAX) ? INT_MAX :
501 (nVal64 < INT_MIN) ? INT_MIN : (int) nVal64;
502 INTEGER(ans)[iRow]=nVal;
503 if (((GIntBig)nVal != nVal64) && int64 == 2) {
504 warning("Integer64 value clamped: feature %d", iRow);
505 }
506 }
507 } else {
508 if (int64 == 3) {
509 SET_STRING_ELT(ans, iRow, NA_STRING);
510 } else {
511 INTEGER(ans)[iRow]=NA_INTEGER;
512 }
513 }
514 break;
515 #endif
516 case OFTReal:
517 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
518 if (poFeature->IsFieldSetAndNotNull(iField))
519 #else
520 if (poFeature->IsFieldSet(iField))
521 #endif
522 REAL(ans)[iRow]=poFeature->GetFieldAsDouble(iField);
523 else REAL(ans)[iRow]=NA_REAL;
524 break;
525 case OFTString:
526 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
527 if (poFeature->IsFieldSetAndNotNull(iField))
528 #else
529 if (poFeature->IsFieldSet(iField))
530 #endif
531 SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
532 else SET_STRING_ELT(ans, iRow, NA_STRING);
533 break;
534 case OFTDate:
535 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
536 if (poFeature->IsFieldSetAndNotNull(iField))
537 #else
538 if (poFeature->IsFieldSet(iField))
539 #endif
540 SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
541 else SET_STRING_ELT(ans, iRow, NA_STRING);
542 break;
543 case OFTDateTime:
544 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
545 if (poFeature->IsFieldSetAndNotNull(iField))
546 #else
547 if (poFeature->IsFieldSet(iField))
548 #endif
549 SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
550 else SET_STRING_ELT(ans, iRow, NA_STRING);
551 break;
552 case OFTTime:
553 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
554 if (poFeature->IsFieldSetAndNotNull(iField))
555 #else
556 if (poFeature->IsFieldSet(iField))
557 #endif
558 SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
559 else SET_STRING_ELT(ans, iRow, NA_STRING);
560 break;
561
562 default:
563 OGRFeature::DestroyFeature( poFeature );
564 // delete poFeature;
565 uninstallErrorHandlerAndTriggerError();
566 error("Unsupported field type. should have been caught before");
567 }
568 OGRFeature::DestroyFeature( poFeature );
569 // delete poFeature;
570 //#ifdef EJP
571 // according to tutorial: OGRFeature::DestroyFeature(poFeature);
572 // see comment FW in OGR tutorial: We could just "delete" it,
573 // but this can cause problems in windows builds where the GDAL DLL
574 // has a different "heap" from the main program. To be on the safe
575 // side we use a GDAL function to delete the feature.
576 iRow++;
577 //#endif
578 }
579 if (warn_int64 == 1) {
580 warning("Integer64 values larger than %g lost significance after conversion to double", dbl_max_int64);
581 }
582 uninstallErrorHandlerAndTriggerError();
583 UNPROTECT(1);
584 return(ans);
585 }
586 // }
587 #ifdef __cplusplus
588 }
589 #endif
590
591
592 #ifdef __cplusplus
593 extern "C" {
594 #endif
595 // extern "C" {
596
ogrReadListColumn(OGRLayer * poLayer,SEXP FIDs,int iField,int k,int int64)597 SEXP ogrReadListColumn(OGRLayer *poLayer, SEXP FIDs, int iField, int k, int int64){
598 // read feature data and return something according to the type
599 OGRFeatureDefn *poDefn;
600 OGRFieldDefn *poField;
601 OGRFeature *poFeature;
602 int iRow,nRows,nlist;
603 SEXP ans = R_NilValue;
604
605 nRows=length(FIDs);
606 // get field data from layer
607 installErrorHandler();
608 poDefn = poLayer->GetLayerDefn();
609 poField = poDefn->GetFieldDefn(iField);
610 uninstallErrorHandlerAndTriggerError();
611 if(poField == NULL){
612 error("Error getting field %d ",iField);
613 }
614 // allocate an object for the result depending on the feature type:
615 installErrorHandler();
616 switch(poField->GetType()){
617 case OFTIntegerList:
618 PROTECT(ans=allocVector(INTSXP,nRows));
619 break;
620 #ifdef GDALV2
621 case OFTInteger64List:
622 if (int64 == 4) {
623 PROTECT(ans=allocVector(REALSXP,nRows));
624 } else if (int64 == 3) {
625 PROTECT(ans=allocVector(STRSXP,nRows));
626 } else {
627 PROTECT(ans=allocVector(INTSXP,nRows));
628 }
629 break;
630 #endif
631 case OFTRealList:
632 PROTECT(ans=allocVector(REALSXP,nRows));
633 break;
634 case OFTStringList:
635 PROTECT(ans=allocVector(STRSXP,nRows));
636 break;
637 default:
638 const char *desc = poField->GetFieldTypeName(poField->GetType());
639 uninstallErrorHandlerAndTriggerError();
640 error("unsupported field type: %s", desc);
641 break;
642 }
643 uninstallErrorHandlerAndTriggerError();
644
645 // now go over each row and retrieve data. iRow is an index in a
646 // vector of FIDs
647 installErrorHandler();
648 poLayer->ResetReading();
649 OGRField* psField;
650 iRow = 0;
651 double DINT_MAX = 2251799813685248.0;
652 double DINT_MIN = -2251799813685248.0;
653
654 while((poFeature = poLayer->GetNextFeature()) != NULL) {
655 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
656 if (poFeature->IsFieldSetAndNotNull(iField)) {
657 #else
658 if (poFeature->IsFieldSet(iField)) {
659 #endif
660
661 // now get the value using the right type:
662 psField = poFeature->GetRawFieldRef(iField);
663
664 switch(poField->GetType()){
665 case OFTIntegerList:
666 nlist = psField->IntegerList.nCount;
667 if (k < nlist)
668 INTEGER(ans)[iRow] = psField->IntegerList.paList[k];
669 else INTEGER(ans)[iRow]=NA_INTEGER;
670 break;
671 #ifdef GDALV2
672 case OFTInteger64List:
673 nlist = psField->Integer64List.nCount;
674 if (k < nlist) {
675 GIntBig nVal64 = psField->Integer64List.paList[k];
676 if (int64 == 4) {
677 REAL(ans)[iRow] = (double) nVal64;
678 } else if (int64 == 3) {
679 double dnval = (double) nVal64;
680 if (dnval > DINT_MAX || dnval < DINT_MIN)
681 warning("Integer64 value clamped: feature %d", iRow);
682 char szItem[32];
683 // CPL FORMAT assumes > ISO C++98
684 snprintf(szItem, sizeof(szItem), "%.0f", dnval);
685 SET_STRING_ELT(ans, iRow, mkChar(szItem));
686 } else {
687 int nVal = (nVal64 > INT_MAX) ? INT_MAX :
688 (nVal64 < INT_MIN) ? INT_MIN : (int) nVal64;
689 if (((GIntBig)nVal != nVal64) && int64 == 2) {
690 warning("Integer64 value clamped: feature %d", iRow);
691 }
692 INTEGER(ans)[iRow]=nVal;
693 }
694 } else {
695 if (int64 == 3) {
696 SET_STRING_ELT(ans, iRow, NA_STRING);
697 } else {
698 INTEGER(ans)[iRow]=NA_INTEGER;
699 }
700 }
701 break;
702 #endif
703
704 case OFTRealList:
705 nlist = psField->RealList.nCount;
706 if (k < nlist)
707 REAL(ans)[iRow] = psField->RealList.paList[k];
708 else REAL(ans)[iRow]=NA_REAL;
709 break;
710
711 case OFTStringList:
712 nlist = psField->StringList.nCount;
713 if (k < nlist)
714 SET_STRING_ELT(ans,iRow,mkChar(psField->StringList.paList[k]));
715 else SET_STRING_ELT(ans, iRow, NA_STRING);
716 break;
717
718 default:
719 OGRFeature::DestroyFeature( poFeature );
720 // delete poFeature;
721 uninstallErrorHandlerAndTriggerError();
722 error("Unsupported field type. should have been caught before");
723 }
724 }
725 OGRFeature::DestroyFeature( poFeature );
726 // delete poFeature;
727 iRow++;
728 }
729 uninstallErrorHandlerAndTriggerError();
730 UNPROTECT(1);
731 return(ans);
732 }
733 // }
734 #ifdef __cplusplus
735 }
736 #endif
737
738
739 #ifdef __cplusplus
740 extern "C" {
741 #endif
742 // extern "C" {
ogrDataFrame(SEXP ogrSource,SEXP Layer,SEXP FIDs,SEXP iFields)743 SEXP ogrDataFrame(SEXP ogrSource, SEXP Layer, SEXP FIDs, SEXP iFields){
744 // query an OGR data source and return a list
745 SEXP ans;
746 SEXP nListFields, ListFields=R_NilValue, int64;
747 OGRLayer *poLayer;
748 #ifdef GDALV2
749 GDALDataset *poDS;
750 #else
751 OGRDataSource *poDS;
752 OGRSFDriver *poDriver;
753 #endif
754
755 int iField, nflds=length(iFields), j=0, k;
756 int pc=0;
757
758 // open the data source layer or error
759 installErrorHandler();
760 #ifdef GDALV2
761 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
762 #else
763 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource,0)),
764 FALSE, &poDriver);
765 #endif
766 uninstallErrorHandlerAndTriggerError();
767
768 if(poDS==NULL){
769 error("Cannot open file");
770 }
771
772 installErrorHandler();
773 poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
774 uninstallErrorHandlerAndTriggerError();
775
776 if(poLayer == NULL){
777 error("Cannot open layer");
778 }
779
780 PROTECT(int64 = getAttrib(iFields, install("int64"))); pc++;
781 PROTECT(nListFields = getAttrib(iFields, install("nListFields"))); pc++;
782
783 // reserve a list for the result
784 if (INTEGER_POINTER(nListFields)[0] == 0) {
785 PROTECT(ans=allocVector(VECSXP,length(iFields))); pc++;
786 } else {
787 nflds = INTEGER_POINTER(getAttrib(iFields, install("nflds")))[0];
788 PROTECT(ans=allocVector(VECSXP,nflds)); pc++;
789 PROTECT(ListFields = getAttrib(iFields, install("ListFields"))); pc++;
790 }
791 // now set each element of the list
792 installErrorHandler();
793 if (INTEGER_POINTER(nListFields)[0] == 0) {
794 for(iField=0;iField<length(iFields);iField++){
795 SET_VECTOR_ELT(ans,iField,ogrReadColumn(poLayer, FIDs, INTEGER(iFields)[iField], INTEGER(int64)[0]));
796 }
797 } else {
798 j=0;
799 for(iField=0;iField<length(iFields);iField++){
800 if (INTEGER_POINTER(ListFields)[iField] == 0) {
801 SET_VECTOR_ELT(ans, j,
802 ogrReadColumn(poLayer, FIDs, INTEGER(iFields)[iField], INTEGER(int64)[0]));
803 j++;
804 } else {
805 for (k=0; k < INTEGER_POINTER(ListFields)[iField]; k++) {
806 SET_VECTOR_ELT(ans, j,
807 ogrReadListColumn(poLayer, FIDs,
808 INTEGER(iFields)[iField], k, INTEGER(int64)[0]));
809 j++;
810 }
811 }
812 }
813 }
814 uninstallErrorHandlerAndTriggerError();
815 // clean up and return
816 installErrorHandler();
817 #ifdef GDALV2
818 GDALClose( poDS );
819 #else
820 OGRDataSource::DestroyDataSource( poDS );
821 #endif
822 // delete poDS;
823 uninstallErrorHandlerAndTriggerError();
824 UNPROTECT(pc);
825 return(ans);
826 }
827
828 // }
829 #ifdef __cplusplus
830 }
831 #endif
832
833
834 #ifdef __cplusplus
835 extern "C" {
836 #endif
837 // extern "C" {
838 /* SEXP OGRFeatureInfo (SEXP ogrSource, SEXP Layer){ unused function
839 SEXP ans=NULL;
840 OGRLayer *poLayer;
841 OGRDataSource *poDS;
842 OGRFeatureDefn *poDefn;
843 OGRSFDriver *poDriver;
844
845 installErrorHandler();
846 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource,0)),
847 FALSE, &poDriver);
848 uninstallErrorHandlerAndTriggerError();
849
850 if(poDS==NULL){
851 error("Cannot open file");
852 }
853
854 installErrorHandler();
855 poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
856 uninstallErrorHandlerAndTriggerError();
857
858 if(poLayer == NULL){
859 error("Cannot open layer");
860 }
861 installErrorHandler();
862 poDefn = poLayer->GetLayerDefn();
863 uninstallErrorHandlerAndTriggerError();
864 installErrorHandler();
865 for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ )
866 {
867 OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr );
868
869 Rprintf( "%s: %s (%d.%d)\n",
870 poField->GetNameRef(),
871 poField->GetFieldTypeName( poField->GetType() ),
872 poField->GetWidth(),
873 poField->GetPrecision() );
874 }
875 uninstallErrorHandlerAndTriggerError();
876
877
878 // PROTECT(ans=allocVector(INTSXP,1));
879 // INTEGER(ans)[0]=999;
880
881 installErrorHandler();
882 OGRDataSource::DestroyDataSource( poDS );
883 // delete poDS;
884 uninstallErrorHandlerAndTriggerError();
885 // UNPROTECT(1);
886 return(R_NilValue);
887 }*/
888
889
ogrCheckExists(SEXP ogrSource,SEXP Layer)890 SEXP ogrCheckExists (SEXP ogrSource, SEXP Layer) {
891 OGRLayer *poLayer;
892 #ifdef GDALV2
893 GDALDataset *poDS;
894 GDALDriver *poDriver;
895 #else
896 OGRDataSource *poDS;
897 OGRSFDriver *poDriver;
898 #endif
899 SEXP ans, drv;
900 int pc=0;
901 PROTECT(ans=NEW_LOGICAL(1)); pc++;
902
903 installErrorHandler();
904 #ifdef GDALV2
905 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
906 if (poDS != NULL) poDriver = poDS->GetDriver();
907 #else
908 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource, 0)),
909 FALSE, &poDriver);
910 #endif
911 uninstallErrorHandlerAndTriggerError();
912
913 if (poDS==NULL){
914 // installErrorHandler();
915 // OGRDataSource::DestroyDataSource( poDS );
916 // uninstallErrorHandlerAndTriggerError();
917 // delete poDS;
918 LOGICAL_POINTER(ans)[0] = FALSE;
919 UNPROTECT(pc);
920 return(ans);
921 }
922
923 installErrorHandler();
924 poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
925 uninstallErrorHandlerAndTriggerError();
926
927 if (poLayer == NULL){
928 installErrorHandler();
929 #ifdef GDALV2
930 GDALClose( poDS );
931 #else
932 OGRDataSource::DestroyDataSource( poDS );
933 #endif
934 uninstallErrorHandlerAndTriggerError();
935 // delete poDS;
936 LOGICAL_POINTER(ans)[0] = FALSE;
937 UNPROTECT(pc);
938 return(ans);
939 }
940
941 LOGICAL_POINTER(ans)[0] = TRUE;
942
943 PROTECT(drv=allocVector(STRSXP,1)); pc++;
944 installErrorHandler();
945 #ifdef GDALV2
946 SET_STRING_ELT(drv, 0, mkChar(poDriver->GetDescription()));
947 #else
948 SET_STRING_ELT(drv, 0, mkChar(poDriver->GetName()));
949 #endif
950 uninstallErrorHandlerAndTriggerError();
951 setAttrib(ans, install("driver"), drv);
952
953 installErrorHandler();
954 #ifdef GDALV2
955 GDALClose( poDS );
956 #else
957 OGRDataSource::DestroyDataSource( poDS );
958 #endif
959 uninstallErrorHandlerAndTriggerError();
960 // delete poDS;
961 UNPROTECT(pc);
962 return(ans);
963 }
964
965
RGDAL_ogrDeleteLayer(SEXP ogrSource,SEXP Layer,SEXP ogrDriver)966 SEXP RGDAL_ogrDeleteLayer (SEXP ogrSource, SEXP Layer, SEXP ogrDriver) {
967 OGRLayer *poLayer;
968 #ifdef GDALV2
969 GDALDataset *poDS;
970 GDALDriver *poDriver;
971 #else
972 OGRDataSource *poDS;
973 OGRSFDriver *poDriver;
974 #endif
975 int iLayer = -1;
976 int flag = 0;
977
978 installErrorHandler();
979 #ifdef GDALV2
980 poDriver = GetGDALDriverManager()->GetDriverByName(CHAR(STRING_ELT(ogrDriver, 0)));
981 #else
982 poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(
983 CHAR(STRING_ELT(ogrDriver, 0)) );
984 #endif
985 uninstallErrorHandlerAndTriggerError();
986 if (poDriver == NULL) {
987 error("Driver not available");
988 }
989
990 installErrorHandler();
991 #ifdef GDALV2
992 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
993 if(poDS==NULL){
994 error("Cannot open data source");
995 }
996 if (!EQUAL(CHAR(STRING_ELT(ogrDriver, 0)),
997 poDS->GetDriver()->GetDescription())) {
998 GDALClose( poDS );
999 poDS = NULL;
1000 }
1001 #else
1002 poDS = poDriver->Open(CHAR(STRING_ELT(ogrSource, 0)),
1003 TRUE);
1004 #endif
1005 uninstallErrorHandlerAndTriggerError();
1006
1007 if (poDS==NULL)
1008 error("Cannot open data source for update");
1009
1010 installErrorHandler();
1011 for(iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++) {
1012 poLayer = poDS->GetLayer(iLayer);
1013 #ifdef GDALV2
1014 if (poLayer != NULL && EQUAL(poLayer->GetName(),
1015 CHAR(STRING_ELT(Layer, 0)))) {
1016 flag = 1;
1017 break;
1018 }
1019 #else
1020 if (poLayer != NULL && EQUAL(poLayer->GetLayerDefn()->GetName(),
1021 CHAR(STRING_ELT(Layer, 0)))) {
1022 flag = 1;
1023 break;
1024 }
1025 #endif
1026 }
1027 uninstallErrorHandlerAndTriggerError();
1028 installErrorHandler();
1029 if (flag != 0) {
1030 int res = poDS->DeleteLayer(iLayer);
1031 if (res != OGRERR_NONE) {
1032 #ifdef GDALV2
1033 GDALClose( poDS );
1034 #else
1035 OGRDataSource::DestroyDataSource( poDS );
1036 #endif
1037 uninstallErrorHandlerAndTriggerError();
1038 error("ogrDeleteLayer: failed to delete layer");
1039 }
1040 } else {
1041 warning("ogrDeleteLayer: no such layer");
1042 }
1043 #ifdef GDALV2
1044 GDALClose( poDS );
1045 #else
1046 OGRDataSource::DestroyDataSource( poDS );
1047 #endif
1048 uninstallErrorHandlerAndTriggerError();
1049 return(R_NilValue);
1050 }
1051
RGDAL_ogrDeleteDataSource(SEXP ogrSource,SEXP ogrDriver)1052 SEXP RGDAL_ogrDeleteDataSource (SEXP ogrSource, SEXP ogrDriver) {
1053 #ifdef GDALV2
1054 GDALDriver *poDriver;
1055 #else
1056 OGRSFDriver *poDriver;
1057 #endif
1058
1059 installErrorHandler();
1060 #ifdef GDALV2
1061 poDriver = GetGDALDriverManager()->GetDriverByName(CHAR(STRING_ELT(ogrDriver, 0)));
1062 #else
1063 poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(
1064 CHAR(STRING_ELT(ogrDriver, 0)) );
1065 #endif
1066 uninstallErrorHandlerAndTriggerError();
1067 if (poDriver == NULL) {
1068 error("Driver not available");
1069 }
1070 installErrorHandler();
1071 #ifdef GDALV2
1072 poDriver->Delete(CHAR(STRING_ELT(ogrSource, 0)));
1073 #else
1074 if (poDriver->TestCapability(ODrCDeleteDataSource)) {
1075 if (poDriver->DeleteDataSource(CHAR(STRING_ELT(ogrSource, 0)))
1076 != OGRERR_NONE) {
1077 uninstallErrorHandlerAndTriggerError();
1078 error("Data source could not be deleted");
1079 }
1080 } else {
1081 uninstallErrorHandlerAndTriggerError();
1082 error("This driver is not capable of data source deletion");
1083 }
1084 #endif
1085 uninstallErrorHandlerAndTriggerError();
1086 return(R_NilValue);
1087 }
1088
1089
RGDAL_ogrListLayers(SEXP ogrSource)1090 SEXP RGDAL_ogrListLayers (SEXP ogrSource) {
1091 #ifdef GDALV2
1092 GDALDataset *poDS;
1093 GDALDriver *poDriver;
1094 #else
1095 OGRDataSource *poDS;
1096 OGRSFDriver *poDriver;
1097 #endif
1098 OGRLayer *poLayer;
1099 int i, nlayers;
1100 SEXP ans, debug;
1101 int pc=0;
1102
1103 installErrorHandler();
1104 #ifdef GDALV2
1105 poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
1106 if(poDS==NULL){
1107 uninstallErrorHandlerAndTriggerError();
1108 error("Cannot open data source");
1109 }
1110 poDriver = poDS->GetDriver();
1111 #else
1112 poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource, 0)),
1113 FALSE, &poDriver);
1114 #endif
1115 uninstallErrorHandlerAndTriggerError();
1116
1117 if(poDS==NULL){
1118 error("Cannot open data source");
1119 }
1120
1121 PROTECT(debug = getAttrib(ogrSource, install("debug"))); pc++;
1122 installErrorHandler();
1123 nlayers = poDS->GetLayerCount();
1124 uninstallErrorHandlerAndTriggerError();
1125 if (LOGICAL_POINTER(debug)[0] == TRUE)
1126 Rprintf("ogrListLayers: nlayers %d\n", nlayers);
1127
1128 PROTECT(ans=NEW_CHARACTER(nlayers+1)); pc++;
1129
1130 for (i=0; i<nlayers; i++) {
1131 installErrorHandler();
1132 poLayer = poDS->GetLayer(i);
1133
1134 if(poLayer == NULL){
1135 if (LOGICAL_POINTER(debug)[0] == TRUE) {
1136 SET_STRING_ELT(ans, i, mkChar(""));
1137 Rprintf("ogrListLayers: NULL layer %d\n", i);
1138 } else {
1139 uninstallErrorHandlerAndTriggerError();
1140 error("Cannot open layer");
1141 }
1142 } else {
1143 SET_STRING_ELT(ans, i, mkChar(poLayer->GetLayerDefn()->GetName()));
1144 }
1145 uninstallErrorHandlerAndTriggerError();
1146 }
1147
1148 installErrorHandler();
1149 #ifdef GDALV2
1150 SET_STRING_ELT(ans, nlayers, mkChar(poDriver->GetDescription()));
1151 #else
1152 SET_STRING_ELT(ans, nlayers, mkChar(poDriver->GetName()));
1153 #endif
1154 uninstallErrorHandlerAndTriggerError();
1155
1156 installErrorHandler();
1157 #ifdef GDALV2
1158 GDALClose( poDS );
1159 #else
1160 OGRDataSource::DestroyDataSource( poDS );
1161 #endif
1162 uninstallErrorHandlerAndTriggerError();
1163
1164 UNPROTECT(pc);
1165 return(ans);
1166
1167 }
1168
1169 //}
1170
1171
1172 #ifdef __cplusplus
1173 }
1174 #endif
1175
1176