service.c @ 679

Last change on this file since 679 was 395, checked in by djay, 12 years ago
Upgrade ogr2ogr to follow new ogr2ogr original source code.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 45.0 KB

Rev	Line
[1]	1	/******************************************************************************
	2	* $Id: ogr2ogr.cpp 15473 2008-10-07 20:59:24Z warmerdam $
	3	*
	4	* Project: OpenGIS Simple Features Reference Implementation
	5	* Purpose: Simple client for translating between formats.
	6	* Author: Frank Warmerdam, warmerdam@pobox.com
	7	*
	8	******************************************************************************
	9	* Copyright (c) 1999, Frank Warmerdam
	10	*
	11	* Permission is hereby granted, free of charge, to any person obtaining a
	12	* copy of this software and associated documentation files (the "Software"),
	13	* to deal in the Software without restriction, including without limitation
	14	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	15	* and/or sell copies of the Software, and to permit persons to whom the
	16	* Software is furnished to do so, subject to the following conditions:
	17	*
	18	* The above copyright notice and this permission notice shall be included
	19	* in all copies or substantial portions of the Software.
	20	*
	21	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	22	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	23	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	24	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	25	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	26	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	27	* DEALINGS IN THE SOFTWARE.
	28	****************************************************************************/
	29
	30	#include "ogrsf_frmts.h"
	31	#include "ogr_p.h"
	32	#include "cpl_conv.h"
	33	#include "cpl_string.h"
	34	#include "ogr_api.h"
	35	#ifdef ZOO_SERVICE
	36	#include "service.h"
	37	#endif
	38
	39	CPL_CVSID("$Id: ogr2ogr.cpp 15473 2008-10-07 20:59:24Z warmerdam $");
	40
[395]	41	#ifdef WIN32
	42	#define strcasecmp _stricmp
	43	#define strncasecmp _strnicmp
	44	#endif
	45
[1]	46	#ifdef ZOO_SERVICE
	47	extern "C" {
	48	#endif
	49
	50	static void Usage();
	51
	52	static int TranslateLayer( OGRDataSource *poSrcDS,
	53	OGRLayer * poSrcLayer,
	54	OGRDataSource *poDstDS,
	55	char ** papszLSCO,
	56	const char *pszNewLayerName,
	57	int bTransform,
	58	OGRSpatialReference *poOutputSRS,
	59	OGRSpatialReference *poSourceSRS,
	60	char **papszSelFields,
	61	int bAppend, int eGType,
	62	int bOverwrite,
	63	double dfMaxSegmentLength);
	64
	65	static int bSkipFailures = FALSE;
	66	static int nGroupTransactions = 200;
[395]	67	static int bPreserveFID = TRUE;
[1]	68	static int nFIDToFetch = OGRNullFID;
	69
	70	/************************************************************************/
	71	/* main() */
	72	/************************************************************************/
	73
	74	#ifdef ZOO_SERVICE
	75	#ifdef WIN32
	76	__declspec(dllexport)
	77	#endif
	78	int Ogr2Ogr(maps& conf,maps& inputs,maps*& outputs)
	79	#else
	80	int main( int nArgc, char ** papszArgv )
	81	#endif
	82	{
	83	const char *pszFormat = "ESRI Shapefile";
	84	const char *pszDataSource = NULL;
	85	const char *pszDestDataSource = NULL;
[49]	86	const char *pszwebDestData = NULL;
[1]	87	char **papszLayers = NULL;
	88	char papszDSCO = NULL, papszLCO = NULL;
	89	int bTransform = FALSE;
	90	int bAppend = FALSE, bUpdate = FALSE, bOverwrite = FALSE;
	91	const char *pszOutputSRSDef = NULL;
	92	const char *pszSourceSRSDef = NULL;
	93	OGRSpatialReference *poOutputSRS = NULL;
	94	OGRSpatialReference *poSourceSRS = NULL;
	95	const char *pszNewLayerName = NULL;
	96	const char *pszWHERE = NULL;
	97	OGRGeometry *poSpatialFilter = NULL;
	98	const char *pszSelect;
	99	char **papszSelFields = NULL;
	100	const char *pszSQLStatement = NULL;
	101	int eGType = -2;
[252]	102	double dfMaxSegmentLength = 0;
[1]	103
[395]	104	#ifdef ZOO_SERVICE
	105	dumpMaps(inputs);
	106	#endif
[1]	107	/* Check strict compilation and runtime library version as we use C++ API */
	108	if (! GDAL_CHECK_VERSION("ogr2ogr"))
	109	#ifdef ZOO_SERVICE
	110	{
	111	fprintf(stderr,"Not correct version of the gdal library\n");
[38]	112	setMapInMaps(conf,"lenv","message","Unable to check gdal version for ogr2ogr_service.zo");
[1]	113	return SERVICE_FAILED;
	114	}
	115	#else
	116	exit(1);
	117	#endif
	118	/* -------------------------------------------------------------------- */
	119	/* Register format(s). */
	120	/* -------------------------------------------------------------------- */
	121	OGRRegisterAll();
	122
	123	#ifdef ZOO_SERVICE
[40]	124	map *tmpMap=NULL;
[1]	125	char dataPath[1024];
	126	tmpMap=getMapFromMaps(conf,"main","dataPath");
	127	if(tmpMap!=NULL)
	128	sprintf(dataPath,"%s",tmpMap->value);
	129	tmpMap=NULL;
	130	char tempPath[1024];
	131	tmpMap=getMapFromMaps(conf,"main","tmpPath");
	132	if(tmpMap!=NULL){
	133	sprintf(tempPath,"%s",tmpMap->value);
	134	}
[49]	135
	136	tmpMap=NULL;
	137	char serverAddress[1024];
	138	tmpMap=getMapFromMaps(conf,"main","serverAddress");
	139	if(tmpMap!=NULL){
	140	sprintf(serverAddress,"%s",tmpMap->value);
	141	}
	142
	143	tmpMap=NULL;
	144	char tmpurl[1024];
	145	tmpMap=getMapFromMaps(conf,"main","tmpurl");
	146	if(tmpMap!=NULL){
	147	sprintf(tmpurl,"%s",tmpMap->value);
	148	}
[1]	149
[40]	150	tmpMap=NULL;
[1]	151	tmpMap=getMapFromMaps(inputs,"F","value");
[395]	152	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	153	pszFormat=tmpMap->value;
	154	}
	155
[40]	156	tmpMap=NULL;
[1]	157	tmpMap=getMapFromMaps(inputs,"DSCO","value");
[395]	158	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	159	papszDSCO = CSLAddString(papszDSCO, tmpMap->value );
	160	}
	161
