service.c @ 616

Last change on this file since 616 was 499, checked in by djay, 10 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

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"
[491]	28
	29	#include "cpl_minixml.h"
	30	#include "ogr_api.h"
	31	#include "ogrsf_frmts.h"
	32
[9]	33	#include "geos_c.h"
[1]	34	#include "service.h"
[36]	35	#include "service_internal.h"
[1]	36
	37	extern "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);
[216]	50	char base64(const char input, int length);
[1]	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;
[491]	59	const char * xpathExpr="/////*[local-name()='Polygon' or local-name()='MultiPolygon']";
[1]	60	xpathCtx = xmlXPathNewContext(doc);
	61	xpathObj = xmlXPathEvalExpression(BAD_CAST xpathExpr,xpathCtx);
	62	if(!xpathObj->nodesetval){
[216]	63	setMapInMaps(conf,"lenv","message",_ss("Unable to parse Input Polygon"));
	64	setMapInMaps(conf,"lenv","code","InvalidParameterValue");
	65	return NULL;
[1]	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);
[9]	79	char tmp=(char)calloc((xmlStrlen(xmlStrstr(xmlbuff,BAD_CAST "?>"))-1),sizeof(char));
	80	sprintf(tmp,"%s",xmlStrstr(xmlbuff,BAD_CAST "?>")+2);
[1]	81	xmlXPathFreeObject(xpathObj);
[9]	82	xmlXPathFreeContext(xpathCtx);
[1]	83	xmlFree(xmlbuff);
	84	xmlFreeDoc(doc);
[9]	85	xmlFreeDoc(ndoc);
[216]	86	#ifndef WIN32
[1]	87	xmlCleanupParser();
[216]	88	#endif
[1]	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);
[9]	93	free(tmp);
[1]	94	if(res==NULL){
[36]	95	setMapInMaps(conf,"lenv","message",_ss("Unable to call OGR_G_CreatFromGML"));
[26]	96	return NULL;
[1]	97	}
	98	else
[26]	99	return res;
[1]	100	}
	101
[216]	102	#ifdef WIN32
	103	__declspec(dllexport)
	104	#endif
[9]	105	int Simplify(maps& conf,maps& inputs,maps*& outputs){
[497]	106	OGRRegisterAll();
	107
[9]	108	double tolerance;
[497]	109	map* tmp0=getMapFromMaps(inputs,"Tolerance","value");
[9]	110	if(tmp0==NULL){
	111	tolerance=atof("2.0");
[1]	112	}
[9]	113	else
	114	tolerance=atof(tmp0->value);
[497]	115
	116	maps* cursor=inputs;
	117	OGRGeometryH geometry;
	118	OGRGeometry *res;
	119	OGRLayer *poDstLayer;
	120	const char *oDriver1;
	121	OGRDataSource *poODS;
[1]	122	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
[26]	123	if(!tmp){
[36]	124	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[1]	125	return SERVICE_FAILED;
[26]	126	}
[497]	127	char filename[1024];
[26]	128	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
[497]	129	const char *oDriver;
	130	oDriver="GeoJSON";
	131	sprintf(filename,"/vsimem/input_%d.json",getpid());
[1]	132	if(tmp1!=NULL){
[497]	133	if(strcmp(tmp1->value,"text/xml")==0){
	134	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	135	oDriver="GML";
	136	}
[9]	137	}
[497]	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);
[216]	292	#endif
[497]	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);
[216]	313	#endif
[497]	314	}
	315	}
[1]	316	}
[497]	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();
[1]	328	return SERVICE_SUCCEEDED;
	329
