service.c @ 894

Last change on this file since 894 was 769, checked in by djay, 8 years ago
Fix typo.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 57.3 KB

Rev	Line
[1]	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
[9]	25	#include "cpl_conv.h"
[1]	26	#include "ogr_api.h"
[9]	27	#include "ogr_geometry.h"
[766]	28	#if GDAL_VERSION_MAJOR >= 2
	29	#include <gdal_priv.h>
	30	#endif
[491]	31
	32	#include "cpl_minixml.h"
	33	#include "ogr_api.h"
	34	#include "ogrsf_frmts.h"
	35
[9]	36	#include "geos_c.h"
[1]	37	#include "service.h"
[36]	38	#include "service_internal.h"
[1]	39
	40	extern "C" {
	41	#include <libxml/tree.h>
	42	#include <libxml/parser.h>
	43	#include <libxml/xpath.h>
	44	#include <libxml/xpathInternals.h>
	45
[766]	46	/*#include <openssl/sha.h>
[1]	47	#include <openssl/hmac.h>
	48	#include <openssl/evp.h>
	49	#include <openssl/bio.h>
	50	#include <openssl/buffer.h>
[766]	51	*/
[1]	52
	53	void printExceptionReportResponse(maps,map);
[216]	54	char base64(const char input, int length);
[1]	55
	56	OGRGeometryH createGeometryFromGML(maps* conf,char* inputStr){
	57	xmlInitParser();
	58	xmlDocPtr doc = xmlParseMemory(inputStr,strlen(inputStr));
	59	xmlChar *xmlbuff;
	60	int buffersize;
	61	xmlXPathContextPtr xpathCtx;
	62	xmlXPathObjectPtr xpathObj;
[491]	63	const char * xpathExpr="/////*[local-name()='Polygon' or local-name()='MultiPolygon']";
[1]	64	xpathCtx = xmlXPathNewContext(doc);
	65	xpathObj = xmlXPathEvalExpression(BAD_CAST xpathExpr,xpathCtx);
	66	if(!xpathObj->nodesetval){
[216]	67	setMapInMaps(conf,"lenv","message",_ss("Unable to parse Input Polygon"));
	68	setMapInMaps(conf,"lenv","code","InvalidParameterValue");
	69	return NULL;
[1]	70	}
	71	int size = (xpathObj->nodesetval) ? xpathObj->nodesetval->nodeNr : 0;
	72	/**
	73	* Create a temporary XML document
	74	*/
	75	xmlDocPtr ndoc = xmlNewDoc(BAD_CAST "1.0");
	76	/**
	77	* Only one polygon should be provided so we use it as the root node.
	78	*/
	79	for(int k=size-1;k>=0;k--){
	80	xmlDocSetRootElement(ndoc, xpathObj->nodesetval->nodeTab[k]);
	81	}
	82	xmlDocDumpFormatMemory(ndoc, &xmlbuff, &buffersize, 1);
[9]	83	char tmp=(char)calloc((xmlStrlen(xmlStrstr(xmlbuff,BAD_CAST "?>"))-1),sizeof(char));
	84	sprintf(tmp,"%s",xmlStrstr(xmlbuff,BAD_CAST "?>")+2);
[1]	85	xmlXPathFreeObject(xpathObj);
[9]	86	xmlXPathFreeContext(xpathCtx);
[1]	87	xmlFree(xmlbuff);
	88	xmlFreeDoc(doc);
[9]	89	xmlFreeDoc(ndoc);
[216]	90	#ifndef WIN32
[1]	91	xmlCleanupParser();
[216]	92	#endif
[1]	93	#ifdef DEBUG
	94	fprintf(stderr,"\nService internal print\n Loading the geometry from GML string ...");
	95	#endif
	96	OGRGeometryH res=OGR_G_CreateFromGML(tmp);
[9]	97	free(tmp);
[1]	98	if(res==NULL){
[36]	99	setMapInMaps(conf,"lenv","message",_ss("Unable to call OGR_G_CreatFromGML"));
[26]	100	return NULL;
[1]	101	}
	102	else
[26]	103	return res;
[1]	104	}
	105
[216]	106	#ifdef WIN32
	107	__declspec(dllexport)
	108	#endif
[9]	109	int Simplify(maps& conf,maps& inputs,maps*& outputs){
[497]	110	OGRRegisterAll();
	111
[9]	112	double tolerance;
[497]	113	map* tmp0=getMapFromMaps(inputs,"Tolerance","value");
[9]	114	if(tmp0==NULL){
	115	tolerance=atof("2.0");
[1]	116	}
[9]	117	else
	118	tolerance=atof(tmp0->value);
[497]	119
	120	maps* cursor=inputs;
	121	OGRGeometryH geometry;
	122	OGRGeometry *res;
	123	OGRLayer *poDstLayer;
	124	const char *oDriver1;
[766]	125	#if GDAL_VERSION_MAJOR >= 2
	126	GDALDataset *poODS;
	127	#else
	128	OGRDataSource *poODS;
	129	#endif
[1]	130	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
[26]	131	if(!tmp){
[36]	132	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[1]	133	return SERVICE_FAILED;
[26]	134	}
[497]	135	char filename[1024];
[26]	136	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
[497]	137	const char *oDriver;
	138	oDriver="GeoJSON";
	139	sprintf(filename,"/vsimem/input_%d.json",getpid());
[1]	140	if(tmp1!=NULL){
[497]	141	if(strcmp(tmp1->value,"text/xml")==0){
	142	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	143	oDriver="GML";
	144	}
[9]	145	}
[497]	146	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte)tmp->value,strlen(tmp->value),FALSE);
	147	VSIFCloseL(ifile);
[766]	148
	149	#if GDAL_VERSION_MAJOR >= 2
	150	GDALDataset *ipoDS =
	151	(GDALDataset*) GDALOpenEx( filename,
	152	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	153	NULL, NULL, NULL );
	154	GDALDriverManager* poR=GetGDALDriverManager();
	155	GDALDriver *poDriver = NULL;
	156	#else
	157	OGRDataSource* ipoDS =
	158	OGRSFDriverRegistrar::Open(filename,FALSE);
	159	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	160	OGRSFDriver *poDriver = NULL;
	161	#endif
[497]	162	char pszDestDataSource[100];
	163	if( ipoDS == NULL )
	164	{
	165	fprintf( stderr, "FAILURE:\n"
	166	"Unable to open datasource `%s' with the following drivers.\n",
	167	filename );
	168
	169	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	170	{
[766]	171	#if GDAL_VERSION_MAJOR >= 2
	172	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	173	#else
[497]	174	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
[766]	175	#endif
[497]	176	}
	177	char tmp[1024];
	178	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	179	setMapInMaps(conf,"lenv","message",tmp);
	180	return SERVICE_FAILED;
	181	}
	182	for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
	183	iLayer++ )
	184	{
	185	OGRLayer *poLayer = ipoDS->GetLayer(iLayer);
	186
	187	if( poLayer == NULL )
	188	{
	189	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	190	iLayer );
	191	char tmp[1024];
	192	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	193	setMapInMaps(conf,"lenv","message",tmp);
	194	return SERVICE_FAILED;
	195	}
	196
	197	OGRFeature *poFeature;
[766]	198
[497]	199	int iDriver;
	200
	201	map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
	202	oDriver1="GeoJSON";
	203	sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
	204	if(tmpMap!=NULL){
	205	if(strcmp(tmpMap->value,"text/xml")==0){
	206	sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
	207	oDriver1="GML";
	208	}
	209	}
	210
	211	for( iDriver = 0;
	212	iDriver < poR->GetDriverCount() && poDriver == NULL;
	213	iDriver++ )
	214	{
[766]	215	#if GDAL_VERSION_MAJOR >=2
	216	if( EQUAL(poR->GetDriver(iDriver)->GetDescription(),oDriver1) )
	217	#else
[497]	218	if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
[766]	219	#endif
[497]	220	{
	221	poDriver = poR->GetDriver(iDriver);
	222	}
	223	}
	224
	225	if( poDriver == NULL )
	226	{
	227	char emessage[8192];
	228	sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
	229	sprintf( emessage, "%sThe following drivers are available:\n",emessage );
	230
	231	for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	232	{
[766]	233	#if GDAL_VERSION_MAJOR >=2
	234	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	235	#else
[497]	236	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
[766]	237	#endif
[497]	238	}
	239
	240	setMapInMaps(conf,"lenv","message",emessage);
	241	return SERVICE_FAILED;
	242
	243	}
	244