[40]	162	tmpMap=NULL;
[1]	163	tmpMap=getMapFromMaps(inputs,"LCO","value");
[395]	164	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	165	papszLCO = CSLAddString(papszLCO, tmpMap->value );
	166	}
	167
[40]	168	tmpMap=NULL;
[1]	169	tmpMap=getMapFromMaps(inputs,"preserve_fid","value");
[395]	170	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	171	bPreserveFID = TRUE;
	172	}
	173
[40]	174	tmpMap=NULL;
[1]	175	tmpMap=getMapFromMaps(inputs,"skipfailure","value");
[395]	176	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	177	bSkipFailures = TRUE;
	178	nGroupTransactions = 1; /* #2409 */
[40]	179	}
[1]	180
[395]	181	/* if exist, overwrite the data with the same name */
[40]	182	tmpMap=NULL;
[395]	183	tmpMap=getMapFromMaps(inputs,"overwrite","value");
	184	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	185	bOverwrite = TRUE;
	186	}
	187
	188	tmpMap=NULL;
[1]	189	tmpMap=getMapFromMaps(inputs,"append","value");
[395]	190	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"TRUE",4)==0){
	191	bAppend = TRUE;
[40]	192	}
[1]	193
[40]	194	tmpMap=NULL;
[1]	195	tmpMap=getMapFromMaps(inputs,"update","value");
[395]	196	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"TRUE",4)==0){
	197	bUpdate = TRUE;
[40]	198	}
[1]	199
[40]	200	tmpMap=NULL;
[1]	201	tmpMap=getMapFromMaps(inputs,"fid","value");
[395]	202	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	203	nFIDToFetch = atoi(tmpMap->value);
[40]	204	}
[1]	205
[40]	206	tmpMap=NULL;
[1]	207	tmpMap=getMapFromMaps(inputs,"sql","value");
[395]	208	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	209	pszSQLStatement = tmpMap->value;
[40]	210	}
[1]	211
[40]	212	tmpMap=NULL;
[1]	213	tmpMap=getMapFromMaps(inputs,"nln","value");
[395]	214	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	215	pszNewLayerName = tmpMap->value;
[40]	216	}
[1]	217
[40]	218	tmpMap=NULL;
[1]	219	tmpMap=getMapFromMaps(inputs,"nlt","value");
[395]	220	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	221	pszNewLayerName = tmpMap->value;
	222	if( EQUAL(tmpMap->value,"NONE") )
	223	eGType = wkbNone;
	224	else if( EQUAL(tmpMap->value,"GEOMETRY") )
	225	eGType = wkbUnknown;
	226	else if( EQUAL(tmpMap->value,"POINT") )
	227	eGType = wkbPoint;
	228	else if( EQUAL(tmpMap->value,"LINESTRING") )
	229	eGType = wkbLineString;
	230	else if( EQUAL(tmpMap->value,"POLYGON") )
	231	eGType = wkbPolygon;
	232	else if( EQUAL(tmpMap->value,"GEOMETRYCOLLECTION") )
	233	eGType = wkbGeometryCollection;
	234	else if( EQUAL(tmpMap->value,"MULTIPOINT") )
	235	eGType = wkbMultiPoint;
	236	else if( EQUAL(tmpMap->value,"MULTILINESTRING") )
	237	eGType = wkbMultiLineString;
	238	else if( EQUAL(tmpMap->value,"MULTIPOLYGON") )
	239	eGType = wkbMultiPolygon;
	240	else if( EQUAL(tmpMap->value,"GEOMETRY25D") )
	241	eGType = wkbUnknown \| wkb25DBit;
	242	else if( EQUAL(tmpMap->value,"POINT25D") )
	243	eGType = wkbPoint25D;
	244	else if( EQUAL(tmpMap->value,"LINESTRING25D") )
	245	eGType = wkbLineString25D;
	246	else if( EQUAL(tmpMap->value,"POLYGON25D") )
	247	eGType = wkbPolygon25D;
	248	else if( EQUAL(tmpMap->value,"GEOMETRYCOLLECTION25D") )
	249	eGType = wkbGeometryCollection25D;
	250	else if( EQUAL(tmpMap->value,"MULTIPOINT25D") )
	251	eGType = wkbMultiPoint25D;
	252	else if( EQUAL(tmpMap->value,"MULTILINESTRING25D") )
	253	eGType = wkbMultiLineString25D;
	254	else if( EQUAL(tmpMap->value,"MULTIPOLYGON25D") )
	255	eGType = wkbMultiPolygon25D;
	256	else
	257	{
	258	fprintf( stderr, "-nlt %s: type not recognised.\n",
	259	tmpMap->value );
	260	exit( 1 );
	261	}
[40]	262	}
[1]	263
[40]	264	tmpMap=NULL;
[1]	265	tmpMap=getMapFromMaps(inputs,"tg","value");
[395]	266	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	267	nGroupTransactions = atoi(tmpMap->value);
[40]	268	}
[1]	269
[40]	270	tmpMap=NULL;
[1]	271	tmpMap=getMapFromMaps(inputs,"s_srs","value");
[395]	272	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	273	pszSourceSRSDef = strdup(tmpMap->value);
[40]	274	}
[1]	275
[40]	276	tmpMap=NULL;
[1]	277	tmpMap=getMapFromMaps(inputs,"a_srs","value");
[395]	278	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	279	pszOutputSRSDef = strdup(tmpMap->value);
[40]	280	}
[1]	281
[40]	282	tmpMap=NULL;
[1]	283	tmpMap=getMapFromMaps(inputs,"t_srs","value");
[395]	284	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	285	pszOutputSRSDef = strdup(tmpMap->value);
	286	bTransform = TRUE;
[40]	287	}
[1]	288
[40]	289	tmpMap=NULL;
[1]	290	tmpMap=getMapFromMaps(inputs,"SPAT","value");
[395]	291	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	292	char *tmp=tmpMap->value;
	293	char *t=strtok(tmp,",");
	294	int cnt=0;
	295	double dfULX, dfULY, dfLRX, dfLRY;
	296	while(t!=NULL){
	297	switch(cnt){
	298	case 0:
	299	dfULX = atof(t);
	300	break;
	301	case 1:
	302	dfULY = atof(t);
	303	break;
	304	case 2:
	305	dfLRX = atof(t);
	306	break;
	307	case 3:
	308	dfLRY = atof(t);
	309	break;
	310	}
	311	fprintf(stderr,"%s\n\n",t);
	312	fprintf(stderr,"%f - %f - %f - %f\n\n",dfULX,dfULY,dfLRX,dfLRY);
	313	t=strtok(NULL,",");
	314	cnt++;
	315	}
	316
