static void msUVRasterLayerInfoInitialize(layerObj *layer)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
if( uvlinfo != NULL )
return;
uvlinfo = (uvRasterLayerInfo *) msSmallCalloc(1,sizeof(uvRasterLayerInfo));
layer->layerinfo = uvlinfo;
uvlinfo->band_count = -1;
/* uvlinfo->raster_query_mode = RQM_ENTRY_PER_PIXEL; */
/* uvlinfo->range_mode = -1; /\* inactive *\/ */
/* uvlinfo->refcount = 0; */
/* uvlinfo->shape_tolerance = 0.0; */
uvlinfo->u = NULL;
uvlinfo->v = NULL;
uvlinfo->width = 0;
uvlinfo->height = 0;
/* uvlinfo->query_result_hard_max = 1000000; */
/* if( CSLFetchNameValue( layer->processing, "RASTER_QUERY_MAX_RESULT" ) */
/* != NULL ) */
/* { */
/* uvlinfo->query_result_hard_max = */
/* atoi(CSLFetchNameValue( layer->processing, "RASTER_QUERY_MAX_RESULT" )); */
/* } */
}
int msPreloadSVGSymbol(symbolObj *symbol)
{
#if defined(USE_SVG_CAIRO) || defined(USE_RSVG)
struct svg_symbol_cache *cache;
if(!symbol->renderer_cache) {
cache = msSmallCalloc(1,sizeof(struct svg_symbol_cache));
symbol->renderer_free_func = &freeSVGCache;
} else {
cache = symbol->renderer_cache;
}
if(cache->svgc)
return MS_SUCCESS;
#ifdef USE_SVG_CAIRO
{
unsigned int svg_width, svg_height;
int status;
status = svg_cairo_create(&cache->svgc);
if (status) {
msSetError(MS_RENDERERERR, "problem creating cairo svg", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
status = svg_cairo_parse(cache->svgc, symbol->full_pixmap_path);
if (status) {
msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
svg_cairo_get_size (cache->svgc, &svg_width, &svg_height);
if (svg_width == 0 || svg_height == 0) {
msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
symbol->sizex = svg_width;
symbol->sizey = svg_height;
}
#else
{
RsvgDimensionData dim;
cache->svgc = rsvg_handle_new_from_file(symbol->full_pixmap_path,NULL);
if(!cache->svgc) {
msSetError(MS_RENDERERERR,"failed to load svg file %s", "msPreloadSVGSymbol()", symbol->full_pixmap_path);
}
rsvg_handle_get_dimensions_sub (cache->svgc, &dim, NULL);
symbol->sizex = dim.width;
symbol->sizey = dim.height;
}
#endif
symbol->renderer_cache = cache;
return MS_SUCCESS;
#else
msSetError(MS_MISCERR, "SVG Symbols requested but is not built with libsvgcairo",
"msPreloadSVGSymbol()");
return MS_FAILURE;
#endif
}
static void msContourLayerInfoInitialize(layerObj *layer)
{
contourLayerInfo *clinfo = (contourLayerInfo *) layer->layerinfo;
if (clinfo != NULL)
return;
clinfo = (contourLayerInfo *) msSmallCalloc(1,sizeof(contourLayerInfo));
layer->layerinfo = clinfo;
clinfo->hOrigDS = NULL;
clinfo->hDS = NULL;
clinfo->extent.minx = -1.0;
clinfo->extent.miny = -1.0;
clinfo->extent.maxx = -1.0;
clinfo->extent.maxy = -1.0;
initLayer(&clinfo->ogrLayer, layer->map);
clinfo->ogrLayer.type = layer->type;
clinfo->ogrLayer.debug = layer->debug;
clinfo->ogrLayer.connectiontype = MS_OGR;
clinfo->ogrLayer.name = msStrdup(layer->name);
clinfo->ogrLayer.connection = (char*)msSmallMalloc(strlen(clinfo->ogrLayer.name)+13);
sprintf(clinfo->ogrLayer.connection, "__%s_CONTOUR__", clinfo->ogrLayer.name);
clinfo->ogrLayer.units = layer->units;
}
template<class VertexSource> int renderPolygonHatches(imageObj *img,VertexSource &clipper, colorObj *color)
{
if(img->format->renderer == MS_RENDER_WITH_AGG) {
AGG2Renderer *r = AGG_RENDERER(img);
r->m_rasterizer_aa_gamma.reset();
r->m_rasterizer_aa_gamma.filling_rule(mapserver::fill_non_zero);
r->m_rasterizer_aa_gamma.add_path(clipper);
r->m_renderer_scanline.color(aggColor(color));
mapserver::render_scanlines(r->m_rasterizer_aa_gamma, r->sl_poly, r->m_renderer_scanline);
} else {
shapeObj shape;
msInitShape(&shape);
int allocated = 20;
lineObj line;
shape.line = &line;
shape.numlines = 1;
shape.line[0].point = (pointObj*)msSmallCalloc(allocated,sizeof(pointObj));
shape.line[0].numpoints = 0;
double x=0,y=0;
unsigned int cmd;
clipper.rewind(0);
while((cmd = clipper.vertex(&x,&y)) != mapserver::path_cmd_stop) {
switch(cmd) {
case mapserver::path_cmd_line_to:
if(shape.line[0].numpoints == allocated) {
allocated *= 2;
shape.line[0].point = (pointObj*)msSmallRealloc(shape.line[0].point, allocated*sizeof(pointObj));
}
shape.line[0].point[shape.line[0].numpoints].x = x;
shape.line[0].point[shape.line[0].numpoints].y = y;
shape.line[0].numpoints++;
break;
case mapserver::path_cmd_move_to:
shape.line[0].point[0].x = x;
shape.line[0].point[0].y = y;
shape.line[0].numpoints = 1;
break;
case mapserver::path_cmd_end_poly|mapserver::path_flags_close:
if(shape.line[0].numpoints > 2) {
if(UNLIKELY(MS_FAILURE == MS_IMAGE_RENDERER(img)->renderPolygon(img,&shape,color))) {
free(shape.line[0].point);
return MS_FAILURE;
}
}
break;
default:
assert(0); //WTF?
}
}
free(shape.line[0].point);
}
return MS_SUCCESS;
}
int aggInitializeRasterBuffer(rasterBufferObj *rb, int width, int height, int mode)
{
rb->type = MS_BUFFER_BYTE_RGBA;
rb->data.rgba.pixel_step = 4;
rb->data.rgba.row_step = rb->data.rgba.pixel_step * width;
rb->width = width;
rb->height = height;
int nBytes = rb->data.rgba.row_step * height;
rb->data.rgba.pixels = (band_type*)msSmallCalloc(nBytes,sizeof(band_type));
rb->data.rgba.r = &(rb->data.rgba.pixels[band_order::R]);
rb->data.rgba.g = &(rb->data.rgba.pixels[band_order::G]);
rb->data.rgba.b = &(rb->data.rgba.pixels[band_order::B]);
if(mode == MS_IMAGEMODE_RGBA) {
rb->data.rgba.a = &(rb->data.rgba.pixels[band_order::A]);
}
return MS_SUCCESS;
}
/*
* Initialize the renderer, create buffer, allocate memory.
*/
imageObj *utfgridCreateImage(int width, int height, outputFormatObj *format, colorObj * bg)
{
UTFGridRenderer *r;
r = new UTFGridRenderer;
r->data = new lookupTable;
r->utfresolution = atof(msGetOutputFormatOption(format, "UTFRESOLUTION", "4"));
if(r->utfresolution < 1) {
msSetError(MS_MISCERR, "UTFRESOLUTION smaller that 1 in the mapfile.", "utfgridCreateImage()");
return NULL;
}
r->layerwatch = 0;
r->renderlayer = 0;
r->useutfitem = 0;
r->useutfdata = 0;
r->duplicates = EQUAL("true", msGetOutputFormatOption(format, "DUPLICATES", "true"));
r->utfvalue = 0;
r->buffer = (band_type*)msSmallMalloc(width/r->utfresolution * height/r->utfresolution * sizeof(band_type));
/* AGG specific operations */
r->m_rendering_buffer.attach(r->buffer, width/r->utfresolution, height/r->utfresolution, width/r->utfresolution);
r->m_pixel_format.attach(r->m_rendering_buffer);
r->m_renderer_base.attach(r->m_pixel_format);
r->m_renderer_scanline.attach(r->m_renderer_base);
r->m_renderer_base.clear(UTF_WATER);
r->m_rasterizer.gamma(mapserver::gamma_none());
r->utflayer = NULL;
imageObj *image = NULL;
image = (imageObj *) msSmallCalloc(1,sizeof(imageObj));
image->img.plugin = (void*) r;
return image;
}
int msUVRASTERLayerGetItems(layerObj *layer)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
if( uvlinfo == NULL )
return MS_FAILURE;
layer->numitems = 0;
layer->items = (char **) msSmallCalloc(sizeof(char *),10);;
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_ANGLE);
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_MINUS_ANGLE);
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_LENGTH);
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_LENGTH_2);
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_U);
layer->items[layer->numitems++] = msStrdup(MSUVRASTER_V);
layer->items[layer->numitems] = NULL;
return msUVRASTERLayerInitItemInfo(layer);
}
/*
** Polygon fill. Based on "Concave Polygon Scan Conversion" by Paul
** Heckbert from "Graphics Gems", Academic Press, 1990.
**
*/
static void imageFilledPolygon(gdImagePtr im, shapeObj *p, int c)
{
typedef struct { /* a polygon edge */
double x; /* x coordinate of edge's intersection with current scanline */
double dx; /* change in x with respect to y */
int i; /* point index */
int l; /* line number */
int s; /* scanline */
} pEdge;
pointObj *point1, *point2;
int k, l, i, j, xl, xr, ymin, ymax, y, n,nvert, nact, m;
int wrong_order;
pEdge *edge, *temp;
pEdge **active;
int *yhist, *edgeindex;
if(p->numlines == 0) return;
n=0;
for(i=0; i<p->numlines; i++) {
n += p->line[i].numpoints;
}
if(n == 0) return;
edge = (pEdge *) msSmallCalloc(n,sizeof(pEdge)); /* All edges in the polygon */
edgeindex = (int *) msSmallCalloc(n,sizeof(int)); /* Index to edges sorted by scanline */
active = (pEdge **) msSmallCalloc(n,sizeof(pEdge*)); /* Pointers to active edges for current scanline */
nvert=0;
ymin= (int) ceil(p->line[0].point[0].y-0.5);
ymax= (int) floor(p->line[0].point[0].y-0.5);
/* populate the edge table */
for(l=0; l<p->numlines; l++) {
for(i=0; i < p->line[l].numpoints; i++) {
j = i < p->line[l].numpoints -1 ? i+1 : 0;
if (p->line[l].point[i].y < p->line[l].point[j].y ) {
point1 = &(p->line[l].point[i]);
point2 = &(p->line[l].point[j]);
} else {
point2 = &(p->line[l].point[i]);
point1 = &(p->line[l].point[j]);
}
edge[nvert].dx = point2->y == point1->y ? 0 : (point2->x - point1->x) / (point2->y - point1->y);
edge[nvert].s = MS_NINT( p->line[l].point[i].y ); /* ceil( p->line[l].point[i].y - 0.5 ); */
edge[nvert].x = point1->x;
edge[nvert].i = nvert;
edge[nvert].l = l;
ymin = MS_MIN(ymin,edge[nvert].s);
ymax = MS_MAX(ymax,edge[nvert].s);
nvert++;
}
}
/* Use histogram sort to create a bucket-sorted edgeindex by scanline */
yhist = (int*) msSmallCalloc(ymax - ymin + 2, sizeof(int));
for(i=0; i<nvert; i++) {
yhist[ edge[i].s - ymin + 1 ]++;
}
for(i=0; i<=(ymax - ymin); i++) {/* Calculate starting point in edgeindex for each scanline */
yhist[i+1] += yhist[i];
}
for(i=0; i<nvert; i++) { /* Bucket sort edges into edgeindex */
y = edge[i].s;
edgeindex[yhist[y-ymin]] = i;
yhist[y-ymin]++;
}
free(yhist);
k=0;
nact=0;
for (y=ymin; y<=ymax; y++) { /* step through scanlines */
/* scanline y is at y+.5 in continuous coordinates */
/* check vertices between previous scanline and current one, if any */
for (; k<nvert && edge[edgeindex[k]].s <= y; k++) {
i = edge[edgeindex[k]].i;
/* vertex previous to i */
if(i==0 || edge[i].l != edge[i-1].l)
j = i + p->line[edge[i].l].numpoints - 1;
else
j = i - 1;
if (edge[j].s <= y ) { /* old edge, remove from active list */
for (m=0; m<nact && active[m]->i!=j; m++);
if (m<nact) {
nact--;
active[m]=active[nact];
}
} else if (edge[j].s > y) { /* new edge, insert into active list */
active[nact]= & edge[j];
nact++;
}
/* vertex next after i */
if(i==nvert-1 || edge[i].l != edge[i+1].l)
j = i - p->line[edge[i].l].numpoints + 1;
else
j = i + 1;
if (edge[j].s <= y - 1 ) { /* old edge, remove from active list */
for (m=0; m<nact && active[m]->i!=i; m++);
if (m<nact) {
nact--;
active[m]=active[nact];
}
} else if (edge[j].s > y ) { /* new edge, insert into active list */
active[nact]= & edge[i];
nact++;
}
}
/* Sort active edges by x */
do {
wrong_order = 0;
for(i=0; i < nact-1; i++) {
if(active[i]->x > active[i+1]->x) {
wrong_order = 1;
SWAP(active[i], active[i+1], temp);
}
}
} while(wrong_order);
/* draw horizontal spans for scanline y */
for (j=0; j<nact; j+=2) {
/* j -> j+1 is inside, j+1 -> j+2 is outside */
xl = (int) MS_NINT(active[j]->x );
xr = (int) (active[j+1]->x - 0.5) ;
if(active[j]->x != active[j+1]->x)
imageScanline(im, xl, xr, y, c);
active[j]->x += active[j]->dx; /* increment edge coords */
active[j+1]->x += active[j+1]->dx;
}
}
free(active);
free(edgeindex);
free(edge);
}
int msUVRASTERLayerWhichShapes(layerObj *layer, rectObj rect, int isQuery)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
imageObj *image_tmp;
outputFormatObj *outputformat = NULL;
mapObj *map_tmp;
double map_cellsize;
unsigned int spacing;
int width, height, u_src_off, v_src_off, i, x, y;
char **alteredProcessing = NULL, *saved_layer_mask;
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;
}
/*
** Allocate mapObj structure
*/
map_tmp = (mapObj *)msSmallCalloc(sizeof(mapObj),1);
if(initMap(map_tmp) == -1) { /* initialize this map */
msFree(map_tmp);
return(MS_FAILURE);
}
/* -------------------------------------------------------------------- */
/* Determine desired spacing. Default to 32 if not otherwise set */
/* -------------------------------------------------------------------- */
spacing = 32;
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_cellsize = MS_MAX(MS_CELLSIZE(rect.minx, rect.maxx,layer->map->width),
MS_CELLSIZE(rect.miny,rect.maxy,layer->map->height));
map_tmp->cellsize = 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;
outputformat = (outputFormatObj *) msSmallCalloc(1,sizeof(outputFormatObj));
outputformat->bands = uvlinfo->band_count = 2;
outputformat->name = NULL;
outputformat->driver = NULL;
outputformat->refcount = 0;
outputformat->vtable = NULL;
outputformat->device = NULL;
outputformat->renderer = MS_RENDER_WITH_RAWDATA;
outputformat->imagemode = MS_IMAGEMODE_FLOAT32;
msAppendOutputFormat(map_tmp, outputformat);
msCopyHashTable(&map_tmp->configoptions, &layer->map->configoptions);
map_tmp->mappath = msStrdup(layer->map->mappath);
map_tmp->shapepath = msStrdup(layer->map->shapepath);
map_tmp->extent.minx = rect.minx-(0.5*map_cellsize)+(0.5*map_tmp->cellsize);
map_tmp->extent.miny = rect.miny-(0.5*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;
msCopyProjection(&map_tmp->projection, &layer->projection);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): extent: %g %g %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->outputformatlist[0],
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;
}
/* disable masking at this level: we don't want to apply the mask at the raster level,
* it will be applied with the correct cellsize and image size in the vector rendering
* phase.
*/
saved_layer_mask = layer->mask;
layer->mask = NULL;
if (msDrawRasterLayerLow(map_tmp, layer, image_tmp, NULL ) == MS_FAILURE) {
msSetError(MS_MISCERR, "Unable to draw raster data.", "msUVRASTERLayerWhichShapes()");
layer->mask = saved_layer_mask;
return MS_FAILURE;
}
/* restore layer mask */
layer->mask = saved_layer_mask;
/* restore the saved processing */
if (alteredProcessing != NULL) {
layer->processing = savedProcessing;
CSLDestroy(alteredProcessing);
}
/* 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 */
msFreeMap(map_tmp);
uvlinfo->next_shape = 0;
return MS_SUCCESS;
}
int msRenderRasterizedSVGSymbol(imageObj *img, double x, double y, symbolObj *symbol, symbolStyleObj *style)
{
#if defined(USE_SVG_CAIRO) || defined(USE_RSVG)
struct svg_symbol_cache *svg_cache;
symbolStyleObj pixstyle;
symbolObj pixsymbol;
int status;
if(MS_SUCCESS != msPreloadSVGSymbol(symbol))
return MS_FAILURE;
svg_cache = (struct svg_symbol_cache*) symbol->renderer_cache;
//already rendered at the right size and scale? return
if(svg_cache->scale != style->scale || svg_cache->rotation != style->rotation) {
cairo_t *cr;
cairo_surface_t *surface;
unsigned char *pb;
int width, height, surface_w, surface_h;
/* need to recompute the pixmap */
if(svg_cache->pixmap_buffer) {
msFreeRasterBuffer(svg_cache->pixmap_buffer);
} else {
svg_cache->pixmap_buffer = msSmallCalloc(1,sizeof(rasterBufferObj));
}
//increase pixmap size to accomodate scaling/rotation
if (style->scale != 1.0) {
width = surface_w = (symbol->sizex * style->scale + 0.5);
height = surface_h = (symbol->sizey * style->scale + 0.5);
} else {
width = surface_w = symbol->sizex;
height = surface_h = symbol->sizey;
}
if (style->rotation != 0) {
surface_w = surface_h = MS_NINT(MS_MAX(height, width) * 1.415);
}
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, surface_w, surface_h);
cr = cairo_create(surface);
if (style->rotation != 0) {
cairo_translate(cr, surface_w / 2, surface_h / 2);
cairo_rotate(cr, -style->rotation);
cairo_translate(cr, -width / 2, -height / 2);
}
if (style->scale != 1.0) {
cairo_scale(cr, style->scale, style->scale);
}
#ifdef USE_SVG_CAIRO
if(svg_cairo_render(svg_cache->svgc, cr) != SVG_CAIRO_STATUS_SUCCESS) {
return MS_FAILURE;
}
#else
rsvg_handle_render_cairo(svg_cache->svgc, cr);
#endif
pb = cairo_image_surface_get_data(surface);
//set up raster
initializeRasterBufferCairo(svg_cache->pixmap_buffer, surface_w, surface_h, 0);
memcpy(svg_cache->pixmap_buffer->data.rgba.pixels, pb, surface_w * surface_h * 4 * sizeof (unsigned char));
svg_cache->scale = style->scale;
svg_cache->rotation = style->rotation;
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
assert(svg_cache->pixmap_buffer->height && svg_cache->pixmap_buffer->width);
pixstyle = *style;
pixstyle.rotation = 0.0;
pixstyle.scale = 1.0;
pixsymbol.pixmap_buffer = svg_cache->pixmap_buffer;
pixsymbol.type = MS_SYMBOL_PIXMAP;
status = MS_IMAGE_RENDERER(img)->renderPixmapSymbol(img,x,y,&pixsymbol,&pixstyle);
MS_IMAGE_RENDERER(img)->freeSymbol(&pixsymbol);
return status;
#else
msSetError(MS_MISCERR, "SVG Symbols requested but MapServer is not built with libsvgcairo",
"renderSVGSymbolCairo()");
return MS_FAILURE;
#endif
}
/*
* Utility function to create a IM image. Returns
* a pointer to an imageObj structure.
*/
imageObj *msImageCreateIM(int width, int height, outputFormatObj *format,
char *imagepath, char *imageurl, double resolution, double defresolution)
{
imageObj *image=NULL;
if (setvbuf(stdout, NULL, _IONBF , 0)) {
printf("Whoops...");
};
DEBUG_IF printf("msImageCreateIM<BR>\n");
if (width > 0 && height > 0) {
image = (imageObj *)msSmallCalloc(1,sizeof(imageObj));
imgStr.string = &(image->img.imagemap);
imgStr.alloc_size = &(image->size);
image->format = format;
format->refcount++;
image->width = width;
image->height = height;
image->imagepath = NULL;
image->imageurl = NULL;
image->resolution = resolution;
image->resolutionfactor = resolution/defresolution;
if( strcasecmp("ON",msGetOutputFormatOption( format, "DXF", "OFF" )) == 0) {
dxf = 1;
im_iprintf(&layerStr, " 2\nLAYER\n 70\n 10\n");
} else
dxf = 0;
if( strcasecmp("ON",msGetOutputFormatOption( format, "SCRIPT", "OFF" )) == 0) {
dxf = 2;
im_iprintf(&layerStr, "");
}
/* get href formation string options */
polyHrefFmt = makeFmtSafe(msGetOutputFormatOption
( format, "POLYHREF", "javascript:Clicked('%s');"), 1);
polyMOverFmt = makeFmtSafe(msGetOutputFormatOption
( format, "POLYMOUSEOVER", ""), 1);
polyMOutFmt = makeFmtSafe(msGetOutputFormatOption
( format, "POLYMOUSEOUT", ""), 1);
symbolHrefFmt = makeFmtSafe(msGetOutputFormatOption
( format, "SYMBOLHREF", "javascript:SymbolClicked();"), 1);
symbolMOverFmt = makeFmtSafe(msGetOutputFormatOption
( format, "SYMBOLMOUSEOVER", ""), 1);
symbolMOutFmt = makeFmtSafe(msGetOutputFormatOption
( format, "SYMBOLMOUSEOUT", ""), 1);
/* get name of client-side image map */
mapName = msGetOutputFormatOption
( format, "MAPNAME", "map1" );
/* should we suppress area declarations with no title? */
if( strcasecmp("YES",msGetOutputFormatOption( format, "SUPPRESS", "NO" )) == 0) {
suppressEmpty=1;
}
lname = msStrdup("NONE");
*(imgStr.string) = msStrdup("");
if (*(imgStr.string)) {
*(imgStr.alloc_size) =
imgStr.string_len = strlen(*(imgStr.string));
} else {
*(imgStr.alloc_size) =
imgStr.string_len = 0;
}
if (imagepath) {
image->imagepath = msStrdup(imagepath);
}
if (imageurl) {
image->imageurl = msStrdup(imageurl);
}
return image;
} else {
msSetError(MS_IMGERR,
"Cannot create IM image of size %d x %d.",
"msImageCreateIM()", width, height );
}
return image;
}
int KmlRenderer::startNewLayer(imageObj *img, layerObj *layer)
{
char *layerName=NULL;
const char *value=NULL;
LayerNode = xmlNewNode(NULL, BAD_CAST "Folder");
layerName = getLayerName(layer);
xmlNewChild(LayerNode, NULL, BAD_CAST "name", BAD_CAST layerName);
msFree(layerName);
const char *layerVisibility = layer->status != MS_OFF ? "1" : "0";
xmlNewChild(LayerNode, NULL, BAD_CAST "visibility", BAD_CAST layerVisibility);
const char *layerDsiplayFolder = msLookupHashTable(&(layer->metadata), "kml_folder_display");
if (layerDsiplayFolder == NULL)
layerDsiplayFolder = msLookupHashTable(&(layer->map->web.metadata), "kml_folder_display");
if (!layerDsiplayFolder || strlen(layerDsiplayFolder)<=0) {
xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_check");
}
else {
if (strcasecmp(layerDsiplayFolder, "checkHideChildren") == 0)
xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_checkHideChildren");
else if (strcasecmp(layerDsiplayFolder, "checkOffOnly") == 0)
xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_checkOffOnly");
else if (strcasecmp(layerDsiplayFolder, "radioFolder") == 0)
xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_radioFolder");
else
xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_check");
}
/*Init few things on the first layer*/
if (FirstLayer) {
FirstLayer = MS_FALSE;
map = layer->map;
if (layer->map->mappath)
snprintf(MapPath, sizeof(MapPath), "%s", layer->map->mappath);
/*First rendered layer - check mapfile projection*/
checkProjection(layer->map);
/*check for image path and image url*/
if (layer->map->debug && (layer->map->web.imageurl == NULL || layer->map->web.imagepath == NULL))
msDebug("KmlRenderer::startNewLayer: imagepath and imageurl should be set in the web object\n");
/*map rect for ground overlay*/
MapExtent = layer->map->extent;
MapCellsize = layer->map->cellsize;
BgColor = layer->map->imagecolor;
xmlNewChild(DocNode, NULL, BAD_CAST "name", BAD_CAST layer->map->name);
aggFormat = msSelectOutputFormat( layer->map, "png24");
aggFormat->transparent = MS_TRUE;
}
currentLayer = layer;
if (!msLayerIsOpen(layer)) {
if (msLayerOpen(layer) != MS_SUCCESS) {
msSetError(MS_MISCERR, "msLayerOpen failed", "KmlRenderer::startNewLayer" );
return MS_FAILURE;
}
}
/*pre process the layer to set things that make sense for kml output*/
if (img)
processLayer(layer, img->format);
else
processLayer(layer, NULL);
if (msLookupHashTable(&layer->metadata, "kml_description"))
pszLayerDescMetadata = msLookupHashTable(&layer->metadata, "kml_description");
else if (msLookupHashTable(&layer->metadata, "ows_description"))
pszLayerDescMetadata = msLookupHashTable(&layer->metadata, "ows_description");
value=msLookupHashTable(&layer->metadata, "kml_include_items");
if (!value)
value=msLookupHashTable(&layer->metadata, "ows_include_items");
if (value)
papszLayerIncludeItems = msStringSplit(value, ',', &nIncludeItems);
value=msLookupHashTable(&layer->metadata, "kml_exclude_items");
if (!value)
value=msLookupHashTable(&layer->metadata, "ows_exclude_items");
if (value)
papszLayerExcludeItems = msStringSplit(value, ',', &nExcludeItems);
if (msLookupHashTable(&layer->metadata, "kml_name_item"))
pszLayerNameAttributeMetadata = msLookupHashTable(&layer->metadata, "kml_name_item");
/*get all attributes*/
if(msLayerWhichItems(layer, MS_TRUE, NULL) != MS_SUCCESS) {
return MS_FAILURE;
}
NumItems = layer->numitems;
if (NumItems) {
Items = (char **)msSmallCalloc(NumItems, sizeof(char *));
for (int i=0; i<NumItems; i++)
Items[i] = msStrdup(layer->items[i]);
}
const char* elevationAttribute = msLookupHashTable(&layer->metadata, "kml_elevation_attribute");
if( elevationAttribute ) {
mElevationFromAttribute = true;
for( int i = 0; i < layer->numitems; ++i ) {
if( strcasecmp( layer->items[i], elevationAttribute ) == 0 ) {
mElevationAttributeIndex = i;
}
}
}
setupRenderingParams(&layer->metadata);
return MS_SUCCESS;
}
int msPreloadSVGSymbol(symbolObj *symbol)
{
#ifdef USE_SVG_CAIRO
int status;
unsigned int svg_width, svg_height;
struct svg_symbol_cache *cache;
if(!symbol->renderer_cache) {
cache = msSmallCalloc(1,sizeof(struct svg_symbol_cache));
} else {
cache = symbol->renderer_cache;
}
if(cache->svgc)
return MS_SUCCESS;
if (!symbol->svg_text) {
FILE *stream;
long int file_len;
if ((stream = fopen(symbol->full_pixmap_path, "rb")) == NULL) {
msSetError(MS_IOERR, "Could not open svg file %s", "msPreloadSVGSymbol()",symbol->full_pixmap_path);
return (MS_FAILURE);
}
fseek(stream, 0, SEEK_END);
file_len = ftell(stream);
rewind(stream);
symbol->svg_text = (char*) msSmallMalloc(sizeof (char) * file_len);
if (1 != fread(symbol->svg_text, file_len, 1, stream)) {
msSetError(MS_IOERR, "failed to read %d bytes from svg file %s", "loadSymbol()", file_len, symbol->full_pixmap_path);
free(symbol->svg_text);
return MS_FAILURE;
}
symbol->svg_text[file_len - 1] = '\0';
fclose(stream);
}
status = svg_cairo_create(&cache->svgc);
if (status) {
msSetError(MS_RENDERERERR, "problem creating cairo svg", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
status = svg_cairo_parse_buffer(cache->svgc, symbol->svg_text, strlen(symbol->svg_text));
if (status) {
msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
svg_cairo_get_size (cache->svgc, &svg_width, &svg_height);
if (svg_width == 0 || svg_height == 0) {
msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
return MS_FAILURE;
}
symbol->sizex = svg_width;
symbol->sizey = svg_height;
symbol->renderer_cache = cache;
return MS_SUCCESS;
#else
msSetError(MS_MISCERR, "SVG Symbols requested but is not built with libsvgcairo",
"msPreloadSVGSymbol()");
return MS_FAILURE;
#endif
}