[497]	330	}
[1]	331
[491]	332	int applyOne(maps& conf,maps& inputs,maps& outputs,OGRGeometry (OGRGeometry::myFunc)() const,const char schema){
	333	OGRRegisterAll();
	334
[1]	335	maps* cursor=inputs;
	336	OGRGeometryH geometry,res;
[491]	337	OGRLayer *poDstLayer;
	338	const char *oDriver1;
	339	OGRDataSource *poODS;
[9]	340	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
[35]	341	if(!tmp){
[36]	342	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[9]	343	return SERVICE_FAILED;
[35]	344	}
[491]	345	char filename[1024];
[9]	346	map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
[491]	347	const char *oDriver;
	348	oDriver="GeoJSON";
	349	sprintf(filename,"/vsimem/input_%d.json",getpid());
[9]	350	if(tmp1!=NULL){
[491]	351	if(strcmp(tmp1->value,"text/xml")==0){
	352	sprintf(filename,"/vsimem/input_%d.xml",getpid());
	353	oDriver="GML";
	354	}
[1]	355	}
[491]	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;
[1]	376	}
[491]	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
[1]	535	}
[491]	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();
[1]	547	return SERVICE_SUCCEEDED;
	548	}
	549
	550	#ifdef WIN32
	551	__declspec(dllexport)
	552	#endif
[9]	553	int Buffer(maps& conf,maps& inputs,maps*& outputs){
[491]	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	}
[497]	701
[491]	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
[9]	776	}
	777
[1]	778	#ifdef WIN32
	779	__declspec(dllexport)
	780	#endif
[9]	781	int Boundary(maps& conf,maps& inputs,maps*& outputs){
[491]	782	return applyOne(conf,inputs,outputs,&OGRGeometry::Boundary,"http://fooa/gml/3.1.0/polygon.xsd");
[9]	783	}
	784
	785	#ifdef WIN32
	786	__declspec(dllexport)
	787	#endif
	788	int ConvexHull(maps& conf,maps& inputs,maps*& outputs){
[491]	789	return applyOne(conf,inputs,outputs,&OGRGeometry::ConvexHull,"http://fooa/gml/3.1.0/polygon.xsd");
[9]	790	}
	791
	792
[491]	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	}
[9]	803	}
[491]	804	VSILFILE ifile=VSIFileFromMemBuffer(filename,(GByte*)tmp->value,strlen(tmp->value),FALSE);
	805	VSIFCloseL(ifile);
	806	return OGRSFDriverRegistrar::Open(*filename,FALSE);
[9]	807	}
	808
[491]	809	int applyOneBool(maps& conf,maps& inputs,maps& outputs,OGRBoolean (OGRGeometry::myFunc)() const){
[1]	810	#ifdef DEBUG
[491]	811	fprintf(stderr,"\nService internal print\n");
[216]	812	#endif
[491]	813	OGRRegisterAll();
[9]	814
[1]	815	maps* cursor=inputs;
[491]	816	OGRGeometryH geometry,res;
	817	OGRLayer *poDstLayer;
	818	const char *oDriver1;
	819	OGRDataSource *poODS;
[216]	820	#ifdef DEBUG
[491]	821	dumpMaps(cursor);
[216]	822	#endif
[491]	823	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	824	if(!tmp){
	825	setMapInMaps(conf,"lenv","message",_ss("Unable to parse the input geometry from InputPolygon"));
[26]	826	return SERVICE_FAILED;
	827	}
[491]	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)
[216]	905	#endif
[491]	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)
[216]	912	#endif
[491]	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){
[216]	926	#ifdef DEBUG
[491]	927	fprintf(stderr,"\nService internal print\n");
[216]	928	#endif
[491]	929	OGRRegisterAll();
	930
	931	maps* cursor=inputs;
	932	OGRGeometryH geometry,res;
	933	OGRLayer *poDstLayer;
	934	//const char *oDriver1;
	935	OGRDataSource *poODS;
[216]	936	#ifdef DEBUG
[491]	937	dumpMaps(cursor);
[216]	938	#endif
[491]	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;
[1]	968	}
[491]	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	{
[216]	1023	#ifdef DEBUG
[491]	1024	fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetName());
[216]	1025	#endif
[491]	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
[499]	1091	OGRFeatureDefn *poFDefn = poLayer2->GetLayerDefn();
[491]	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	}
[499]	1153	OGRFeature::DestroyFeature( poFeature1 );
[491]	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)
[26]	1165	return SERVICE_FAILED;
[491]	1166	setMapInMaps(outputs,"Result","value",res1);
	1167	free(res1);
	1168	OGRCleanupAll();