[766]	245	#if GDAL_VERSION_MAJOR >=2
	246	if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
	247	#else
	248	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	249	#endif
	250	{
	251	char emessage[1024];
	252	sprintf( emessage, "%s driver does not support data source creation.\n",
	253	"json" );
	254	setMapInMaps(conf,"lenv","message",emessage);
	255	return SERVICE_FAILED;
	256	}
[497]	257
	258	char **papszDSCO=NULL;
[766]	259	#if GDAL_VERSION_MAJOR >=2
	260	poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
	261	#else
[497]	262	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
[766]	263	#endif
[497]	264	if( poODS == NULL ){
	265	char emessage[1024];
	266	sprintf( emessage, "%s driver failed to create %s\n",
	267	"json", pszDestDataSource );
	268	setMapInMaps(conf,"lenv","message",emessage);
	269	return SERVICE_FAILED;
	270	}
	271
	272	if( !poODS->TestCapability( ODsCCreateLayer ) )
	273	{
	274	char emessage[1024];
	275	sprintf( emessage,
	276	"Layer %s not found, and CreateLayer not supported by driver.",
	277	"Result" );
	278	setMapInMaps(conf,"lenv","message",emessage);
	279	return SERVICE_FAILED;
	280	}
	281
	282	poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
	283	if( poDstLayer == NULL ){
	284	setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
	285	return SERVICE_FAILED;
	286	}
	287
	288	OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
	289	int iField;
	290	int hasMmField=0;
	291
	292	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
	293	{
	294	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	295	if (iField >= 0)
	296	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
	297	else
	298	{
	299	fprintf( stderr, "Field '%s' not found in source layer.\n",
	300	iField );
	301	return SERVICE_FAILED;
	302	}
	303	}
	304
	305	while(TRUE){
	306	OGRFeature *poDstFeature = NULL;
	307	poFeature = poLayer->GetNextFeature();
	308	if( poFeature == NULL )
	309	break;
	310	if(poFeature->GetGeometryRef() != NULL){
	311	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	312	if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
	313	{
	314	char tmpMsg[1024];
	315	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	316	poFeature->GetFID(), poFDefn->GetName() );
	317
	318	OGRFeature::DestroyFeature( poFeature );
	319	OGRFeature::DestroyFeature( poDstFeature );
	320	return SERVICE_FAILED;
	321	}
	322	geometry=poFeature->GetGeometryRef();
	323	#if GDAL_VERSION_MAJOR == 1 && GDAL_VERSION_MINOR < 11
	324	GEOSGeometry* ggeometry=((OGRGeometry *) geometry)->exportToGEOS();
	325	GEOSGeometry* gres=GEOSTopologyPreserveSimplify(ggeometry,tolerance);
	326	if(gres!=NULL)
	327	res=(OGRGeometry*)OGRGeometryFactory::createFromGEOS(gres);
	328	#else
	329	res=((OGRGeometry *) geometry)->SimplifyPreserveTopology(tolerance);
[216]	330	#endif
[497]	331	if(poDstFeature->SetGeometryDirectly(res) != OGRERR_NONE )
	332	{
	333	char tmpMsg[1024];
	334	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	335	poFeature->GetFID(), poFDefn->GetName() );
	336
	337	OGRFeature::DestroyFeature( poFeature );
	338	OGRFeature::DestroyFeature( poDstFeature );
	339	return SERVICE_FAILED;
	340	}
	341	OGRFeature::DestroyFeature( poFeature );
	342	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
	343	{
	344	OGRFeature::DestroyFeature( poDstFeature );
	345	return SERVICE_FAILED;
	346	}
	347	OGRFeature::DestroyFeature( poDstFeature );
	348	#if GDAL_VERSION_MAJOR == 1 && GDAL_VERSION_MINOR < 11
	349	GEOSGeom_destroy( ggeometry);
	350	GEOSGeom_destroy( gres);
[216]	351	#endif
[497]	352	}
	353	}
[1]	354	}
[497]	355
	356	delete poODS;
	357	delete ipoDS;
	358
	359	char *res1=readVSIFile(conf,pszDestDataSource);
	360	if(res1==NULL)
	361	return SERVICE_FAILED;
	362	setMapInMaps(outputs,"Result","value",res1);
	363	free(res1);
	364
	365	OGRCleanupAll();
[766]	366	dumpMaps(outputs);
[1]	367	return SERVICE_SUCCEEDED;
	368
[497]	369	}
[1]	370
[766]	371	int applyOne(maps& conf,maps& inputs,maps& outputs,OGRGeometry (OGRGeometry::myFunc)() const,const char schema){
[491]	372	OGRRegisterAll();
	373
[1]	374	maps* cursor=inputs;
	375	OGRGeometryH geometry,res;
[491]	376	OGRLayer *poDstLayer;
	377	const char *oDriver1;
[766]	378	#if GDAL_VERSION_MAJOR >= 2
	379	GDALDataset *poODS;
	380	#else
	381	OGRDataSource *poODS;
	382	#endif
[9]	383	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
[35]	384	if(!tmp){
[36]	385	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[9]	386	return SERVICE_FAILED;
[35]	387	}
[491]	388	char filename[1024];
[9]	389	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
[491]	390	const char *oDriver;
	391	oDriver="GeoJSON";
	392	sprintf(filename,"/vsimem/input_%d.json",getpid());
[9]	393	if(tmp1!=NULL){
[491]	394	if(strcmp(tmp1->value,"text/xml")==0){
	395	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	396	oDriver="GML";
	397	}
[1]	398	}
[491]	399	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte)tmp->value,strlen(tmp->value),FALSE);
	400	VSIFCloseL(ifile);
[766]	401	#if GDAL_VERSION_MAJOR >= 2
	402	GDALDataset *ipoDS =
	403	(GDALDataset*) GDALOpenEx( filename,
	404	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	405	NULL, NULL, NULL );
	406	GDALDriverManager* poR=GetGDALDriverManager();
	407	GDALDriver *poDriver = NULL;
	408	#else
	409	OGRDataSource* ipoDS =
	410	OGRSFDriverRegistrar::Open(filename,FALSE);
	411	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	412	OGRSFDriver *poDriver = NULL;
	413	#endif
[491]	414	char pszDestDataSource[100];
	415	if( ipoDS == NULL )
	416	{
	417	fprintf( stderr, "FAILURE:\n"
	418	"Unable to open datasource `%s' with the following drivers.\n",
	419	filename );
[766]	420	char emessage[1024];
[491]	421	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	422	{
[766]	423	#if GDAL_VERSION_MAJOR >=2
	424	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	425	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	426	#else
	427	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
	428	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
	429	#endif
[491]	430	}
	431	char tmp[1024];
[766]	432	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.\n%s",filename,emessage);
[491]	433	setMapInMaps(conf,"lenv","message",tmp);
	434	return SERVICE_FAILED;
[1]	435	}
[766]	436
[491]	437	for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
	438	iLayer++ )
	439	{
	440	OGRLayer *poLayer = ipoDS->GetLayer(iLayer);
	441
	442	if( poLayer == NULL )
	443	{
	444	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	445	iLayer );
	446	char tmp[1024];
	447	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	448	setMapInMaps(conf,"lenv","message",tmp);
	449	return SERVICE_FAILED;
	450	}
	451
	452	OGRFeature *poFeature;
	453
	454	/* -------------------------------------------------------------------- */
	455	/* Try opening the output datasource as an existing, writable */
	456	/* -------------------------------------------------------------------- */
	457
	458	int iDriver;
	459
	460	map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
	461	oDriver1="GeoJSON";
	462	sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
	463	if(tmpMap!=NULL){
	464	if(strcmp(tmpMap->value,"text/xml")==0){
	465	sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
	466	oDriver1="GML";
	467	}
	468	}
	469
	470	for( iDriver = 0;
	471	iDriver < poR->GetDriverCount() && poDriver == NULL;
	472	iDriver++ )
	473	{
[766]	474
	475	if( EQUAL(
	476	#if GDAL_VERSION_MAJOR >=2
	477	poR->GetDriver(iDriver)->GetDescription()
	478	#else
	479	poR->GetDriver(iDriver)->GetName()
	480	#endif
	481	,oDriver1) )
[491]	482	{
	483	poDriver = poR->GetDriver(iDriver);
	484	}
	485	}
	486
	487	if( poDriver == NULL )
	488	{
	489	char emessage[8192];
	490	sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
	491	sprintf( emessage, "%sThe following drivers are available:\n",emessage );
[766]	492	for( iDriver = 0;iDriver < poR->GetDriverCount();iDriver++ )
[491]	493	{
[766]	494	#if GDAL_VERSION_MAJOR >=2
	495	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	496	#else
[491]	497	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
[766]	498	#endif
[491]	499	}
	500
	501	setMapInMaps(conf,"lenv","message",emessage);
	502	return SERVICE_FAILED;
	503
	504	}
	505