[40]	317	OGRLinearRing oRing;
	318
	319	oRing.addPoint( dfULX, dfULY );
	320	oRing.addPoint( dfULX, dfLRY );
	321	oRing.addPoint( dfLRX, dfLRY );
	322	oRing.addPoint( dfLRX, dfULY );
	323	oRing.addPoint( dfULX, dfULY );
	324	poSpatialFilter = new OGRPolygon();
	325	((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
	326	}
[1]	327
[40]	328	tmpMap=NULL;
[1]	329	tmpMap=getMapFromMaps(inputs,"where","value");
[395]	330	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	331	pszWHERE = tmpMap->value;
[40]	332	}
[1]	333
[40]	334	tmpMap=NULL;
[1]	335	tmpMap=getMapFromMaps(inputs,"select","value");
[395]	336	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	337	pszSelect = tmpMap->value;
	338	papszSelFields = CSLTokenizeStringComplex(pszSelect, " ,",
	339	FALSE, FALSE );
[40]	340	}
[1]	341
[40]	342	tmpMap=NULL;
[1]	343	tmpMap=getMapFromMaps(inputs,"segmentize","value");
[395]	344	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
[1]	345	dfMaxSegmentLength = atof(tmpMap->value);
[40]	346	}
[1]	347
[395]	348	/*tmpMap=NULL;
[1]	349	tmpMap=getMapFromMaps(inputs,"segmentize","value");
	350	if(tmpMap!=NULL){
	351	dfMaxSegmentLength = atof(tmpMap->value);
[395]	352	}*/
[1]	353
	354	tmpMap=NULL;
	355	tmpMap=getMapFromMaps(inputs,"InputDSN","value");
[395]	356	if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
	357	if(strncasecmp(tmpMap->value,"PG",2)!=0 &&
	358	strncasecmp(tmpMap->value,"My",2)!=0 &&
	359	strncasecmp(tmpMap->value,"OCI",3)!=0 ){
	360	if(strncasecmp(dataPath,tmpMap->value,strlen(dataPath))==0 \|\|
	361	strncasecmp(tempPath,tmpMap->value,strlen(tempPath))==0){
	362	pszDataSource=strdup(tmpMap->value);
	363	}else{
	364	pszDataSource=(char)malloc(sizeof(char)(strlen(dataPath)+strlen(tmpMap->value)+2));
	365	sprintf((char*)pszDataSource,"%s/%s",dataPath,tmpMap->value);
	366	}
	367	}else{
	368	pszDataSource=(char)malloc(sizeof(char)(strlen(tmpMap->value)+1));
	369	sprintf((char*)pszDataSource,"%s",tmpMap->value);
	370	}
[1]	371	}
	372
	373	tmpMap=NULL;
	374	tmpMap=getMapFromMaps(inputs,"OutputDSN","value");
	375	if(tmpMap!=NULL){
[395]	376	if(strncasecmp(tmpMap->value,"PG",2)!=0 &&
	377	strncasecmp(tmpMap->value,"MY",2)!=0 &&
	378	strncasecmp(tmpMap->value,"OCI",3)!=0){
	379	pszDestDataSource=(char)malloc(sizeof(char)(strlen(tempPath)+strlen(tmpMap->value)+4));
	380	sprintf((char)pszDestDataSource,"%s/%s",tempPath,tmpMap->value/,ext*/);
	381	pszwebDestData=(char)malloc(sizeof(char)(strlen(serverAddress)+strlen(tmpurl)+strlen(tmpMap->value)+4));
	382	sprintf((char)pszwebDestData,"%s%s/%s",serverAddress,tmpurl,tmpMap->value/,ext*/);
	383	}
	384	else{
	385	pszDestDataSource=(char)malloc(sizeof(char)(strlen(tmpMap->value)+1));
	386	sprintf((char)pszDestDataSource,"%s",tmpMap->value/,ext*/);
	387	pszwebDestData=(char)malloc(sizeof(char)(strlen(serverAddress)+strlen(tmpurl)+strlen(tmpMap->value)+4));
	388	sprintf((char)pszwebDestData,"%s%s/%s",serverAddress,tmpurl,tmpMap->value/,ext*/);
	389	}
[1]	390	}
	391