[1]	1169	return SERVICE_SUCCEEDED;
	1170	}
[9]	1171
	1172	#ifdef WIN32
	1173	__declspec(dllexport)
	1174	#endif
	1175	int Difference(maps& conf,maps& inputs,maps*& outputs){
[491]	1176	return applyTwo(conf,inputs,outputs,&OGRGeometry::Difference);
[9]	1177	}
[1]	1178
	1179	#ifdef WIN32
	1180	__declspec(dllexport)
	1181	#endif
[9]	1182	int SymDifference(maps& conf,maps& inputs,maps*& outputs){
[491]	1183	return applyTwo(conf,inputs,outputs,&OGRGeometry::SymDifference);
[9]	1184	}
	1185
	1186	#ifdef WIN32
	1187	__declspec(dllexport)
	1188	#endif
	1189	int Intersection(maps& conf,maps& inputs,maps*& outputs){
[491]	1190	return applyTwo(conf,inputs,outputs,&OGRGeometry::Intersection);
[9]	1191	}
	1192
	1193	#ifdef WIN32
	1194	__declspec(dllexport)
	1195	#endif
	1196	int Union(maps& conf,maps& inputs,maps*& outputs){
[491]	1197	return applyTwo(conf,inputs,outputs,&OGRGeometry::Union);
[9]	1198	}
	1199
[491]	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
[9]	1310	#ifdef WIN32
	1311	__declspec(dllexport)
	1312	#endif
[491]	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
[1]	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	}
[26]	1395	if(geometry1==NULL){
[36]	1396	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity1."));
[26]	1397	fprintf(stderr,"SERVICE FAILED !\n");
	1398	return SERVICE_FAILED;
	1399	}
[1]	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	}
[26]	1418	if(geometry2==NULL){
[36]	1419	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry for InputEntity2."));
[26]	1420	fprintf(stderr,"SERVICE FAILED !\n");
	1421	return SERVICE_FAILED;
	1422	}
	1423	res=OGR_G_Distance(geometry1,geometry2);
[1]	1424	char tmpres[100];
[55]	1425	sprintf(tmpres,"%f",res);
[26]	1426	setMapInMaps(outputs,"Distance","value",tmpres);
	1427	setMapInMaps(outputs,"Distance","dataType","float");
[1]	1428	#ifdef DEBUG
	1429	dumpMaps(outputs);
	1430	fprintf(stderr,"\nService internal print\n===\n");
	1431	#endif
	1432	return SERVICE_SUCCEEDED;
	1433	}
	1434
[9]	1435	#ifdef WIN32
	1436	__declspec(dllexport)
	1437	#endif
[1]	1438	int GetArea(maps& conf,maps& inputs,maps*& outputs){
	1439	fprintf(stderr,"GETAREA \n");
	1440	double res;
	1441	/**
[26]	1442	* Extract Geometry from the InputPolygon value
[1]	1443	*/
[26]	1444	OGRGeometryH geometry;
	1445	map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
	1446	if(tmp==NULL){
[36]	1447	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
[26]	1448	return SERVICE_FAILED;
	1449	}
[1]	1450	fprintf(stderr,"geometry creation %s \n",tmp->value);
[26]	1451	geometry=createGeometryFromGML(conf,tmp->value);
	1452	if(geometry==NULL){
[36]	1453	setMapInMaps(conf,"lenv","message",_ss("Unable to parse input geometry from InputPolygon"));
[26]	1454	return SERVICE_FAILED;
	1455	}
[1]	1456	fprintf(stderr,"geometry created %s \n",tmp->value);
[491]	1457	res=OGR_G_Area(geometry);
[1]	1458	fprintf(stderr,"area %d \n",res);
	1459	/**
[26]	1460	* Filling the outputs
[1]	1461	*/
	1462	char tmp1[100];
[55]	1463	sprintf(tmp1,"%f",res);
[26]	1464	setMapInMaps(outputs,"Area","value",tmp1);
	1465	setMapInMaps(outputs,"Area","dataType","float");
[1]	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.

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links