[766]	506	#if GDAL_VERSION_MAJOR >=2
	507	if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
	508	#else
	509	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	510	#endif
	511	{
[491]	512	char emessage[1024];
	513	sprintf( emessage, "%s driver does not support data source creation.\n",
	514	"json" );
	515	setMapInMaps(conf,"lenv","message",emessage);
	516	return SERVICE_FAILED;
	517	}
	518
	519	/* -------------------------------------------------------------------- */
	520	/* Create the output data source. */
	521	/* -------------------------------------------------------------------- */
	522	//map* tpath=getMapFromMaps(conf,"main","tmpPath");
	523	char **papszDSCO=NULL;
[766]	524	#if GDAL_VERSION_MAJOR >=2
	525	poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
	526	#else
[491]	527	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
[766]	528	#endif
[491]	529	if( poODS == NULL ){
	530	char emessage[1024];
	531	sprintf( emessage, "%s driver failed to create %s\n",
	532	"json", pszDestDataSource );
	533	setMapInMaps(conf,"lenv","message",emessage);
	534	return SERVICE_FAILED;
	535	}
	536
	537	/* -------------------------------------------------------------------- */
	538	/* Create the layer. */
	539	/* -------------------------------------------------------------------- */
	540	if( !poODS->TestCapability( ODsCCreateLayer ) )
	541	{
	542	char emessage[1024];
	543	sprintf( emessage,
	544	"Layer %s not found, and CreateLayer not supported by driver.",
	545	"Result" );
	546	setMapInMaps(conf,"lenv","message",emessage);
	547	return SERVICE_FAILED;
	548	}
	549
	550
	551	poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
	552	if( poDstLayer == NULL ){
	553	setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
	554	return SERVICE_FAILED;
	555	}
	556
	557	OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
	558	int iField;
	559	int hasMmField=0;
	560
	561	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
	562	{
	563	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	564	if (iField >= 0)
	565	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
	566	else
	567	{
	568	fprintf( stderr, "Field '%s' not found in source layer.\n",
	569	iField );
	570	return SERVICE_FAILED;
	571	}
	572	}
	573
	574	while(TRUE){
	575	OGRFeature *poDstFeature = NULL;
	576	poFeature = poLayer->GetNextFeature();
	577	if( poFeature == NULL )
	578	break;
	579	if(poFeature->GetGeometryRef() != NULL){
	580	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	581	if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
	582	{
	583	char tmpMsg[1024];
	584	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	585	poFeature->GetFID(), poFDefn->GetName() );
	586
	587	OGRFeature::DestroyFeature( poFeature );
	588	OGRFeature::DestroyFeature( poDstFeature );
	589	return SERVICE_FAILED;
	590	}
	591	if(poDstFeature->SetGeometryDirectly((poDstFeature->GetGeometryRef()->*myFunc)()) != OGRERR_NONE )
	592	{
	593	char tmpMsg[1024];
	594	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	595	poFeature->GetFID(), poFDefn->GetName() );
	596
	597	OGRFeature::DestroyFeature( poFeature );
	598	OGRFeature::DestroyFeature( poDstFeature );
	599	return SERVICE_FAILED;
	600	}
	601	OGRFeature::DestroyFeature( poFeature );
	602	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
	603	{
	604	OGRFeature::DestroyFeature( poDstFeature );
	605	return SERVICE_FAILED;
	606	}
	607	OGRFeature::DestroyFeature( poDstFeature );
	608	}
	609	}
	610
[1]	611	}
[491]	612
	613	delete poODS;
	614	delete ipoDS;
	615
	616	char *res1=readVSIFile(conf,pszDestDataSource);
	617	if(res1==NULL)
	618	return SERVICE_FAILED;
	619	setMapInMaps(outputs,"Result","value",res1);
	620	free(res1);
	621
	622	OGRCleanupAll();
[1]	623	return SERVICE_SUCCEEDED;
	624	}
	625
	626	#ifdef WIN32
	627	__declspec(dllexport)
	628	#endif
[9]	629	int Buffer(maps& conf,maps& inputs,maps*& outputs){
[491]	630	OGRRegisterAll();
	631
	632	double bufferDistance;
	633	map* tmp0=getMapFromMaps(inputs,"BufferDistance","value");
	634	if(tmp0==NULL){
	635	bufferDistance=atof("10.0");
	636	}
	637	else
	638	bufferDistance=atof(tmp0->value);
	639
	640	maps* cursor=inputs;
	641	OGRGeometryH geometry,res;
	642	OGRLayer *poDstLayer;
	643	const char *oDriver1;
[766]	644	#if GDAL_VERSION_MAJOR >= 2
	645	GDALDataset *poODS;
	646	#else
	647	OGRDataSource *poODS;
	648	#endif
[491]	649	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	650	if(!tmp){
	651	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
	652	return SERVICE_FAILED;
	653	}
	654	char filename[1024];
	655	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
	656	const char *oDriver;
	657	oDriver="GeoJSON";
	658	sprintf(filename,"/vsimem/input_%d.json",getpid());
	659	if(tmp1!=NULL){
	660	if(strcmp(tmp1->value,"text/xml")==0){
	661	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	662	oDriver="GML";
	663	}
	664	}
	665	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte)tmp->value,strlen(tmp->value),FALSE);
	666	VSIFCloseL(ifile);
[766]	667	#if GDAL_VERSION_MAJOR >= 2
	668	GDALDataset *ipoDS =
	669	(GDALDataset*) GDALOpenEx( filename,
	670	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	671	NULL, NULL, NULL );
	672	GDALDriverManager* poR=GetGDALDriverManager();
	673	GDALDriver *poDriver = NULL;
	674	#else
	675	OGRDataSource* ipoDS =
	676	OGRSFDriverRegistrar::Open(filename,FALSE);
	677	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	678	OGRSFDriver *poDriver = NULL;
	679	#endif
[491]	680	char pszDestDataSource[100];
	681	if( ipoDS == NULL )
	682	{
	683
	684	fprintf( stderr, "FAILURE:\n"
	685	"Unable to open datasource `%s' with the following drivers.\n",
	686	filename );
	687
	688	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	689	{
[766]	690	#if GDAL_VERSION_MAJOR >= 2
	691	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	692	#else
[491]	693	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
[766]	694	#endif
[491]	695	}
	696	char tmp[1024];
	697	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	698	setMapInMaps(conf,"lenv","message",tmp);
	699	return SERVICE_FAILED;
	700	}
	701	for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
	702	iLayer++ )
	703	{
	704	OGRLayer *poLayer = ipoDS->GetLayer(iLayer);
	705
	706	if( poLayer == NULL )
	707	{
	708	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	709	iLayer );
	710	char tmp[1024];
	711	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	712	setMapInMaps(conf,"lenv","message",tmp);
	713	return SERVICE_FAILED;
	714	}
	715
	716	OGRFeature *poFeature;
	717
	718	/* -------------------------------------------------------------------- */
	719	/* Try opening the output datasource as an existing, writable */
	720	/* -------------------------------------------------------------------- */
	721
	722	int iDriver;
	723
	724	map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
	725	oDriver1="GeoJSON";
	726	sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
	727	if(tmpMap!=NULL){
	728	if(strcmp(tmpMap->value,"text/xml")==0){
	729	sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
	730	oDriver1="GML";
	731	}
	732	}
	733
	734	for( iDriver = 0;
	735	iDriver < poR->GetDriverCount() && poDriver == NULL;
	736	iDriver++ )
	737	{
[766]	738	#if GDAL_VERSION_MAJOR >=2
	739	if( EQUAL(poR->GetDriver(iDriver)->GetDescription(),oDriver1) )
	740	#else
[491]	741	if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
[766]	742	#endif
[491]	743	{
	744	poDriver = poR->GetDriver(iDriver);
	745	}
	746	}
	747
	748	if( poDriver == NULL )
	749	{
	750	char emessage[8192];
	751	sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
	752	sprintf( emessage, "%sThe following drivers are available:\n",emessage );
	753
	754	for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	755	{
[766]	756	#if GDAL_VERSION_MAJOR >=2
	757	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	758	#else
[491]	759	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
[766]	760	#endif
[491]	761	}
	762
	763	setMapInMaps(conf,"lenv","message",emessage);
	764	return SERVICE_FAILED;
	765
	766	}
	767