[395]	392	fprintf(stderr,"Message %s\n",pszDestDataSource);
[1]	393	#else
	394	/* -------------------------------------------------------------------- */
	395	/* Processing command line arguments. */
	396	/* -------------------------------------------------------------------- */
	397	nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
	398
	399	if( nArgc < 1 )
	400	exit( -nArgc );
	401
	402	for( int iArg = 1; iArg < nArgc; iArg++ )
	403	{
	404	if( EQUAL(papszArgv[iArg], "--utility_version") )
	405	{
	406	printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
	407	papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
	408	return 0;
	409	}
	410	else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 )
	411	{
	412	pszFormat = papszArgv[++iArg];
	413	}
	414	else if( EQUAL(papszArgv[iArg],"-dsco") && iArg < nArgc-1 )
	415	{
	416	papszDSCO = CSLAddString(papszDSCO, papszArgv[++iArg] );
	417	}
	418	else if( EQUAL(papszArgv[iArg],"-lco") && iArg < nArgc-1 )
	419	{
	420	papszLCO = CSLAddString(papszLCO, papszArgv[++iArg] );
	421	}
	422	else if( EQUAL(papszArgv[iArg],"-preserve_fid") )
	423	{
	424	bPreserveFID = TRUE;
	425	}
	426	else if( EQUALN(papszArgv[iArg],"-skip",5) )
	427	{
	428	bSkipFailures = TRUE;
	429	nGroupTransactions = 1; /* #2409 */
	430	}
	431	else if( EQUAL(papszArgv[iArg],"-append") )
	432	{
	433	bAppend = TRUE;
	434	}
	435	else if( EQUAL(papszArgv[iArg],"-overwrite") )
	436	{
	437	bOverwrite = TRUE;
	438	}
	439	else if( EQUAL(papszArgv[iArg],"-update") )
	440	{
	441	bUpdate = TRUE;
	442	}
	443	else if( EQUAL(papszArgv[iArg],"-fid") && papszArgv[iArg+1] != NULL )
	444	{
	445	nFIDToFetch = atoi(papszArgv[++iArg]);
	446	}
	447	else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL )
	448	{
	449	pszSQLStatement = papszArgv[++iArg];
	450	}
	451	else if( EQUAL(papszArgv[iArg],"-nln") && iArg < nArgc-1 )
	452	{
	453	pszNewLayerName = papszArgv[++iArg];
	454	}
	455	else if( EQUAL(papszArgv[iArg],"-nlt") && iArg < nArgc-1 )
	456	{
	457	if( EQUAL(papszArgv[iArg+1],"NONE") )
	458	eGType = wkbNone;
	459	else if( EQUAL(papszArgv[iArg+1],"GEOMETRY") )
	460	eGType = wkbUnknown;
	461	else if( EQUAL(papszArgv[iArg+1],"POINT") )
	462	eGType = wkbPoint;
	463	else if( EQUAL(papszArgv[iArg+1],"LINESTRING") )
	464	eGType = wkbLineString;
	465	else if( EQUAL(papszArgv[iArg+1],"POLYGON") )
	466	eGType = wkbPolygon;
	467	else if( EQUAL(papszArgv[iArg+1],"GEOMETRYCOLLECTION") )
	468	eGType = wkbGeometryCollection;
	469	else if( EQUAL(papszArgv[iArg+1],"MULTIPOINT") )
	470	eGType = wkbMultiPoint;
	471	else if( EQUAL(papszArgv[iArg+1],"MULTILINESTRING") )
	472	eGType = wkbMultiLineString;
	473	else if( EQUAL(papszArgv[iArg+1],"MULTIPOLYGON") )
	474	eGType = wkbMultiPolygon;
	475	else if( EQUAL(papszArgv[iArg+1],"GEOMETRY25D") )
	476	eGType = wkbUnknown \| wkb25DBit;
	477	else if( EQUAL(papszArgv[iArg+1],"POINT25D") )
	478	eGType = wkbPoint25D;
	479	else if( EQUAL(papszArgv[iArg+1],"LINESTRING25D") )
	480	eGType = wkbLineString25D;
	481	else if( EQUAL(papszArgv[iArg+1],"POLYGON25D") )
	482	eGType = wkbPolygon25D;
	483	else if( EQUAL(papszArgv[iArg+1],"GEOMETRYCOLLECTION25D") )
	484	eGType = wkbGeometryCollection25D;
	485	else if( EQUAL(papszArgv[iArg+1],"MULTIPOINT25D") )
	486	eGType = wkbMultiPoint25D;
	487	else if( EQUAL(papszArgv[iArg+1],"MULTILINESTRING25D") )
	488	eGType = wkbMultiLineString25D;
	489	else if( EQUAL(papszArgv[iArg+1],"MULTIPOLYGON25D") )
	490	eGType = wkbMultiPolygon25D;
	491	else
	492	{
	493	fprintf( stderr, "-nlt %s: type not recognised.\n",
	494	papszArgv[iArg+1] );
	495	exit( 1 );
	496	}
	497	iArg++;
	498	}
	499	else if( (EQUAL(papszArgv[iArg],"-tg") \|\|
	500	EQUAL(papszArgv[iArg],"-gt")) && iArg < nArgc-1 )
	501	{
	502	nGroupTransactions = atoi(papszArgv[++iArg]);
	503	}
	504	else if( EQUAL(papszArgv[iArg],"-s_srs") && iArg < nArgc-1 )
	505	{
	506	pszSourceSRSDef = papszArgv[++iArg];
	507	}
	508	else if( EQUAL(papszArgv[iArg],"-a_srs") && iArg < nArgc-1 )
	509	{
	510	pszOutputSRSDef = papszArgv[++iArg];
	511	}
	512	else if( EQUAL(papszArgv[iArg],"-t_srs") && iArg < nArgc-1 )
	513	{
	514	pszOutputSRSDef = papszArgv[++iArg];
	515	bTransform = TRUE;
	516	}
	517	else if( EQUAL(papszArgv[iArg],"-spat")
	518	&& papszArgv[iArg+1] != NULL
	519	&& papszArgv[iArg+2] != NULL
	520	&& papszArgv[iArg+3] != NULL
	521	&& papszArgv[iArg+4] != NULL )
	522	{
	523	OGRLinearRing oRing;
	524
	525	oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
	526	oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
	527	oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
	528	oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
	529	oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
	530
	531	poSpatialFilter = new OGRPolygon();
	532	((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
	533	iArg += 4;
	534	}
	535	else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
	536	{
	537	pszWHERE = papszArgv[++iArg];
	538	}
	539	else if( EQUAL(papszArgv[iArg],"-select") && papszArgv[iArg+1] != NULL)
	540	{
	541	pszSelect = papszArgv[++iArg];
	542	papszSelFields = CSLTokenizeStringComplex(pszSelect, " ,",
	543	FALSE, FALSE );
	544	}
	545	else if( EQUAL(papszArgv[iArg],"-segmentize") && iArg < nArgc-1 )
	546	{
	547	dfMaxSegmentLength = atof(papszArgv[++iArg]);
	548	}
	549	else if( papszArgv[iArg][0] == '-' )
	550	{
	551	Usage();
	552	}
	553	else if( pszDestDataSource == NULL )
	554	pszDestDataSource = papszArgv[iArg];
	555	else if( pszDataSource == NULL )
	556	pszDataSource = papszArgv[iArg];
	557	else
	558	papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
	559	}
	560	#endif
	561
	562	if( pszDataSource == NULL )
	563	#ifdef ZOO_SERVICE
	564	{
[395]	565	#else
	566	Usage();
[1]	567	#endif
	568	#ifdef ZOO_SERVICE
[39]	569	setMapInMaps(conf,"lenv","message","Wrong parameter");
	570	return SERVICE_FAILED;
[1]	571	}
	572	#endif
	573
	574	/* -------------------------------------------------------------------- */
	575	/* Open data source. */
	576	/* -------------------------------------------------------------------- */
	577	OGRDataSource *poDS;
	578
	579	poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE );
	580
	581	/* -------------------------------------------------------------------- */
	582	/* Report failure */
	583	/* -------------------------------------------------------------------- */
	584	if( poDS == NULL )
	585	{
	586	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	587
	588	fprintf( stderr, "FAILURE:\n"
	589	"Unable to open datasource `%s' with the following drivers.\n",
	590	pszDataSource );
	591
	592	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	593	{
	594	fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetName() );
	595	}
	596	#ifdef ZOO_SERVICE
[39]	597	char tmp[1024];
	598	sprintf(tmp,"Unable to open datasource `%s' with the following drivers.",pszDataSource);
	599	setMapInMaps(conf,"lenv","message",tmp);
	600	return SERVICE_FAILED;
