/**
* The function used as ZOOUpdateStatus from the JavaScript environment
* (ZOO-API).
*
* @param cx the JavaScript context
* @param argc the number of parameters
* @param argv1 the parameter values
* @return true
* @see setHeader,_updateStatus
*/
JSBool
JSUpdateStatus(JSContext *cx, uintN argc, jsval *argv1)
{
jsval *argv = JS_ARGV(cx,argv1);
JS_MaybeGC(cx);
int istatus=0;
char *status=NULL;
maps *conf;
if(argc>2){
#ifdef JS_DEBUG
fprintf(stderr,"Number of arguments used to call the function : %i",argc);
#endif
return JS_FALSE;
}
conf=mapsFromJSObject(cx,argv[0]);
if(JS_ValueToInt32(cx,argv[1],&istatus)==JS_TRUE){
char tmpStatus[4];
sprintf(tmpStatus,"%i",istatus);
tmpStatus[3]=0;
status=strdup(tmpStatus);
}
if(getMapFromMaps(conf,"lenv","status")!=NULL){
if(status!=NULL){
setMapInMaps(conf,"lenv","status",status);
free(status);
}
else
setMapInMaps(conf,"lenv","status","15");
_updateStatus(conf);
}
freeMaps(&conf);
free(conf);
JS_MaybeGC(cx);
return JS_TRUE;
}
/**
* Update the ongoing status of a running service from the Ruby environment
* (ZOO-API)
*
* @param argc the number of parameters
* @param argv the parameter values given from the Ruby environment
* @param obj the Ruby object on which we run the method
* @return a new Ruby string containing the translated value
* @see _updateStatus
*/
VALUE
RubyUpdateStatus(int argc, VALUE *argv, VALUE obj)
{
maps* conf;
VALUE confdict=argv[0];
int istatus=argv[1];
char* status;
if (istatus < 0 || istatus > 100){
fprintf(stderr,"Status must be a percentage.");
return Qnil;
}else{
char tmpStatus[4];
snprintf(tmpStatus, 4, "%i", istatus);
status = zStrdup(tmpStatus);
}
/* now update the map */
{
VALUE lenv = rb_hash_aref(confdict,rb_str_new2("lenv"));
if(TYPE(lenv)!=T_NIL){
VALUE valobj=rb_str_new2(status);
rb_hash_aset(lenv,rb_str_new2("status"),valobj);
}
}
conf = mapsFromRubyHash(confdict);
if (getMapFromMaps(conf,"lenv","status") != NULL){
fprintf(stderr,"STATUS RETURNED : %s\n",status);
if(status!=NULL){
setMapInMaps(conf,"lenv","status",status);
free(status);
}
else
setMapInMaps(conf,"lenv","status","15");
_updateStatus(conf);
}
freeMaps(&conf);
free(conf);
return Qnil;
}
int getServiceFromYAML(maps* conf, char* file,service** service,char *name){
FILE *fh = fopen("test.yml", "r");
if(current_content!=NULL){
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}
#ifdef DEBUG_SERVICE_CONF
fprintf(stderr,"(STARTING)FREE current_element\n");
#endif
if(current_element!=NULL){
freeElements(¤t_element);
free(current_element);
current_element=NULL;
}
my_service=NULL;
my_service=*service;
my_service->name=strdup(name);
my_service->content=NULL;
my_service->metadata=NULL;
my_service->inputs=NULL;
my_service->outputs=NULL;
fh = fopen(file,"r");
if (fh==NULL){
fprintf(stderr,"error : file not found\n") ;
return -1;
}
yaml_parser_t parser;
yaml_token_t token; /* new variable */
/* Initialize parser */
if(!yaml_parser_initialize(&parser))
fputs("Failed to initialize parser!\n", stderr);
if(fh == NULL)
fputs("Failed to open file!\n", stderr);
/* Set input file */
yaml_parser_set_input_file(&parser, fh);
/* BEGIN new code */
int level=0;
int plevel=level;
int ilevel=-1;
int blevel=-1;
int ttype=0;
int wait_metadata=-1;
char *cur_key;
do {
yaml_parser_scan(&parser, &token);
switch(token.type)
{
/* Stream start/end */
case YAML_STREAM_START_TOKEN:
#ifdef DEBUG_YAML
puts("STREAM START");
#endif
break;
case YAML_STREAM_END_TOKEN:
#ifdef DEBUG_YAML
puts("STREAM END");
#endif
break;
/* Token types (read before actual token) */
case YAML_KEY_TOKEN:
#ifdef DEBUG_YAML
printf("(Key token) ");
#endif
ttype=0;
break;
case YAML_VALUE_TOKEN:
#ifdef DEBUG_YAML
printf("(Value token) ");
#endif
ttype=1;
break;
/* Block delimeters */
case YAML_BLOCK_SEQUENCE_START_TOKEN:
#ifdef DEBUG_YAML
puts("<b>Start Block (Sequence)</b>");
#endif
break;
case YAML_BLOCK_ENTRY_TOKEN:
#ifdef DEBUG_YAML
puts("<b>Start Block (Entry)</b>");
#endif
break;
case YAML_BLOCK_END_TOKEN:
blevel--;
if(ilevel>=0)
ilevel--;
#ifdef DEBUG_YAML
printf("<b>End block</b> (%d,%d,%d,%d)\n", blevel,level,ilevel,ttype);
#endif
break;
/* Data */
case YAML_BLOCK_MAPPING_START_TOKEN:
#ifdef DEBUG_YAML
puts("[Block mapping]");
#endif
blevel++;
break;
case YAML_SCALAR_TOKEN:
if(ttype==0){
cur_key=zStrdup((char *)token.data.scalar.value);
}
if(ttype==1){
if(current_content==NULL){
current_content=createMap(cur_key,(char *)token.data.scalar.value);
}else{
addToMap(current_content,cur_key,(char *)token.data.scalar.value);
}
free(cur_key);
cur_key=NULL;
}
if(ttype==0 && blevel==0 && level==0 && strcasecmp((char *)token.data.scalar.value,"MetaData")==0 && blevel==0){
addMapToMap(&my_service->content,current_content);
#ifdef DEBUG_YAML
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
wait_metadata=1;
}
if(ttype==0 && blevel>0 && level>0 && strcasecmp((char *)token.data.scalar.value,"MetaData")==0){
if(current_element->content==NULL && current_content!=NULL)
addMapToMap(¤t_element->content,current_content);
#ifdef DEBUG_YAML
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
wait_metadata=1;
}
if(ttype==0 && strcasecmp((char *)token.data.scalar.value,"inputs")==0 && blevel==0){
if(wait_metadata>0){
addMapToMap(&my_service->metadata,current_content);
wait_metadata=-1;
}else{
if(current_content!=NULL && my_service->content==NULL)
addMapToMap(&my_service->content,current_content);
}
#ifdef DEBUG_YAML
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
wait_metadata=false;
level++;
}
if(ttype==0 && strcasecmp((char *)token.data.scalar.value,"outputs")==0 && blevel==1){
level++;
#ifdef DEBUG_YAML
dumpMap(current_content);
printf("\n***\n%d (%d,%d,%d,%d)\n+++\n", current_element->defaults==NULL,blevel,level,ilevel,ttype);
#endif
if(current_element->defaults==NULL && current_content!=NULL && ilevel<0){
current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
current_element->defaults->content=NULL;
current_element->defaults->next=NULL;
addMapToMap(¤t_element->defaults->content,current_content);
#ifdef DEBUG_YAML
dumpElements(current_element);
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}else{
if(current_content!=NULL && ilevel<=0){
addMapToIoType(¤t_element->supported,current_content);
#ifdef DEBUG_YAML
dumpElements(current_element);
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}
}
}
if(level==1 && strcasecmp((char *)token.data.scalar.value,"default")==0){
ilevel=0;
}
if(level==1 && strcasecmp((char *)token.data.scalar.value,"supported")==0){
#ifdef DEBUG_YAML
dumpMap(current_content);
printf("\n***\n%d (%d,%d,%d,%d)\n+++\n", current_element->defaults==NULL,blevel,level,ilevel,ttype);
#endif
if(current_element->defaults==NULL && current_content!=NULL && ilevel<0){
current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
current_element->defaults->content=NULL;
current_element->defaults->next=NULL;
addMapToMap(¤t_element->defaults->content,current_content);
#ifdef DEBUG_YAML
dumpElements(current_element);
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}else{
if(current_content!=NULL && ilevel<=0){
if(current_element->supported==NULL){
current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
current_element->supported->content=NULL;
current_element->supported->next=NULL;
}
addMapToMap(¤t_element->supported->content,current_content);
#ifdef DEBUG_YAML
dumpElements(current_element);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}
}
ilevel=1;
}
if(strncasecmp((char *)token.data.scalar.value,"ComplexData",11)==0 ||
strncasecmp((char *)token.data.scalar.value,"LiteralData",10)==0 ||
strncasecmp((char *)token.data.scalar.value,"ComplexOutput",13)==0 ||
strncasecmp((char *)token.data.scalar.value,"LiteralOutput",12)==0 ||
strncasecmp((char *)token.data.scalar.value,"BoundingBoxOutput",13)==0 ||
strncasecmp((char *)token.data.scalar.value,"BoundingBoxData",12)==0){
current_element->format=zStrdup((char *)token.data.scalar.value);
free(cur_key);
cur_key=NULL;
if(wait_metadata>0 && current_content!=NULL){
addMapToMap(¤t_element->metadata,current_content);
wait_metadata=-1;
}else{
if(current_content!=NULL){
addMapToMap(¤t_element->content,current_content);
}
}
#ifdef DEBUG_YAML
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
#ifdef DEBUG_YAML
dumpElements(current_element);
#endif
}
if(blevel==1 && level==1){
if(current_element!=NULL && current_content!=NULL){
if(current_element->defaults==NULL){
current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
current_element->defaults->content=NULL;
current_element->defaults->next=NULL;
addMapToMap(¤t_element->defaults->content,current_content);
}else{
if(current_element->supported==NULL){
current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
current_element->supported->content=NULL;
current_element->supported->next=NULL;
addMapToMap(¤t_element->supported->content,current_content);
}else
addMapToIoType(¤t_element->supported,current_content);
}
}
if(current_element!=NULL){
if(my_service->inputs==NULL)
my_service->inputs=dupElements(current_element);
else
addToElements(&my_service->inputs,current_element);
freeElements(¤t_element);
free(current_element);
}
plevel=level;
current_element=(elements*)malloc(ELEMENTS_SIZE);
current_element->name=zStrdup((char *)token.data.scalar.value);
current_element->content=NULL;
current_element->metadata=NULL;
current_element->format=NULL;
current_element->defaults=NULL;
current_element->supported=NULL;
current_element->next=NULL;
}
if(blevel==1 && level==2){
if(current_element!=NULL && current_content!=NULL){
if(current_element->defaults==NULL){
current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
current_element->defaults->content=NULL;
current_element->defaults->next=NULL;
addMapToMap(¤t_element->defaults->content,current_content);
}else{
if(current_element->supported==NULL){
current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
current_element->supported->content=NULL;
current_element->supported->next=NULL;
addMapToMap(¤t_element->supported->content,current_content);
}else
addMapToIoType(¤t_element->supported,current_content);
}
}
if(current_element!=NULL){
if(plevel==level){
if(my_service->outputs==NULL)
my_service->outputs=dupElements(current_element);
else
addToElements(&my_service->outputs,current_element);
}else{
if(my_service->inputs==NULL)
my_service->inputs=dupElements(current_element);
else
addToElements(&my_service->inputs,current_element);
}
freeElements(¤t_element);
free(current_element);
}
plevel=level;
current_element=(elements*)malloc(ELEMENTS_SIZE);
current_element->name=zStrdup((char *)token.data.scalar.value);
current_element->content=NULL;
current_element->metadata=NULL;
current_element->format=NULL;
current_element->defaults=NULL;
current_element->supported=NULL;
current_element->next=NULL;
}
#ifdef DEBUG_YAML
printf("scalar %s (%d,%d,%d,%d,%d)\n", token.data.scalar.value,blevel,level,plevel,ilevel,ttype);
#endif
break;
/* Others */
default:
if(token.type==0){
char tmp[1024];
sprintf(tmp,"Wrong charater found in %s: \\t",name);
setMapInMaps(conf,"lenv","message",tmp);
return -1;
}
#ifdef DEBUG_YAML
printf("Got token of type %d\n", token.type);
#endif
break;
}
if(token.type != YAML_STREAM_END_TOKEN )
yaml_token_delete(&token);
} while(token.type != YAML_STREAM_END_TOKEN);
yaml_token_delete(&token);
#ifdef DEBUG_YAML
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
if(current_element!=NULL && current_content!=NULL){
if(current_element->defaults==NULL){
current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
current_element->defaults->content=NULL;
current_element->defaults->next=NULL;
addMapToMap(¤t_element->defaults->content,current_content);
}else{
if(current_element->supported==NULL){
current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
current_element->supported->content=NULL;
current_element->supported->next=NULL;
addMapToMap(¤t_element->supported->content,current_content);
}else
addMapToIoType(¤t_element->supported,current_content);
}
#ifdef DEBUG_YAML
dumpMap(current_content);
fprintf(stderr,"MSG: %s %d \n",__FILE__,__LINE__);
#endif
freeMap(¤t_content);
free(current_content);
current_content=NULL;
}
if(current_element!=NULL){
if(my_service->outputs==NULL)
my_service->outputs=dupElements(current_element);
else
addToElements(&my_service->outputs,current_element);
freeElements(¤t_element);
free(current_element);
current_element=NULL;
}
/* END new code */
/* Cleanup */
yaml_parser_delete(&parser);
fclose(fh);
#ifdef DEBUG_YAML
dumpService(my_service);
#endif
*service=my_service;
return 1;
}
int Delaunay(maps*& conf,maps*& inputs,maps*& outputs){
#ifdef DEBUG
fprintf(stderr,"\nService internal print\nStarting\n");
#endif
maps* cursor=inputs;
OGRGeometryH geometry,res;
int bufferDistance;
map* tmpm=NULL;
OGRRegisterAll();
std::vector<Point> points;
if(int res=parseInput(conf,inputs,&points,"/vsimem/tmp")!=SERVICE_SUCCEEDED)
return res;
DelaunayT T;
T.insert(points.begin(), points.end());
/* -------------------------------------------------------------------- */
/* Try opening the output datasource as an existing, writable */
/* -------------------------------------------------------------------- */
#if GDAL_VERSION_MAJOR >= 2
GDALDataset *poODS;
GDALDriverManager* poR=GetGDALDriverManager();
GDALDriver *poDriver = NULL;
#else
OGRDataSource *poODS;
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
OGRSFDriver *poDriver = NULL;
#endif
int iDriver;
map *tmpMap=getMapFromMaps(outputs,"Result","mimeType");
const char *oDriver;
oDriver="GeoJSON";
if(tmpMap!=NULL){
if(strcmp(tmpMap->value,"text/xml")==0){
oDriver="GML";
}
}
for( iDriver = 0;
iDriver < poR->GetDriverCount() && poDriver == NULL;
iDriver++ )
{
#ifdef DEBUG
#if GDAL_VERSION_MAJOR >= 2
fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetDescription());
#else
fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetName());
#endif
#endif
if( EQUAL(
#if GDAL_VERSION_MAJOR >= 2
poR->GetDriver(iDriver)->GetDescription()
#else
poR->GetDriver(iDriver)->GetName()
#endif
,
oDriver) )
{
poDriver = poR->GetDriver(iDriver);
}
}
if( poDriver == NULL )
{
char emessage[8192];
sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
sprintf( emessage, "%sThe following drivers are available:\n",emessage );
for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
#if GDAL_VERSION_MAJOR >= 2
sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
#else
sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
#endif
}
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
#if GDAL_VERSION_MAJOR >=2
if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
#else
if( !poDriver->TestCapability( ODrCCreateDataSource ) )
#endif
{
char emessage[1024];
sprintf( emessage, "%s driver does not support data source creation.\n",
"json" );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
/* -------------------------------------------------------------------- */
/* Create the output data source. */
/* -------------------------------------------------------------------- */
char *pszDestDataSource=(char*)malloc(100);
char **papszDSCO=NULL;
sprintf(pszDestDataSource,"/vsimem/result_%d",getpid());
#if GDAL_VERSION_MAJOR >=2
poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
#else
poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
#endif
if( poODS == NULL ){
char emessage[1024];
sprintf( emessage, "%s driver failed to create %s\n",
"json", pszDestDataSource );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
/* -------------------------------------------------------------------- */
/* Create the layer. */
/* -------------------------------------------------------------------- */
if( !poODS->TestCapability( ODsCCreateLayer ) )
{
char emessage[1024];
sprintf( emessage,
"Layer %s not found, and CreateLayer not supported by driver.",
"Result" );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
CPLErrorReset();
OGRLayer *poDstLayer = poODS->CreateLayer( "Result", NULL,wkbPolygon,NULL);
if( poDstLayer == NULL ){
setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
return SERVICE_FAILED;
}
for(DelaunayT::Finite_faces_iterator fit = T.finite_faces_begin();
fit != T.finite_faces_end(); ++fit) {
DelaunayT::Face_handle face = fit;
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( poDstLayer ) );
OGRGeometryH hCollection = OGR_G_CreateGeometry( wkbGeometryCollection );
OGRGeometryH currLine=OGR_G_CreateGeometry(wkbLinearRing);
OGRGeometryH currPoly=OGR_G_CreateGeometry(wkbPolygon);
OGR_G_AddPoint_2D(currLine,T.triangle(face)[0].x(),T.triangle(face)[0].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[1].x(),T.triangle(face)[1].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[2].x(),T.triangle(face)[2].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[0].x(),T.triangle(face)[0].y());
OGR_G_AddGeometryDirectly( currPoly, currLine );
OGR_G_AddGeometryDirectly( hCollection, currPoly );
OGR_F_SetGeometry( hFeature, hCollection );
OGR_G_DestroyGeometry(hCollection);
if( OGR_L_CreateFeature( poDstLayer, hFeature ) != OGRERR_NONE ){
setMapInMaps(conf,"lenv","message","Failed to create feature in file.\n");
return SERVICE_FAILED;
}
OGR_F_Destroy( hFeature );
}
OGR_DS_Destroy( poODS );
#ifdef DEBUG
std::cerr << "The Voronoi diagram has " << ns << " finite edges "
<< " and " << nr << " rays" << std::endl;
#endif
char *res1=readVSIFile(conf,pszDestDataSource);
if(res1==NULL)
return SERVICE_FAILED;
setMapInMaps(outputs,"Result","value",res1);
free(res1);
if(strcmp(oDriver,"GML")==0)
setMapInMaps(outputs,"Result","mimeType","text/xml");
else
setMapInMaps(outputs,"Result","mimeType","application/json");
setMapInMaps(outputs,"Result","encoding","UTF-8");
OGRCleanupAll();
return SERVICE_SUCCEEDED;
}
int tindex(maps*& conf, maps*& inputs,maps*& outputs)
{
char *index_filename = NULL;
const char *tile_index = "location";
int i_arg, ti_field;
OGRDataSourceH hTileIndexDS;
OGRLayerH hLayer = NULL;
OGRFeatureDefnH hFDefn;
int write_absolute_path = FALSE;
char* current_path = NULL;
int i;
int nExistingFiles;
int skip_different_projection = FALSE;
char** existingFilesTab = NULL;
int alreadyExistingProjectionRefValid = FALSE;
char* alreadyExistingProjectionRef = NULL;
char* index_filename_mod;
int bExists;
VSIStatBuf sStatBuf;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
char tmp[1024];
sprintf(tmp, "At least, GDAL >= 1.4.0 is required for this version of"
"tindex, which was compiled against GDAL %s\n", GDAL_RELEASE_NAME);
return SERVICE_FAILED;
}
GDALAllRegister();
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Get the directory name to search for raster file to index. */
/* -------------------------------------------------------------------- */
char *tmpDataDir;
char *pszDataDir;
map* tmpMap=getMapFromMaps(conf,"main","isTrial");
map* tmpMap1=getMapFromMaps(conf,"main","dataPath");
map* tmpInputMap=getMapFromMaps(inputs,"dir","value");
if(tmpMap!=NULL && strcasecmp(tmpMap->value,"true")==0){
pszDataDir=(char*) malloc((strlen(tmpInputMap->value)+strlen(tmpMap1->value)+5+1)*sizeof(char));
sprintf(pszDataDir,"%s/ftp/%s",tmpMap1->value,tmpInputMap->value);
}else{
pszDataDir=(char*) malloc(((strlen(tmpInputMap->value)+1)*sizeof(char)));
sprintf(pszDataDir,"%s",tmpInputMap->value);
}
tmpMap=getMapFromMaps(inputs,"iname","value");
tmpMap1=getMapFromMaps(inputs,"idir","value");
map* tmpMap2=getMapFromMaps(conf,"main","dataPath");
if(tmpMap!=NULL && tmpMap1!=NULL && tmpMap2!=NULL){
index_filename = (char*) malloc((strlen(tmpMap->value)+strlen(tmpMap1->value)+strlen(tmpMap2->value)+12)*sizeof(char));
sprintf(index_filename,"%s/dirs/%s/%s.shp",tmpMap2->value,tmpMap1->value,tmpMap->value);
}
fprintf(stderr,"Filename %s\n",index_filename);
/* -------------------------------------------------------------------- */
/* Open or create the target shapefile and DBF file. */
/* -------------------------------------------------------------------- */
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "shp"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
if (!bExists)
{
CPLFree(index_filename_mod);
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "SHP"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
}
CPLFree(index_filename_mod);
if (bExists)
{
hTileIndexDS = OGROpen( index_filename, TRUE, NULL );
if (hTileIndexDS != NULL)
{
hLayer = OGR_DS_GetLayer(hTileIndexDS, 0);
}
}
else
{
OGRSFDriverH hDriver;
const char* pszDriverName = "ESRI Shapefile";
fprintf( stderr,"Creating new index file...\n" );
hDriver = OGRGetDriverByName( pszDriverName );
if( hDriver == NULL )
{
char msg[1024];
sprintf( msg, "%s driver not available.", pszDriverName );
setMapInMaps(conf,"lenv","message",msg);
return SERVICE_FAILED;
}
hTileIndexDS = OGR_Dr_CreateDataSource( hDriver, index_filename, NULL );
if (hTileIndexDS)
{
char* pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
OGRSpatialReferenceH hSpatialRef = NULL;
GDALDatasetH hDS = GDALOpen( index_filename, GA_ReadOnly );
if (hDS)
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != NULL && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
}
GDALClose(hDS);
}
DIR *dirp = opendir(pszDataDir);
if(dirp==NULL){
char tmp1[1024];
sprintf(tmp1,_ss("The specified path %s doesn't exist."),pszDataDir);
setMapInMaps(conf,"lenv","message",tmp1);
return SERVICE_FAILED;
}
char *res=NULL;
struct dirent *dp;
tmpMap=getMapFromMaps(inputs,"ext","value");
char *ext;
if(tmpMap!=NULL)
ext=tmpMap->value;
while ((dp = readdir(dirp)) != NULL){
if(strncmp(dp->d_name,".",1)!=0&&strncmp(dp->d_name,"..",2)!=0){
char* argv=(char*) malloc((strlen(dp->d_name)+strlen(pszDataDir)+2)*sizeof(char));
sprintf(argv,"%s/%s",pszDataDir,dp->d_name);
GDALDatasetH hDS0 = GDALOpen( argv, GA_ReadOnly );
if (hDS0)
{
const char* pszWKT = GDALGetProjectionRef(hDS0);
fprintf(stderr,"SRS %s \n",pszWKT);
if (pszWKT != NULL && pszWKT[0] != '\0')
{
if (hSpatialRef)
OSRRelease(hSpatialRef);
hSpatialRef = OSRNewSpatialReference(pszWKT);
}
GDALClose(hDS);
}
break;
}
}
closedir(dirp);
hLayer = OGR_DS_CreateLayer( hTileIndexDS, pszLayerName, hSpatialRef, wkbPolygon, NULL );
CPLFree(pszLayerName);
if (hSpatialRef)
OSRRelease(hSpatialRef);
if (hLayer)
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
OGR_Fld_SetWidth( hFieldDefn, 255);
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == NULL || hLayer == NULL )
{
char msg[1024];
sprintf( msg, "Unable to open/create shapefile `%s'.",
index_filename );
setMapInMaps(conf,"lenv","message",msg);
}
hFDefn = OGR_L_GetLayerDefn(hLayer);
for( ti_field = 0; ti_field < OGR_FD_GetFieldCount(hFDefn); ti_field++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, ti_field );
if( strcmp(OGR_Fld_GetNameRef(hFieldDefn), tile_index) == 0 )
break;
}
if( ti_field == OGR_FD_GetFieldCount(hFDefn) )
{
char msg[1024];
sprintf( msg, "Unable to find field `%s' in DBF file `%s'.\n",
tile_index, index_filename );
setMapInMaps(conf,"lenv","message",msg);
return SERVICE_FAILED;
}
/* Load in memory existing file names in SHP */
nExistingFiles = OGR_L_GetFeatureCount(hLayer, FALSE);
if (nExistingFiles)
{
OGRFeatureH hFeature;
existingFilesTab = (char**)CPLMalloc(nExistingFiles * sizeof(char*));
for(i=0;i<nExistingFiles;i++)
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] = CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if (i == 0)
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if (hDS)
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if (write_absolute_path)
{
current_path = CPLGetCurrentDir();
if (current_path == NULL)
{
fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n");
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
DIR *dirp = opendir(pszDataDir);
if(dirp==NULL){
char tmp1[1024];
sprintf(tmp1,_ss("The specified path %s doesn't exist."),pszDataDir);
setMapInMaps(conf,"lenv","message",tmp1);
return SERVICE_FAILED;
}
char *res=NULL;
struct dirent *dp;
tmpMap=getMapFromMaps(inputs,"ext","value");
char *ext;
if(tmpMap!=NULL)
ext=tmpMap->value;
while ((dp = readdir(dirp)) != NULL){
if(strlen(dp->d_name)>2 && strstr(dp->d_name,".")!=0 && strstr(dp->d_name,ext)>0){
char* argv=(char*) malloc((strlen(dp->d_name)+strlen(pszDataDir)+2)*sizeof(char));
sprintf(argv,"%s/%s",pszDataDir,dp->d_name);
GDALDatasetH hDS;
double adfGeoTransform[6];
double adfX[5], adfY[5];
int nXSize, nYSize;
char* fileNameToWrite;
const char* projectionRef;
VSIStatBuf sStatBuf;
int k;
OGRFeatureH hFeature;
OGRGeometryH hPoly, hRing;
/* Make sure it is a file before building absolute path name */
if (write_absolute_path && CPLIsFilenameRelative( argv ) &&
VSIStat( argv, &sStatBuf ) == 0)
{
fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path, argv));
}
else
{
fileNameToWrite = CPLStrdup(argv);
}
/* Checks that file is not already in tileindex */
for(i=0;i<nExistingFiles;i++)
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr, "File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
hDS = GDALOpen( argv, GA_ReadOnly );
if( hDS == NULL )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv );
CPLFree(fileNameToWrite);
continue;
}
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& ABS(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
projectionRef = GDALGetProjectionRef(hDS);
if (alreadyExistingProjectionRefValid)
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull = alreadyExistingProjectionRef && alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(stderr, "Warning : %s is not using the same projection system as "
"other files in the tileindex. This may cause problems when "
"using it in MapServer for example.%s\n", argv,
(skip_different_projection) ? " Skipping it" : "");
if (skip_different_projection)
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
hPoly = OGR_G_CreateGeometry(wkbPolygon);
hRing = OGR_G_CreateGeometry(wkbLinearRing);
for(k=0;k<5;k++)
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
fprintf( stderr, "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
}
CPLFree(current_path);
if (nExistingFiles)
{
for(i=0;i<nExistingFiles;i++)
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
OGR_DS_Destroy( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
setMapInMaps(outputs,"Result","value","Tile index successfully created.");
//CSLDestroy(argv);
return SERVICE_SUCCEEDED;
}
int getSymbols(maps*& conf,maps*& inputs,maps*& outputs)
{
FT_Error error = FT_Init_FreeType( &library );
map* tmpMap4Path=getMapFromMaps(conf,"main","dataPath");
map* tmpMap=getMapFromMaps(inputs,"ttf","value");
char ttfFile[1024];
sprintf(ttfFile,"%s/fonts/%s",tmpMap4Path->value,tmpMap->value);
fprintf(stderr,"File to open : %s\n",ttfFile);
error = FT_New_Face( library, ttfFile, 0, &face );
if ( error == FT_Err_Unknown_File_Format ){
setMapInMaps(conf,"lenv","message","Error unknow format");
return SERVICE_FAILED;
}
else if ( error ) {
setMapInMaps(conf,"lenv","message","Unable to load the specified file");
return SERVICE_FAILED;
}
//int *charcodes=(int *)malloc(face->num_glyphs*sizeof(int));
//printf("%d|",face->num_glyphs);
int n;
FT_CharMap found = 0;
FT_CharMap charmap;
int disp=0;
char *charCodes=NULL;
for ( n = 0; n < face->num_charmaps; n++ ) {
charmap = face->charmaps[n];
//printf("\nplatform_id : %d ; encoding_id %d\n",charmap->platform_id,charmap->encoding_id);
found = charmap;
error = FT_Set_Charmap( face, found );
FT_UInt agindex;
FT_ULong charcode;
charcode=FT_Get_First_Char(face,&agindex);
int count=1;
if(agindex==0){
setMapInMaps(conf,"lenv","message","Unable to find anything in your font file");
return SERVICE_FAILED;
}
else{
char tmp[100];
if(charCodes==NULL){
sprintf(tmp,"%d",charcode);
charCodes=(char*)malloc((strlen(tmp)+2)*sizeof(char));
sprintf(charCodes,"[%s",tmp);
}else{
sprintf(tmp,",%d",charcode);
char *tmp2=strdup(charCodes);
charCodes=(char*)realloc(charCodes,(strlen(tmp2)+strlen(tmp)+1)*sizeof(char));
memcpy(charCodes+strlen(tmp2),tmp,strlen(tmp)+1);
free(tmp2);
}
while ( agindex != 0 )
{
charcode = FT_Get_Next_Char( face, charcode, &agindex );
if(agindex != 0 ){
char tmp1[100];
sprintf(tmp1,",%d",charcode);
char *tmp2=strdup(charCodes);
charCodes=(char*)realloc(charCodes,(strlen(tmp2)+strlen(tmp1)+1)*sizeof(char));
memcpy(charCodes+strlen(tmp2),tmp1,strlen(tmp1)+1);
free(tmp2);
}
}
}
}
char *tmp2=strdup(charCodes);
charCodes=(char*)realloc(charCodes,(strlen(tmp2)+2)*sizeof(char));
memcpy(charCodes+strlen(tmp2),"]",2);
free(tmp2);
//printf("\n**%s**\n",charCodes);
setMapInMaps(outputs,"Result","value",charCodes);
return SERVICE_SUCCEEDED;
}
int Gdal_Contour(maps*& conf,maps*& inputs,maps*& outputs)
#endif
{
fprintf(stderr,"DEBUG HELLO %f %d\n",__FILE__,__LINE__);
fflush(stderr);
GDALDatasetH hSrcDS;
int i, b3D = FALSE, bNoDataSet = FALSE, bIgnoreNoData = FALSE;
int nBandIn = 1;
double dfInterval = 0.0, dfNoData = 0.0, dfOffset = 0.0;
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
const char *pszElevAttrib = NULL;
const char *pszFormat = "ESRI Shapefile";
char **papszDSCO = NULL, **papszLCO = NULL;
double adfFixedLevels[1000];
int nFixedLevelCount = 0;
const char *pszNewLayerName = "contour";
int bQuiet = FALSE;
GDALProgressFunc pfnProgress = NULL;
fprintf(stderr,"DEBUG HELLO %f %d\n",__FILE__,__LINE__);
fflush(stderr);
#ifndef ZOO_SERVICE
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
#endif
GDALAllRegister();
OGRRegisterAll();
#ifndef ZOO_SERVICE
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "--help") )
Usage();
else if( EQUAL(argv[i],"-a") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszElevAttrib = argv[++i];
}
else if( EQUAL(argv[i],"-off") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
dfOffset = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-i") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
dfInterval = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-fl") )
{
if( i >= argc-1 )
Usage(CPLSPrintf("%s option requires at least 1 argument", argv[i]));
while( i < argc-1
&& nFixedLevelCount
< (int)(sizeof(adfFixedLevels)/sizeof(double))
&& ArgIsNumeric(argv[i+1]) )
adfFixedLevels[nFixedLevelCount++] = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-b") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nBandIn = atoi(argv[++i]);
}
else if( EQUAL(argv[i],"-f") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = argv[++i];
}
else if( EQUAL(argv[i],"-dsco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszDSCO = CSLAddString(papszDSCO, argv[++i] );
}
else if( EQUAL(argv[i],"-lco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszLCO = CSLAddString(papszLCO, argv[++i] );
}
else if( EQUAL(argv[i],"-3d") )
{
b3D = TRUE;
}
else if( EQUAL(argv[i],"-snodata") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
bNoDataSet = TRUE;
dfNoData = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-nln") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszNewLayerName = argv[++i];
}
else if( EQUAL(argv[i],"-inodata") )
{
bIgnoreNoData = TRUE;
}
else if ( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") )
{
bQuiet = TRUE;
}
else if( pszSrcFilename == NULL )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == NULL )
{
pszDstFilename = argv[i];
}
else
Usage("Too many command options.");
}
#else
bQuiet = TRUE;
bIgnoreNoData = TRUE;
map* tmpMap=NULL;
tmpMap=NULL;
tmpMap=getMapFromMaps(inputs,"a","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
pszElevAttrib = strdup(tmpMap->value);
}
tmpMap=getMapFromMaps(inputs,"off","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
dfOffset = atof(tmpMap->value);
}
tmpMap=getMapFromMaps(inputs,"i","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
dfInterval = atof(tmpMap->value);
}
tmpMap=getMapFromMaps(inputs,"b","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
nBandIn = atoi(tmpMap->value);
}
tmpMap=getMapFromMaps(inputs,"InputDSN","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
pszSrcFilename = strdup(tmpMap->value);
}
tmpMap=getMapFromMaps(inputs,"OutputDSN","value");
if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){
pszDstFilename = strdup(tmpMap->value);
}
#endif
if( dfInterval == 0.0 && nFixedLevelCount == 0 )
{
Usage("Neither -i nor -fl are specified.");
}
if (pszSrcFilename == NULL)
{
Usage("Missing source filename.");
}
if (pszDstFilename == NULL)
{
Usage("Missing destination filename.");
}
if (!bQuiet)
pfnProgress = GDALTermProgress;
/* -------------------------------------------------------------------- */
/* Open source raster file. */
/* -------------------------------------------------------------------- */
GDALRasterBandH hBand;
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == NULL ){
#ifndef ZOO_SERVICE
exit( 2 );
#else
setMapInMaps(conf,"lenv","message","Unable to open the file");
#endif
}
hBand = GDALGetRasterBand( hSrcDS, nBandIn );
if( hBand == NULL )
{
#ifndef ZOO_SERVICE
CPLError( CE_Failure, CPLE_AppDefined,
"Band %d does not exist on dataset.",
nBandIn );
exit(2);
#else
char tmp[1024];
sprintf(tmp,"Band %d does not exist on dataset.",nBandIn);
setMapInMaps(conf,"lenv","message",tmp);
return SERVICE_FAILED;
#endif
}
if( !bNoDataSet && !bIgnoreNoData )
dfNoData = GDALGetRasterNoDataValue( hBand, &bNoDataSet );
/* -------------------------------------------------------------------- */
/* Try to get a coordinate system from the raster. */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hSRS = NULL;
const char *pszWKT = GDALGetProjectionRef( hSrcDS );
if( pszWKT != NULL && strlen(pszWKT) != 0 )
hSRS = OSRNewSpatialReference( pszWKT );
/* -------------------------------------------------------------------- */
/* Create the outputfile. */
/* -------------------------------------------------------------------- */
OGRDataSourceH hDS;
OGRSFDriverH hDriver = OGRGetDriverByName( pszFormat );
OGRFieldDefnH hFld;
OGRLayerH hLayer;
if( hDriver == NULL )
{
#ifndef ZOO_SERVICE
fprintf( stderr, "Unable to find format driver named %s.\n",
pszFormat );
exit( 10 );
#else
char tmp[1024];
sprintf( tmp, "Unable to find format driver named %s.\n", pszFormat );
setMapInMaps(conf,"lenv","message",tmp);
return SERVICE_FAILED;
#endif
}
hDS = OGR_Dr_CreateDataSource( hDriver, pszDstFilename, papszDSCO );
if( hDS == NULL ){
#ifndef ZOO_SERVICE
exit( 1 );
#else
setMapInMaps(conf,"lenv","message","Unable to create the file");
return SERVICE_FAILED;
#endif
}
hLayer = OGR_DS_CreateLayer( hDS, pszNewLayerName, hSRS,
b3D ? wkbLineString25D : wkbLineString,
papszLCO );
if( hLayer == NULL )
exit( 1 );
hFld = OGR_Fld_Create( "ID", OFTInteger );
OGR_Fld_SetWidth( hFld, 8 );
OGR_L_CreateField( hLayer, hFld, FALSE );
OGR_Fld_Destroy( hFld );
if( pszElevAttrib )
{
hFld = OGR_Fld_Create( pszElevAttrib, OFTReal );
OGR_Fld_SetWidth( hFld, 12 );
OGR_Fld_SetPrecision( hFld, 3 );
OGR_L_CreateField( hLayer, hFld, FALSE );
OGR_Fld_Destroy( hFld );
}
/* -------------------------------------------------------------------- */
/* Invoke. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
eErr = GDALContourGenerate( hBand, dfInterval, dfOffset,
nFixedLevelCount, adfFixedLevels,
bNoDataSet, dfNoData, hLayer,
OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hLayer ),
"ID" ),
(pszElevAttrib == NULL) ? -1 :
OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hLayer ),
pszElevAttrib ),
pfnProgress, NULL );
OGR_DS_Destroy( hDS );
GDALClose( hSrcDS );
if (hSRS)
OSRDestroySpatialReference( hSRS );
#ifndef ZOO_SERVICE
CSLDestroy( argv );
CSLDestroy( papszDSCO );
CSLDestroy( papszLCO );
GDALDestroyDriverManager();
OGRCleanupAll();
return 0;
#else
GDALDestroyDriverManager();
OGRCleanupAll();
char tmp[1024];
sprintf(tmp,"File %s successfully created.",pszDstFilename);
setMapInMaps(outputs,"Result","value",tmp);
return SERVICE_SUCCEEDED;
#endif
}