[766]	768	#if GDAL_VERSION_MAJOR >=2
	769	if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
	770	#else
	771	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	772	#endif
	773	{
[491]	774	char emessage[1024];
	775	sprintf( emessage, "%s driver does not support data source creation.\n",
	776	"json" );
	777	setMapInMaps(conf,"lenv","message",emessage);
	778	return SERVICE_FAILED;
	779	}
	780
	781	/* -------------------------------------------------------------------- */
	782	/* Create the output data source. */
	783	/* -------------------------------------------------------------------- */
	784	//map* tpath=getMapFromMaps(conf,"main","tmpPath");
	785	char **papszDSCO=NULL;
[766]	786	#if GDAL_VERSION_MAJOR >=2
	787	poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
	788	#else
[491]	789	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
[766]	790	#endif
[491]	791	if( poODS == NULL ){
	792	char emessage[1024];
	793	sprintf( emessage, "%s driver failed to create %s\n",
	794	"json", pszDestDataSource );
	795	setMapInMaps(conf,"lenv","message",emessage);
	796	return SERVICE_FAILED;
	797	}
	798
	799	/* -------------------------------------------------------------------- */
	800	/* Create the layer. */
	801	/* -------------------------------------------------------------------- */
	802	if( !poODS->TestCapability( ODsCCreateLayer ) )
	803	{
	804	char emessage[1024];
	805	sprintf( emessage,
	806	"Layer %s not found, and CreateLayer not supported by driver.",
	807	"Result" );
	808	setMapInMaps(conf,"lenv","message",emessage);
	809	return SERVICE_FAILED;
	810	}
[497]	811
[491]	812	poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
	813	if( poDstLayer == NULL ){
	814	setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
	815	return SERVICE_FAILED;
	816	}
	817
	818	OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
	819	int iField;
	820	int hasMmField=0;
	821
	822	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
	823	{
	824	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	825	if (iField >= 0)
	826	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
	827	else
	828	{
	829	fprintf( stderr, "Field '%s' not found in source layer.\n",
	830	iField );
	831	return SERVICE_FAILED;
	832	}
	833	}
	834
	835	while(TRUE){
	836	OGRFeature *poDstFeature = NULL;
	837	poFeature = poLayer->GetNextFeature();
	838	if( poFeature == NULL )
	839	break;
	840	if(poFeature->GetGeometryRef() != NULL){
	841	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	842	if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
	843	{
	844	char tmpMsg[1024];
	845	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	846	poFeature->GetFID(), poFDefn->GetName() );
	847
	848	OGRFeature::DestroyFeature( poFeature );
	849	OGRFeature::DestroyFeature( poDstFeature );
	850	return SERVICE_FAILED;
	851	}
	852	if(poDstFeature->SetGeometryDirectly(poDstFeature->GetGeometryRef()->Buffer(bufferDistance,30)) != OGRERR_NONE )
	853	{
	854	char tmpMsg[1024];
	855	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	856	poFeature->GetFID(), poFDefn->GetName() );
	857
	858	OGRFeature::DestroyFeature( poFeature );
	859	OGRFeature::DestroyFeature( poDstFeature );
	860	return SERVICE_FAILED;
	861	}
	862	OGRFeature::DestroyFeature( poFeature );
	863	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
	864	{
	865	OGRFeature::DestroyFeature( poDstFeature );
	866	return SERVICE_FAILED;
	867	}
	868	OGRFeature::DestroyFeature( poDstFeature );
	869	}
	870	}
	871
	872	}
	873
	874	delete poODS;
	875	delete ipoDS;
	876
	877	char *res1=readVSIFile(conf,pszDestDataSource);
	878	if(res1==NULL)
	879	return SERVICE_FAILED;
	880	setMapInMaps(outputs,"Result","value",res1);
	881	free(res1);
	882
	883	OGRCleanupAll();
	884	return SERVICE_SUCCEEDED;
	885
[9]	886	}
	887
[1]	888	#ifdef WIN32
	889	__declspec(dllexport)
	890	#endif
[766]	891	int Centroid(maps& conf,maps& inputs,maps*& outputs){
	892	OGRRegisterAll();
	893
	894	maps* cursor=inputs;
	895	OGRGeometryH geometry,res;
	896	OGRLayer *poDstLayer;
	897	const char *oDriver1;
	898	#if GDAL_VERSION_MAJOR >= 2
	899	GDALDataset *poODS;
	900	#else
	901	OGRDataSource *poODS;
	902	#endif
	903	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	904	if(!tmp){
	905	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
	906	return SERVICE_FAILED;
	907	}
	908	char filename[1024];
	909	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
	910	const char *oDriver;
	911	oDriver="GeoJSON";
	912	sprintf(filename,"/vsimem/input_%d.json",getpid());
	913	if(tmp1!=NULL){
	914	if(strcmp(tmp1->value,"text/xml")==0){
	915	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	916	oDriver="GML";
	917	}
	918	}
	919	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte)tmp->value,strlen(tmp->value),FALSE);
	920	VSIFCloseL(ifile);
	921	#if GDAL_VERSION_MAJOR >= 2
	922	GDALDataset *ipoDS =
	923	(GDALDataset*) GDALOpenEx( filename,
	924	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	925	NULL, NULL, NULL );
	926	GDALDriverManager* poR=GetGDALDriverManager();
	927	GDALDriver *poDriver = NULL;
	928	#else
	929	OGRDataSource* ipoDS =
	930	OGRSFDriverRegistrar::Open(filename,FALSE);
	931	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	932	OGRSFDriver *poDriver = NULL;
	933	#endif
	934	char pszDestDataSource[100];
	935	if( ipoDS == NULL )
	936	{
	937
	938	fprintf( stderr, "FAILURE:\n"
	939	"Unable to open datasource `%s' with the following drivers.\n",
	940	filename );
	941
	942	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	943	{
	944	#if GDAL_VERSION_MAJOR >= 2
	945	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	946	#else
	947	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
	948	#endif
	949	}
	950	char tmp[1024];
	951	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	952	setMapInMaps(conf,"lenv","message",tmp);
	953	return SERVICE_FAILED;
	954	}
	955	for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
	956	iLayer++ )
	957	{
	958	OGRLayer *poLayer = ipoDS->GetLayer(iLayer);
	959
	960	if( poLayer == NULL )
	961	{
	962	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	963	iLayer );
	964	char tmp[1024];
	965	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	966	setMapInMaps(conf,"lenv","message",tmp);
	967	return SERVICE_FAILED;
	968	}
	969
	970	OGRFeature *poFeature;
	971
	972	/* -------------------------------------------------------------------- */
	973	/* Try opening the output datasource as an existing, writable */
	974	/* -------------------------------------------------------------------- */
	975
	976	int iDriver;
	977
	978	map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
	979	oDriver1="GeoJSON";
	980	sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
	981	if(tmpMap!=NULL){
	982	if(strcmp(tmpMap->value,"text/xml")==0){
	983	sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
	984	oDriver1="GML";
	985	}
	986	}
	987
	988	for( iDriver = 0;
	989	iDriver < poR->GetDriverCount() && poDriver == NULL;
	990	iDriver++ )
	991	{
	992	#if GDAL_VERSION_MAJOR >=2
	993	if( EQUAL(poR->GetDriver(iDriver)->GetDescription(),oDriver1) )
	994	#else
	995	if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1) )
	996	#endif
	997	{
	998	poDriver = poR->GetDriver(iDriver);
	999	}
	1000	}
	1001
	1002	if( poDriver == NULL )
	1003	{
	1004	char emessage[8192];
	1005	sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
	1006	sprintf( emessage, "%sThe following drivers are available:\n",emessage );
	1007
	1008	for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	1009	{
	1010	#if GDAL_VERSION_MAJOR >=2
	1011	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	1012	#else
	1013	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
	1014	#endif
	1015	}
	1016
	1017	setMapInMaps(conf,"lenv","message",emessage);
	1018	return SERVICE_FAILED;
	1019
	1020	}
	1021
	1022	#if GDAL_VERSION_MAJOR >=2
	1023	if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
	1024	#else
	1025	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	1026	#endif
	1027	{
	1028	char emessage[1024];
	1029	sprintf( emessage, "%s driver does not support data source creation.\n",
	1030	"json" );
	1031	setMapInMaps(conf,"lenv","message",emessage);
	1032	return SERVICE_FAILED;
	1033	}
	1034
	1035	/* -------------------------------------------------------------------- */
	1036	/* Create the output data source. */
	1037	/* -------------------------------------------------------------------- */
	1038	//map* tpath=getMapFromMaps(conf,"main","tmpPath");
	1039	char **papszDSCO=NULL;
	1040	#if GDAL_VERSION_MAJOR >=2
	1041	poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
	1042	#else
	1043	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
	1044	#endif
	1045	if( poODS == NULL ){
	1046	char emessage[1024];
	1047	sprintf( emessage, "%s driver failed to create %s\n",
	1048	"json", pszDestDataSource );
	1049	setMapInMaps(conf,"lenv","message",emessage);
	1050	return SERVICE_FAILED;
	1051	}
	1052
	1053	/* -------------------------------------------------------------------- */
	1054	/* Create the layer. */
	1055	/* -------------------------------------------------------------------- */
	1056	if( !poODS->TestCapability( ODsCCreateLayer ) )
	1057	{
	1058	char emessage[1024];
	1059	sprintf( emessage,
	1060	"Layer %s not found, and CreateLayer not supported by driver.",
	1061	"Result" );
	1062	setMapInMaps(conf,"lenv","message",emessage);
	1063	return SERVICE_FAILED;
	1064	}
	1065
	1066	poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
	1067	if( poDstLayer == NULL ){
	1068	setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
	1069	return SERVICE_FAILED;
	1070	}
	1071
	1072	OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
	1073	int iField;
	1074	int hasMmField=0;
	1075
	1076	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
	1077	{
	1078	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	1079	if (iField >= 0)
	1080	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
	1081	else
	1082	{
	1083	fprintf( stderr, "Field '%s' not found in source layer.\n",
	1084	iField );
	1085	return SERVICE_FAILED;
	1086	}
	1087	}
	1088
	1089	while(TRUE){
	1090	OGRFeature *poDstFeature = NULL;
	1091	poFeature = poLayer->GetNextFeature();
	1092	if( poFeature == NULL )
	1093	break;
	1094	if(poFeature->GetGeometryRef() != NULL){
	1095	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	1096	if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
	1097	{
	1098	char tmpMsg[1024];
	1099	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	1100	poFeature->GetFID(), poFDefn->GetName() );
	1101
	1102	OGRFeature::DestroyFeature( poFeature );
	1103	OGRFeature::DestroyFeature( poDstFeature );
	1104	return SERVICE_FAILED;
	1105	}
	1106	OGRPoint* poPoint=new OGRPoint();
	1107	poDstFeature->GetGeometryRef()->Centroid(poPoint);
	1108	if(poDstFeature->SetGeometryDirectly(poPoint)!= OGRERR_NONE ){
	1109	char tmpMsg[1024];
	1110	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	1111	poFeature->GetFID(), poFDefn->GetName() );
	1112
	1113	OGRFeature::DestroyFeature( poFeature );
	1114	OGRFeature::DestroyFeature( poDstFeature );
	1115	return SERVICE_FAILED;
	1116	}
	1117	OGRFeature::DestroyFeature( poFeature );
	1118	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
	1119	{
	1120	OGRFeature::DestroyFeature( poDstFeature );
	1121	return SERVICE_FAILED;
	1122	}
	1123	OGRFeature::DestroyFeature( poDstFeature );
	1124	}
	1125	}
	1126
	1127	}
	1128
	1129	delete poODS;
	1130	delete ipoDS;
	1131
	1132	char *res1=readVSIFile(conf,pszDestDataSource);
	1133	if(res1==NULL)
	1134	return SERVICE_FAILED;
	1135	setMapInMaps(outputs,"Result","value",res1);
	1136	free(res1);
	1137
	1138	OGRCleanupAll();
	1139	return SERVICE_SUCCEEDED;
	1140
	1141	}
	1142
	1143	#ifdef WIN32
	1144	__declspec(dllexport)
	1145	#endif
