/******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: Google Earth KML output
* Author: David Kana and the MapServer team
*
******************************************************************************
* Copyright (c) 1996-2009 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapserver-config.h"
#ifdef USE_KML
#include "mapserver.h"
#include "maperror.h"
#include "mapkmlrenderer.h"
#include "mapio.h"
#include "mapows.h"
#include "cpl_conv.h"
#include "cpl_vsi.h"
#include "cpl_string.h"
#define KML_MAXFEATURES_TODRAW 1000
KmlRenderer::KmlRenderer(int width, int height, outputFormatObj * /*format*/,
colorObj * /*color*/)
: Width(width), Height(height), MapCellsize(1.0), XmlDoc(NULL),
LayerNode(NULL), GroundOverlayNode(NULL), PlacemarkNode(NULL),
GeomNode(NULL), Items(NULL), NumItems(0), FirstLayer(MS_TRUE), map(NULL),
currentLayer(NULL), mElevationFromAttribute(false),
mElevationAttributeIndex(-1), mCurrentElevationValue(0.0)
{
/*private variables*/
pszLayerDescMetadata = NULL;
papszLayerIncludeItems = NULL;
nIncludeItems = 0;
papszLayerExcludeItems = NULL;
nExcludeItems = 0;
pszLayerNameAttributeMetadata =
NULL; /*metadata to use for a name for each feature*/
LineStyle = NULL;
numLineStyle = 0;
xmlNodePtr styleNode;
xmlNodePtr listStyleNode;
/* Create document.*/
XmlDoc = xmlNewDoc(BAD_CAST "1.0");
xmlNodePtr rootNode = xmlNewNode(NULL, BAD_CAST "kml");
/* Name spaces*/
xmlSetNs(rootNode,
xmlNewNs(rootNode, BAD_CAST "http://www.opengis.net/kml/2.2", NULL));
xmlDocSetRootElement(XmlDoc, rootNode);
DocNode = xmlNewChild(rootNode, NULL, BAD_CAST "Document", NULL);
styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);
xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_check");
listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);
xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType", BAD_CAST "check");
styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);
xmlNewProp(styleNode, BAD_CAST "id",
BAD_CAST "LayerFolder_checkHideChildren");
listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);
xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType",
BAD_CAST "checkHideChildren");
styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);
xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_checkOffOnly");
listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);
xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType",
BAD_CAST "checkOffOnly");
styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);
xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_radioFolder");
listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);
xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType",
BAD_CAST "radioFolder");
StyleHashTable = msCreateHashTable();
}
KmlRenderer::~KmlRenderer() {
if (XmlDoc)
xmlFreeDoc(XmlDoc);
if (StyleHashTable)
msFreeHashTable(StyleHashTable);
if (LineStyle)
msFree(LineStyle);
xmlCleanupParser();
}
imageObj *KmlRenderer::createImage(int, int, outputFormatObj *, colorObj *) {
return NULL;
}
int KmlRenderer::saveImage(imageObj *, FILE *fp, outputFormatObj *format) {
/* -------------------------------------------------------------------- */
/* Write out the document. */
/* -------------------------------------------------------------------- */
int bufSize = 0;
xmlChar *buf = NULL;
msIOContext *context = NULL;
int chunkSize = 4096;
int bZip = MS_FALSE;
if (msIO_needBinaryStdout() == MS_FAILURE)
return MS_FAILURE;
xmlDocDumpFormatMemoryEnc(XmlDoc, &buf, &bufSize, "UTF-8", 1);
if (format && format->driver && strcasecmp(format->driver, "kmz") == 0) {
bZip = MS_TRUE;
}
if (bZip) {
VSILFILE *fpZip;
int bytes_read;
char buffer[1024];
char *zip_filename = NULL;
void *hZip = NULL;
const char *timestamp;
timestamp = msGetOutputFormatOption(format, "TIMESTAMP", "NOW");
char **papszOptions = nullptr;
papszOptions = CSLAddNameValue(papszOptions, "TIMESTAMP", timestamp);
zip_filename = msTmpFile(NULL, NULL, "/vsimem/kmlzip/", "kmz");
hZip = CPLCreateZip(zip_filename, NULL);
CPLCreateFileInZip(hZip, "mapserver.kml", papszOptions);
for (int i = 0; i < bufSize; i += chunkSize) {
int size = chunkSize;
if (i + size > bufSize)
size = bufSize - i;
CPLWriteFileInZip(hZip, buf + i, size);
}
CPLCloseFileInZip(hZip);
CPLCloseZip(hZip);
CSLDestroy(papszOptions);
context = msIO_getHandler(fp);
fpZip = VSIFOpenL(zip_filename, "r");
while ((bytes_read = VSIFReadL(buffer, 1, sizeof(buffer), fpZip)) > 0) {
if (context)
msIO_contextWrite(context, buffer, bytes_read);
else
msIO_fwrite(buffer, 1, bytes_read, fp);
}
VSIFCloseL(fpZip);
msFree(zip_filename);
xmlFree(buf);
return (MS_SUCCESS);
}
context = msIO_getHandler(fp);
for (int i = 0; i < bufSize; i += chunkSize) {
int size = chunkSize;
if (i + size > bufSize)
size = bufSize - i;
if (context)
msIO_contextWrite(context, buf + i, size);
else
msIO_fwrite(buf + i, 1, size, fp);
}
xmlFree(buf);
return (MS_SUCCESS);
}
/************************************************************************/
/* processLayer */
/* */
/* Set parameters that make sense to a kml output. */
/************************************************************************/
void KmlRenderer::processLayer(layerObj *layer, outputFormatObj *format) {
int i;
const char *asRaster = NULL;
int nMaxFeatures = -1;
const char *pszTmp;
char szTmp[10];
if (!layer)
return;
/*turn of labelcache*/
layer->labelcache = MS_OFF;
/*if there are labels we want the coordinates to
be the center of the element.*/
for (i = 0; i < layer->numclasses; i++)
if (layer->_class[i]->numlabels > 0)
layer->_class[i]->labels[0]->position = MS_XY;
/*we do not want to draw multiple styles.
the new rendering architecture does not allow
to know if we are dealing with a multi-style.
So here we remove all styles beside the first one*/
for (i = 0; i < layer->numclasses; i++) {
while (layer->_class[i]->numstyles > 1)
msDeleteStyle(layer->_class[i], layer->_class[i]->numstyles - 1);
}
/*if layer has a metadata KML_OUTPUTASRASTER set to true, add a processing
directive to use an agg driver*/
asRaster = msLookupHashTable(&layer->metadata, "kml_outputasraster");
if (!asRaster)
asRaster =
msLookupHashTable(&(layer->map->web.metadata), "kml_outputasraster");
if (asRaster &&
(strcasecmp(asRaster, "true") == 0 || strcasecmp(asRaster, "yes") == 0))
msLayerAddProcessing(layer, "RENDERER=png24");
/*set a maxfeaturestodraw, if not already set*/
pszTmp = msLookupHashTable(&layer->metadata, "maxfeaturestodraw");
if (pszTmp)
nMaxFeatures = atoi(pszTmp);
else {
pszTmp = msLookupHashTable(&layer->map->web.metadata, "maxfeaturestodraw");
if (pszTmp)
nMaxFeatures = atoi(pszTmp);
}
if (nMaxFeatures < 0 && format)
nMaxFeatures =
atoi(msGetOutputFormatOption(format, "maxfeaturestodraw", "-1"));
if (nMaxFeatures < 0 && format) {
snprintf(szTmp, sizeof(szTmp), "%d", KML_MAXFEATURES_TODRAW);
msSetOutputFormatOption(format, "maxfeaturestodraw", szTmp);
}
}
/************************************************************************/
/* getLayerName */
/* */
/* Internal utility function to build name used for the layer. */
/************************************************************************/
char *KmlRenderer::getLayerName(layerObj *layer) {
char stmp[20];
const char *name = NULL;
;
if (!layer)
return NULL;
name = msLookupHashTable(&layer->metadata, "ows_name");
if (name && strlen(name) > 0)
return msStrdup(name);
if (layer->name && strlen(layer->name) > 0)
return msStrdup(layer->name);
sprintf(stmp, "Layer%d", layer->index);
return msStrdup(stmp);
}
const char *KmlRenderer::getAliasName(layerObj *lp, char *pszItemName,
const char *namespaces) {
const char *pszAlias = NULL;
if (lp && pszItemName && strlen(pszItemName) > 0) {
char szTmp[256];
snprintf(szTmp, sizeof(szTmp), "%s_alias", pszItemName);
pszAlias = msOWSLookupMetadata(&(lp->metadata), namespaces, szTmp);
}
return pszAlias;
}
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) 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 KmlRenderer::closeNewLayer(imageObj *, layerObj *) {
flushPlacemark();
xmlAddChild(DocNode, LayerNode);
if (Items) {
msFreeCharArray(Items, NumItems);
Items = NULL;
NumItems = 0;
}
if (pszLayerDescMetadata)
pszLayerDescMetadata = NULL;
if (pszLayerNameAttributeMetadata)
pszLayerNameAttributeMetadata = NULL;
if (papszLayerIncludeItems && nIncludeItems > 0)
msFreeCharArray(papszLayerIncludeItems, nIncludeItems);
papszLayerIncludeItems = NULL;
if (papszLayerExcludeItems && nExcludeItems > 0)
msFreeCharArray(papszLayerExcludeItems, nExcludeItems);
papszLayerExcludeItems = NULL;
return MS_SUCCESS;
}
int KmlRenderer::mergeRasterBuffer(imageObj *image, rasterBufferObj *rb) {
assert(rb && rb->type == MS_BUFFER_BYTE_RGBA);
char *tmpFileName = NULL;
char *tmpUrl = NULL;
FILE *tmpFile = NULL;
tmpFileName = msTmpFile(NULL, MapPath, image->imagepath, "png");
tmpFile = fopen(tmpFileName, "wb");
if (tmpFile) {
if (!aggFormat->vtable)
msInitializeRendererVTable(aggFormat);
msSaveRasterBuffer(map, rb, tmpFile, aggFormat);
tmpUrl = msStrdup(image->imageurl);
tmpUrl = msStringConcatenate(tmpUrl, (char *)(msGetBasename(tmpFileName)));
tmpUrl = msStringConcatenate(tmpUrl, ".png");
createGroundOverlayNode(LayerNode, tmpUrl, currentLayer);
msFree(tmpFileName);
msFree(tmpUrl);
fclose(tmpFile);
return MS_SUCCESS;
} else {
msSetError(MS_IOERR, "Failed to create file for kml overlay",
"KmlRenderer::mergeRasterBuffer()");
return MS_FAILURE;
}
}
void KmlRenderer::setupRenderingParams(hashTableObj *layerMetadata) {
AltitudeMode = 0;
Extrude = 0;
Tessellate = 0;
const char *altitudeModeVal =
msLookupHashTable(layerMetadata, "kml_altitudeMode");
if (altitudeModeVal) {
if (strcasecmp(altitudeModeVal, "absolute") == 0)
AltitudeMode = absolute;
else if (strcasecmp(altitudeModeVal, "relativeToGround") == 0)
AltitudeMode = relativeToGround;
else if (strcasecmp(altitudeModeVal, "clampToGround") == 0)
AltitudeMode = clampToGround;
}
const char *extrudeVal = msLookupHashTable(layerMetadata, "kml_extrude");
if (altitudeModeVal) {
Extrude = atoi(extrudeVal);
}
const char *tessellateVal =
msLookupHashTable(layerMetadata, "kml_tessellate");
if (tessellateVal) {
Tessellate = atoi(tessellateVal);
}
}
int KmlRenderer::checkProjection(mapObj *map) {
projectionObj *projection = &map->projection;
if (projection && projection->numargs > 0 &&
msProjIsGeographicCRS(projection)) {
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);
msProjectionInheritContextFrom(&out, projection);
msLoadProjectionString(&out, epsg_string);
sRect = map->extent;
msProjectRect(projection, &out, &sRect);
msFreeProjectionExceptContext(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;
}
}
xmlNodePtr KmlRenderer::createPlacemarkNode(xmlNodePtr parentNode,
char *styleUrl) {
xmlNodePtr placemarkNode =
xmlNewChild(parentNode, NULL, BAD_CAST "Placemark", NULL);
/*always add a name. It will be replaced by a text value if available*/
char tmpid[100];
char *stmp = NULL, *layerName = NULL;
if (CurrentShapeName && strlen(CurrentShapeName) > 0) {
xmlNewChild(placemarkNode, NULL, BAD_CAST "name",
BAD_CAST CurrentShapeName);
} else {
sprintf(tmpid, ".%d", CurrentShapeIndex);
layerName = getLayerName(currentLayer);
stmp = msStringConcatenate(stmp, layerName);
stmp = msStringConcatenate(stmp, tmpid);
xmlNewChild(placemarkNode, NULL, BAD_CAST "name", BAD_CAST stmp);
}
msFree(layerName);
msFree(stmp);
if (styleUrl)
xmlNewChild(placemarkNode, NULL, BAD_CAST "styleUrl", BAD_CAST styleUrl);
return placemarkNode;
}
void KmlRenderer::renderLine(imageObj *, shapeObj *p, strokeStyleObj *style) {
if (p->numlines == 0)
return;
if (PlacemarkNode == NULL)
PlacemarkNode = createPlacemarkNode(LayerNode, NULL);
if (!PlacemarkNode)
return;
addLineStyleToList(style);
SymbologyFlag[Line] = 1;
/*p->index > CurrentDrawnShapeIndexneed to be reviewd. Added since the height
level code caches shapes when rendering lines*/
if (CurrentDrawnShapeIndex == -1 || p->index > CurrentDrawnShapeIndex) {
xmlNodePtr geomNode = getGeomParentNode("LineString");
addAddRenderingSpecifications(geomNode);
addCoordsNode(geomNode, p->line[0].point, p->line[0].numpoints);
/* more than one line => MultiGeometry*/
if (p->numlines > 1) {
geomNode = getGeomParentNode("LineString"); // returns MultiGeom Node
for (int i = 1; i < p->numlines; i++) {
xmlNodePtr lineStringNode =
xmlNewChild(geomNode, NULL, BAD_CAST "LineString", NULL);
addAddRenderingSpecifications(lineStringNode);
addCoordsNode(lineStringNode, p->line[i].point, p->line[i].numpoints);
}
}
CurrentDrawnShapeIndex = p->index;
}
}
void KmlRenderer::renderPolygon(imageObj *, shapeObj *p, colorObj *color) {
if (PlacemarkNode == NULL)
PlacemarkNode = createPlacemarkNode(LayerNode, NULL);
if (!PlacemarkNode)
return;
memcpy(&PolygonColor, color, sizeof(colorObj));
SymbologyFlag[Polygon] = 1;
if (p->index != CurrentDrawnShapeIndex) {
xmlNodePtr geomParentNode = getGeomParentNode("Polygon");
for (int i = 0; i < p->numlines; i++) {
xmlNodePtr bdryNode = NULL;
if (i == 0) /* __TODO__ check ring order*/
bdryNode =
xmlNewChild(geomParentNode, NULL, BAD_CAST "outerBoundaryIs", NULL);
else
bdryNode =
xmlNewChild(geomParentNode, NULL, BAD_CAST "innerBoundaryIs", NULL);
xmlNodePtr ringNode =
xmlNewChild(bdryNode, NULL, BAD_CAST "LinearRing", NULL);
addAddRenderingSpecifications(ringNode);
addCoordsNode(ringNode, p->line[i].point, p->line[i].numpoints);
}
CurrentDrawnShapeIndex = p->index;
}
}
void KmlRenderer::addCoordsNode(xmlNodePtr parentNode, pointObj *pts,
int numPts) {
char lineBuf[128];
xmlNodePtr coordsNode =
xmlNewChild(parentNode, NULL, BAD_CAST "coordinates", NULL);
xmlNodeAddContent(coordsNode, BAD_CAST "\n");
for (int i = 0; i < numPts; i++) {
if (mElevationFromAttribute) {
sprintf(lineBuf, "\t%.8f,%.8f,%.8f\n", pts[i].x, pts[i].y,
mCurrentElevationValue);
} else if (AltitudeMode == relativeToGround || AltitudeMode == absolute) {
sprintf(lineBuf, "\t%.8f,%.8f,%.8f\n", pts[i].x, pts[i].y, pts[i].z);
} else
sprintf(lineBuf, "\t%.8f,%.8f\n", pts[i].x, pts[i].y);
xmlNodeAddContent(coordsNode, BAD_CAST lineBuf);
}
xmlNodeAddContent(coordsNode, BAD_CAST "\t");
}
void KmlRenderer::renderGlyphs(imageObj *, const textSymbolObj *ts,
colorObj *clr, colorObj * /*oc*/, int /*ow*/) {
if (ts->annotext == NULL || ts->textpath->numglyphs == 0)
return;
if (PlacemarkNode == NULL)
PlacemarkNode = createPlacemarkNode(LayerNode, NULL);
if (!PlacemarkNode)
return;
memcpy(&LabelColor, clr, sizeof(colorObj));
SymbologyFlag[Label] = 1;
/*there is alaws a default name (layer.shapeid). Replace it*/
for (xmlNodePtr node = PlacemarkNode->children; node; node = node->next) {
if (node->type != XML_ELEMENT_NODE)
continue;
if (strcmp((char *)node->name, "name") == 0) {
xmlNodeSetContent(node, BAD_CAST ts->annotext);
break;
}
}
/*xmlNewChild(PlacemarkNode, NULL, BAD_CAST "name", BAD_CAST text);*/
xmlNodePtr geomNode = getGeomParentNode("Point");
addAddRenderingSpecifications(geomNode);
pointObj pt;
pt.x = ts->textpath->glyphs[0].pnt.x;
pt.y = ts->textpath->glyphs[0].pnt.y;
pt.z = 0.0;
addCoordsNode(geomNode, &pt, 1);
}
void KmlRenderer::addAddRenderingSpecifications(xmlNodePtr node) {
/*
0
0
clampToGround
*/
if (Extrude)
xmlNewChild(node, NULL, BAD_CAST "extrude", BAD_CAST "1");
if (Tessellate)
xmlNewChild(node, NULL, BAD_CAST "tessellate", BAD_CAST "1");
if (AltitudeMode == absolute)
xmlNewChild(node, NULL, BAD_CAST "altitudeMode", BAD_CAST "absolute");
else if (AltitudeMode == relativeToGround)
xmlNewChild(node, NULL, BAD_CAST "altitudeMode",
BAD_CAST "relativeToGround");
else if (AltitudeMode == clampToGround)
xmlNewChild(node, NULL, BAD_CAST "altitudeMode", BAD_CAST "clampToGround");
}
imageObj *agg2CreateImage(int width, int height, outputFormatObj *format,
colorObj *bg);
int KmlRenderer::createIconImage(char *fileName, symbolObj *symbol,
symbolStyleObj *symstyle) {
pointObj p;
int status;
imageObj *tmpImg = NULL;
tmpImg =
agg2CreateImage((int)(symbol->sizex * symstyle->scale),
(int)(symbol->sizey * symstyle->scale), aggFormat, NULL);
tmpImg->format = aggFormat;
if (!aggFormat->vtable)
msInitializeRendererVTable(aggFormat);
p.x = symbol->sizex * symstyle->scale / 2;
p.y = symbol->sizey * symstyle->scale / 2;
p.z = 0.0;
status = msDrawMarkerSymbol(map, tmpImg, &p, symstyle->style, 1);
if (status != MS_SUCCESS)
return status;
return msSaveImage(map, tmpImg, fileName);
}
void KmlRenderer::renderSymbol(imageObj *img, double x, double y,
symbolObj *symbol, symbolStyleObj *style) {
if (PlacemarkNode == NULL)
PlacemarkNode = createPlacemarkNode(LayerNode, NULL);
if (!PlacemarkNode)
return;
snprintf(SymbolUrl, sizeof(SymbolUrl), "%s",
lookupSymbolUrl(img, symbol, style));
SymbologyFlag[Symbol] = 1;
xmlNodePtr geomNode = getGeomParentNode("Point");
addAddRenderingSpecifications(geomNode);
pointObj pt;
pt.x = x;
pt.y = y;
pt.z = 0.0;
addCoordsNode(geomNode, &pt, 1);
}
void KmlRenderer::renderPixmapSymbol(imageObj *img, double x, double y,
symbolObj *symbol, symbolStyleObj *style) {
renderSymbol(img, x, y, symbol, style);
}
void KmlRenderer::renderVectorSymbol(imageObj *img, double x, double y,
symbolObj *symbol, symbolStyleObj *style) {
renderSymbol(img, x, y, symbol, style);
}
void KmlRenderer::renderEllipseSymbol(imageObj *img, double x, double y,
symbolObj *symbol,
symbolStyleObj *style) {
renderSymbol(img, x, y, symbol, style);
}
void KmlRenderer::renderTruetypeSymbol(imageObj *img, double x, double y,
symbolObj *symbol,
symbolStyleObj *style) {
renderSymbol(img, x, y, symbol, style);
}
xmlNodePtr KmlRenderer::createGroundOverlayNode(xmlNodePtr parentNode,
char *imageHref,
layerObj *layer) {
/*
GroundOverlay.kml
7fffffff
1
http://www.google.com/intl/en/images/logo.gif
onInterval
86400
0.75
37.83234
37.832122
-122.373033
-122.373724
45
*/
char layerHexColor[32];
xmlNodePtr groundOverlayNode =
xmlNewChild(parentNode, NULL, BAD_CAST "GroundOverlay", NULL);
char *layerName = getLayerName(layer);
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "name", BAD_CAST layerName);
if (layer->compositer && layer->compositer->opacity > 0 &&
layer->compositer->opacity < 100) {
sprintf(layerHexColor, "%02xffffff",
(unsigned int)MS_NINT(layer->compositer->opacity * 2.55));
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "color",
BAD_CAST layerHexColor);
} else
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "color", BAD_CAST "ffffffff");
char stmp[20];
sprintf(stmp, "%d", layer->index);
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "drawOrder", BAD_CAST stmp);
if (imageHref) {
xmlNodePtr iconNode =
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "Icon", NULL);
xmlNewChild(iconNode, NULL, BAD_CAST "href", BAD_CAST imageHref);
}
char crdStr[64];
rectObj mapextent;
if (map->gt.need_geotransform == MS_TRUE)
mapextent = currentLayer->map->saved_extent;
else
mapextent = currentLayer->map->extent;
xmlNodePtr latLonBoxNode =
xmlNewChild(groundOverlayNode, NULL, BAD_CAST "LatLonBox", NULL);
sprintf(crdStr, "%.8f", mapextent.maxy);
xmlNewChild(latLonBoxNode, NULL, BAD_CAST "north", BAD_CAST crdStr);
sprintf(crdStr, "%.8f", mapextent.miny);
xmlNewChild(latLonBoxNode, NULL, BAD_CAST "south", BAD_CAST crdStr);
sprintf(crdStr, "%.8f", mapextent.minx);
xmlNewChild(latLonBoxNode, NULL, BAD_CAST "west", BAD_CAST crdStr);
sprintf(crdStr, "%.8f", mapextent.maxx);
xmlNewChild(latLonBoxNode, NULL, BAD_CAST "east", BAD_CAST crdStr);
xmlNewChild(latLonBoxNode, NULL, BAD_CAST "rotation", BAD_CAST "0.0");
return groundOverlayNode;
}
void KmlRenderer::startShape(imageObj *, shapeObj *shape) {
if (PlacemarkNode)
flushPlacemark();
CurrentShapeIndex = -1;
CurrentDrawnShapeIndex = -1;
CurrentShapeName = NULL;
/*should be done at endshape but the plugin architecture does not call
* endshape yet*/
if (LineStyle) {
msFree(LineStyle);
LineStyle = NULL;
numLineStyle = 0;
}
CurrentShapeIndex = shape->index;
if (pszLayerNameAttributeMetadata) {
for (int i = 0; i < currentLayer->numitems; i++) {
if (strcasecmp(currentLayer->items[i], pszLayerNameAttributeMetadata) ==
0 &&
shape->values[i]) {
CurrentShapeName = msStrdup(shape->values[i]);
break;
}
}
}
PlacemarkNode = NULL;
GeomNode = NULL;
DescriptionNode = createDescriptionNode(shape);
if (mElevationFromAttribute && shape->numvalues > mElevationAttributeIndex &&
mElevationAttributeIndex >= 0 &&
shape->values[mElevationAttributeIndex]) {
mCurrentElevationValue = atof(shape->values[mElevationAttributeIndex]);
}
memset(SymbologyFlag, 0, NumSymbologyFlag);
}
void KmlRenderer::endShape(imageObj *, shapeObj *) {
CurrentShapeIndex = -1;
if (CurrentShapeName)
msFree(CurrentShapeName);
CurrentShapeName = NULL;
}
xmlNodePtr KmlRenderer::getGeomParentNode(const char *geomName) {
/*we do not need a multi-geometry for point layers*/
if (currentLayer->type != MS_LAYER_POINT &&
currentLayer->type != MS_LAYER_ANNOTATION && GeomNode) {
/*placemark geometry already defined, we need multigeometry node*/
xmlNodePtr multiGeomNode = xmlNewNode(NULL, BAD_CAST "MultiGeometry");
xmlAddChild(multiGeomNode, GeomNode);
GeomNode = multiGeomNode;
xmlNodePtr geomNode =
xmlNewChild(multiGeomNode, NULL, BAD_CAST geomName, NULL);
return geomNode;
} else {
GeomNode = xmlNewNode(NULL, BAD_CAST geomName);
return GeomNode;
}
}
const char *KmlRenderer::lookupSymbolUrl(imageObj *img, symbolObj *symbol,
symbolStyleObj *symstyle) {
char symbolHexColor[32];
/*
*/
sprintf(symbolHexColor, "%02x%02x%02x%02x", symstyle->style->color.alpha,
symstyle->style->color.blue, symstyle->style->color.green,
symstyle->style->color.red);
snprintf(SymbolName, sizeof(SymbolName), "symbol_%s_%.1f_%s", symbol->name,
symstyle->scale, symbolHexColor);
const char *symbolUrl = msLookupHashTable(StyleHashTable, SymbolName);
if (!symbolUrl) {
char iconFileName[MS_MAXPATHLEN];
char iconUrl[MS_MAXPATHLEN];
if (img->imagepath) {
char *tmpFileName = msTmpFile(NULL, MapPath, img->imagepath, "png");
snprintf(iconFileName, sizeof(iconFileName), "%s", tmpFileName);
msFree(tmpFileName);
} else {
sprintf(iconFileName, "symbol_%s_%.1f.%s", symbol->name, symstyle->scale,
"png");
}
if (createIconImage(iconFileName, symbol, symstyle) != MS_SUCCESS) {
msSetError(MS_IOERR, "Error creating icon file '%s'",
"KmlRenderer::lookupSymbolStyle()", iconFileName);
return NULL;
}
if (img->imageurl)
sprintf(iconUrl, "%s%s.%s", img->imageurl, msGetBasename(iconFileName),
"png");
else
snprintf(iconUrl, sizeof(iconUrl), "%s", iconFileName);
hashObj *hash = msInsertHashTable(StyleHashTable, SymbolName, iconUrl);
symbolUrl = hash->data;
}
return symbolUrl;
}
const char *KmlRenderer::lookupPlacemarkStyle() {
char lineHexColor[32];
char polygonHexColor[32];
char labelHexColor[32];
char *styleName = NULL;
styleName = msStringConcatenate(styleName, "style");
if (SymbologyFlag[Line]) {
/*
ffffffff
normal
1
*/
for (int i = 0; i < numLineStyle; i++) {
if (currentLayer && currentLayer->compositer &&
currentLayer->compositer->opacity > 0 &&
currentLayer->compositer->opacity < 100 &&
LineStyle[i].color->alpha == 255)
LineStyle[i].color->alpha =
MS_NINT(currentLayer->compositer->opacity * 2.55);
sprintf(lineHexColor, "%02x%02x%02x%02x", LineStyle[i].color->alpha,
LineStyle[0].color->blue, LineStyle[i].color->green,
LineStyle[i].color->red);
char lineStyleName[64];
snprintf(lineStyleName, sizeof(lineStyleName), "_line_%s_w%.1f",
lineHexColor, LineStyle[i].width);
styleName = msStringConcatenate(styleName, lineStyleName);
}
}
if (SymbologyFlag[Polygon]) {
/*
ffffffff
normal
1
1
*/
if (currentLayer && currentLayer->compositer &&
currentLayer->compositer->opacity > 0 &&
currentLayer->compositer->opacity < 100 && PolygonColor.alpha == 255)
PolygonColor.alpha = MS_NINT(currentLayer->compositer->opacity * 2.55);
sprintf(polygonHexColor, "%02x%02x%02x%02x", PolygonColor.alpha,
PolygonColor.blue, PolygonColor.green, PolygonColor.red);
char polygonStyleName[64];
sprintf(polygonStyleName, "_polygon_%s", polygonHexColor);
styleName = msStringConcatenate(styleName, polygonStyleName);
}
if (SymbologyFlag[Label]) {
/*
ffffffff
normal
1
*/
if (currentLayer && currentLayer->compositer &&
currentLayer->compositer->opacity > 0 &&
currentLayer->compositer->opacity < 100 && LabelColor.alpha == 255)
LabelColor.alpha = MS_NINT(currentLayer->compositer->opacity * 2.55);
sprintf(labelHexColor, "%02x%02x%02x%02x", LabelColor.alpha,
LabelColor.blue, LabelColor.green, LabelColor.red);
// __TODO__ add label scale
char labelStyleName[64];
sprintf(labelStyleName, "_label_%s", labelHexColor);
styleName = msStringConcatenate(styleName, labelStyleName);
}
if (SymbologyFlag[Symbol]) {
/*
*/
/* __TODO__ add label scale */
styleName = msStringConcatenate(styleName, "_");
styleName = msStringConcatenate(styleName, SymbolName);
}
const char *styleUrl = msLookupHashTable(StyleHashTable, styleName);
if (!styleUrl) {
char *styleValue = NULL;
styleValue = msStringConcatenate(styleValue, "#");
styleValue = msStringConcatenate(styleValue, styleName);
hashObj *hash = msInsertHashTable(StyleHashTable, styleName, styleValue);
styleUrl = hash->data;
msFree(styleValue);
/* Insert new Style node into Document node*/
xmlNodePtr styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);
xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST styleName);
if (SymbologyFlag[Polygon]) {
xmlNodePtr polyStyleNode =
xmlNewChild(styleNode, NULL, BAD_CAST "PolyStyle", NULL);
xmlNewChild(polyStyleNode, NULL, BAD_CAST "color",
BAD_CAST polygonHexColor);
}
if (SymbologyFlag[Line]) {
for (int i = 0; i < numLineStyle; i++) {
xmlNodePtr lineStyleNode =
xmlNewChild(styleNode, NULL, BAD_CAST "LineStyle", NULL);
sprintf(lineHexColor, "%02x%02x%02x%02x", LineStyle[i].color->alpha,
LineStyle[i].color->blue, LineStyle[i].color->green,
LineStyle[i].color->red);
xmlNewChild(lineStyleNode, NULL, BAD_CAST "color",
BAD_CAST lineHexColor);
char width[16];
sprintf(width, "%.1f", LineStyle[i].width);
xmlNewChild(lineStyleNode, NULL, BAD_CAST "width", BAD_CAST width);
}
}
if (SymbologyFlag[Symbol]) {
xmlNodePtr iconStyleNode =
xmlNewChild(styleNode, NULL, BAD_CAST "IconStyle", NULL);
xmlNodePtr iconNode =
xmlNewChild(iconStyleNode, NULL, BAD_CAST "Icon", NULL);
xmlNewChild(iconNode, NULL, BAD_CAST "href", BAD_CAST SymbolUrl);
/*char scale[16];
sprintf(scale, "%.1f", style->scale);
xmlNewChild(iconStyleNode, NULL, BAD_CAST "scale", BAD_CAST scale);*/
} else {
const char *value =
msLookupHashTable(¤tLayer->metadata, "kml_default_symbol_href");
if (value && strlen(value) > 0) {
xmlNodePtr iconStyleNode =
xmlNewChild(styleNode, NULL, BAD_CAST "IconStyle", NULL);
xmlNodePtr iconNode =
xmlNewChild(iconStyleNode, NULL, BAD_CAST "Icon", NULL);
xmlNewChild(iconNode, NULL, BAD_CAST "href", BAD_CAST value);
}
}
if (SymbologyFlag[Label]) {
xmlNodePtr labelStyleNode =
xmlNewChild(styleNode, NULL, BAD_CAST "LabelStyle", NULL);
xmlNewChild(labelStyleNode, NULL, BAD_CAST "color",
BAD_CAST labelHexColor);
/*char scale[16];
sprintf(scale, "%.1f", style->scale);
xmlNewChild(iconStyleNode, NULL, BAD_CAST "scale", BAD_CAST scale);*/
}
}
if (styleName)
msFree(styleName);
return styleUrl;
}
void KmlRenderer::flushPlacemark() {
if (PlacemarkNode) {
const char *styleUrl = lookupPlacemarkStyle();
xmlNewChild(PlacemarkNode, NULL, BAD_CAST "styleUrl", BAD_CAST styleUrl);
if (DescriptionNode)
xmlAddChild(PlacemarkNode, DescriptionNode);
if (GeomNode)
xmlAddChild(PlacemarkNode, GeomNode);
}
}
xmlNodePtr KmlRenderer::createDescriptionNode(shapeObj *shape) {
/*
*/
/*description nodes for vector layers:
- if kml_description is set, use it
- if not, dump the attributes */
if (pszLayerDescMetadata) {
char *pszTmp = NULL;
char *pszTmpDesc = NULL;
size_t bufferSize = 0;
pszTmpDesc = msStrdup(pszLayerDescMetadata);
for (int i = 0; i < currentLayer->numitems; i++) {
bufferSize = strlen(currentLayer->items[i]) + 3;
pszTmp = (char *)msSmallMalloc(bufferSize);
snprintf(pszTmp, bufferSize, "%%%s%%", currentLayer->items[i]);
if (strcasestr(pszTmpDesc, pszTmp))
pszTmpDesc =
msCaseReplaceSubstring(pszTmpDesc, pszTmp, shape->values[i]);
msFree(pszTmp);
}
xmlNodePtr descriptionNode = xmlNewNode(NULL, BAD_CAST "description");
xmlNodeAddContent(descriptionNode, BAD_CAST pszTmpDesc);
msFree(pszTmpDesc);
return descriptionNode;
} else if ((papszLayerIncludeItems && nIncludeItems > 0) ||
(papszLayerExcludeItems && nExcludeItems > 0)) {
/* -------------------------------------------------------------------- */
/* preferred way is to use the ExtendedData tag (#3728) */
/* http://code.google.com/apis/kml/documentation/extendeddata.html */
/* -------------------------------------------------------------------- */
xmlNodePtr extendedDataNode = xmlNewNode(NULL, BAD_CAST "ExtendedData");
xmlNodePtr dataNode = NULL;
const char *pszAlias = NULL;
int bIncludeAll = MS_FALSE;
if (papszLayerIncludeItems && nIncludeItems == 1 &&
strcasecmp(papszLayerIncludeItems[0], "all") == 0)
bIncludeAll = MS_TRUE;
for (int i = 0; i < currentLayer->numitems; i++) {
int j = 0, k = 0;
/*TODO optimize to calculate this only once per layer*/
for (j = 0; j < nIncludeItems; j++) {
if (strcasecmp(currentLayer->items[i], papszLayerIncludeItems[j]) == 0)
break;
}
if (j < nIncludeItems || bIncludeAll) {
if (papszLayerExcludeItems && nExcludeItems > 0) {
for (k = 0; k < nExcludeItems; k++) {
if (strcasecmp(currentLayer->items[i], papszLayerExcludeItems[k]) ==
0)
break;
}
}
if (nExcludeItems == 0 || k == nExcludeItems) {
dataNode = xmlNewNode(NULL, BAD_CAST "Data");
xmlNewProp(dataNode, BAD_CAST "name",
BAD_CAST currentLayer->items[i]);
pszAlias = getAliasName(currentLayer, currentLayer->items[i], "GO");
if (pszAlias)
xmlNewChild(dataNode, NULL, BAD_CAST "displayName",
BAD_CAST pszAlias);
else
xmlNewChild(dataNode, NULL, BAD_CAST "displayName",
BAD_CAST currentLayer->items[i]);
if (shape->values[i] && strlen(shape->values[i]))
xmlNewChild(dataNode, NULL, BAD_CAST "value",
BAD_CAST shape->values[i]);
else
xmlNewChild(dataNode, NULL, BAD_CAST "value", NULL);
xmlAddChild(extendedDataNode, dataNode);
}
}
}
return extendedDataNode;
}
return NULL;
}
void KmlRenderer::addLineStyleToList(strokeStyleObj *style) {
/*actually this is not necessary. kml only uses the last LineStyle
so we should not bother keeping them all*/
int i = 0;
for (i = 0; i < numLineStyle; i++) {
if (style->width == LineStyle[i].width &&
LineStyle[i].color->alpha == style->color->alpha &&
LineStyle[i].color->red == style->color->red &&
LineStyle[i].color->green == style->color->green &&
LineStyle[i].color->blue == style->color->blue)
break;
}
if (i == numLineStyle) {
numLineStyle++;
if (LineStyle == NULL)
LineStyle = (strokeStyleObj *)msSmallMalloc(sizeof(strokeStyleObj));
else
LineStyle = (strokeStyleObj *)msSmallRealloc(
LineStyle, sizeof(strokeStyleObj) * numLineStyle);
memcpy(&LineStyle[numLineStyle - 1], style, sizeof(strokeStyleObj));
}
}
#endif