static int FTLParseEpsgString(char *pszEpsg, projectionObj *psProj)
{
int nStatus = MS_FALSE;
int nTokens = 0;
char **tokens = NULL;
int nEpsgTmp=0;
#ifdef USE_PROJ
if (pszEpsg && psProj)
{
nTokens = 0;
tokens = msStringSplit(pszEpsg,'#', &nTokens);
if (tokens && nTokens == 2)
{
char szTmp[32];
sprintf(szTmp, "init=epsg:%s",tokens[1]);
msInitProjection(psProj);
if (msLoadProjectionString(psProj, szTmp) == 0)
nStatus = MS_TRUE;
}
else if (tokens && nTokens == 1)
{
if (tokens)
msFreeCharArray(tokens, nTokens);
nTokens = 0;
tokens = msStringSplit(pszEpsg,':', &nTokens);
nEpsgTmp = -1;
if (tokens && nTokens == 1)
{
nEpsgTmp = atoi(tokens[0]);
}
else if (tokens && nTokens == 2)
{
nEpsgTmp = atoi(tokens[1]);
}
if (nEpsgTmp > 0)
{
char szTmp[32];
sprintf(szTmp, "init=epsg:%d",nEpsgTmp);
msInitProjection(psProj);
if (msLoadProjectionString(psProj, szTmp) == 0)
nStatus = MS_TRUE;
}
}
if (tokens)
msFreeCharArray(tokens, nTokens);
}
#endif
return nStatus;
}
int KmlRenderer::checkProjection(mapObj *map)
{
projectionObj *projection= &map->projection;
#ifdef USE_PROJ
if (projection && projection->numargs > 0 && pj_is_latlong(projection->proj))
{
return MS_SUCCESS;
}
else
{
char epsg_string[100];
rectObj sRect;
projectionObj out;
/* for layer the do not have any projection set, set them with the current map
projection*/
if (projection && projection->numargs > 0)
{
layerObj *lp = NULL;
int i =0;
char *pszMapProjectString = msGetProjectionString(projection);
if (pszMapProjectString)
{
for(i=0; i<map->numlayers; i++)
{
lp = GET_LAYER(map, i);
if (lp->projection.numargs == 0 && lp->transform == MS_TRUE)
{
msFreeProjection(&lp->projection);
msLoadProjectionString(&lp->projection, pszMapProjectString);
}
}
msFree(pszMapProjectString);
}
}
strcpy(epsg_string, "epsg:4326" );
msInitProjection(&out);
msLoadProjectionString(&out, epsg_string);
sRect = map->extent;
msProjectRect(projection, &out, &sRect);
msFreeProjection(projection);
msLoadProjectionString(projection, epsg_string);
/*change also units and extents*/
map->extent = sRect;
map->units = MS_DD;
if (map->debug)
msDebug("KmlRenderer::checkProjection: Mapfile projection set to epsg:4326\n");
return MS_SUCCESS;
}
#else
msSetError(MS_MISCERR, "Projection support not enabled", "KmlRenderer::checkProjection" );
return MS_FAILURE;
#endif
}
int msProjectRect(projectionObj *in, projectionObj *out, rectObj *rect)
{
#ifdef notdef
return msProjectRectTraditionalEdge( in, out, rect );
#else
char *over = "+over";
int ret;
projectionObj in_over,out_over,*inp,*outp;
/*
* Issue #4892: When projecting a rectangle we do not want proj to wrap resulting
* coordinates around the dateline, as in practice a requested bounding box of
* -22.000.000, -YYY, 22.000.000, YYY should be projected as
* -190,-YYY,190,YYY rather than 170,-YYY,-170,YYY as would happen when wrapping (and
* vice-versa when projecting from lonlat to metric).
* To enforce this, we clone the input projections and add the "+over" proj
* parameter in order to disable dateline wrapping.
*/
if(out) {
msInitProjection(&out_over);
msCopyProjectionExtended(&out_over,out,&over,1);
outp = &out_over;
} else {
outp = out;
}
if(in) {
msInitProjection(&in_over);
msCopyProjectionExtended(&in_over,in,&over,1);
inp = &in_over;
} else {
inp = in;
}
ret = msProjectRectAsPolygon(inp,outp, rect );
if(in)
msFreeProjection(&in_over);
if(out)
msFreeProjection(&out_over);
return ret;
#endif
}
static projectionObj* msGetProjectNormalized( const projectionObj* p )
{
int i;
char* pszNewProj4Def;
projectionObj* pnew;
pnew = (projectionObj*)msSmallMalloc(sizeof(projectionObj));
msInitProjection(pnew);
msCopyProjection(pnew, (projectionObj*)p);
if(p->proj == NULL )
return pnew;
/* Normalize definition so that msProjectDiffers() works better */
pszNewProj4Def = pj_get_def( p->proj, 0 );
msFreeCharArray(pnew->args, pnew->numargs);
pnew->args = msStringSplit(pszNewProj4Def,'+', &pnew->numargs);
for(i = 0; i < pnew->numargs; i++)
{
/* Remove trailing space */
if( strlen(pnew->args[i]) > 0 && pnew->args[i][strlen(pnew->args[i])-1] == ' ' )
pnew->args[i][strlen(pnew->args[i])-1] = '\0';
/* Remove spurious no_defs or init= */
if( strcmp(pnew->args[i], "no_defs") == 0 ||
strncmp(pnew->args[i], "init=", 5) == 0 )
{
if( i < pnew->numargs - 1 )
{
msFree(pnew->args[i]);
memmove(pnew->args + i, pnew->args + i + 1,
sizeof(char*) * (pnew->numargs - 1 -i ));
}
pnew->numargs --;
i --;
continue;
}
}
/* Sort the strings so they can be compared */
qsort(pnew->args, pnew->numargs, sizeof(char*), msProjectSortString);
/*{
fprintf(stderr, "'%s' =\n", pszNewProj4Def);
for(i = 0; i < p->numargs; i++)
fprintf(stderr, "'%s' ", p->args[i]);
fprintf(stderr, "\n");
}*/
pj_dalloc(pszNewProj4Def);
return pnew;
}
xmlNodePtr msOWSCommonBoundingBox(xmlNsPtr psNsOws, const char *crs, int dimensions, double minx, double miny, double maxx, double maxy)
{
char LowerCorner[100];
char UpperCorner[100];
char dim_string[100];
xmlNodePtr psRootNode = NULL;
/* Do we need to reorient tuple axes? */
if(crs && strstr(crs, "imageCRS") == NULL) {
projectionObj proj;
msInitProjection( &proj );
if( msLoadProjectionString( &proj, (char *) crs ) == 0 ) {
msAxisNormalizePoints( &proj, 1, &minx, &miny );
msAxisNormalizePoints( &proj, 1, &maxx, &maxy );
}
msFreeProjection( &proj );
}
if (_validateNamespace(psNsOws) == MS_FAILURE)
psNsOws = xmlNewNs(psRootNode, BAD_CAST MS_OWSCOMMON_OWS_NAMESPACE_URI, BAD_CAST MS_OWSCOMMON_OWS_NAMESPACE_PREFIX);
/* create element name */
psRootNode = xmlNewNode(psNsOws, BAD_CAST "BoundingBox");
/* add attributes to the root element */
xmlNewProp(psRootNode, BAD_CAST "crs", BAD_CAST crs);
snprintf( dim_string, sizeof(dim_string), "%d", dimensions );
xmlNewProp(psRootNode, BAD_CAST "dimensions", BAD_CAST dim_string);
snprintf(LowerCorner, sizeof(LowerCorner), "%.15g %.15g", minx, miny);
snprintf(UpperCorner, sizeof(UpperCorner), "%.15g %.15g", maxx, maxy);
/* add child elements */
xmlNewChild(psRootNode, psNsOws,BAD_CAST "LowerCorner",BAD_CAST LowerCorner);
xmlNewChild(psRootNode, psNsOws,BAD_CAST "UpperCorner",BAD_CAST UpperCorner);
return psRootNode;
}
char *FLTGetSpatialComparisonCommonExpression(FilterEncodingNode *psNode, layerObj *lp)
{
char *pszExpression = NULL;
shapeObj *psQueryShape = NULL;
double dfDistance = -1;
int nUnit = -1, nLayerUnit = -1;
char *pszWktText = NULL;
char szBuffer[256];
char *pszTmp=NULL;
projectionObj sProjTmp;
rectObj sQueryRect;
shapeObj *psTmpShape=NULL;
int bBBoxQuery = 0;
int bAlreadyReprojected = 0;
if (psNode == NULL || lp == NULL)
return NULL;
if (psNode->eType != FILTER_NODE_TYPE_SPATIAL)
return NULL;
/* get the shape */
if (FLTIsBBoxFilter(psNode)) {
char szPolygon[512];
FLTGetBBOX(psNode, &sQueryRect);
snprintf(szPolygon, sizeof(szPolygon),
"POLYGON((%.18f %.18f,%.18f %.18f,%.18f %.18f,%.18f %.18f,%.18f %.18f))",
sQueryRect.minx, sQueryRect.miny,
sQueryRect.minx, sQueryRect.maxy,
sQueryRect.maxx, sQueryRect.maxy,
sQueryRect.maxx, sQueryRect.miny,
sQueryRect.minx, sQueryRect.miny);
psTmpShape = msShapeFromWKT(szPolygon);
/*
** This is a horrible hack to deal with world-extent requests and
** reprojection. msProjectRect() detects if reprojection from longlat to
** projected SRS, and in that case it transforms the bbox to -1e-15,-1e-15,1e15,1e15
** to ensure that all features are returned.
**
** Make wfs_200_cite_filter_bbox_world.xml and wfs_200_cite_postgis_bbox_world.xml pass
*/
if (fabs(sQueryRect.minx - -180.0) < 1e-5 &&
fabs(sQueryRect.miny - -90.0) < 1e-5 &&
fabs(sQueryRect.maxx - 180.0) < 1e-5 &&
fabs(sQueryRect.maxy - 90.0) < 1e-5)
{
if (lp->projection.numargs > 0) {
if (psNode->pszSRS)
msInitProjection(&sProjTmp);
if (psNode->pszSRS) {
/* Use the non EPSG variant since axis swapping is done in FLTDoAxisSwappingIfNecessary */
if (msLoadProjectionString(&sProjTmp, psNode->pszSRS) == 0) {
msProjectRect(&sProjTmp, &lp->projection, &sQueryRect);
}
} else if (lp->map->projection.numargs > 0)
msProjectRect(&lp->map->projection, &lp->projection, &sQueryRect);
if (psNode->pszSRS)
msFreeProjection(&sProjTmp);
}
if (sQueryRect.minx <= -1e14) {
msFreeShape(psTmpShape);
msFree(psTmpShape);
psTmpShape = (shapeObj*) msSmallMalloc(sizeof(shapeObj));
msInitShape(psTmpShape);
msRectToPolygon(sQueryRect, psTmpShape);
bAlreadyReprojected = 1;
}
}
bBBoxQuery = 1;
} else {
/* other geos type operations */
/* project shape to layer projection. If the proj is not part of the filter query,
assume that the cooredinates are in the map projection */
psQueryShape = FLTGetShape(psNode, &dfDistance, &nUnit);
if ((strcasecmp(psNode->pszValue, "DWithin") == 0 || strcasecmp(psNode->pszValue, "Beyond") == 0 ) && dfDistance > 0) {
nLayerUnit = lp->units;
if(nLayerUnit == -1) nLayerUnit = GetMapserverUnitUsingProj(&lp->projection);
if(nLayerUnit == -1) nLayerUnit = lp->map->units;
if(nLayerUnit == -1) nLayerUnit = GetMapserverUnitUsingProj(&lp->map->projection);
if (nUnit >= 0 && nUnit != nLayerUnit)
dfDistance *= msInchesPerUnit(nUnit,0)/msInchesPerUnit(nLayerUnit,0); /* target is layer units */
}
psTmpShape = psQueryShape;
}
if (psTmpShape) {
/*
** target is layer projection
*/
if (!bAlreadyReprojected && lp->projection.numargs > 0) {
if (psNode->pszSRS)
msInitProjection(&sProjTmp);
if (psNode->pszSRS) {
/* Use the non EPSG variant since axis swapping is done in FLTDoAxisSwappingIfNecessary */
if (msLoadProjectionString(&sProjTmp, psNode->pszSRS) == 0) {
msProjectShape(&sProjTmp, &lp->projection, psTmpShape);
}
} else if (lp->map->projection.numargs > 0)
msProjectShape(&lp->map->projection, &lp->projection, psTmpShape);
if (psNode->pszSRS)
msFreeProjection(&sProjTmp);
}
/* function name */
if (bBBoxQuery) {
sprintf(szBuffer, "%s", "intersects");
} else {
if (strncasecmp(psNode->pszValue, "intersect", 9) == 0)
sprintf(szBuffer, "%s", "intersects");
else {
pszTmp = msStrdup(psNode->pszValue);
msStringToLower(pszTmp);
sprintf(szBuffer, "%s", pszTmp);
msFree(pszTmp);
}
}
pszExpression = msStringConcatenate(pszExpression, szBuffer);
pszExpression = msStringConcatenate(pszExpression, "(");
/* geometry binding */
sprintf(szBuffer, "%s", "[shape]");
pszExpression = msStringConcatenate(pszExpression, szBuffer);
pszExpression = msStringConcatenate(pszExpression, ",");
/* filter geometry */
pszWktText = msGEOSShapeToWKT(psTmpShape);
sprintf(szBuffer, "%s", "fromText('");
pszExpression = msStringConcatenate(pszExpression, szBuffer);
pszExpression = msStringConcatenate(pszExpression, pszWktText);
sprintf(szBuffer, "%s", "')");
pszExpression = msStringConcatenate(pszExpression, szBuffer);
msGEOSFreeWKT(pszWktText);
/* (optional) beyond/dwithin distance, always 0.0 since we apply the distance as a buffer earlier */
if ((strcasecmp(psNode->pszValue, "DWithin") == 0 || strcasecmp(psNode->pszValue, "Beyond") == 0)) {
// pszExpression = msStringConcatenate(pszExpression, ",0.0");
sprintf(szBuffer, ",%g", dfDistance);
pszExpression = msStringConcatenate(pszExpression, szBuffer);
}
/* terminate the function */
pszExpression = msStringConcatenate(pszExpression, ") = TRUE");
}
/*
** Cleanup
*/
if (bBBoxQuery) {
msFreeShape(psTmpShape);
msFree(psTmpShape);
}
return pszExpression;
}
int msUVRASTERLayerWhichShapes(layerObj *layer, rectObj rect, int isQuery)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
imageObj *image_tmp;
mapObj map_tmp;
unsigned int spacing;
int width, height, u_src_off, v_src_off, i, x, y;
char **alteredProcessing = NULL;
char **savedProcessing = NULL;
if (layer->debug)
msDebug("Entering msUVRASTERLayerWhichShapes().\n");
if( uvlinfo == NULL )
return MS_FAILURE;
/* QUERY NOT SUPPORTED YET */
if (isQuery == MS_TRUE) {
msSetError( MS_MISCERR, "Query is not supported for UV layer.", "msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
if( CSLFetchNameValue( layer->processing, "BANDS" ) == NULL ) {
msSetError( MS_MISCERR, "BANDS processing option is required for UV layer. You have to specified 2 bands.",
"msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Determine desired spacing. Default to 30 if not otherwise set */
/* -------------------------------------------------------------------- */
spacing = 30;
if( CSLFetchNameValue( layer->processing, "UV_SPACING" ) != NULL ) {
spacing =
atoi(CSLFetchNameValue( layer->processing, "UV_SPACING" ));
}
width = (int)ceil(layer->map->width/spacing);
height = (int)ceil(layer->map->height/spacing);
map_tmp.cellsize = layer->map->cellsize*spacing;
if (layer->debug)
msDebug("msUVRASTERLayerWhichShapes(): width: %d, height: %d, cellsize: %g\n",
width, height, map_tmp.cellsize);
/* Initialize our dummy map */
MS_INIT_COLOR(map_tmp.imagecolor, 255,255,255,255);
map_tmp.resolution = layer->map->resolution;
map_tmp.defresolution = layer->map->defresolution;
map_tmp.outputformat = (outputFormatObj *) msSmallCalloc(1,sizeof(outputFormatObj));
uvlinfo->band_count = map_tmp.outputformat->bands = 2;
map_tmp.outputformat->name = NULL;
map_tmp.outputformat->driver = NULL;
map_tmp.outputformat->refcount = 0;
map_tmp.outputformat->vtable = NULL;
map_tmp.outputformat->device = NULL;
map_tmp.outputformat->renderer = MS_RENDER_WITH_RAWDATA;
map_tmp.outputformat->imagemode = MS_IMAGEMODE_FLOAT32;
map_tmp.mappath = layer->map->mappath;
map_tmp.shapepath = layer->map->shapepath;
map_tmp.extent.minx = layer->map->extent.minx-(0.5*layer->map->cellsize)+(0.5*map_tmp.cellsize);
map_tmp.extent.miny = layer->map->extent.miny-(0.5*layer->map->cellsize)+(0.5*map_tmp.cellsize);
map_tmp.extent.maxx = map_tmp.extent.minx+((width-1)*map_tmp.cellsize);
map_tmp.extent.maxy = map_tmp.extent.miny+((height-1)*map_tmp.cellsize);
map_tmp.gt.rotation_angle = 0.0;
msInitProjection(&map_tmp.projection);
msCopyProjection(&map_tmp.projection, &layer->map->projection);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): extent: %g %d %g %g\n",
map_tmp.extent.minx, map_tmp.extent.miny,
map_tmp.extent.maxx, map_tmp.extent.maxy);
/* important to use that function, to compute map
geotransform, used by the resampling*/
msMapSetSize(&map_tmp, width, height);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): geotransform: %g %g %g %g %g %g\n",
map_tmp.gt.geotransform[0], map_tmp.gt.geotransform[1],
map_tmp.gt.geotransform[2], map_tmp.gt.geotransform[3],
map_tmp.gt.geotransform[4], map_tmp.gt.geotransform[5]);
uvlinfo->extent = map_tmp.extent;
image_tmp = msImageCreate(width, height, map_tmp.outputformat,
NULL, NULL, map_tmp.resolution, map_tmp.defresolution,
&(map_tmp.imagecolor));
/* Default set to AVERAGE resampling */
if( CSLFetchNameValue( layer->processing, "RESAMPLE" ) == NULL ) {
alteredProcessing = CSLDuplicate( layer->processing );
alteredProcessing =
CSLSetNameValue( alteredProcessing, "RESAMPLE",
"AVERAGE");
savedProcessing = layer->processing;
layer->processing = alteredProcessing;
}
if (msDrawRasterLayerLow(&map_tmp, layer, image_tmp, NULL ) == MS_FAILURE) {
msSetError(MS_MISCERR, "Unable to draw raster data.", NULL, "msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
/* restore the saved processing */
if (alteredProcessing != NULL)
layer->processing = savedProcessing;
/* free old query arrays */
if (uvlinfo->u) {
for (i=0; i<uvlinfo->width; ++i) {
free(uvlinfo->u[i]);
}
free(uvlinfo->u);
}
if (uvlinfo->v) {
for (i=0; i<uvlinfo->height; ++i) {
free(uvlinfo->v[i]);
}
free(uvlinfo->v);
}
/* Update our uv layer structure */
uvlinfo->width = width;
uvlinfo->height = height;
uvlinfo->query_results = width*height;
uvlinfo->u = (float **)msSmallMalloc(sizeof(float *)*width);
uvlinfo->v = (float **)msSmallMalloc(sizeof(float *)*width);
for (x = 0; x < width; ++x) {
uvlinfo->u[x] = (float *)msSmallMalloc(height * sizeof(float));
uvlinfo->v[x] = (float *)msSmallMalloc(height * sizeof(float));
for (y = 0; y < height; ++y) {
u_src_off = v_src_off = x + y * width;
v_src_off += width*height;
uvlinfo->u[x][y] = image_tmp->img.raw_float[u_src_off];
uvlinfo->v[x][y] = image_tmp->img.raw_float[v_src_off];
/* null vector? update the number of results */
if (uvlinfo->u[x][y] == 0 && uvlinfo->v[x][y] == 0)
--uvlinfo->query_results;
}
}
msFreeImage(image_tmp); /* we do not need the imageObj anymore */
uvlinfo->which_rect = map_tmp.extent;
uvlinfo->next_shape = 0;
return MS_SUCCESS;
}