[9]	1146	int Boundary(maps& conf,maps& inputs,maps*& outputs){
[491]	1147	return applyOne(conf,inputs,outputs,&OGRGeometry::Boundary,"http://fooa/gml/3.1.0/polygon.xsd");
[9]	1148	}
	1149
	1150	#ifdef WIN32
	1151	__declspec(dllexport)
	1152	#endif
	1153	int ConvexHull(maps& conf,maps& inputs,maps*& outputs){
[491]	1154	return applyOne(conf,inputs,outputs,&OGRGeometry::ConvexHull,"http://fooa/gml/3.1.0/polygon.xsd");
[9]	1155	}
	1156
[766]	1157	#if GDAL_VERSION_MAJOR >= 2
	1158	GDALDataset*
	1159	#else
	1160	OGRDataSource*
	1161	#endif
	1162	loadEntity(maps* conf,maps* inputs,char filename,const char oDriver,const char *entity,int iter){
[491]	1163	map* tmp=getMapFromMaps(inputs,entity,"value");
	1164	map* tmp1=getMapFromMaps(inputs,entity,"mimeType");
	1165	*oDriver="GeoJSON";
	1166	sprintf(*filename,"/vsimem/input_%d.json",getpid()+iter);
	1167	if(tmp1!=NULL){
	1168	if(strcmp(tmp1->value,"text/xml")==0){
	1169	sprintf(*filename,"/vsimem/input_%d.xml",getpid()+iter);
	1170	*oDriver="GML";
	1171	}
[9]	1172	}
[491]	1173	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
	1174	VSIFCloseL(ifile);
[766]	1175	#if GDAL_VERSION_MAJOR >= 2
	1176	return (GDALDataset) GDALOpenEx( filename,
	1177	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	1178	NULL, NULL, NULL );
	1179	#else
[491]	1180	return OGRSFDriverRegistrar::Open(*filename,FALSE);
[766]	1181	#endif
[9]	1182	}
	1183
[491]	1184	int applyOneBool(maps& conf,maps& inputs,maps& outputs,OGRBoolean (OGRGeometry::myFunc)() const){
[1]	1185	#ifdef DEBUG
[491]	1186	fprintf(stderr,"\nService internal print\n");
[216]	1187	#endif
[491]	1188	OGRRegisterAll();
[9]	1189
[1]	1190	maps* cursor=inputs;
[491]	1191	OGRGeometryH geometry,res;
	1192	OGRLayer *poDstLayer;
	1193	const char *oDriver1;
	1194	OGRDataSource *poODS;
[216]	1195	#ifdef DEBUG
[491]	1196	dumpMaps(cursor);
[216]	1197	#endif
[491]	1198	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	1199	if(!tmp){
	1200	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[26]	1201	return SERVICE_FAILED;
	1202	}
[491]	1203	char filename[1024];
	1204	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
	1205	const char *oDriver;
	1206	oDriver="GeoJSON";
	1207	sprintf(filename,"/vsimem/input_%d.json",getpid());
	1208	if(tmp1!=NULL){
	1209	if(strcmp(tmp1->value,"text/xml")==0){
	1210	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	1211	oDriver="GML";
	1212	}
	1213	}
	1214	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte)tmp->value,strlen(tmp->value),FALSE);
	1215	VSIFCloseL(ifile);
[766]	1216
	1217	#if GDAL_VERSION_MAJOR >= 2
	1218	GDALDataset *ipoDS =
	1219	(GDALDataset*) GDALOpenEx( filename,
	1220	GDAL_OF_READONLY \| GDAL_OF_VECTOR,
	1221	NULL, NULL, NULL );
	1222	GDALDriverManager* poR=GetGDALDriverManager();
	1223	GDALDriver *poDriver = NULL;
	1224	#else
	1225	OGRDataSource* ipoDS =
	1226	OGRSFDriverRegistrar::Open(filename,FALSE);
	1227	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	1228	OGRSFDriver *poDriver = NULL;
	1229	#endif
[491]	1230	char pszDestDataSource[100];
	1231	if( ipoDS == NULL )
[766]	1232	{
[491]	1233	fprintf( stderr, "FAILURE:\n"
	1234	"Unable to open datasource `%s' with the following drivers.\n",
	1235	filename );
	1236
	1237	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	1238	{
[766]	1239	#if GDAL_VERSION_MAJOR >= 2
	1240	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	1241	#else
[491]	1242	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
[766]	1243	#endif
[491]	1244	}
	1245	char tmp[1024];
	1246	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	1247	setMapInMaps(conf,"lenv","message",tmp);
	1248	return SERVICE_FAILED;
	1249	}
	1250	for( int iLayer = 0; iLayer < ipoDS->GetLayerCount();
	1251	iLayer++ )
	1252	{
	1253	OGRLayer *poLayer = ipoDS->GetLayer(iLayer);
	1254
	1255	if( poLayer == NULL )
	1256	{
	1257	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	1258	iLayer );
	1259	char tmp[1024];
	1260	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	1261	setMapInMaps(conf,"lenv","message",tmp);
	1262	return SERVICE_FAILED;
	1263	}
	1264
	1265	OGRFeature *poFeature;
	1266
	1267
	1268	while(TRUE){
	1269	OGRFeature *poDstFeature = NULL;
	1270	poFeature = poLayer->GetNextFeature();
	1271	if( poFeature == NULL )
	1272	break;
	1273	if(poFeature->GetGeometryRef() != NULL){
	1274	if((poFeature->GetGeometryRef()->*myFunc)()==0){
	1275	setMapInMaps(outputs,"Result","value","false");
	1276	OGRFeature::DestroyFeature( poFeature );
	1277	delete ipoDS;
	1278	return SERVICE_SUCCEEDED;
	1279	}
	1280	}
	1281	OGRFeature::DestroyFeature( poFeature );
	1282	}
	1283
	1284	}
	1285
	1286	delete ipoDS;
	1287	setMapInMaps(outputs,"Result","value","true");
	1288
	1289	OGRCleanupAll();
	1290	return SERVICE_SUCCEEDED;
	1291	}
	1292
	1293	#ifdef WIN32
	1294	__declspec(dllexport)