[1]	601	#else
	602	exit( 1 );
	603	#endif
	604	}
	605
	606	/* -------------------------------------------------------------------- */
	607	/* Try opening the output datasource as an existing, writable */
	608	/* -------------------------------------------------------------------- */
	609	OGRDataSource *poODS;
	610
	611	if( bUpdate )
	612	{
	613	poODS = OGRSFDriverRegistrar::Open( pszDestDataSource, TRUE );
	614	if( poODS == NULL )
	615	{
	616	fprintf( stderr, "FAILURE:\n"
	617	"Unable to open existing output datasource `%s'.\n",
	618	pszDestDataSource );
	619	#ifdef ZOO_SERVICE
[39]	620	char tmp[1024];
	621	sprintf(tmp,"Unable to open existing output datasource `%s'.",pszDestDataSource);
	622	setMapInMaps(conf,"lenv","message",tmp);
	623	return SERVICE_FAILED;
[1]	624	#else
	625	exit( 1 );
	626	#endif
	627	}
	628
	629	if( CSLCount(papszDSCO) > 0 )
	630	{
	631	fprintf( stderr, "WARNING: Datasource creation options ignored since an existing datasource\n"
	632	" being updated.\n" );
	633	}
	634	}
	635
	636	/* -------------------------------------------------------------------- */
	637	/* Find the output driver. */
	638	/* -------------------------------------------------------------------- */
	639	else
	640	{
	641	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	642	OGRSFDriver *poDriver = NULL;
	643	int iDriver;
	644
	645	for( iDriver = 0;
	646	iDriver < poR->GetDriverCount() && poDriver == NULL;
	647	iDriver++ )
	648	{
	649	if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) )
	650	{
	651	poDriver = poR->GetDriver(iDriver);
	652	}
	653	}
	654
	655	if( poDriver == NULL )
	656	{
	657	fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat );
	658	fprintf( stderr, "The following drivers are available:\n" );
	659
	660	for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	661	{
	662	fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() );
	663	}
	664	#ifdef ZOO_SERVICE
[39]	665	char tmp[1024];
	666	sprintf(tmp,"Unable to find driver `%s'.",pszFormat);
	667	setMapInMaps(conf,"lenv","message",tmp);
	668	return SERVICE_FAILED;
[1]	669	#else
	670	exit( 1 );
	671	#endif
	672	}
	673
	674	if( !poDriver->TestCapability( ODrCCreateDataSource ) )
	675	{
	676	fprintf( stderr, "%s driver does not support data source creation.\n",
	677	pszFormat );
	678	#ifdef ZOO_SERVICE
[39]	679	char tmp[1024];
	680	sprintf(tmp,"%s driver does not support data source creation.",pszFormat);
	681	setMapInMaps(conf,"lenv","message",tmp);
	682	return SERVICE_FAILED;
[1]	683	#else
	684	exit( 1 );
	685	#endif
	686	}
	687
	688	/* -------------------------------------------------------------------- */
	689	/* Create the output data source. */
	690	/* -------------------------------------------------------------------- */
	691	poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
	692	if( poODS == NULL )
	693	{
	694	fprintf( stderr, "%s driver failed to create %s\n",
	695	pszFormat, pszDestDataSource );
	696	#ifdef ZOO_SERVICE
[39]	697	char tmp[1024];
	698	sprintf(tmp,"%s driver failed to create %s",pszFormat, pszDestDataSource);
	699	setMapInMaps(conf,"lenv","message",tmp);
	700	return SERVICE_FAILED;
[1]	701	#else
	702	exit( 1 );
	703	#endif
	704	}
	705	}
	706
	707	/* -------------------------------------------------------------------- */
	708	/* Parse the output SRS definition if possible. */
	709	/* -------------------------------------------------------------------- */
	710	if( pszOutputSRSDef != NULL )
	711	{
	712	poOutputSRS = new OGRSpatialReference();
	713	if( poOutputSRS->SetFromUserInput( pszOutputSRSDef ) != OGRERR_NONE )
	714	{
	715	fprintf( stderr, "Failed to process SRS definition: %s\n",
	716	pszOutputSRSDef );
	717	#ifdef ZOO_SERVICE
[39]	718	char tmp[1024];
	719	sprintf(tmp,"Failed to process SRS definition: %s",pszOutputSRSDef);
	720	setMapInMaps(conf,"lenv","message",tmp);
	721	return SERVICE_FAILED;
[1]	722	#else
	723	exit( 1 );
	724	#endif
	725	}
	726	}
	727
	728	/* -------------------------------------------------------------------- */
	729	/* Parse the source SRS definition if possible. */
	730	/* -------------------------------------------------------------------- */
	731	if( pszSourceSRSDef != NULL )
	732	{
	733	poSourceSRS = new OGRSpatialReference();
	734	if( poSourceSRS->SetFromUserInput( pszSourceSRSDef ) != OGRERR_NONE )
	735	{
	736	fprintf( stderr, "Failed to process SRS definition: %s\n",
	737	pszSourceSRSDef );
	738	#ifdef ZOO_SERVICE
[39]	739	char tmp[1024];
	740	sprintf(tmp,"Failed to process SRS definition: %s",pszOutputSRSDef);
	741	setMapInMaps(conf,"lenv","message",tmp);
	742	return SERVICE_FAILED;
[1]	743	#else
	744	exit( 1 );
	745	#endif
	746	}
	747	}
	748
	749	/* -------------------------------------------------------------------- */
	750	/* Special case for -sql clause. No source layers required. */
	751	/* -------------------------------------------------------------------- */
	752	if( pszSQLStatement != NULL )
	753	{
	754	OGRLayer *poResultSet;
	755
	756	if( pszWHERE != NULL )
	757	fprintf( stderr, "-where clause ignored in combination with -sql.\n" );
	758	if( CSLCount(papszLayers) > 0 )
[395]	759	fprintf( stderr, "layer names ignored in combination with -sql. (%s)\n", pszSQLStatement);
[1]	760
	761	poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
	762	NULL );
	763
	764	if( poResultSet != NULL )
	765	{
	766	if( !TranslateLayer( poDS, poResultSet, poODS, papszLCO,
	767	pszNewLayerName, bTransform, poOutputSRS,
	768	poSourceSRS, papszSelFields, bAppend, eGType,
	769	bOverwrite, dfMaxSegmentLength ))
	770	{
	771	CPLError( CE_Failure, CPLE_AppDefined,
	772	"Terminating translation prematurely after failed\n"
	773	"translation from sql statement." );
	774
	775	exit( 1 );
	776	}
	777	poDS->ReleaseResultSet( poResultSet );
	778	}
	779	}
	780
	781	/* -------------------------------------------------------------------- */
	782	/* Process each data source layer. */
	783	/* -------------------------------------------------------------------- */
	784	for( int iLayer = 0;
	785	pszSQLStatement == NULL && iLayer < poDS->GetLayerCount();
	786	iLayer++ )
	787	{
	788	OGRLayer *poLayer = poDS->GetLayer(iLayer);
	789
	790	if( poLayer == NULL )
	791	{
	792	fprintf( stderr, "FAILURE: Couldn't fetch advertised layer %d!\n",
	793	iLayer );
	794	#ifdef ZOO_SERVICE
[39]	795	char tmp[1024];
	796	sprintf(tmp,"Couldn't fetch advertised layer %d!",iLayer);
	797	setMapInMaps(conf,"lenv","message",tmp);
	798	return SERVICE_FAILED;
[1]	799	#else
[39]	800	exit( 1 );
[1]	801	#endif
	802	}
	803
	804	if( CSLCount(papszLayers) == 0
	805	\|\| CSLFindString( papszLayers,
	806	poLayer->GetLayerDefn()->GetName() ) != -1 )
	807	{
	808	if( pszWHERE != NULL )
	809	poLayer->SetAttributeFilter( pszWHERE );
	810
	811	if( poSpatialFilter != NULL )
	812	poLayer->SetSpatialFilter( poSpatialFilter );
	813
	814	if( !TranslateLayer( poDS, poLayer, poODS, papszLCO,
	815	pszNewLayerName, bTransform, poOutputSRS,
	816	poSourceSRS, papszSelFields, bAppend, eGType,
	817	bOverwrite, dfMaxSegmentLength )
	818	&& !bSkipFailures )
	819	{
	820	#ifdef ZOO_SERVICE
[39]	821	char tmp[1024];
	822	sprintf(tmp,"Terminating translation prematurely after failed of layer %s",poLayer->GetLayerDefn()->GetName() );
	823	setMapInMaps(conf,"lenv","message",tmp);
	824	return SERVICE_FAILED;
[1]	825	#else
[395]	826	CPLError( CE_Failure, CPLE_AppDefined,
	827	"Terminating translation prematurely after failed\n"
	828	"translation of layer %s (use -skipfailures to skip errors)\n",
	829	poLayer->GetLayerDefn()->GetName() );
	830
[1]	831	exit( 1 );
	832	#endif
	833	}
	834	}
	835	}
	836
