source: trunk/zoo-project/zoo-services/ogr/base-vect-ops/service.c @ 499

Last change on this file since 499 was 499, checked in by djay, 7 years ago

Small fix in applyTwo for services taking two parameters and returning a FeatureCollection?.

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 44.7 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 * Copyright 2008-2009 GeoLabs SARL. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#include "cpl_conv.h"
26#include "ogr_api.h"
27#include "ogr_geometry.h"
28
29#include "cpl_minixml.h"
30#include "ogr_api.h"
31#include "ogrsf_frmts.h"
32
33#include "geos_c.h"
34#include "service.h"
35#include "service_internal.h"
36
37extern "C" {
38#include <libxml/tree.h>
39#include <libxml/parser.h>
40#include <libxml/xpath.h>
41#include <libxml/xpathInternals.h>
42
43#include <openssl/sha.h>
44#include <openssl/hmac.h>
45#include <openssl/evp.h>
46#include <openssl/bio.h>
47#include <openssl/buffer.h>
48
49  void printExceptionReportResponse(maps*,map*);
50  char *base64(const char *input, int length);
51
52  OGRGeometryH createGeometryFromGML(maps* conf,char* inputStr){
53    xmlInitParser();
54    xmlDocPtr doc = xmlParseMemory(inputStr,strlen(inputStr));
55    xmlChar *xmlbuff;
56    int buffersize;
57    xmlXPathContextPtr xpathCtx;
58    xmlXPathObjectPtr xpathObj;
59    const char * xpathExpr="/*/*/*/*/*[local-name()='Polygon' or local-name()='MultiPolygon']";
60    xpathCtx = xmlXPathNewContext(doc);
61    xpathObj = xmlXPathEvalExpression(BAD_CAST xpathExpr,xpathCtx);
62    if(!xpathObj->nodesetval){
63      setMapInMaps(conf,"lenv","message",_ss("Unable to parse Input Polygon"));
64      setMapInMaps(conf,"lenv","code","InvalidParameterValue");
65      return NULL;
66    }
67    int size = (xpathObj->nodesetval) ? xpathObj->nodesetval->nodeNr : 0;
68    /**
69     * Create a temporary XML document
70     */
71    xmlDocPtr ndoc = xmlNewDoc(BAD_CAST "1.0");
72    /**
73     * Only one polygon should be provided so we use it as the root node.
74     */
75    for(int k=size-1;k>=0;k--){ 
76      xmlDocSetRootElement(ndoc, xpathObj->nodesetval->nodeTab[k]);
77    }
78    xmlDocDumpFormatMemory(ndoc, &xmlbuff, &buffersize, 1);
79    char *tmp=(char*)calloc((xmlStrlen(xmlStrstr(xmlbuff,BAD_CAST "?>"))-1),sizeof(char));
80    sprintf(tmp,"%s",xmlStrstr(xmlbuff,BAD_CAST "?>")+2);
81    xmlXPathFreeObject(xpathObj);
82    xmlXPathFreeContext(xpathCtx);
83    xmlFree(xmlbuff);
84    xmlFreeDoc(doc);
85    xmlFreeDoc(ndoc);
86#ifndef WIN32
87    xmlCleanupParser();
88#endif
89#ifdef DEBUG
90    fprintf(stderr,"\nService internal print\n Loading the geometry from GML string ...");
91#endif
92    OGRGeometryH res=OGR_G_CreateFromGML(tmp);
93    free(tmp);
94    if(res==NULL){
95      setMapInMaps(conf,"lenv","message",_ss("Unable to call OGR_G_CreatFromGML"));
96      return NULL;
97    }
98    else
99      return res;
100  }
101
102#ifdef WIN32
103  __declspec(dllexport)
104#endif
105  int Simplify(maps*& conf,maps*& inputs,maps*& outputs){
106    OGRRegisterAll();
107
108    double tolerance;
109    map* tmp0=getMapFromMaps(inputs,"Tolerance","value");
110    if(tmp0==NULL){
111      tolerance=atof("2.0");
112    }
113    else
114      tolerance=atof(tmp0->value);
115
116    maps* cursor=inputs;
117    OGRGeometryH geometry;
118    OGRGeometry *res;
119    OGRLayer *poDstLayer;
120    const char *oDriver1;
121    OGRDataSource       *poODS;
122    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
123    if(!tmp){
124      setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
125      return SERVICE_FAILED;
126    }
127    char filename[1024];
128    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
129    const char *oDriver;
130    oDriver="GeoJSON";
131    sprintf(filename,"/vsimem/input_%d.json",getpid());
132    if(tmp1!=NULL){
133      if(strcmp(tmp1->value,"text/xml")==0){
134        sprintf(filename,"/vsimem/input_%d.xml",getpid());
135        oDriver="GML";
136      }
137    }
138    VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
139    VSIFCloseL(ifile);
140    OGRDataSource* ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
141    char pszDestDataSource[100];
142    if( ipoDS == NULL )
143      {
144        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
145       
146        fprintf( stderr, "FAILURE:\n"
147                 "Unable to open datasource `%s' with the following drivers.\n",
148                 filename );
149       
150        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
151          {
152            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
153          }
154        char tmp[1024];
155        sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
156        setMapInMaps(conf,"lenv","message",tmp);
157        return SERVICE_FAILED;
158      }
159    for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
160         iLayer++ )
161      {
162        OGRLayer        *poLayer = ipoDS->GetLayer(iLayer);
163       
164        if( poLayer == NULL )
165          {
166            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
167                     iLayer );
168            char tmp[1024];
169            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
170            setMapInMaps(conf,"lenv","message",tmp);
171            return SERVICE_FAILED;
172          }
173       
174        OGRFeature  *poFeature;
175       
176        OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
177        OGRSFDriver          *poDriver = NULL;
178        int                  iDriver;
179       
180        map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
181        oDriver1="GeoJSON";
182        sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
183        if(tmpMap!=NULL){
184          if(strcmp(tmpMap->value,"text/xml")==0){
185            sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
186            oDriver1="GML";
187          }
188        }
189       
190        for( iDriver = 0;
191             iDriver < poR->GetDriverCount() && poDriver == NULL;
192             iDriver++ )
193          {
194            if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
195              {
196                poDriver = poR->GetDriver(iDriver);
197              }
198          }
199       
200        if( poDriver == NULL )
201          {
202            char emessage[8192];
203            sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
204            sprintf( emessage,  "%sThe following drivers are available:\n",emessage );
205           
206            for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
207              {
208                sprintf( emessage,  "%s  -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
209              }
210           
211            setMapInMaps(conf,"lenv","message",emessage);
212            return SERVICE_FAILED;
213           
214          }
215       
216        if( !poDriver->TestCapability( ODrCCreateDataSource ) ){
217          char emessage[1024];
218          sprintf( emessage,  "%s driver does not support data source creation.\n",
219                   "json" );
220          setMapInMaps(conf,"lenv","message",emessage);
221          return SERVICE_FAILED;
222        }
223       
224        char **papszDSCO=NULL;
225        poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
226        if( poODS == NULL ){
227          char emessage[1024];     
228          sprintf( emessage,  "%s driver failed to create %s\n", 
229                   "json", pszDestDataSource );
230          setMapInMaps(conf,"lenv","message",emessage);
231          return SERVICE_FAILED;
232        }
233       
234        if( !poODS->TestCapability( ODsCCreateLayer ) )
235          {
236            char emessage[1024];
237            sprintf( emessage, 
238                     "Layer %s not found, and CreateLayer not supported by driver.", 
239                     "Result" );
240            setMapInMaps(conf,"lenv","message",emessage);
241            return SERVICE_FAILED;
242          }
243       
244        poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
245        if( poDstLayer == NULL ){
246          setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
247          return SERVICE_FAILED;
248        }
249       
250        OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
251        int iField;
252        int hasMmField=0;
253       
254        for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
255          {
256            OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
257            if (iField >= 0)
258                poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
259            else
260            {
261                fprintf( stderr, "Field '%s' not found in source layer.\n", 
262                        iField );
263                return SERVICE_FAILED;
264            }
265          }
266
267        while(TRUE){
268          OGRFeature      *poDstFeature = NULL;
269          poFeature = poLayer->GetNextFeature();
270          if( poFeature == NULL )
271            break;
272          if(poFeature->GetGeometryRef() != NULL){
273            poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
274            if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
275              {
276                char tmpMsg[1024];
277                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
278                         poFeature->GetFID(), poFDefn->GetName() );
279               
280                OGRFeature::DestroyFeature( poFeature );
281                OGRFeature::DestroyFeature( poDstFeature );
282                return SERVICE_FAILED;
283              }
284            geometry=poFeature->GetGeometryRef();
285#if GDAL_VERSION_MAJOR == 1 && GDAL_VERSION_MINOR < 11
286            GEOSGeometry* ggeometry=((OGRGeometry *) geometry)->exportToGEOS();
287            GEOSGeometry* gres=GEOSTopologyPreserveSimplify(ggeometry,tolerance);
288            if(gres!=NULL)
289              res=(OGRGeometry*)OGRGeometryFactory::createFromGEOS(gres);
290#else
291            res=((OGRGeometry *) geometry)->SimplifyPreserveTopology(tolerance);
292#endif
293            if(poDstFeature->SetGeometryDirectly(res) != OGRERR_NONE )
294              {
295                char tmpMsg[1024];
296                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
297                         poFeature->GetFID(), poFDefn->GetName() );
298               
299                OGRFeature::DestroyFeature( poFeature );
300                OGRFeature::DestroyFeature( poDstFeature );
301                return SERVICE_FAILED;
302              }
303            OGRFeature::DestroyFeature( poFeature );
304            if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
305              {         
306                OGRFeature::DestroyFeature( poDstFeature );
307                return SERVICE_FAILED;
308              }
309            OGRFeature::DestroyFeature( poDstFeature );
310#if GDAL_VERSION_MAJOR == 1 && GDAL_VERSION_MINOR < 11
311            GEOSGeom_destroy( ggeometry);
312            GEOSGeom_destroy( gres);
313#endif
314          }
315        }
316      }
317
318    delete poODS;
319    delete ipoDS;
320
321    char *res1=readVSIFile(conf,pszDestDataSource);
322    if(res1==NULL)
323      return SERVICE_FAILED;
324    setMapInMaps(outputs,"Result","value",res1);
325    free(res1);
326
327    OGRCleanupAll();
328    return SERVICE_SUCCEEDED;
329
330}
331
332  int applyOne(maps*& conf,maps*& inputs,maps*& outputs,OGRGeometry* (OGRGeometry::*myFunc)() const,const char* schema){
333    OGRRegisterAll();
334
335    maps* cursor=inputs;
336    OGRGeometryH geometry,res;
337    OGRLayer *poDstLayer;
338    const char *oDriver1;
339    OGRDataSource       *poODS;
340    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
341    if(!tmp){
342      setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
343      return SERVICE_FAILED;
344    }
345    char filename[1024];
346    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
347    const char *oDriver;
348    oDriver="GeoJSON";
349    sprintf(filename,"/vsimem/input_%d.json",getpid());
350    if(tmp1!=NULL){
351      if(strcmp(tmp1->value,"text/xml")==0){
352        sprintf(filename,"/vsimem/input_%d.xml",getpid());
353        oDriver="GML";
354      }
355    }
356    VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
357    VSIFCloseL(ifile);
358    OGRDataSource* ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
359    char pszDestDataSource[100];
360    if( ipoDS == NULL )
361      {
362        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
363       
364        fprintf( stderr, "FAILURE:\n"
365                 "Unable to open datasource `%s' with the following drivers.\n",
366                 filename );
367       
368        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
369          {
370            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
371          }
372        char tmp[1024];
373        sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
374        setMapInMaps(conf,"lenv","message",tmp);
375        return SERVICE_FAILED;
376      }
377    for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
378         iLayer++ )
379      {
380        OGRLayer        *poLayer = ipoDS->GetLayer(iLayer);
381       
382        if( poLayer == NULL )
383          {
384            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
385                     iLayer );
386            char tmp[1024];
387            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
388            setMapInMaps(conf,"lenv","message",tmp);
389            return SERVICE_FAILED;
390          }
391       
392        OGRFeature  *poFeature;
393
394        /* -------------------------------------------------------------------- */
395        /*      Try opening the output datasource as an existing, writable      */
396        /* -------------------------------------------------------------------- */
397       
398        OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
399        OGRSFDriver          *poDriver = NULL;
400        int                  iDriver;
401       
402        map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
403        oDriver1="GeoJSON";
404        sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
405        if(tmpMap!=NULL){
406          if(strcmp(tmpMap->value,"text/xml")==0){
407            sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
408            oDriver1="GML";
409          }
410        }
411       
412        for( iDriver = 0;
413             iDriver < poR->GetDriverCount() && poDriver == NULL;
414             iDriver++ )
415          {
416            if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
417              {
418                poDriver = poR->GetDriver(iDriver);
419              }
420          }
421       
422        if( poDriver == NULL )
423          {
424            char emessage[8192];
425            sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
426            sprintf( emessage,  "%sThe following drivers are available:\n",emessage );
427           
428            for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
429              {
430                sprintf( emessage,  "%s  -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
431              }
432           
433            setMapInMaps(conf,"lenv","message",emessage);
434            return SERVICE_FAILED;
435           
436          }
437       
438        if( !poDriver->TestCapability( ODrCCreateDataSource ) ){
439          char emessage[1024];
440          sprintf( emessage,  "%s driver does not support data source creation.\n",
441                   "json" );
442          setMapInMaps(conf,"lenv","message",emessage);
443          return SERVICE_FAILED;
444        }
445       
446        /* -------------------------------------------------------------------- */
447        /*      Create the output data source.                                  */
448        /* -------------------------------------------------------------------- */
449        //map* tpath=getMapFromMaps(conf,"main","tmpPath");
450        char **papszDSCO=NULL;
451        poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
452        if( poODS == NULL ){
453          char emessage[1024];     
454          sprintf( emessage,  "%s driver failed to create %s\n", 
455                   "json", pszDestDataSource );
456          setMapInMaps(conf,"lenv","message",emessage);
457          return SERVICE_FAILED;
458        }
459       
460        /* -------------------------------------------------------------------- */
461        /*      Create the layer.                                               */
462        /* -------------------------------------------------------------------- */
463        if( !poODS->TestCapability( ODsCCreateLayer ) )
464          {
465            char emessage[1024];
466            sprintf( emessage, 
467                     "Layer %s not found, and CreateLayer not supported by driver.", 
468                     "Result" );
469            setMapInMaps(conf,"lenv","message",emessage);
470            return SERVICE_FAILED;
471          }
472       
473        //CPLErrorReset();
474       
475        poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
476        if( poDstLayer == NULL ){
477          setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
478          return SERVICE_FAILED;
479        }
480       
481        OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
482        int iField;
483        int hasMmField=0;
484       
485        for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
486          {
487            OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
488            if (iField >= 0)
489                poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
490            else
491            {
492                fprintf( stderr, "Field '%s' not found in source layer.\n", 
493                        iField );
494                return SERVICE_FAILED;
495            }
496          }
497
498        while(TRUE){
499          OGRFeature      *poDstFeature = NULL;
500          poFeature = poLayer->GetNextFeature();
501          if( poFeature == NULL )
502            break;
503          if(poFeature->GetGeometryRef() != NULL){
504            poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
505            if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
506              {
507                char tmpMsg[1024];
508                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
509                         poFeature->GetFID(), poFDefn->GetName() );
510               
511                OGRFeature::DestroyFeature( poFeature );
512                OGRFeature::DestroyFeature( poDstFeature );
513                return SERVICE_FAILED;
514              }
515            if(poDstFeature->SetGeometryDirectly((poDstFeature->GetGeometryRef()->*myFunc)()) != OGRERR_NONE )
516              {
517                char tmpMsg[1024];
518                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
519                         poFeature->GetFID(), poFDefn->GetName() );
520               
521                OGRFeature::DestroyFeature( poFeature );
522                OGRFeature::DestroyFeature( poDstFeature );
523                return SERVICE_FAILED;
524              }
525            OGRFeature::DestroyFeature( poFeature );
526            if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
527              {         
528                OGRFeature::DestroyFeature( poDstFeature );
529                return SERVICE_FAILED;
530              }
531            OGRFeature::DestroyFeature( poDstFeature );
532          }
533        }
534
535      }
536
537    delete poODS;
538    delete ipoDS;
539
540    char *res1=readVSIFile(conf,pszDestDataSource);
541    if(res1==NULL)
542      return SERVICE_FAILED;
543    setMapInMaps(outputs,"Result","value",res1);
544    free(res1);
545
546    OGRCleanupAll();
547    return SERVICE_SUCCEEDED;
548  }
549
550#ifdef WIN32
551  __declspec(dllexport)
552#endif
553int Buffer(maps*& conf,maps*& inputs,maps*& outputs){
554    OGRRegisterAll();
555
556    double bufferDistance;
557    map* tmp0=getMapFromMaps(inputs,"BufferDistance","value");
558    if(tmp0==NULL){
559      bufferDistance=atof("10.0");
560    }
561    else
562      bufferDistance=atof(tmp0->value);
563
564    maps* cursor=inputs;
565    OGRGeometryH geometry,res;
566    OGRLayer *poDstLayer;
567    const char *oDriver1;
568    OGRDataSource       *poODS;
569    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
570    if(!tmp){
571      setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
572      return SERVICE_FAILED;
573    }
574    char filename[1024];
575    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
576    const char *oDriver;
577    oDriver="GeoJSON";
578    sprintf(filename,"/vsimem/input_%d.json",getpid());
579    if(tmp1!=NULL){
580      if(strcmp(tmp1->value,"text/xml")==0){
581        sprintf(filename,"/vsimem/input_%d.xml",getpid());
582        oDriver="GML";
583      }
584    }
585    VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
586    VSIFCloseL(ifile);
587    OGRDataSource* ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
588    char pszDestDataSource[100];
589    if( ipoDS == NULL )
590      {
591        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
592       
593        fprintf( stderr, "FAILURE:\n"
594                 "Unable to open datasource `%s' with the following drivers.\n",
595                 filename );
596       
597        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
598          {
599            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
600          }
601        char tmp[1024];
602        sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
603        setMapInMaps(conf,"lenv","message",tmp);
604        return SERVICE_FAILED;
605      }
606    for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
607         iLayer++ )
608      {
609        OGRLayer        *poLayer = ipoDS->GetLayer(iLayer);
610       
611        if( poLayer == NULL )
612          {
613            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
614                     iLayer );
615            char tmp[1024];
616            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
617            setMapInMaps(conf,"lenv","message",tmp);
618            return SERVICE_FAILED;
619          }
620       
621        OGRFeature  *poFeature;
622
623        /* -------------------------------------------------------------------- */
624        /*      Try opening the output datasource as an existing, writable      */
625        /* -------------------------------------------------------------------- */
626       
627        OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
628        OGRSFDriver          *poDriver = NULL;
629        int                  iDriver;
630       
631        map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
632        oDriver1="GeoJSON";
633        sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
634        if(tmpMap!=NULL){
635          if(strcmp(tmpMap->value,"text/xml")==0){
636            sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
637            oDriver1="GML";
638          }
639        }
640       
641        for( iDriver = 0;
642             iDriver < poR->GetDriverCount() && poDriver == NULL;
643             iDriver++ )
644          {
645            if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
646              {
647                poDriver = poR->GetDriver(iDriver);
648              }
649          }
650       
651        if( poDriver == NULL )
652          {
653            char emessage[8192];
654            sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
655            sprintf( emessage,  "%sThe following drivers are available:\n",emessage );
656           
657            for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
658              {
659                sprintf( emessage,  "%s  -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
660              }
661           
662            setMapInMaps(conf,"lenv","message",emessage);
663            return SERVICE_FAILED;
664           
665          }
666       
667        if( !poDriver->TestCapability( ODrCCreateDataSource ) ){
668          char emessage[1024];
669          sprintf( emessage,  "%s driver does not support data source creation.\n",
670                   "json" );
671          setMapInMaps(conf,"lenv","message",emessage);
672          return SERVICE_FAILED;
673        }
674       
675        /* -------------------------------------------------------------------- */
676        /*      Create the output data source.                                  */
677        /* -------------------------------------------------------------------- */
678        //map* tpath=getMapFromMaps(conf,"main","tmpPath");
679        char **papszDSCO=NULL;
680        poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
681        if( poODS == NULL ){
682          char emessage[1024];     
683          sprintf( emessage,  "%s driver failed to create %s\n", 
684                   "json", pszDestDataSource );
685          setMapInMaps(conf,"lenv","message",emessage);
686          return SERVICE_FAILED;
687        }
688       
689        /* -------------------------------------------------------------------- */
690        /*      Create the layer.                                               */
691        /* -------------------------------------------------------------------- */
692        if( !poODS->TestCapability( ODsCCreateLayer ) )
693          {
694            char emessage[1024];
695            sprintf( emessage, 
696                     "Layer %s not found, and CreateLayer not supported by driver.", 
697                     "Result" );
698            setMapInMaps(conf,"lenv","message",emessage);
699            return SERVICE_FAILED;
700          }
701
702        poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
703        if( poDstLayer == NULL ){
704          setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
705          return SERVICE_FAILED;
706        }
707       
708        OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
709        int iField;
710        int hasMmField=0;
711       
712        for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
713          {
714            OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
715            if (iField >= 0)
716                poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
717            else
718            {
719                fprintf( stderr, "Field '%s' not found in source layer.\n", 
720                        iField );
721                return SERVICE_FAILED;
722            }
723          }
724
725        while(TRUE){
726          OGRFeature      *poDstFeature = NULL;
727          poFeature = poLayer->GetNextFeature();
728          if( poFeature == NULL )
729            break;
730          if(poFeature->GetGeometryRef() != NULL){
731            poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
732            if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
733              {
734                char tmpMsg[1024];
735                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
736                         poFeature->GetFID(), poFDefn->GetName() );
737               
738                OGRFeature::DestroyFeature( poFeature );
739                OGRFeature::DestroyFeature( poDstFeature );
740                return SERVICE_FAILED;
741              }
742            if(poDstFeature->SetGeometryDirectly(poDstFeature->GetGeometryRef()->Buffer(bufferDistance,30)) != OGRERR_NONE )
743              {
744                char tmpMsg[1024];
745                sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
746                         poFeature->GetFID(), poFDefn->GetName() );
747               
748                OGRFeature::DestroyFeature( poFeature );
749                OGRFeature::DestroyFeature( poDstFeature );
750                return SERVICE_FAILED;
751              }
752            OGRFeature::DestroyFeature( poFeature );
753            if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
754              {         
755                OGRFeature::DestroyFeature( poDstFeature );
756                return SERVICE_FAILED;
757              }
758            OGRFeature::DestroyFeature( poDstFeature );
759          }
760        }
761
762      }
763
764    delete poODS;
765    delete ipoDS;
766
767    char *res1=readVSIFile(conf,pszDestDataSource);
768    if(res1==NULL)
769      return SERVICE_FAILED;
770    setMapInMaps(outputs,"Result","value",res1);
771    free(res1);
772
773    OGRCleanupAll();
774    return SERVICE_SUCCEEDED;
775
776}
777
778#ifdef WIN32
779  __declspec(dllexport)
780#endif
781  int Boundary(maps*& conf,maps*& inputs,maps*& outputs){
782    return applyOne(conf,inputs,outputs,&OGRGeometry::Boundary,"http://fooa/gml/3.1.0/polygon.xsd");
783  }
784
785#ifdef WIN32
786  __declspec(dllexport)
787#endif
788  int ConvexHull(maps*& conf,maps*& inputs,maps*& outputs){
789    return applyOne(conf,inputs,outputs,&OGRGeometry::ConvexHull,"http://fooa/gml/3.1.0/polygon.xsd");
790  }
791
792
793  OGRDataSource* loadEntity(maps* conf,maps* inputs,char **filename,const char **oDriver,const char *entity,int iter){
794    map* tmp=getMapFromMaps(inputs,entity,"value");
795    map* tmp1=getMapFromMaps(inputs,entity,"mimeType");
796    *oDriver="GeoJSON";
797    sprintf(*filename,"/vsimem/input_%d.json",getpid()+iter);
798    if(tmp1!=NULL){
799      if(strcmp(tmp1->value,"text/xml")==0){
800        sprintf(*filename,"/vsimem/input_%d.xml",getpid()+iter);
801        *oDriver="GML";
802      }
803    }
804    VSILFILE *ifile=VSIFileFromMemBuffer(*filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
805    VSIFCloseL(ifile);
806    return OGRSFDriverRegistrar::Open(*filename,FALSE);   
807  }
808
809  int applyOneBool(maps*& conf,maps*& inputs,maps*& outputs,OGRBoolean (OGRGeometry::*myFunc)() const){
810#ifdef DEBUG
811    fprintf(stderr,"\nService internal print\n");
812#endif
813    OGRRegisterAll();
814
815    maps* cursor=inputs;
816    OGRGeometryH geometry,res;
817    OGRLayer *poDstLayer;
818    const char *oDriver1;
819    OGRDataSource       *poODS;
820#ifdef DEBUG
821    dumpMaps(cursor);
822#endif
823    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
824    if(!tmp){
825      setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
826      return SERVICE_FAILED;
827    }
828    char filename[1024];
829    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
830    const char *oDriver;
831    oDriver="GeoJSON";
832    sprintf(filename,"/vsimem/input_%d.json",getpid());
833    if(tmp1!=NULL){
834      if(strcmp(tmp1->value,"text/xml")==0){
835        sprintf(filename,"/vsimem/input_%d.xml",getpid());
836        oDriver="GML";
837      }
838    }
839    VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
840    VSIFCloseL(ifile);
841    OGRDataSource* ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
842    char pszDestDataSource[100];
843    if( ipoDS == NULL )
844      {
845        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
846       
847        fprintf( stderr, "FAILURE:\n"
848                 "Unable to open datasource `%s' with the following drivers.\n",
849                 filename );
850       
851        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
852          {
853            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
854          }
855        char tmp[1024];
856        sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
857        setMapInMaps(conf,"lenv","message",tmp);
858        return SERVICE_FAILED;
859      }
860    for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
861         iLayer++ )
862      {
863        OGRLayer        *poLayer = ipoDS->GetLayer(iLayer);
864       
865        if( poLayer == NULL )
866          {
867            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
868                     iLayer );
869            char tmp[1024];
870            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
871            setMapInMaps(conf,"lenv","message",tmp);
872            return SERVICE_FAILED;
873          }
874       
875        OGRFeature  *poFeature;
876
877
878        while(TRUE){
879          OGRFeature      *poDstFeature = NULL;
880          poFeature = poLayer->GetNextFeature();
881          if( poFeature == NULL )
882            break;
883          if(poFeature->GetGeometryRef() != NULL){
884            if((poFeature->GetGeometryRef()->*myFunc)()==0){
885              setMapInMaps(outputs,"Result","value","false");
886              OGRFeature::DestroyFeature( poFeature );
887              delete ipoDS;
888              return SERVICE_SUCCEEDED;
889            }
890          }
891          OGRFeature::DestroyFeature( poFeature );
892        }
893
894      }
895
896    delete ipoDS;
897    setMapInMaps(outputs,"Result","value","true");
898
899    OGRCleanupAll();
900    return SERVICE_SUCCEEDED;
901  }
902
903#ifdef WIN32
904  __declspec(dllexport)
905#endif
906  int IsSimple(maps*& conf,maps*& inputs,maps*& outputs){
907    return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsSimple);
908  }
909
910#ifdef WIN32
911  __declspec(dllexport)
912#endif
913  int IsClosed(maps*& conf,maps*& inputs,maps*& outputs){
914    return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsRing);
915  }
916
917#ifdef WIN32
918  __declspec(dllexport)
919#endif
920  int IsValid(maps*& conf,maps*& inputs,maps*& outputs){
921    return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsValid);
922  }
923
924 
925  int applyTwo(maps*& conf,maps*& inputs,maps*& outputs,OGRGeometry* (OGRGeometry::*myFunc)(const OGRGeometry*) const){
926#ifdef DEBUG
927    fprintf(stderr,"\nService internal print\n");
928#endif
929    OGRRegisterAll();
930
931    maps* cursor=inputs;
932    OGRGeometryH geometry,res;
933    OGRLayer *poDstLayer;
934    //const char *oDriver1;
935    OGRDataSource       *poODS;
936#ifdef DEBUG
937    dumpMaps(cursor);
938#endif
939
940    char *filename=(char*)malloc(1024*sizeof(char));
941    const char *oDriver1;
942    OGRDataSource* ipoDS1 = loadEntity(conf,inputs,&filename,&oDriver1,"InputEntity1",1);
943
944    char *filename1=(char*)malloc(1024*sizeof(char));
945    const char *oDriver2;
946    OGRDataSource* ipoDS2 = loadEntity(conf,inputs,&filename1,&oDriver2,"InputEntity2",2);
947    const char *oDriver3;
948    char pszDestDataSource[100];
949    if( ipoDS1 == NULL || ipoDS2 == NULL )
950      {
951        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
952       
953        fprintf( stderr, "FAILURE:\n"
954                 "Unable to open datasource `%s' with the following drivers.\n",
955                 filename );
956       
957        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
958          {
959            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
960          }
961        char tmp[1024];
962        if( ipoDS1 == NULL )
963          sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
964        if( ipoDS2 == NULL )
965          sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename1);
966        setMapInMaps(conf,"lenv","message",tmp);
967        return SERVICE_FAILED;
968      }
969    for( int iLayer = 0; iLayer < ipoDS1->GetLayerCount();
970         iLayer++ )
971      {
972        OGRLayer        *poLayer1 = ipoDS1->GetLayer(iLayer);
973       
974        if( poLayer1 == NULL )
975          {
976            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
977                     iLayer );
978            char tmp[1024];
979            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
980            setMapInMaps(conf,"lenv","message",tmp);
981            return SERVICE_FAILED;
982          }
983
984        for( int iLayer1 = 0; iLayer1 < ipoDS2->GetLayerCount();
985             iLayer1++ )
986          {
987            OGRLayer        *poLayer2 = ipoDS2->GetLayer(iLayer1);
988           
989            if( poLayer1 == NULL )
990              {
991                fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
992                         iLayer1 );
993                char tmp[1024];
994                sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer1);
995                setMapInMaps(conf,"lenv","message",tmp);
996                return SERVICE_FAILED;
997              }
998       
999            OGRFeature  *poFeature1,*poFeature2;
1000
1001            /* -------------------------------------------------------------------- */
1002            /*      Try opening the output datasource as an existing, writable      */
1003            /* -------------------------------------------------------------------- */
1004           
1005            OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
1006            OGRSFDriver          *poDriver = NULL;
1007            int                  iDriver;
1008           
1009            map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
1010            oDriver3="GeoJSON";
1011            sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
1012            if(tmpMap!=NULL){
1013              if(strcmp(tmpMap->value,"text/xml")==0){
1014                sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
1015                oDriver3="GML";
1016              }
1017            }
1018           
1019            for( iDriver = 0;
1020                 iDriver < poR->GetDriverCount() && poDriver == NULL;
1021                 iDriver++ )
1022              {
1023#ifdef DEBUG
1024                fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetName());
1025#endif
1026                if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver3) )
1027                  {
1028                    poDriver = poR->GetDriver(iDriver);
1029                  }
1030              }
1031           
1032            if( poDriver == NULL )
1033              {
1034                char emessage[8192];
1035                sprintf( emessage, "Unable to find driver `%s'.\n", oDriver1 );
1036                sprintf( emessage,  "%sThe following drivers are available:\n",emessage );
1037               
1038                for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
1039                  {
1040                    sprintf( emessage,  "%s  -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
1041                  }
1042               
1043                setMapInMaps(conf,"lenv","message",emessage);
1044                return SERVICE_FAILED;
1045               
1046              }
1047           
1048            if( !poDriver->TestCapability( ODrCCreateDataSource ) ){
1049              char emessage[1024];
1050              sprintf( emessage,  "%s driver does not support data source creation.\n",
1051                       "json" );
1052              setMapInMaps(conf,"lenv","message",emessage);
1053              return SERVICE_FAILED;
1054            }
1055           
1056            /* -------------------------------------------------------------------- */
1057            /*      Create the output data source.                                  */
1058            /* -------------------------------------------------------------------- */
1059            //map* tpath=getMapFromMaps(conf,"main","tmpPath");
1060            char **papszDSCO=NULL;
1061            poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
1062            if( poODS == NULL ){
1063              char emessage[1024];     
1064              sprintf( emessage,  "%s driver failed to create %s\n", 
1065                       "json", pszDestDataSource );
1066              setMapInMaps(conf,"lenv","message",emessage);
1067              return SERVICE_FAILED;
1068            }
1069           
1070            /* -------------------------------------------------------------------- */
1071            /*      Create the layer.                                               */
1072            /* -------------------------------------------------------------------- */
1073            if( !poODS->TestCapability( ODsCCreateLayer ) )
1074              {
1075                char emessage[1024];
1076                sprintf( emessage, 
1077                         "Layer %s not found, and CreateLayer not supported by driver.", 
1078                         "Result" );
1079                setMapInMaps(conf,"lenv","message",emessage);
1080                return SERVICE_FAILED;
1081              }
1082           
1083            //CPLErrorReset();
1084           
1085            poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
1086            if( poDstLayer == NULL ){
1087              setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
1088              return SERVICE_FAILED;
1089            }
1090           
1091            OGRFeatureDefn *poFDefn = poLayer2->GetLayerDefn();
1092            int iField;
1093            int hasMmField=0;
1094           
1095            for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
1096              {
1097                OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
1098                if (iField >= 0)
1099                  poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
1100                else
1101                  {
1102                    fprintf( stderr, "Field '%s' not found in source layer.\n", 
1103                             iField );
1104                    return SERVICE_FAILED;
1105                  }
1106              }
1107           
1108            while(TRUE){
1109              OGRFeature      *poDstFeature = NULL;
1110              poFeature1 = poLayer1->GetNextFeature();
1111              if( poFeature1 == NULL )
1112                break;
1113              while(TRUE){
1114                poFeature2 = poLayer2->GetNextFeature();
1115                if( poFeature2 == NULL )
1116                  break;
1117
1118                if(poFeature1->GetGeometryRef() != NULL && poFeature2->GetGeometryRef() != NULL){
1119                  poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
1120                  if( poDstFeature->SetFrom( poFeature2, TRUE ) != OGRERR_NONE )
1121                    {
1122                      char tmpMsg[1024];
1123                      sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
1124                               poFeature2->GetFID(), poFDefn->GetName() );
1125                     
1126                      OGRFeature::DestroyFeature( poFeature1 );
1127                      OGRFeature::DestroyFeature( poFeature2 );
1128                      OGRFeature::DestroyFeature( poDstFeature );
1129                      return SERVICE_FAILED;
1130                    }
1131                  if(poDstFeature->SetGeometryDirectly((poFeature1->GetGeometryRef()->*myFunc)(poFeature2->GetGeometryRef())) != OGRERR_NONE )
1132                    {
1133                      char tmpMsg[1024];
1134                      sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
1135                               poFeature2->GetFID(), poFDefn->GetName() );
1136                     
1137                      OGRFeature::DestroyFeature( poFeature1 );
1138                      OGRFeature::DestroyFeature( poFeature2 );
1139                      OGRFeature::DestroyFeature( poDstFeature );
1140                      return SERVICE_FAILED;
1141                    }
1142                  OGRFeature::DestroyFeature( poFeature2 );
1143                  if(!poDstFeature->GetGeometryRef()->IsEmpty())
1144                    if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
1145                      {         
1146                        OGRFeature::DestroyFeature( poDstFeature );
1147                        return SERVICE_FAILED;
1148                      }
1149                  OGRFeature::DestroyFeature( poDstFeature );
1150                }
1151              }
1152            }
1153            OGRFeature::DestroyFeature( poFeature1 );
1154          }
1155      }
1156
1157    delete poODS;
1158    delete ipoDS1;
1159    delete ipoDS2;
1160    free(filename);
1161    free(filename1);
1162
1163    char *res1=readVSIFile(conf,pszDestDataSource);
1164    if(res1==NULL)
1165      return SERVICE_FAILED;
1166    setMapInMaps(outputs,"Result","value",res1);
1167    free(res1);
1168    OGRCleanupAll();
1169    return SERVICE_SUCCEEDED;
1170  }
1171 
1172#ifdef WIN32
1173  __declspec(dllexport)
1174#endif
1175  int Difference(maps*& conf,maps*& inputs,maps*& outputs){
1176    return applyTwo(conf,inputs,outputs,&OGRGeometry::Difference);
1177  }
1178
1179#ifdef WIN32
1180  __declspec(dllexport)
1181#endif
1182  int SymDifference(maps*& conf,maps*& inputs,maps*& outputs){
1183    return applyTwo(conf,inputs,outputs,&OGRGeometry::SymDifference);
1184  }
1185
1186#ifdef WIN32
1187  __declspec(dllexport)
1188#endif
1189  int Intersection(maps*& conf,maps*& inputs,maps*& outputs){
1190    return applyTwo(conf,inputs,outputs,&OGRGeometry::Intersection);
1191  }
1192
1193#ifdef WIN32
1194  __declspec(dllexport)
1195#endif
1196  int Union(maps*& conf,maps*& inputs,maps*& outputs){
1197    return applyTwo(conf,inputs,outputs,&OGRGeometry::Union);
1198  }
1199
1200  int applyTwoBool(maps*& conf,maps*& inputs,maps*& outputs,OGRBoolean (OGRGeometry::*myFunc)(const OGRGeometry*) const){
1201    OGRRegisterAll();
1202
1203    maps* cursor=inputs;
1204    OGRGeometryH geometry,res;
1205    OGRLayer *poDstLayer;
1206    OGRDataSource       *poODS;
1207
1208    char *filename=(char*)malloc(1024*sizeof(char));
1209    const char *oDriver1;
1210    OGRDataSource* ipoDS1 = loadEntity(conf,inputs,&filename,&oDriver1,"InputEntity1",1);
1211
1212    char *filename1=(char*)malloc(1024*sizeof(char));
1213    const char *oDriver2;
1214    OGRDataSource* ipoDS2 = loadEntity(conf,inputs,&filename1,&oDriver2,"InputEntity2",2);
1215    const char *oDriver3;
1216    char pszDestDataSource[100];
1217    if( ipoDS1 == NULL || ipoDS2 == NULL )
1218      {
1219        OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();
1220       
1221        fprintf( stderr, "FAILURE:\n"
1222                 "Unable to open datasource `%s' with the following drivers.\n",
1223                 filename );
1224       
1225        for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
1226          {
1227            fprintf( stderr, "  -> %s\n", poR->GetDriver(iDriver)->GetName() );
1228          }
1229        char tmp[1024];
1230        if( ipoDS1 == NULL )
1231          sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
1232        if( ipoDS2 == NULL )
1233          sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename1);
1234        setMapInMaps(conf,"lenv","message",tmp);
1235        return SERVICE_FAILED;
1236      }
1237    for( int iLayer = 0; iLayer < ipoDS1->GetLayerCount();
1238         iLayer++ )
1239      {
1240        OGRLayer        *poLayer1 = ipoDS1->GetLayer(iLayer);
1241       
1242        if( poLayer1 == NULL )
1243          {
1244            fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
1245                     iLayer );
1246            char tmp[1024];
1247            sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
1248            setMapInMaps(conf,"lenv","message",tmp);
1249            return SERVICE_FAILED;
1250          }
1251
1252        for( int iLayer1 = 0; iLayer1 < ipoDS2->GetLayerCount();
1253             iLayer1++ )
1254          {
1255            OGRLayer        *poLayer2 = ipoDS2->GetLayer(iLayer1);
1256           
1257            if( poLayer1 == NULL )
1258              {
1259                fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
1260                         iLayer1 );
1261                char tmp[1024];
1262                sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer1);
1263                setMapInMaps(conf,"lenv","message",tmp);
1264                return SERVICE_FAILED;
1265              }
1266       
1267            OGRFeature  *poFeature1,*poFeature2;
1268
1269
1270            while(TRUE){
1271              OGRFeature      *poDstFeature = NULL;
1272              poFeature1 = poLayer1->GetNextFeature();
1273              if( poFeature1 == NULL )
1274                break;
1275              while(TRUE){
1276                poFeature2 = poLayer2->GetNextFeature();
1277                if( poFeature2 == NULL )
1278                  break;
1279                if(poFeature1->GetGeometryRef() != NULL && poFeature2->GetGeometryRef() != NULL){
1280                  if((poFeature1->GetGeometryRef()->*myFunc)(poFeature2->GetGeometryRef())==0){
1281                    setMapInMaps(outputs,"Result","value","false");
1282                    OGRFeature::DestroyFeature( poFeature1 );
1283                    OGRFeature::DestroyFeature( poFeature2 );
1284                    delete ipoDS1;
1285                    delete ipoDS2;
1286                    free(filename);
1287                    free(filename1);
1288                    return SERVICE_SUCCEEDED;
1289                  }
1290                }
1291                OGRFeature::DestroyFeature( poFeature2 );
1292              }
1293              OGRFeature::DestroyFeature( poFeature1 );
1294            }
1295          }
1296      }
1297
1298    delete ipoDS1;
1299    delete ipoDS2;
1300    free(filename);
1301    free(filename1);
1302
1303    setMapInMaps(outputs,"Result","value","true");
1304
1305    OGRCleanupAll();
1306    return SERVICE_SUCCEEDED;
1307  }
1308
1309
1310#ifdef WIN32
1311  __declspec(dllexport)
1312#endif
1313  int Equals(maps*& conf,maps*& inputs,maps*& outputs){
1314    return applyTwoBool(conf,inputs,outputs,(OGRBoolean (OGRGeometry::*)(const OGRGeometry *) const)&OGRGeometry::Equals);
1315  }
1316
1317#ifdef WIN32
1318  __declspec(dllexport)
1319#endif
1320  int Disjoint(maps*& conf,maps*& inputs,maps*& outputs){
1321    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Disjoint);
1322  }
1323
1324#ifdef WIN32
1325  __declspec(dllexport)
1326#endif
1327  int Touches(maps*& conf,maps*& inputs,maps*& outputs){
1328    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Touches);
1329  }
1330
1331#ifdef WIN32
1332  __declspec(dllexport)
1333#endif
1334  int Crosses(maps*& conf,maps*& inputs,maps*& outputs){
1335    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Crosses);
1336  }
1337
1338#ifdef WIN32
1339  __declspec(dllexport)
1340#endif
1341  int Within(maps*& conf,maps*& inputs,maps*& outputs){
1342    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Within);
1343  }
1344
1345#ifdef WIN32
1346  __declspec(dllexport)
1347#endif
1348  int Contains(maps*& conf,maps*& inputs,maps*& outputs){
1349    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Contains);
1350  }
1351
1352#ifdef WIN32
1353  __declspec(dllexport)
1354#endif
1355  int Overlaps(maps*& conf,maps*& inputs,maps*& outputs){
1356    return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Overlaps);
1357  }
1358
1359#ifdef WIN32
1360  __declspec(dllexport)
1361#endif
1362  int Intersects(maps*& conf,maps*& inputs,maps*& outputs){
1363    return applyTwoBool(conf,inputs,outputs,(OGRBoolean (OGRGeometry::*)(const OGRGeometry *) const)&OGRGeometry::Intersects);
1364  }
1365
1366#ifdef WIN32
1367  __declspec(dllexport)
1368#endif
1369  int Distance(maps*& conf,maps*& inputs,maps*& outputs){
1370#ifdef DEBUG
1371    fprintf(stderr,"\nService internal print1\n");
1372#endif
1373    fflush(stderr);
1374    maps* cursor=inputs;
1375    OGRGeometryH geometry1,geometry2;
1376    double res;
1377    {
1378      map* tmp=getMapFromMaps(inputs,"InputEntity1","value");
1379      map* tmp1=getMapFromMaps(inputs,"InputEntity1","mimeType");
1380#ifdef DEBUG
1381      fprintf(stderr,"MY MAP\n");
1382      dumpMap(tmp1);
1383      dumpMaps(inputs);
1384      fprintf(stderr,"MY MAP\n");
1385#endif
1386      if(tmp1!=NULL){
1387        if(strncmp(tmp1->value,"application/json",16)==0)
1388          geometry1=OGR_G_CreateGeometryFromJson(tmp->value);
1389        else
1390          geometry1=createGeometryFromGML(conf,tmp->value);
1391      }
1392      else
1393        geometry1=createGeometryFromGML(conf,tmp->value);
1394    }
1395    if(geometry1==NULL){
1396      setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity1."));
1397      fprintf(stderr,"SERVICE FAILED !\n");
1398      return SERVICE_FAILED;
1399    }
1400    {
1401      map* tmp=getMapFromMaps(inputs,"InputEntity2","value");
1402      map* tmp1=getMapFromMaps(inputs,"InputEntity2","mimeType");
1403#ifdef DEBUG
1404      fprintf(stderr,"MY MAP\n");
1405      dumpMap(tmp1);
1406      dumpMaps(inputs);
1407      fprintf(stderr,"MY MAP\n");
1408#endif
1409      if(tmp1!=NULL){
1410        if(strncmp(tmp1->value,"application/json",16)==0)
1411          geometry2=OGR_G_CreateGeometryFromJson(tmp->value);
1412        else
1413          geometry2=createGeometryFromGML(conf,tmp->value);
1414      }
1415      else
1416        geometry2=createGeometryFromGML(conf,tmp->value);
1417    }
1418    if(geometry2==NULL){
1419      setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity2."));
1420      fprintf(stderr,"SERVICE FAILED !\n");
1421      return SERVICE_FAILED;
1422    }
1423    res=OGR_G_Distance(geometry1,geometry2);   
1424    char tmpres[100];
1425    sprintf(tmpres,"%f",res);
1426    setMapInMaps(outputs,"Distance","value",tmpres);
1427    setMapInMaps(outputs,"Distance","dataType","float");
1428#ifdef DEBUG
1429    dumpMaps(outputs);
1430    fprintf(stderr,"\nService internal print\n===\n");
1431#endif
1432    return SERVICE_SUCCEEDED;
1433  }
1434
1435#ifdef WIN32
1436  __declspec(dllexport)
1437#endif
1438  int GetArea(maps*& conf,maps*& inputs,maps*& outputs){
1439    fprintf(stderr,"GETAREA \n");
1440    double res;
1441    /**
1442     * Extract Geometry from the InputPolygon value
1443     */
1444    OGRGeometryH geometry;
1445    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
1446    if(tmp==NULL){
1447      setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
1448      return SERVICE_FAILED;
1449    }
1450    fprintf(stderr,"geometry creation %s \n",tmp->value);
1451    geometry=createGeometryFromGML(conf,tmp->value);
1452    if(geometry==NULL){
1453      setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
1454      return SERVICE_FAILED;
1455    }
1456    fprintf(stderr,"geometry created %s \n",tmp->value);
1457    res=OGR_G_Area(geometry);
1458    fprintf(stderr,"area %d \n",res);
1459    /**
1460     * Filling the outputs
1461     */
1462    char tmp1[100];
1463    sprintf(tmp1,"%f",res);
1464    setMapInMaps(outputs,"Area","value",tmp1);
1465    setMapInMaps(outputs,"Area","dataType","float");
1466#ifdef DEBUG
1467    dumpMaps(outputs);
1468#endif
1469    return SERVICE_SUCCEEDED;
1470  }
1471
1472}
Note: See TracBrowser for help on using the repository browser.

Search

ZOO Sponsors

http://www.zoo-project.org/trac/chrome/site/img/geolabs-logo.pnghttp://www.zoo-project.org/trac/chrome/site/img/neogeo-logo.png http://www.zoo-project.org/trac/chrome/site/img/apptech-logo.png http://www.zoo-project.org/trac/chrome/site/img/3liz-logo.png http://www.zoo-project.org/trac/chrome/site/img/gateway-logo.png

Become a sponsor !

Knowledge partners

http://www.zoo-project.org/trac/chrome/site/img/ocu-logo.png http://www.zoo-project.org/trac/chrome/site/img/gucas-logo.png http://www.zoo-project.org/trac/chrome/site/img/polimi-logo.png http://www.zoo-project.org/trac/chrome/site/img/fem-logo.png http://www.zoo-project.org/trac/chrome/site/img/supsi-logo.png http://www.zoo-project.org/trac/chrome/site/img/cumtb-logo.png

Become a knowledge partner

Related links

http://zoo-project.org/img/ogclogo.png http://zoo-project.org/img/osgeologo.png