[216]	1295	#endif
[491]	1296	int IsSimple(maps& conf,maps& inputs,maps*& outputs){
	1297	return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsSimple);
	1298	}
	1299
	1300	#ifdef WIN32
	1301	__declspec(dllexport)
[216]	1302	#endif
[491]	1303	int IsClosed(maps& conf,maps& inputs,maps*& outputs){
	1304	return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsRing);
	1305	}
	1306
	1307	#ifdef WIN32
	1308	__declspec(dllexport)
	1309	#endif
	1310	int IsValid(maps& conf,maps& inputs,maps*& outputs){
	1311	return applyOneBool(conf,inputs,outputs,&OGRGeometry::IsValid);
	1312	}
	1313
	1314
	1315	int applyTwo(maps& conf,maps& inputs,maps& outputs,OGRGeometry (OGRGeometry::myFunc)(const OGRGeometry) const){
[216]	1316	#ifdef DEBUG
[491]	1317	fprintf(stderr,"\nService internal print\n");
[216]	1318	#endif
[491]	1319	OGRRegisterAll();
	1320
	1321	maps* cursor=inputs;
	1322	OGRGeometryH geometry,res;
	1323	OGRLayer *poDstLayer;
	1324	//const char *oDriver1;
[216]	1325	#ifdef DEBUG
[491]	1326	dumpMaps(cursor);
[216]	1327	#endif
[491]	1328
	1329	char filename=(char)malloc(1024*sizeof(char));
	1330	const char *oDriver1;
[766]	1331	#if GDAL_VERSION_MAJOR >= 2
	1332	GDALDataset*
	1333	#else
	1334	OGRDataSource*
	1335	#endif
	1336	ipoDS1 = loadEntity(conf,inputs,&filename,&oDriver1,"InputEntity1",1);
[491]	1337	char filename1=(char)malloc(1024*sizeof(char));
	1338	const char *oDriver2;
[766]	1339	#if GDAL_VERSION_MAJOR >= 2
	1340	GDALDataset*
	1341	#else
	1342	OGRDataSource*
	1343	#endif
	1344	ipoDS2 = loadEntity(conf,inputs,&filename1,&oDriver2,"InputEntity2",2);
[491]	1345	const char *oDriver3;
	1346	char pszDestDataSource[100];
[766]	1347	#if GDAL_VERSION_MAJOR >= 2
	1348	GDALDriverManager* poR=GetGDALDriverManager();
	1349	GDALDriver *poDriver = NULL;
	1350	GDALDataset *poODS;
	1351	#else
	1352	OGRDataSource *poODS;
	1353	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	1354	OGRSFDriver *poDriver = NULL;
	1355	#endif
[491]	1356	if( ipoDS1 == NULL \|\| ipoDS2 == NULL )
	1357	{
	1358
	1359	fprintf( stderr, "FAILURE:\n"
	1360	"Unable to open datasource `%s' with the following drivers.\n",
	1361	filename );
	1362
	1363	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	1364	{
[766]	1365	#if GDAL_VERSION_MAJOR >= 2
	1366	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	1367	#else
[491]	1368	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
[766]	1369	#endif
[491]	1370	}
	1371	char tmp[1024];
	1372	if( ipoDS1 == NULL )
	1373	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	1374	if( ipoDS2 == NULL )
	1375	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename1);
	1376	setMapInMaps(conf,"lenv","message",tmp);
	1377	return SERVICE_FAILED;
[1]	1378	}
[491]	1379	for( int iLayer = 0; iLayer < ipoDS1->GetLayerCount();
	1380	iLayer++ )
	1381	{
	1382	OGRLayer *poLayer1 = ipoDS1->GetLayer(iLayer);
	1383
	1384	if( poLayer1 == NULL )
	1385	{
	1386	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	1387	iLayer );
	1388	char tmp[1024];
	1389	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	1390	setMapInMaps(conf,"lenv","message",tmp);
	1391	return SERVICE_FAILED;
	1392	}
	1393
	1394	for( int iLayer1 = 0; iLayer1 < ipoDS2->GetLayerCount();
	1395	iLayer1++ )
	1396	{
	1397	OGRLayer *poLayer2 = ipoDS2->GetLayer(iLayer1);
	1398
	1399	if( poLayer1 == NULL )
	1400	{
	1401	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	1402	iLayer1 );
	1403	char tmp[1024];
	1404	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer1);
	1405	setMapInMaps(conf,"lenv","message",tmp);
	1406	return SERVICE_FAILED;
	1407	}
	1408
	1409	OGRFeature poFeature1,poFeature2;
	1410
	1411	/* -------------------------------------------------------------------- */
	1412	/* Try opening the output datasource as an existing, writable */
	1413	/* -------------------------------------------------------------------- */
	1414
	1415	int iDriver;
	1416
	1417	map* tmpMap=getMapFromMaps(outputs,"Result","mimeType");
	1418	oDriver3="GeoJSON";
	1419	sprintf(pszDestDataSource,"/vsimem/result_%d.json",getpid());
	1420	if(tmpMap!=NULL){
	1421	if(strcmp(tmpMap->value,"text/xml")==0){
	1422	sprintf(pszDestDataSource,"/vsimem/result_%d.xml",getpid());
	1423	oDriver3="GML";
	1424	}
	1425	}
[769]	1426
[491]	1427	for( iDriver = 0;
	1428	iDriver < poR->GetDriverCount() && poDriver == NULL;
	1429	iDriver++ )
	1430	{
[766]	1431	#if GDAL_VERSION_MAJOR >=2
[769]	1432	if( EQUAL(poR->GetDriver(iDriver)->GetDescription(),oDriver3) )
[766]	1433	#else
[769]	1434	if( EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver3) )
[216]	1435	#endif
[491]	1436	{
	1437	poDriver = poR->GetDriver(iDriver);
	1438	}
	1439	}
	1440
	1441	if( poDriver == NULL )
	1442	{
	1443	char emessage[8192];
	1444	sprintf( emessage, "Unable to find driver `%s'.\n", oDriver1 );
	1445	sprintf( emessage, "%sThe following drivers are available:\n",emessage );
	1446
	1447	for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	1448	{
[766]	1449	#if GDAL_VERSION_MAJOR >= 2
	1450	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
	1451	#else
[491]	1452	sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
[766]	1453	#endif
[491]	1454	}
	1455
	1456	setMapInMaps(conf,"lenv","message",emessage);
	1457	return SERVICE_FAILED;
	1458
	1459	}
	1460
[766]	1461	#if GDAL_VERSION_MAJOR >= 2
	1462	if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
	1463	#else
	1464	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	1465	#endif
	1466	{
	1467	char emessage[1024];
	1468	sprintf( emessage, "%s driver does not support data source creation.\n",
	1469	"json" );
	1470	setMapInMaps(conf,"lenv","message",emessage);
	1471	return SERVICE_FAILED;
	1472	}
[491]	1473
	1474	/* -------------------------------------------------------------------- */
	1475	/* Create the output data source. */
	1476	/* -------------------------------------------------------------------- */
	1477	//map* tpath=getMapFromMaps(conf,"main","tmpPath");
	1478	char **papszDSCO=NULL;
[766]	1479	#if GDAL_VERSION_MAJOR >= 2
	1480	poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
	1481	#else