[395]	837	#ifdef ZOO_SERVICE
	838	outputs->content=createMap("value",(char*)pszwebDestData);
	839	#endif
	840
[1]	841	/* -------------------------------------------------------------------- */
	842	/* Close down. */
	843	/* -------------------------------------------------------------------- */
[395]	844	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	845	delete poOutputSRS;
[395]	846	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	847	delete poSourceSRS;
[395]	848	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	849	delete poODS;
[395]	850	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	851	delete poDS;
[395]	852	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	853
[395]	854	#ifndef ZOO_SERVICE
[1]	855	CSLDestroy(papszSelFields);
[395]	856	CSLDestroy( papszArgv );
[1]	857	#endif
[395]	858	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	859	CSLDestroy( papszLayers );
[395]	860	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
	861	#ifndef ZOO_SERVICE
[1]	862	CSLDestroy( papszDSCO );
	863	CSLDestroy( papszLCO );
[395]	864	#endif
	865	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	866
	867	OGRCleanupAll();
[395]	868	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	869
	870	#ifdef DBMALLOC
	871	malloc_dump(1);
	872	#endif
[395]	873	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
[1]	874
	875	#ifdef ZOO_SERVICE
	876	return SERVICE_SUCCEEDED;
	877	#else
[395]	878	return 0;
[1]	879	#endif
	880	}
	881
	882	/************************************************************************/
	883	/* Usage() */
	884	/************************************************************************/
	885
	886	static void Usage()
	887
	888	{
	889	OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
	890
	891	#ifdef ZOO_SERVICE
	892	fprintf(stderr,
	893	#else
	894	printf(
	895	#endif
	896	"Usage: ogr2ogr [--help-general] [-skipfailures] [-append] [-update] [-gt n]\n"
	897	" [-select field_list] [-where restricted_where] \n"
	898	" [-sql <sql statement>] \n"
	899	" [-spat xmin ymin xmax ymax] [-preserve_fid] [-fid FID]\n"
	900	" [-a_srs srs_def] [-t_srs srs_def] [-s_srs srs_def]\n"
	901	" [-f format_name] [-overwrite] [[-dsco NAME=VALUE] ...]\n"
	902	" [-segmentize max_dist]\n"
	903	" dst_datasource_name src_datasource_name\n"
	904	" [-lco NAME=VALUE] [-nln name] [-nlt type] [layer [layer ...]]\n"
	905	"\n"
	906	" -f format_name: output file format name, possible values are:\n");
	907
	908	for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
	909	{
	910	OGRSFDriver *poDriver = poR->GetDriver(iDriver);
	911
	912	if( poDriver->TestCapability( ODrCCreateDataSource ) )
	913	printf( " -f \"%s\"\n", poDriver->GetName() );
	914	}
	915
	916	#ifdef ZOO_SERVICE
	917	fprintf(stderr,
	918	#else
	919	printf(
	920	#endif
	921	" -append: Append to existing layer instead of creating new if it exists\n"
	922	" -overwrite: delete the output layer and recreate it empty\n"
	923	" -update: Open existing output datasource in update mode\n"
	924	" -select field_list: Comma-delimited list of fields from input layer to\n"
	925	" copy to the new layer (defaults to all)\n"
	926	" -where restricted_where: Attribute query (like SQL WHERE)\n"
	927	" -sql statement: Execute given SQL statement and save result.\n"
	928	" -skipfailures: skip features or layers that fail to convert\n"
	929	" -gt n: group n features per transaction (default 200)\n"
	930	" -spat xmin ymin xmax ymax: spatial query extents\n"
	931	" -segmentize max_dist: maximum distance between 2 nodes.\n"
	932	" Used to create intermediate points\n"
	933	" -dsco NAME=VALUE: Dataset creation option (format specific)\n"
	934	" -lco NAME=VALUE: Layer creation option (format specific)\n"
	935	" -nln name: Assign an alternate name to the new layer\n"
	936	" -nlt type: Force a geometry type for new layer. One of NONE, GEOMETRY,\n"
	937	" POINT, LINESTRING, POLYGON, GEOMETRYCOLLECTION, MULTIPOINT,\n"
	938	" MULTIPOLYGON, or MULTILINESTRING. Add \"25D\" for 3D layers.\n"
	939	" Default is type of source layer.\n" );
	940
	941	#ifdef ZOO_SERVICE
	942	fprintf(stderr,
	943	#else
	944	printf(
	945	#endif
	946	" -a_srs srs_def: Assign an output SRS\n"
	947	" -t_srs srs_def: Reproject/transform to this SRS on output\n"
	948	" -s_srs srs_def: Override source SRS\n"
	949	"\n"
	950	" Srs_def can be a full WKT definition (hard to escape properly),\n"
	951	" or a well known definition (ie. EPSG:4326) or a file with a WKT\n"
	952	" definition.\n" );
	953
	954
	955	#ifndef ZOO_SERVICE
	956	exit( 1 );
	957	#endif
	958	}
	959
	960	/************************************************************************/
	961	/* TranslateLayer() */
	962	/************************************************************************/
	963
	964	static int TranslateLayer( OGRDataSource *poSrcDS,
	965	OGRLayer * poSrcLayer,
	966	OGRDataSource *poDstDS,
	967	char **papszLCO,
	968	const char *pszNewLayerName,
	969	int bTransform,
	970	OGRSpatialReference *poOutputSRS,
	971	OGRSpatialReference *poSourceSRS,
	972	char **papszSelFields,
	973	int bAppend, int eGType, int bOverwrite,
	974	double dfMaxSegmentLength)
[40]	975
[1]	976	{
	977	OGRLayer *poDstLayer;
	978	OGRFeatureDefn *poFDefn;
	979	OGRErr eErr;
	980	int bForceToPolygon = FALSE;
	981	int bForceToMultiPolygon = FALSE;
	982
	983	if( pszNewLayerName == NULL )
	984	pszNewLayerName = poSrcLayer->GetLayerDefn()->GetName();
	985
	986	if( wkbFlatten(eGType) == wkbPolygon )
	987	bForceToPolygon = TRUE;
	988	else if( wkbFlatten(eGType) == wkbMultiPolygon )
	989	bForceToMultiPolygon = TRUE;
	990
	991	/* -------------------------------------------------------------------- */
	992	/* Setup coordinate transformation if we need it. */
	993	/* -------------------------------------------------------------------- */
	994	OGRCoordinateTransformation *poCT = NULL;
	995
	996	if( bTransform )
	997	{
	998	if( poSourceSRS == NULL )
	999	poSourceSRS = poSrcLayer->GetSpatialRef();
	1000
	1001	if( poSourceSRS == NULL )
	1002	{
	1003	fprintf( stderr, "Can't transform coordinates, source layer has no\n"
	1004	"coordinate system. Use -s_srs to set one.\n" );
	1005	#ifdef ZOO_SERVICE
	1006	return SERVICE_FAILED;
	1007	#else
	1008	exit( 1 );
	1009	#endif
	1010	}
	1011
	1012	CPLAssert( NULL != poSourceSRS );
	1013	CPLAssert( NULL != poOutputSRS );
	1014
	1015	poCT = OGRCreateCoordinateTransformation( poSourceSRS, poOutputSRS );
	1016	if( poCT == NULL )
	1017	{
	1018	char *pszWKT = NULL;
	1019
	1020	fprintf( stderr, "Failed to create coordinate transformation between the\n"
	1021	"following coordinate systems. This may be because they\n"
	1022	"are not transformable, or because projection services\n"
	1023	"(PROJ.4 DLL/.so) could not be loaded.\n" );
	1024
	1025	poSourceSRS->exportToPrettyWkt( &pszWKT, FALSE );
	1026	fprintf( stderr, "Source:\n%s\n", pszWKT );
	1027
	1028	poOutputSRS->exportToPrettyWkt( &pszWKT, FALSE );
	1029	fprintf( stderr, "Target:\n%s\n", pszWKT );
	1030	#ifdef ZOO_SERVICE
	1031	return SERVICE_FAILED;
	1032	#else
	1033	exit( 1 );
	1034	#endif
	1035	}
	1036	}
	1037
	1038	/* -------------------------------------------------------------------- */
	1039	/* Get other info. */
	1040	/* -------------------------------------------------------------------- */
	1041	poFDefn = poSrcLayer->GetLayerDefn();
	1042
	1043	if( poOutputSRS == NULL )
	1044	poOutputSRS = poSrcLayer->GetSpatialRef();
	1045
	1046	/* -------------------------------------------------------------------- */
	1047	/* Find the layer. */
	1048	/* -------------------------------------------------------------------- */
	1049	int iLayer = -1;
	1050	poDstLayer = NULL;
	1051
	1052	for( iLayer = 0; iLayer < poDstDS->GetLayerCount(); iLayer++ )
	1053	{
	1054	OGRLayer *poLayer = poDstDS->GetLayer(iLayer);
	1055
	1056	if( poLayer != NULL
	1057	&& EQUAL(poLayer->GetLayerDefn()->GetName(),pszNewLayerName) )
	1058	{
	1059	poDstLayer = poLayer;
	1060	break;
	1061	}
	1062	}
	1063
	1064	/* -------------------------------------------------------------------- */
	1065	/* If the user requested overwrite, and we have the layer in */
	1066	/* question we need to delete it now so it will get recreated */
	1067	/* (overwritten). */
	1068	/* -------------------------------------------------------------------- */
	1069	if( poDstLayer != NULL && bOverwrite )
	1070	{
	1071	if( poDstDS->DeleteLayer( iLayer ) != OGRERR_NONE )
	1072	{
	1073	fprintf( stderr,
	1074	"DeleteLayer() failed when overwrite requested.\n" );
	1075	return FALSE;
	1076	}
	1077	poDstLayer = NULL;
	1078	}
	1079
	1080	/* -------------------------------------------------------------------- */
	1081	/* If the layer does not exist, then create it. */
	1082	/* -------------------------------------------------------------------- */
	1083	if( poDstLayer == NULL )
	1084	{
	1085	if( eGType == -2 )
	1086	eGType = poFDefn->GetGeomType();
	1087
	1088	if( !poDstDS->TestCapability( ODsCCreateLayer ) )
	1089	{
	1090	fprintf( stderr,
	1091	"Layer %s not found, and CreateLayer not supported by driver.",
	1092	pszNewLayerName );
	1093	return FALSE;
	1094	}
	1095
	1096	CPLErrorReset();
	1097
	1098	poDstLayer = poDstDS->CreateLayer( pszNewLayerName, poOutputSRS,
	1099	(OGRwkbGeometryType) eGType,
	1100	papszLCO );
	1101
	1102	if( poDstLayer == NULL )
	1103	return FALSE;
	1104
	1105	bAppend = FALSE;
	1106	}
	1107
	1108	/* -------------------------------------------------------------------- */
	1109	/* Otherwise we will append to it, if append was requested. */
	1110	/* -------------------------------------------------------------------- */
	1111	else if( !bAppend )
	1112	{
	1113	fprintf( stderr, "FAILED: Layer %s already exists, and -append not specified.\n"
	1114	" Consider using -append, or -overwrite.\n",
	1115	pszNewLayerName );
	1116	return FALSE;
	1117	}
	1118	else
	1119	{
	1120	if( CSLCount(papszLCO) > 0 )
	1121	{
	1122	fprintf( stderr, "WARNING: Layer creation options ignored since an existing layer is\n"
	1123	" being appended to.\n" );
	1124	}
	1125	}
	1126
	1127	/* -------------------------------------------------------------------- */
	1128	/* Add fields. Default to copy all field. */
	1129	/* If only a subset of all fields requested, then output only */
	1130	/* the selected fields, and in the order that they were */
	1131	/* selected. */
	1132	/* -------------------------------------------------------------------- */
	1133	int iField;
[395]	1134	int hasMmField=-1;
[1]	1135
	1136	if (papszSelFields && !bAppend )
	1137	{
	1138	for( iField=0; papszSelFields[iField] != NULL; iField++)
	1139	{
	1140	int iSrcField = poFDefn->GetFieldIndex(papszSelFields[iField]);
[395]	1141	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iSrcField);
	1142	fprintf(stderr,"NAME: %s\n",tmp->GetNameRef());
	1143	fflush(stderr);
	1144	if(tmp!=NULL && strncasecmp(tmp->GetNameRef(),"MMID",4)==0)
	1145	hasMmField=1;
[1]	1146	if (iSrcField >= 0)
	1147	poDstLayer->CreateField( poFDefn->GetFieldDefn(iSrcField) );
	1148	else
	1149	{
	1150	fprintf( stderr, "Field '%s' not found in source layer.\n",
	1151	papszSelFields[iField] );
	1152	if( !bSkipFailures )
	1153	return FALSE;
	1154	}
	1155	}
[395]	1156
[1]	1157	}
	1158	else if( !bAppend )
	1159	{
[395]	1160	for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ ){
[1]	1161	poDstLayer->CreateField( poFDefn->GetFieldDefn(iField) );
[395]	1162	OGRFieldDefn *tmp=poFDefn->GetFieldDefn(iField);
	1163	if(tmp!=NULL && strncasecmp(tmp->GetNameRef(),"MMID",4)==0)
	1164	hasMmField=1;
	1165	fprintf(stderr,"NAME: %s\n",tmp->GetNameRef());
	1166	}
[1]	1167	}
[395]	1168	/*if(hasMmField<0){
	1169	OGRFieldDefn oField( "MMID", OFTInteger );
	1170	poDstLayer->CreateField( &oField );
	1171	}*/
[1]	1172
	1173	/* -------------------------------------------------------------------- */
	1174	/* Transfer features. */
	1175	/* -------------------------------------------------------------------- */
	1176	OGRFeature *poFeature;
	1177	int nFeaturesInTransaction = 0;
[395]	1178	int fCount=0;
[1]	1179	poSrcLayer->ResetReading();
	1180
	1181	if( nGroupTransactions )
	1182	poDstLayer->StartTransaction();
	1183
	1184	while( TRUE )
	1185	{
	1186	OGRFeature *poDstFeature = NULL;
	1187
	1188	if( nFIDToFetch != OGRNullFID )
	1189	{
	1190	// Only fetch feature on first pass.
	1191	if( nFeaturesInTransaction == 0 )
	1192	poFeature = poSrcLayer->GetFeature(nFIDToFetch);
	1193	else
	1194	poFeature = NULL;
	1195	}
	1196	else
	1197	poFeature = poSrcLayer->GetNextFeature();
[395]	1198
[1]	1199	if( poFeature == NULL )
	1200	break;
	1201
[395]	1202	//poFeature->SetField((poFeature->GetFieldCount()-1),fCount);
	1203
[1]	1204	if( ++nFeaturesInTransaction == nGroupTransactions )
	1205	{
	1206	poDstLayer->CommitTransaction();
	1207	poDstLayer->StartTransaction();
	1208	nFeaturesInTransaction = 0;
	1209	}
	1210
	1211	CPLErrorReset();
	1212	poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
	1213
	1214	if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
	1215	{
	1216	if( nGroupTransactions )
	1217	poDstLayer->CommitTransaction();
	1218
	1219	CPLError( CE_Failure, CPLE_AppDefined,
	1220	"Unable to translate feature %ld from layer %s.\n",
	1221	poFeature->GetFID(), poFDefn->GetName() );
	1222
	1223	OGRFeature::DestroyFeature( poFeature );
	1224	OGRFeature::DestroyFeature( poDstFeature );
	1225	return FALSE;
	1226	}
	1227
	1228	if( bPreserveFID )
	1229	poDstFeature->SetFID( poFeature->GetFID() );
	1230
[395]	1231	/*if(hasMmField<0){
	1232	poDstFeature->SetField((poDstFeature->GetFieldCount()-1),fCount);
	1233	fCount++;
	1234	}*/
	1235
[1]	1236	#ifndef GDAL_1_5_0
	1237	if (poDstFeature->GetGeometryRef() != NULL && dfMaxSegmentLength > 0)
	1238	poDstFeature->GetGeometryRef()->segmentize(dfMaxSegmentLength);
	1239	#endif
	1240
	1241	if( poCT && poDstFeature->GetGeometryRef() != NULL )
	1242	{
	1243	eErr = poDstFeature->GetGeometryRef()->transform( poCT );
	1244	if( eErr != OGRERR_NONE )
	1245	{
	1246	if( nGroupTransactions )
	1247	poDstLayer->CommitTransaction();
	1248
	1249	fprintf( stderr, "Failed to reproject feature %d (geometry probably out of source or destination SRS).\n",
	1250	(int) poFeature->GetFID() );
	1251	if( !bSkipFailures )
	1252	{
	1253	OGRFeature::DestroyFeature( poFeature );
	1254	OGRFeature::DestroyFeature( poDstFeature );
	1255	return FALSE;
	1256	}
	1257	}
	1258	}
	1259
	1260	if( poDstFeature->GetGeometryRef() != NULL && bForceToPolygon )
	1261	{
	1262	poDstFeature->SetGeometryDirectly(
	1263	OGRGeometryFactory::forceToPolygon(
	1264	poDstFeature->StealGeometry() ) );
	1265	}
	1266
	1267	if( poDstFeature->GetGeometryRef() != NULL && bForceToMultiPolygon )
	1268	{
	1269	poDstFeature->SetGeometryDirectly(
	1270	OGRGeometryFactory::forceToMultiPolygon(
	1271	poDstFeature->StealGeometry() ) );
	1272	}
	1273
	1274	OGRFeature::DestroyFeature( poFeature );
	1275
	1276	CPLErrorReset();
	1277	if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE
	1278	&& !bSkipFailures )
	1279	{
	1280	if( nGroupTransactions )
	1281	poDstLayer->RollbackTransaction();
	1282
	1283	OGRFeature::DestroyFeature( poDstFeature );
	1284	return FALSE;
	1285	}
	1286
	1287	OGRFeature::DestroyFeature( poDstFeature );
	1288	}
	1289
	1290	if( nGroupTransactions )
	1291	poDstLayer->CommitTransaction();
	1292
	1293	/* -------------------------------------------------------------------- */
	1294	/* Cleaning */
	1295	/* -------------------------------------------------------------------- */
	1296	delete poCT;
	1297
	1298	return TRUE;
	1299	}
	1300
	1301	#ifdef ZOO_SERVICE
	1302	}
	1303	#endif

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

Open WPS platform

source: trunk/zoo-project/zoo-services/ogr/ogr2ogr/service.c @ 679

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links