[491]	1482	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
[766]	1483	#endif
[491]	1484	if( poODS == NULL ){
	1485	char emessage[1024];
	1486	sprintf( emessage, "%s driver failed to create %s\n",
	1487	"json", pszDestDataSource );
	1488	setMapInMaps(conf,"lenv","message",emessage);
	1489	return SERVICE_FAILED;
	1490	}
	1491
	1492	/* -------------------------------------------------------------------- */
	1493	/* Create the layer. */
	1494	/* -------------------------------------------------------------------- */
	1495	if( !poODS->TestCapability( ODsCCreateLayer ) )
	1496	{
	1497	char emessage[1024];
	1498	sprintf( emessage,
	1499	"Layer %s not found, and CreateLayer not supported by driver.",
	1500	"Result" );
	1501	setMapInMaps(conf,"lenv","message",emessage);
	1502	return SERVICE_FAILED;
	1503	}
	1504
	1505	//CPLErrorReset();
	1506
	1507	poDstLayer = poODS->CreateLayer( "Result", NULL,wkbUnknown,NULL);
	1508	if( poDstLayer == NULL ){
	1509	setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
	1510	return SERVICE_FAILED;
	1511	}
	1512
[499]	1513	OGRFeatureDefn *poFDefn = poLayer2->GetLayerDefn();
[491]	1514	int iField;
	1515	int hasMmField=0;
	1516
	1517	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
	1518	{
	1519	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	1520	if (iField >= 0)
	1521	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
	1522	else
	1523	{
	1524	fprintf( stderr, "Field '%s' not found in source layer.\n",
	1525	iField );
	1526	return SERVICE_FAILED;
	1527	}
	1528	}
	1529
	1530	while(TRUE){
	1531	OGRFeature *poDstFeature = NULL;
	1532	poFeature1 = poLayer1->GetNextFeature();
	1533	if( poFeature1 == NULL )
	1534	break;
	1535	while(TRUE){
	1536	poFeature2 = poLayer2->GetNextFeature();
	1537	if( poFeature2 == NULL )
	1538	break;
	1539
	1540	if(poFeature1->GetGeometryRef() != NULL && poFeature2->GetGeometryRef() != NULL){
	1541	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	1542	if( poDstFeature->SetFrom( poFeature2, TRUE ) != OGRERR_NONE )
	1543	{
	1544	char tmpMsg[1024];
	1545	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	1546	poFeature2->GetFID(), poFDefn->GetName() );
	1547
	1548	OGRFeature::DestroyFeature( poFeature1 );
	1549	OGRFeature::DestroyFeature( poFeature2 );
	1550	OGRFeature::DestroyFeature( poDstFeature );
	1551	return SERVICE_FAILED;
	1552	}
	1553	if(poDstFeature->SetGeometryDirectly((poFeature1->GetGeometryRef()->*myFunc)(poFeature2->GetGeometryRef())) != OGRERR_NONE )
	1554	{
	1555	char tmpMsg[1024];
	1556	sprintf( tmpMsg,"Unable to translate feature %ld from layer %s.\n",
	1557	poFeature2->GetFID(), poFDefn->GetName() );
	1558
	1559	OGRFeature::DestroyFeature( poFeature1 );
	1560	OGRFeature::DestroyFeature( poFeature2 );
	1561	OGRFeature::DestroyFeature( poDstFeature );
	1562	return SERVICE_FAILED;
	1563	}
	1564	OGRFeature::DestroyFeature( poFeature2 );
	1565	if(!poDstFeature->GetGeometryRef()->IsEmpty())
	1566	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
	1567	{
	1568	OGRFeature::DestroyFeature( poDstFeature );
	1569	return SERVICE_FAILED;
	1570	}
	1571	OGRFeature::DestroyFeature( poDstFeature );
	1572	}
	1573	}
	1574	}
[499]	1575	OGRFeature::DestroyFeature( poFeature1 );
[491]	1576	}
	1577	}
	1578
	1579	delete poODS;
	1580	delete ipoDS1;
	1581	delete ipoDS2;
	1582	free(filename);
	1583	free(filename1);
	1584
	1585	char *res1=readVSIFile(conf,pszDestDataSource);
	1586	if(res1==NULL)
[26]	1587	return SERVICE_FAILED;
[491]	1588	setMapInMaps(outputs,"Result","value",res1);
	1589	free(res1);
	1590	OGRCleanupAll();
[1]	1591	return SERVICE_SUCCEEDED;
	1592	}
[9]	1593
	1594	#ifdef WIN32
	1595	__declspec(dllexport)
	1596	#endif
	1597	int Difference(maps& conf,maps& inputs,maps*& outputs){
[491]	1598	return applyTwo(conf,inputs,outputs,&OGRGeometry::Difference);
[9]	1599	}
[1]	1600
	1601	#ifdef WIN32
	1602	__declspec(dllexport)
	1603	#endif
[9]	1604	int SymDifference(maps& conf,maps& inputs,maps*& outputs){
[491]	1605	return applyTwo(conf,inputs,outputs,&OGRGeometry::SymDifference);
[9]	1606	}
	1607
	1608	#ifdef WIN32
	1609	__declspec(dllexport)
	1610	#endif
	1611	int Intersection(maps& conf,maps& inputs,maps*& outputs){
[491]	1612	return applyTwo(conf,inputs,outputs,&OGRGeometry::Intersection);
[9]	1613	}
	1614
	1615	#ifdef WIN32
	1616	__declspec(dllexport)
	1617	#endif
	1618	int Union(maps& conf,maps& inputs,maps*& outputs){
[491]	1619	return applyTwo(conf,inputs,outputs,&OGRGeometry::Union);
[9]	1620	}
	1621
[491]	1622	int applyTwoBool(maps& conf,maps& inputs,maps& outputs,OGRBoolean (OGRGeometry::myFunc)(const OGRGeometry*) const){
	1623	OGRRegisterAll();
	1624
	1625	maps* cursor=inputs;
	1626	OGRGeometryH geometry,res;
	1627	OGRLayer *poDstLayer;
[766]	1628	#if GDAL_VERSION_MAJOR >= 2
	1629	GDALDataset *poODS;
	1630	#else
	1631	OGRDataSource *poODS;
	1632	#endif
[491]	1633
	1634	char filename=(char)malloc(1024*sizeof(char));
	1635	const char *oDriver1;
[766]	1636	#if GDAL_VERSION_MAJOR >= 2
	1637	GDALDataset*
	1638	#else
	1639	OGRDataSource*
	1640	#endif
	1641	ipoDS1 = loadEntity(conf,inputs,&filename,&oDriver1,"InputEntity1",1);
[491]	1642
	1643	char filename1=(char)malloc(1024*sizeof(char));
	1644	const char *oDriver2;
[766]	1645	#if GDAL_VERSION_MAJOR >= 2
	1646	GDALDataset*
	1647	#else
	1648	OGRDataSource*
	1649	#endif
	1650	ipoDS2 = loadEntity(conf,inputs,&filename1,&oDriver2,"InputEntity2",2);
[491]	1651	const char *oDriver3;
	1652	char pszDestDataSource[100];
[766]	1653	#if GDAL_VERSION_MAJOR >= 2
	1654	GDALDriverManager* poR=GetGDALDriverManager();
	1655	GDALDriver *poDriver = NULL;
	1656	#else
	1657	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	1658	OGRSFDriver *poDriver = NULL;
	1659	#endif
	1660
[491]	1661	if( ipoDS1 == NULL \|\| ipoDS2 == NULL )
	1662	{
	1663	fprintf( stderr, "FAILURE:\n"
	1664	"Unable to open datasource `%s' with the following drivers.\n",
	1665	filename );
	1666
	1667	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	1668	{
[766]	1669	#if GDAL_VERSION_MAJOR >= 2
	1670	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
	1671	#else
[491]	1672	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
[766]	1673	#endif
[491]	1674	}
	1675	char tmp[1024];
	1676	if( ipoDS1 == NULL )
	1677	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename);
	1678	if( ipoDS2 == NULL )
	1679	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",filename1);
	1680	setMapInMaps(conf,"lenv","message",tmp);
	1681	return SERVICE_FAILED;
	1682	}
	1683	for( int iLayer = 0; iLayer < ipoDS1->GetLayerCount();
	1684	iLayer++ )
	1685	{
	1686	OGRLayer *poLayer1 = ipoDS1->GetLayer(iLayer);
	1687
	1688	if( poLayer1 == NULL )
	1689	{
	1690	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	1691	iLayer );
	1692	char tmp[1024];
	1693	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	1694	setMapInMaps(conf,"lenv","message",tmp);
	1695	return SERVICE_FAILED;
	1696	}
	1697
	1698	for( int iLayer1 = 0; iLayer1 < ipoDS2->GetLayerCount();
	1699	iLayer1++ )
	1700	{
	1701	OGRLayer *poLayer2 = ipoDS2->GetLayer(iLayer1);
	1702
	1703	if( poLayer1 == NULL )
	1704	{
	1705	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	1706	iLayer1 );
	1707	char tmp[1024];
	1708	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer1);
	1709	setMapInMaps(conf,"lenv","message",tmp);
	1710	return SERVICE_FAILED;
	1711	}
	1712
	1713	OGRFeature poFeature1,poFeature2;
	1714
	1715
	1716	while(TRUE){
	1717	OGRFeature *poDstFeature = NULL;
	1718	poFeature1 = poLayer1->GetNextFeature();
	1719	if( poFeature1 == NULL )
	1720	break;
	1721	while(TRUE){
	1722	poFeature2 = poLayer2->GetNextFeature();
	1723	if( poFeature2 == NULL )
	1724	break;
	1725	if(poFeature1->GetGeometryRef() != NULL && poFeature2->GetGeometryRef() != NULL){
	1726	if((poFeature1->GetGeometryRef()->*myFunc)(poFeature2->GetGeometryRef())==0){
	1727	setMapInMaps(outputs,"Result","value","false");
	1728	OGRFeature::DestroyFeature( poFeature1 );
	1729	OGRFeature::DestroyFeature( poFeature2 );
	1730	delete ipoDS1;
	1731	delete ipoDS2;
	1732	free(filename);
	1733	free(filename1);
	1734	return SERVICE_SUCCEEDED;
	1735	}
	1736	}
	1737	OGRFeature::DestroyFeature( poFeature2 );
	1738	}
	1739	OGRFeature::DestroyFeature( poFeature1 );
	1740	}
	1741	}
	1742	}
	1743
	1744	delete ipoDS1;
	1745	delete ipoDS2;
	1746	free(filename);
	1747	free(filename1);
	1748
	1749	setMapInMaps(outputs,"Result","value","true");
	1750
	1751	OGRCleanupAll();
	1752	return SERVICE_SUCCEEDED;
	1753	}
	1754
	1755
[9]	1756	#ifdef WIN32
	1757	__declspec(dllexport)
	1758	#endif
[491]	1759	int Equals(maps& conf,maps& inputs,maps*& outputs){
	1760	return applyTwoBool(conf,inputs,outputs,(OGRBoolean (OGRGeometry::)(const OGRGeometry ) const)&OGRGeometry::Equals);
	1761	}
	1762
	1763	#ifdef WIN32
	1764	__declspec(dllexport)
	1765	#endif
	1766	int Disjoint(maps& conf,maps& inputs,maps*& outputs){
	1767	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Disjoint);
	1768	}
	1769
	1770	#ifdef WIN32
	1771	__declspec(dllexport)
	1772	#endif
	1773	int Touches(maps& conf,maps& inputs,maps*& outputs){
	1774	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Touches);
	1775	}
	1776
	1777	#ifdef WIN32
	1778	__declspec(dllexport)
	1779	#endif
	1780	int Crosses(maps& conf,maps& inputs,maps*& outputs){
	1781	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Crosses);
	1782	}
	1783
	1784	#ifdef WIN32
	1785	__declspec(dllexport)
	1786	#endif
	1787	int Within(maps& conf,maps& inputs,maps*& outputs){
	1788	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Within);
	1789	}
	1790
	1791	#ifdef WIN32
	1792	__declspec(dllexport)
	1793	#endif
	1794	int Contains(maps& conf,maps& inputs,maps*& outputs){
	1795	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Contains);
	1796	}
	1797
	1798	#ifdef WIN32
	1799	__declspec(dllexport)
	1800	#endif
	1801	int Overlaps(maps& conf,maps& inputs,maps*& outputs){
	1802	return applyTwoBool(conf,inputs,outputs,&OGRGeometry::Overlaps);
	1803	}
	1804
	1805	#ifdef WIN32
	1806	__declspec(dllexport)
	1807	#endif
	1808	int Intersects(maps& conf,maps& inputs,maps*& outputs){
	1809	return applyTwoBool(conf,inputs,outputs,(OGRBoolean (OGRGeometry::)(const OGRGeometry ) const)&OGRGeometry::Intersects);
	1810	}
	1811
	1812	#ifdef WIN32
	1813	__declspec(dllexport)
	1814	#endif
[1]	1815	int Distance(maps& conf,maps& inputs,maps*& outputs){
	1816	#ifdef DEBUG
	1817	fprintf(stderr,"\nService internal print1\n");
	1818	#endif
	1819	fflush(stderr);
	1820	maps* cursor=inputs;
	1821	OGRGeometryH geometry1,geometry2;
	1822	double res;
	1823	{
	1824	map* tmp=getMapFromMaps(inputs,"InputEntity1","value");
	1825	map* tmp1=getMapFromMaps(inputs,"InputEntity1","mimeType");
	1826	#ifdef DEBUG
	1827	fprintf(stderr,"MY MAP\n");
	1828	dumpMap(tmp1);
	1829	dumpMaps(inputs);
	1830	fprintf(stderr,"MY MAP\n");
	1831	#endif
	1832	if(tmp1!=NULL){
	1833	if(strncmp(tmp1->value,"application/json",16)==0)
	1834	geometry1=OGR_G_CreateGeometryFromJson(tmp->value);
	1835	else
	1836	geometry1=createGeometryFromGML(conf,tmp->value);
	1837	}
	1838	else
	1839	geometry1=createGeometryFromGML(conf,tmp->value);
	1840	}
[26]	1841	if(geometry1==NULL){
[36]	1842	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity1."));
[26]	1843	fprintf(stderr,"SERVICE FAILED !\n");
	1844	return SERVICE_FAILED;
	1845	}
[1]	1846	{
	1847	map* tmp=getMapFromMaps(inputs,"InputEntity2","value");
	1848	map* tmp1=getMapFromMaps(inputs,"InputEntity2","mimeType");
	1849	#ifdef DEBUG
	1850	fprintf(stderr,"MY MAP\n");
	1851	dumpMap(tmp1);
	1852	dumpMaps(inputs);
	1853	fprintf(stderr,"MY MAP\n");
	1854	#endif
	1855	if(tmp1!=NULL){
	1856	if(strncmp(tmp1->value,"application/json",16)==0)
	1857	geometry2=OGR_G_CreateGeometryFromJson(tmp->value);
	1858	else
	1859	geometry2=createGeometryFromGML(conf,tmp->value);
	1860	}
	1861	else
	1862	geometry2=createGeometryFromGML(conf,tmp->value);
	1863	}
[26]	1864	if(geometry2==NULL){
[36]	1865	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity2."));
[26]	1866	fprintf(stderr,"SERVICE FAILED !\n");
	1867	return SERVICE_FAILED;
	1868	}
	1869	res=OGR_G_Distance(geometry1,geometry2);
[1]	1870	char tmpres[100];
[55]	1871	sprintf(tmpres,"%f",res);
[26]	1872	setMapInMaps(outputs,"Distance","value",tmpres);
	1873	setMapInMaps(outputs,"Distance","dataType","float");
[1]	1874	#ifdef DEBUG
	1875	dumpMaps(outputs);
	1876	fprintf(stderr,"\nService internal print\n===\n");
	1877	#endif
	1878	return SERVICE_SUCCEEDED;
	1879	}
	1880
[9]	1881	#ifdef WIN32
	1882	__declspec(dllexport)
	1883	#endif
[1]	1884	int GetArea(maps& conf,maps& inputs,maps*& outputs){
	1885	fprintf(stderr,"GETAREA \n");
	1886	double res;
	1887	/**
[26]	1888	* Extract Geometry from the InputPolygon value
[1]	1889	*/
[26]	1890	OGRGeometryH geometry;
	1891	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	1892	if(tmp==NULL){
[36]	1893	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
[26]	1894	return SERVICE_FAILED;
	1895	}
[1]	1896	fprintf(stderr,"geometry creation %s \n",tmp->value);
[26]	1897	geometry=createGeometryFromGML(conf,tmp->value);
	1898	if(geometry==NULL){
[36]	1899	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
[26]	1900	return SERVICE_FAILED;
	1901	}
[1]	1902	fprintf(stderr,"geometry created %s \n",tmp->value);
[491]	1903	res=OGR_G_Area(geometry);
[1]	1904	fprintf(stderr,"area %d \n",res);
	1905	/**
[26]	1906	* Filling the outputs
[1]	1907	*/
	1908	char tmp1[100];
[55]	1909	sprintf(tmp1,"%f",res);
[26]	1910	setMapInMaps(outputs,"Area","value",tmp1);
	1911	setMapInMaps(outputs,"Area","dataType","float");
[1]	1912	#ifdef DEBUG
	1913	dumpMaps(outputs);
	1914	#endif
	1915	return SERVICE_SUCCEEDED;
	1916	}
	1917
	1918	}

Note: See TracBrowser for help on using the repository browser.

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links