def getGroups(canvas, layers, basemapList, restrictToExtent, extent,
groupedLayers):
group_list = ["baseLayer"] if len(basemapList) else []
no_group_list = []
usedGroups = []
currentVT = ""
for count, layer in enumerate(layers):
vts = layer.customProperty("VectorTilesReader/vector_tile_url")
if (vts is not None and vts != currentVT):
no_group_list.append("lyr_" + safeName(vts))
currentVT = vts
try:
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) +
"_" + unicode(count))
except:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) + "_" +
unicode(count))
return (group_list, no_group_list, usedGroups)
def getGroups(canvas, layers, basemapList, restrictToExtent, extent,
groupedLayers):
group_list = ["baseLayer"] if len(basemapList) else []
no_group_list = []
usedGroups = []
for count, layer in enumerate(layers):
try:
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) +
"_" + unicode(count))
except:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) +
"_" + unicode(count))
return (group_list, no_group_list, usedGroups)
def layersAnd25d(layers, canvas, restrictToExtent, extent, qms):
mapLayers = ["baseLayer"]
osmb = ""
for count, layer in enumerate(layers):
if is25d(layer, canvas, restrictToExtent, extent):
osmb = build25d(canvas, layer, count)
else:
if (qms and not isinstance(layer, TileLayer)) or not qms:
mapLayers.append("lyr_" + safeName(layer.name()) + "_" +
unicode(count))
return (mapLayers, osmb)
def layerToJavascript(iface, layer, encode2json, matchCRS, cluster, info,
restrictToExtent, extent, count, vtLayers):
(minResolution, maxResolution) = getScaleRes(layer)
layerName = safeName(layer.name()) + "_" + unicode(count)
layerAttr = getAttribution(layer)
if layer.type() == layer.VectorLayer and not is25d(
layer, iface.mapCanvas(), restrictToExtent, extent):
renderer = layer.rendererV2()
cluster = isCluster(cluster, renderer)
hmRadius = 0
hmRamp = ""
hmWeight = 0
hmWeightMax = 0
vts = layer.customProperty("VectorTilesReader/vector_tile_url")
if vts is not None:
if vts not in vtLayers:
vtLayers.append(vts)
return getVT(vts), vtLayers
else:
return "", vtLayers
if isinstance(renderer, QgsHeatmapRenderer):
(pointLayerType, hmRadius, hmRamp, hmWeight,
hmWeightMax) = getHeatmap(layer, renderer)
else:
pointLayerType = "Vector"
crsConvert = getCRS(iface, matchCRS)
if layer.providerType() == "WFS" and not encode2json:
return getWFS(layer, layerName, layerAttr, cluster, minResolution,
maxResolution), vtLayers
else:
return getJSON(layerName, crsConvert, layerAttr, cluster,
pointLayerType, minResolution, maxResolution,
hmRadius, hmRamp, hmWeight, hmWeightMax, renderer,
layer), vtLayers
elif layer.type() == layer.RasterLayer:
if layer.providerType().lower() == "wms":
source = layer.source()
opacity = layer.renderer().opacity()
d = parse_qs(source)
if "type" in d and d["type"][0] == "xyz":
return getXYZ(layerName, opacity, minResolution, maxResolution,
layerAttr, d["url"][0]), vtLayers
elif "tileMatrixSet" in d:
return getWMTS(layer, d, layerAttr, layerName, opacity,
minResolution, maxResolution), vtLayers
else:
return getWMS(source, layer, layerAttr, layerName, opacity,
minResolution, maxResolution, info), vtLayers
elif layer.providerType().lower() == "gdal":
return getRaster(iface, layer, layerName, layerAttr, minResolution,
maxResolution, matchCRS), vtLayers
def layerToJavascript(iface, layer, encode2json, matchCRS, cluster):
if layer.hasScaleBasedVisibility():
minRes = 1 / ((1 / layer.minimumScale()) * 39.37 * 90.7)
maxRes = 1 / ((1 / layer.maximumScale()) * 39.37 * 90.7)
minResolution = "\nminResolution:%s,\n" % unicode(minRes)
maxResolution = "maxResolution:%s,\n" % unicode(maxRes)
else:
minResolution = ""
maxResolution = ""
layerName = safeName(layer.name())
if layer.type() == layer.VectorLayer and not is25d(layer,
iface.mapCanvas()):
renderer = layer.rendererV2()
if cluster and (isinstance(renderer, QgsSingleSymbolRendererV2) or
isinstance(renderer, QgsRuleBasedRendererV2)):
cluster = True
else:
cluster = False
if matchCRS:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs().authid()
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: '%(d)s'}""" % {
"d": mapCRS}
else:
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857'}"""
if layer.providerType() == "WFS" and not encode2json:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var jsonSource_%(n)s = new ol.source.Vector({
format: format_%(n)s
});''' % {"n": layerName}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {"n": layerName}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source: ''' % {"n": layerName}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});
function get%(n)sJson(geojson) {
var features_%(n)s = format_%(n)s.readFeatures(geojson);
jsonSource_%(n)s.addFeatures(features_%(n)s);
}''' % {
"name": layer.name(), "n": layerName,
"min": minResolution, "max": maxResolution}
return layerCode
else:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var features_%(n)s = format_%(n)s.readFeatures(geojson_%(n)s, %(crs)s);
var jsonSource_%(n)s = new ol.source.Vector();
jsonSource_%(n)s.addFeatures(features_%(n)s);''' % {"n": layerName,
"crs": crsConvert}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {"n": layerName}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source:''' % {"n": layerName}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});''' % {"name": layer.name(), "n": layerName,
"min": minResolution, "max": maxResolution}
return layerCode
elif layer.type() == layer.RasterLayer:
if layer.providerType().lower() == "wms":
source = layer.source()
layers = re.search(r"layers=(.*?)(?:&|$)", source).groups(0)[0]
url = re.search(r"url=(.*?)(?:&|$)", source).groups(0)[0]
return '''var lyr_%(n)s = new ol.layer.Tile({
source: new ol.source.TileWMS(({
url: "%(url)s",
params: {"LAYERS": "%(layers)s", "TILED": "true"},
})),
title: "%(name)s",
%(minRes)s
%(maxRes)s
});''' % {"layers": layers, "url": url,
"n": layerName, "name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution}
elif layer.providerType().lower() == "gdal":
provider = layer.dataProvider()
crsSrc = layer.crs()
crsDest = QgsCoordinateReferenceSystem(3857)
xform = QgsCoordinateTransform(crsSrc, crsDest)
extentRep = xform.transform(layer.extent())
sExtent = "[%f, %f, %f, %f]" % (extentRep.xMinimum(),
extentRep.yMinimum(),
extentRep.xMaximum(),
extentRep.yMaximum())
return '''var lyr_%(n)s = new ol.layer.Image({
opacity: 1,
title: "%(name)s",
%(minRes)s
%(maxRes)s
source: new ol.source.ImageStatic({
url: "./layers/%(n)s.png",
projection: 'EPSG:3857',
alwaysInRange: true,
//imageSize: [%(col)d, %(row)d],
imageExtent: %(extent)s
})
});''' % {"n": layerName,
"extent": sExtent,
"col": provider.xSize(),
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution,
"row": provider.ySize()}
def writeLayersAndGroups(layers, groups, visible, folder, popup,
settings, json, matchCRS, clustered, iface):
canvas = iface.mapCanvas()
basemapList = settings["Appearance"]["Base layer"]
basemaps = [basemapOL()[item.text()] for _, item in enumerate(basemapList)]
baseLayer = """var baseLayer = new ol.layer.Group({
'title': 'Base maps',
layers: [%s\n]
});""" % ','.join(basemaps)
layerVars = ""
for layer, encode2json, cluster in zip(layers, json, clustered):
try:
if is25d(layer, canvas):
pass
else:
layerVars += "\n".join([layerToJavascript(iface, layer,
encode2json,
matchCRS, cluster)])
except:
layerVars += "\n".join([layerToJavascript(iface, layer,
encode2json, matchCRS,
cluster)])
groupVars = ""
groupedLayers = {}
for group, groupLayers in groups.iteritems():
groupVars += ('''var %s = new ol.layer.Group({
layers: [%s],
title: "%s"});\n''' %
("group_" + safeName(group),
",".join(["lyr_" + safeName(layer.name())
for layer in groupLayers]),
group))
for layer in groupLayers:
groupedLayers[layer.id()] = safeName(group)
mapLayers = ["baseLayer"]
usedGroups = []
osmb = ""
for layer in layers:
try:
renderer = layer.rendererV2()
if is25d(layer, canvas):
shadows = ""
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
fields = layer.pendingFields()
renderer.startRender(renderContext, fields)
for feat in layer.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat,
renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
osmb = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(geojson_{sln});""".format(shadows=shadows, sln=safeName(layer.name()))
else:
mapLayers.append("lyr_" + safeName(layer.name()))
except:
mapLayers.append("lyr_" + safeName(layer.name()))
visibility = ""
for layer, v in zip(mapLayers[1:], visible):
visibility += "\n".join(["%s.setVisible(%s);" % (layer,
unicode(v).lower())])
group_list = ["baseLayer"] if len(basemapList) else []
no_group_list = []
for layer in layers:
try:
if is25d(layer, canvas):
pass
else:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()))
except:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()))
layersList = []
for layer in (group_list + no_group_list):
layersList.append(layer)
layersListString = "var layersList = [" + ",".join(layersList) + "];"
fieldAliases = ""
fieldImages = ""
fieldLabels = ""
for layer, labels in zip(layers, popup):
if layer.type() == layer.VectorLayer:
fieldList = layer.pendingFields()
aliasFields = ""
imageFields = ""
labelFields = ""
for field, label in zip(labels.keys(), labels.values()):
labelFields += "'%(field)s': '%(label)s', " % (
{"field": field, "label": label})
labelFields = "{%(labelFields)s});\n" % (
{"labelFields": labelFields})
labelFields = "lyr_%(name)s.set('fieldLabels', " % (
{"name": safeName(layer.name())}) + labelFields
fieldLabels += labelFields
for f in fieldList:
fieldIndex = fieldList.indexFromName(unicode(f.name()))
aliasFields += "'%(field)s': '%(alias)s', " % (
{"field": f.name(),
"alias": layer.attributeDisplayName(fieldIndex)})
try:
widget = layer.editFormConfig().widgetType(fieldIndex)
except:
widget = layer.editorWidgetV2(fieldIndex)
imageFields += "'%(field)s': '%(image)s', " % (
{"field": f.name(),
"image": widget})
aliasFields = "{%(aliasFields)s});\n" % (
{"aliasFields": aliasFields})
aliasFields = "lyr_%(name)s.set('fieldAliases', " % (
{"name": safeName(layer.name())}) + aliasFields
fieldAliases += aliasFields
imageFields = "{%(imageFields)s});\n" % (
{"imageFields": imageFields})
imageFields = "lyr_%(name)s.set('fieldImages', " % (
{"name": safeName(layer.name())}) + imageFields
fieldImages += imageFields
path = os.path.join(folder, "layers", "layers.js")
with codecs.open(path, "w", "utf-8") as f:
if basemapList:
f.write(baseLayer + "\n")
f.write(layerVars + "\n")
f.write(groupVars + "\n")
f.write(visibility + "\n")
f.write(layersListString + "\n")
f.write(fieldAliases)
f.write(fieldImages)
f.write(fieldLabels)
return osmb
def writeVectorLayer(i, safeLayerName, usedFields, highlight, popupsOnHover,
popup, count, outputProjectFileName, wfsLayers, cluster,
cluster_num, visible, json, legends, new_src, canvas):
(new_pop, labeltext,
popFuncs) = labelsAndPopups(i, safeLayerName, usedFields, highlight,
popupsOnHover, popup, count)
renderer = i.rendererV2()
layer_transp = 1 - (float(i.layerTransparency()) / 100)
new_obj = ""
if is25d(i, canvas):
shadows = ""
renderer = i.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(canvas.mapSettings())
fields = i.pendingFields()
renderer.startRender(renderContext, fields)
for feat in i.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue()
and attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
new_obj = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(json_{sln});""".format(shadows=shadows, sln=safeLayerName)
elif (isinstance(renderer, QgsSingleSymbolRendererV2)
or isinstance(renderer, QgsRuleBasedRendererV2)):
# print safeLayerName + ": single"
(new_obj, legends,
wfsLayers) = singleLayer(renderer, outputProjectFileName,
safeLayerName, wfsLayers, i, layer_transp,
labeltext, cluster, cluster_num, visible,
json, usedFields, legends, count, popFuncs)
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
# print safeLayerName + ": categorized"
(new_obj, legends, wfsLayers) = categorizedLayer(
i, renderer, safeLayerName, outputProjectFileName, layer_transp,
usedFields, count, legends, labeltext, cluster, cluster_num,
popFuncs, visible, json, wfsLayers)
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
# print safeLayerName + ": graduated"
(new_obj, legends,
wfsLayers) = graduatedLayer(i, safeLayerName, renderer,
outputProjectFileName, layer_transp,
labeltext, popFuncs, cluster, cluster_num,
visible, json, usedFields, count, legends,
wfsLayers)
elif isinstance(renderer, Qgs25DRenderer):
# print safeLayerName + ": 2.5d"
pass
if usedFields[count] != 0:
new_src += new_pop.decode("utf-8")
new_src += """
""" + new_obj
if is25d(i, canvas):
pass
else:
new_src += """
bounds_group.addLayer(json_""" + safeLayerName + """JSON);"""
if visible[count]:
if cluster[count] is False:
new_src += """
initialOrder[initialOrder.length] = json_""" + safeLayerName + """JSON;
feature_group.addLayer(json_""" + safeLayerName + """JSON);"""
else:
new_src += """
initialOrder[initialOrder.length] = cluster_group""" + safeLayerName
new_src += """JSON;
cluster_group""" + safeLayerName + """JSON.addTo(map);"""
return new_src, legends, wfsLayers
def layerToJavascript(iface, layer, encode2json, matchCRS, cluster):
if layer.hasScaleBasedVisibility():
minRes = 1 / ((1 / layer.minimumScale()) * 39.37 * 90.7)
maxRes = 1 / ((1 / layer.maximumScale()) * 39.37 * 90.7)
minResolution = "\nminResolution:%s,\n" % unicode(minRes)
maxResolution = "maxResolution:%s,\n" % unicode(maxRes)
else:
minResolution = ""
maxResolution = ""
layerName = safeName(layer.name())
if layer.type() == layer.VectorLayer and not is25d(layer,
iface.mapCanvas()):
renderer = layer.rendererV2()
if cluster and (isinstance(renderer, QgsSingleSymbolRendererV2)
or isinstance(renderer, QgsRuleBasedRendererV2)):
cluster = True
else:
cluster = False
if isinstance(renderer, QgsHeatmapRenderer):
pointLayerType = "Heatmap"
hmRadius = renderer.radius()
colorRamp = renderer.colorRamp()
hmStart = colorRamp.color1().name()
hmEnd = colorRamp.color2().name()
hmRamp = "['" + hmStart + "', "
hmStops = colorRamp.stops()
for stop in hmStops:
hmRamp += "'" + stop.color.name() + "', "
hmRamp += "'" + hmEnd + "']"
hmWeight = renderer.weightExpression()
hmWeightId = layer.fieldNameIndex(hmWeight)
hmWeightMax = layer.maximumValue(hmWeightId)
else:
pointLayerType = "Vector"
if matchCRS:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs().authid()
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: '%(d)s'}""" % {
"d": mapCRS
}
else:
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857'}"""
if layer.providerType() == "WFS" and not encode2json:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var jsonSource_%(n)s = new ol.source.Vector({
format: format_%(n)s
});''' % {
"n": layerName
}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {
"n": layerName
}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source: ''' % {
"n": layerName
}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});
function get%(n)sJson(geojson) {
var features_%(n)s = format_%(n)s.readFeatures(geojson);
jsonSource_%(n)s.addFeatures(features_%(n)s);
}''' % {
"name": layer.name(),
"n": layerName,
"min": minResolution,
"max": maxResolution
}
return layerCode
else:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var features_%(n)s = format_%(n)s.readFeatures(geojson_%(n)s, %(crs)s);
var jsonSource_%(n)s = new ol.source.Vector();
jsonSource_%(n)s.addFeatures(features_%(n)s);''' % {
"n": layerName,
"crs": crsConvert
}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {
"n": layerName
}
layerCode += '''var lyr_%(n)s = new ol.layer.%(t)s({
source:''' % {
"n": layerName,
"t": pointLayerType
}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s''' % {
"min": minResolution,
"max": maxResolution
}
if pointLayerType == "Vector":
layerCode += '''
style: style_%(n)s,''' % {
"n": layerName
}
else:
layerCode += '''
radius: %(hmRadius)d * 2,
gradient: %(hmRamp)s,
blur: 15,
shadow: 250,''' % {
"hmRadius": hmRadius,
"hmRamp": hmRamp
}
if hmWeight != "":
layerCode += '''
weight: function(feature){
var weightField = '%(hmWeight)s';
var featureWeight = feature.get(weightField);
var maxWeight = %(hmWeightMax)d;
var calibratedWeight = featureWeight/maxWeight;
return calibratedWeight;
},''' % {
"hmWeight": hmWeight,
"hmWeightMax": hmWeightMax
}
layerCode += '''
title: "%(name)s"
});''' % {
"name": layer.name()
}
return layerCode
elif layer.type() == layer.RasterLayer:
if layer.providerType().lower() == "wms":
source = layer.source()
layers = re.search(r"layers=(.*?)(?:&|$)", source).groups(0)[0]
url = re.search(r"url=(.*?)(?:&|$)", source).groups(0)[0]
return '''var lyr_%(n)s = new ol.layer.Tile({
source: new ol.source.TileWMS(({
url: "%(url)s",
params: {"LAYERS": "%(layers)s", "TILED": "true"},
})),
title: "%(name)s",
%(minRes)s
%(maxRes)s
});''' % {
"layers": layers,
"url": url,
"n": layerName,
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution
}
elif layer.providerType().lower() == "gdal":
provider = layer.dataProvider()
crsSrc = layer.crs()
crsDest = QgsCoordinateReferenceSystem(3857)
xform = QgsCoordinateTransform(crsSrc, crsDest)
extentRep = xform.transform(layer.extent())
sExtent = "[%f, %f, %f, %f]" % (
extentRep.xMinimum(), extentRep.yMinimum(),
extentRep.xMaximum(), extentRep.yMaximum())
return '''var lyr_%(n)s = new ol.layer.Image({
opacity: 1,
title: "%(name)s",
%(minRes)s
%(maxRes)s
source: new ol.source.ImageStatic({
url: "./layers/%(n)s.png",
projection: 'EPSG:3857',
alwaysInRange: true,
//imageSize: [%(col)d, %(row)d],
imageExtent: %(extent)s
})
});''' % {
"n": layerName,
"extent": sExtent,
"col": provider.xSize(),
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution,
"row": provider.ySize()
}
def writeLayersAndGroups(layers, groups, visible, folder, popup, settings,
json, matchCRS, clustered, iface):
canvas = iface.mapCanvas()
basemapList = settings["Appearance"]["Base layer"]
basemaps = [basemapOL()[item.text()] for _, item in enumerate(basemapList)]
baseLayer = """var baseLayer = new ol.layer.Group({
'title': 'Base maps',
layers: [%s\n]
});""" % ','.join(basemaps)
layerVars = ""
for layer, encode2json, cluster in zip(layers, json, clustered):
try:
if is25d(layer, canvas):
pass
else:
layerVars += "\n".join([
layerToJavascript(iface, layer, encode2json, matchCRS,
cluster)
])
except:
layerVars += "\n".join([
layerToJavascript(iface, layer, encode2json, matchCRS, cluster)
])
groupVars = ""
groupedLayers = {}
for group, groupLayers in groups.iteritems():
groupVars += (
'''var %s = new ol.layer.Group({
layers: [%s],
title: "%s"});\n''' %
("group_" + safeName(group), ",".join(
["lyr_" + safeName(layer.name())
for layer in groupLayers]), group))
for layer in groupLayers:
groupedLayers[layer.id()] = safeName(group)
mapLayers = ["baseLayer"]
usedGroups = []
osmb = ""
for layer in layers:
try:
renderer = layer.rendererV2()
if is25d(layer, canvas):
shadows = ""
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
fields = layer.pendingFields()
renderer.startRender(renderContext, fields)
for feat in layer.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue()
and attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(
feat, renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
osmb = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(geojson_{sln});""".format(shadows=shadows, sln=safeName(layer.name()))
else:
mapLayers.append("lyr_" + safeName(layer.name()))
except:
mapLayers.append("lyr_" + safeName(layer.name()))
visibility = ""
for layer, v in zip(mapLayers[1:], visible):
visibility += "\n".join(
["%s.setVisible(%s);" % (layer, unicode(v).lower())])
group_list = ["baseLayer"] if len(basemapList) else []
no_group_list = []
for layer in layers:
try:
if is25d(layer, canvas):
pass
else:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()))
except:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()))
layersList = []
for layer in (group_list + no_group_list):
layersList.append(layer)
layersListString = "var layersList = [" + ",".join(layersList) + "];"
fieldAliases = ""
fieldImages = ""
fieldLabels = ""
for layer, labels in zip(layers, popup):
if layer.type() == layer.VectorLayer:
fieldList = layer.pendingFields()
aliasFields = ""
imageFields = ""
labelFields = ""
for field, label in zip(labels.keys(), labels.values()):
labelFields += "'%(field)s': '%(label)s', " % ({
"field": field,
"label": label
})
labelFields = "{%(labelFields)s});\n" % ({
"labelFields": labelFields
})
labelFields = "lyr_%(name)s.set('fieldLabels', " % ({
"name":
safeName(layer.name())
}) + labelFields
fieldLabels += labelFields
for f in fieldList:
fieldIndex = fieldList.indexFromName(unicode(f.name()))
aliasFields += "'%(field)s': '%(alias)s', " % (
{
"field": f.name(),
"alias": layer.attributeDisplayName(fieldIndex)
})
try:
widget = layer.editFormConfig().widgetType(fieldIndex)
except:
widget = layer.editorWidgetV2(fieldIndex)
imageFields += "'%(field)s': '%(image)s', " % (
{
"field": f.name(),
"image": widget
})
aliasFields = "{%(aliasFields)s});\n" % ({
"aliasFields": aliasFields
})
aliasFields = "lyr_%(name)s.set('fieldAliases', " % ({
"name":
safeName(layer.name())
}) + aliasFields
fieldAliases += aliasFields
imageFields = "{%(imageFields)s});\n" % ({
"imageFields": imageFields
})
imageFields = "lyr_%(name)s.set('fieldImages', " % ({
"name":
safeName(layer.name())
}) + imageFields
fieldImages += imageFields
path = os.path.join(folder, "layers", "layers.js")
with codecs.open(path, "w", "utf-8") as f:
if basemapList:
f.write(baseLayer + "\n")
f.write(layerVars + "\n")
f.write(groupVars + "\n")
f.write(visibility + "\n")
f.write(layersListString + "\n")
f.write(fieldAliases)
f.write(fieldImages)
f.write(fieldLabels)
return osmb
def writeLayersAndGroups(layers, groups, visible, folder, popup,
settings, json, matchCRS, clustered, iface,
restrictToExtent, extent):
canvas = iface.mapCanvas()
basemapList = settings["Appearance"]["Base layer"]
basemaps = [basemapOL()[item] for _, item in enumerate(basemapList)]
if len(basemapList) > 1:
baseGroup = "Base maps"
else:
baseGroup = ""
baseLayer = """var baseLayer = new ol.layer.Group({
'title': '%s',
layers: [%s\n]
});""" % (baseGroup, ','.join(basemaps))
layerVars = ""
layer_names_id = {}
for count, (layer, encode2json, cluster) in enumerate(zip(layers, json,
clustered)):
layer_names_id[layer.id()] = str(count)
try:
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
layerVars += "\n".join([layerToJavascript(iface, layer,
encode2json,
matchCRS, cluster,
restrictToExtent,
extent, count)])
except:
try:
layerVars += "\n".join([layerToJavascript(iface, layer,
encode2json,
matchCRS, cluster,
restrictToExtent,
extent, count)])
except:
pass
groupVars = ""
groupedLayers = {}
for group, groupLayers in groups.iteritems():
groupLayerObjs = ""
for layer in groupLayers:
try:
if isinstance(layer, TileLayer):
continue
except:
pass
groupLayerObjs += ("lyr_" + safeName(layer.name()) +
layer_names_id[layer.id()] + ",")
groupVars += ('''var %s = new ol.layer.Group({
layers: [%s],
title: "%s"});\n''' %
("group_" + safeName(group), groupLayerObjs, group))
for layer in groupLayers:
groupedLayers[layer.id()] = safeName(group)
mapLayers = ["baseLayer"]
usedGroups = []
osmb = ""
for count, layer in enumerate(layers):
try:
renderer = layer.rendererV2()
if is25d(layer, canvas, restrictToExtent, extent):
shadows = ""
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
fields = layer.pendingFields()
renderer.startRender(renderContext, fields)
for feat in layer.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat,
renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
osmb = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(json_{sln}{count});""".format(shadows=shadows,
sln=safeName(layer.name()),
count=unicode(count))
else:
try:
if not isinstance(layer, TileLayer):
mapLayers.append("lyr_" + safeName(layer.name()) +
unicode(count))
except:
mapLayers.append("lyr_" + safeName(layer.name()) +
unicode(count))
except:
QgsMessageLog.logMessage(traceback.format_exc(), "qgis2web",
level=QgsMessageLog.CRITICAL)
try:
if not isinstance(layer, TileLayer):
mapLayers.append("lyr_" + safeName(layer.name()) +
unicode(count))
except:
mapLayers.append("lyr_" + safeName(layer.name()) +
unicode(count))
visibility = ""
for layer, v in zip(mapLayers[1:], visible):
visibility += "\n".join(["%s.setVisible(%s);" % (layer,
unicode(v).lower())])
group_list = ["baseLayer"] if len(basemapList) else []
no_group_list = []
for count, layer in enumerate(layers):
try:
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) +
unicode(count))
except:
if layer.id() in groupedLayers:
groupName = groupedLayers[layer.id()]
if groupName not in usedGroups:
group_list.append("group_" + safeName(groupName))
usedGroups.append(groupName)
else:
no_group_list.append("lyr_" + safeName(layer.name()) +
unicode(count))
layersList = []
for layer in (group_list + no_group_list):
layersList.append(layer)
layersListString = "var layersList = [" + ",".join(layersList) + "];"
fieldAliases = ""
fieldImages = ""
fieldLabels = ""
blend_mode = ""
for count, (layer, labels) in enumerate(zip(layers, popup)):
sln = safeName(layer.name()) + unicode(count)
if layer.type() == layer.VectorLayer and not is25d(layer, canvas,
restrictToExtent,
extent):
fieldList = layer.pendingFields()
aliasFields = ""
imageFields = ""
labelFields = ""
for field, label in zip(labels.keys(), labels.values()):
labelFields += "'%(field)s': '%(label)s', " % (
{"field": field, "label": label})
labelFields = "{%(labelFields)s});\n" % (
{"labelFields": labelFields})
labelFields = "lyr_%(name)s.set('fieldLabels', " % (
{"name": sln}) + labelFields
fieldLabels += labelFields
for f in fieldList:
fieldIndex = fieldList.indexFromName(unicode(f.name()))
aliasFields += "'%(field)s': '%(alias)s', " % (
{"field": f.name(),
"alias": layer.attributeDisplayName(fieldIndex)})
widget = layer.editFormConfig().widgetType(fieldIndex)
imageFields += "'%(field)s': '%(image)s', " % (
{"field": f.name(),
"image": widget})
aliasFields = "{%(aliasFields)s});\n" % (
{"aliasFields": aliasFields})
aliasFields = "lyr_%(name)s.set('fieldAliases', " % (
{"name": sln}) + aliasFields
fieldAliases += aliasFields
imageFields = "{%(imageFields)s});\n" % (
{"imageFields": imageFields})
imageFields = "lyr_%(name)s.set('fieldImages', " % (
{"name": sln}) + imageFields
fieldImages += imageFields
blend_mode = """lyr_%(name)s.on('precompose', function(evt) {
evt.context.globalCompositeOperation = '%(blend)s';
});""" % (
{"name": sln,
"blend": BLEND_MODES[layer.blendMode()]})
path = os.path.join(folder, "layers", "layers.js")
with codecs.open(path, "w", "utf-8") as f:
if basemapList:
f.write(baseLayer + "\n")
f.write(layerVars + "\n")
f.write(groupVars + "\n")
f.write(visibility + "\n")
f.write(layersListString + "\n")
f.write(fieldAliases)
f.write(fieldImages)
f.write(fieldLabels)
f.write(blend_mode)
return osmb
def exportJSONLayer(layer, eachPopup, precision, tmpFileName, exp_crs,
layerFileName, safeLayerName, minify, canvas,
restrictToExtent, iface, extent):
cleanedLayer = writeTmpLayer(layer, eachPopup, restrictToExtent,
iface, extent)
if is25d(layer, canvas, restrictToExtent, extent):
provider = cleanedLayer.dataProvider()
provider.addAttributes([QgsField("height", QVariant.Double),
QgsField("wallColor", QVariant.String),
QgsField("roofColor", QVariant.String)])
cleanedLayer.updateFields()
fields = cleanedLayer.pendingFields()
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
feats = layer.getFeatures()
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
expression = QgsExpression('eval(@qgis_25d_height)')
heightField = fields.indexFromName("height")
wallField = fields.indexFromName("wallColor")
roofField = fields.indexFromName("roofColor")
renderer.startRender(renderContext, fields)
cleanedLayer.startEditing()
for feat in feats:
context.setFeature(feat)
height = expression.evaluate(context)
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
wallColor = symbol.symbolLayer(1).subSymbol().color().name()
roofColor = symbol.symbolLayer(2).subSymbol().color().name()
cleanedLayer.changeAttributeValue(feat.id() + 1,
heightField, height)
cleanedLayer.changeAttributeValue(feat.id() + 1,
wallField, wallColor)
cleanedLayer.changeAttributeValue(feat.id() + 1,
roofField, roofColor)
cleanedLayer.commitChanges()
renderer.stopRender(renderContext)
writer = QgsVectorFileWriter
if precision != "maintain":
options = "COORDINATE_PRECISION=" + unicode(precision)
else:
options = ""
writer.writeAsVectorFormat(cleanedLayer, tmpFileName, 'utf-8', exp_crs,
'GeoJson', 0, layerOptions=[options])
with open(layerFileName, "w") as f2:
f2.write("var json_" + unicode(safeLayerName) + "=")
with open(tmpFileName, "r") as tmpFile:
for line in tmpFile:
if minify:
line = line.strip("\n\t ")
line = removeSpaces(line)
f2.write(line)
os.remove(tmpFileName)
fields = layer.pendingFields()
for field in fields:
exportImages(layer, field.name(), layerFileName)
def writeVectorLayer(i, safeLayerName, usedFields, highlight, popupsOnHover,
popup, count, outputProjectFileName, wfsLayers, cluster,
cluster_num, visible, json, legends, new_src, canvas):
(new_pop, labeltext,
popFuncs) = labelsAndPopups(i, safeLayerName, usedFields, highlight,
popupsOnHover, popup, count)
renderer = i.rendererV2()
layer_transp = 1 - (float(i.layerTransparency()) / 100)
new_obj = ""
if is25d(i, canvas):
shadows = ""
renderer = i.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
fields = i.pendingFields()
renderer.startRender(renderContext, fields)
for feat in i.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
new_obj = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(json_{sln});""".format(shadows=shadows, sln=safeLayerName)
elif (isinstance(renderer, QgsSingleSymbolRendererV2) or
isinstance(renderer, QgsRuleBasedRendererV2)):
print safeLayerName + ": single"
(new_obj, legends,
wfsLayers) = singleLayer(renderer, outputProjectFileName,
safeLayerName, wfsLayers, i, layer_transp,
labeltext, cluster, cluster_num, visible,
json, usedFields, legends, count, popFuncs)
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
print safeLayerName + ": categorized"
(new_obj, legends,
wfsLayers) = categorizedLayer(i, renderer, safeLayerName,
outputProjectFileName, layer_transp,
usedFields, count, legends, labeltext,
cluster, cluster_num, popFuncs, visible,
json, wfsLayers)
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
print safeLayerName + ": graduated"
(new_obj, legends,
wfsLayers) = graduatedLayer(i, safeLayerName, renderer,
outputProjectFileName, layer_transp,
labeltext, popFuncs, cluster, cluster_num,
visible, json, usedFields, count, legends,
wfsLayers)
elif isinstance(renderer, Qgs25DRenderer):
print safeLayerName + ": 2.5d"
if usedFields[count] != 0:
new_src += new_pop.decode("utf-8")
new_src += """
""" + new_obj
if is25d(i, canvas):
pass
else:
new_src += """
bounds_group.addLayer(json_""" + safeLayerName + """JSON);"""
if visible[count]:
if cluster[count] is False:
new_src += """
feature_group.addLayer(json_""" + safeLayerName + """JSON);"""
else:
new_src += """
cluster_group""" + safeLayerName + """JSON.addTo(map);"""
return new_src, legends, wfsLayers
def writeLayersAndGroups(layers, groups, visible, folder, popup, settings,
json, matchCRS, clustered, getFeatureInfo, iface,
restrictToExtent, extent, bounds, authid):
canvas = iface.mapCanvas()
basemapList = settings["Appearance"]["Base layer"]
baseLayer = getBasemaps(basemapList)
layerVars = ""
layer_names_id = {}
vtLayers = []
for count, (layer, encode2json, cluster,
info) in enumerate(zip(layers, json, clustered,
getFeatureInfo)):
layer_names_id[layer.id()] = str(count)
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
(layerVar, vtLayers) = layerToJavascript(iface, layer, encode2json,
matchCRS, cluster, info,
restrictToExtent, extent,
count, vtLayers)
layerVars += "\n".join([layerVar])
(groupVars, groupedLayers) = buildGroups(groups, qms, layer_names_id)
(mapLayers, layerObjs, osmb) = layersAnd25d(layers, canvas,
restrictToExtent, extent, qms)
visibility = getVisibility(mapLayers, layerObjs, visible)
usedGroups = []
(group_list, no_group_list,
usedGroups) = getGroups(canvas, layers, basemapList, restrictToExtent,
extent, groupedLayers)
layersList = []
currentVT = ""
for layer in (group_list + no_group_list):
layersList.append(layer)
layersListString = "var layersList = [" + ",".join(layersList) + "];"
fieldAliases = ""
fieldImages = ""
fieldLabels = ""
blend_mode = ""
for count, (layer, labels) in enumerate(zip(layers, popup)):
vts = layer.customProperty("VectorTilesReader/vector_tile_url")
sln = safeName(layer.name()) + "_" + unicode(count)
if (layer.type() == layer.VectorLayer and vts is None
and not isinstance(layer.rendererV2(), QgsHeatmapRenderer)
and not is25d(layer, canvas, restrictToExtent, extent)):
(fieldLabels, fieldAliases, fieldImages,
blend_mode) = getPopups(layer, labels, sln, fieldLabels,
fieldAliases, fieldImages)
path = os.path.join(folder, "layers", "layers.js")
with codecs.open(path, "w", "utf-8") as f:
if matchCRS:
f.write("""ol.proj.get("%s").setExtent(%s);
""" % (authid, bounds))
f.write("""var wms_layers = [];\n""")
if basemapList:
f.write(baseLayer + "\n")
f.write(layerVars + "\n")
f.write(groupVars + "\n")
f.write(visibility + "\n")
f.write(layersListString + "\n")
f.write(fieldAliases)
f.write(fieldImages)
f.write(fieldLabels)
f.write(blend_mode)
return osmb
def exportJSONLayer(layer, eachPopup, precision, tmpFileName, exp_crs,
layerFileName, safeLayerName, minify, canvas):
cleanedLayer = writeTmpLayer(layer, eachPopup)
if is25d(layer, canvas):
provider = cleanedLayer.dataProvider()
provider.addAttributes([QgsField("height", QVariant.Double),
QgsField("wallColor", QVariant.String),
QgsField("roofColor", QVariant.String)])
cleanedLayer.updateFields()
fields = cleanedLayer.pendingFields()
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
feats = layer.getFeatures()
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
expression = QgsExpression('eval(@qgis_25d_height)')
heightField = fields.indexFromName("height")
wallField = fields.indexFromName("wallColor")
roofField = fields.indexFromName("roofColor")
renderer.startRender(renderContext, fields)
cleanedLayer.startEditing()
for feat in feats:
context.setFeature(feat)
height = expression.evaluate(context)
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
wallColor = symbol.symbolLayer(1).subSymbol().color().name()
roofColor = symbol.symbolLayer(2).subSymbol().color().name()
cleanedLayer.changeAttributeValue(feat.id() + 1,
heightField, height)
cleanedLayer.changeAttributeValue(feat.id() + 1,
wallField, wallColor)
cleanedLayer.changeAttributeValue(feat.id() + 1,
roofField, roofColor)
cleanedLayer.commitChanges()
renderer.stopRender(renderContext)
writer = QgsVectorFileWriter
if precision != "maintain":
options = "COORDINATE_PRECISION=" + unicode(precision)
else:
options = ""
writer.writeAsVectorFormat(cleanedLayer, tmpFileName, 'utf-8', exp_crs,
'GeoJson', 0, layerOptions=[options])
with open(layerFileName, "w") as f2:
f2.write("var json_" + unicode(safeLayerName) + "=")
with open(tmpFileName, "r") as tmpFile:
for line in tmpFile:
if minify:
line = line.strip("\n\t ")
line = removeSpaces(line)
f2.write(line)
os.remove(tmpFileName)
fields = layer.pendingFields()
for field in fields:
exportImages(layer, field.name(), layerFileName)
def writeVectorLayer(layer, safeLayerName, usedFields, highlight,
popupsOnHover, popup, outputProjectFileName, wfsLayers,
cluster, visible, json, legends, new_src, canvas, zIndex,
restrictToExtent, extent):
zIndex = zIndex + 600
markerFolder = os.path.join(outputProjectFileName, "markers")
(new_pop, labeltext,
popFuncs) = labelsAndPopups(layer, safeLayerName, highlight,
popupsOnHover, popup, outputProjectFileName)
renderer = layer.rendererV2()
layer_transp = 1 - (float(layer.layerTransparency()) / 100)
style = ""
if is25d(layer, canvas, restrictToExtent, extent):
shadows = ""
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(canvas.mapSettings())
fields = layer.pendingFields()
renderer.startRender(renderContext, fields)
for feat in layer.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
new_obj = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(json_{sln});""".format(shadows=shadows, sln=safeLayerName)
elif isinstance(renderer, QgsHeatmapRenderer):
(new_obj, legends,
wfsLayers) = heatmapLayer(layer, safeLayerName, renderer, legends,
wfsLayers)
elif isinstance(renderer, QgsSingleSymbolRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder,
outputProjectFileName)
(new_obj, legends,
wfsLayers) = singleLayer(renderer, outputProjectFileName,
safeLayerName, wfsLayers, layer, labeltext,
cluster, json, usedFields, legends,
markerType)
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder,
outputProjectFileName)
(new_obj, legends,
wfsLayers) = categorizedLayer(layer, renderer, safeLayerName,
outputProjectFileName, usedFields,
legends, labeltext, cluster, json,
wfsLayers, markerType)
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder,
outputProjectFileName)
(new_obj, legends,
wfsLayers) = graduatedLayer(layer, safeLayerName, renderer,
outputProjectFileName, labeltext, cluster,
json, usedFields, legends, wfsLayers,
markerType)
elif isinstance(renderer, QgsRuleBasedRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder,
outputProjectFileName)
(new_obj, legends,
wfsLayers) = ruleBasedLayer(layer, renderer, safeLayerName,
outputProjectFileName, usedFields,
legends, labeltext, cluster, json,
wfsLayers, markerType)
blend = BLEND_MODES[layer.blendMode()]
new_obj = u"""{style}
map.createPane('pane_{sln}');
map.getPane('pane_{sln}').style.zIndex = {zIndex};
map.getPane('pane_{sln}').style['mix-blend-mode'] = '{blend}';
{new_obj}""".format(
style=style, sln=safeLayerName, zIndex=zIndex,
blend=blend, new_obj=new_obj)
if usedFields != 0:
new_src += new_pop.decode("utf-8")
new_src += """
""" + new_obj
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
new_src += """
bounds_group.addLayer(layer_""" + safeLayerName + """);"""
if visible:
if cluster is False:
new_src += """
map.addLayer(layer_""" + safeLayerName + """);"""
else:
new_src += """
cluster_""" + safeLayerName + """.addTo(map);"""
return new_src, legends, wfsLayers
def writeVectorLayer(layer, safeLayerName, usedFields, highlight,
popupsOnHover, popup, outputProjectFileName, wfsLayers,
cluster, visible, json, legends, new_src, canvas, zIndex):
zIndex = zIndex + 600
markerFolder = os.path.join(outputProjectFileName, "markers")
(new_pop, labeltext,
popFuncs) = labelsAndPopups(layer, safeLayerName, highlight,
popupsOnHover, popup)
renderer = layer.rendererV2()
layer_transp = 1 - (float(layer.layerTransparency()) / 100)
style = ""
if is25d(layer, canvas):
shadows = ""
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(canvas.mapSettings())
fields = layer.pendingFields()
renderer.startRender(renderContext, fields)
for feat in layer.getFeatures():
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue() and
attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(feat, renderContext)
symbolLayer = symbol.symbolLayer(0)
if not symbolLayer.paintEffect().effectList()[0].enabled():
shadows = "'2015-07-15 10:00:00'"
renderer.stopRender(renderContext)
new_obj = """
var osmb = new OSMBuildings(map).date(new Date({shadows}));
osmb.set(json_{sln});""".format(shadows=shadows, sln=safeLayerName)
# else:
# layer_style = getLayerStyle(layer, safeLayerName)
elif isinstance(renderer, QgsHeatmapRenderer):
(new_obj, legends,
wfsLayers) = heatmapLayer(layer, safeLayerName, renderer, legends,
wfsLayers)
elif (isinstance(renderer, QgsSingleSymbolRendererV2) or
isinstance(renderer, QgsRuleBasedRendererV2)):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder)
(new_obj, legends,
wfsLayers) = singleLayer(renderer, outputProjectFileName,
safeLayerName, wfsLayers, layer, labeltext,
cluster, json, usedFields, legends,
markerType)
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder)
(new_obj, legends,
wfsLayers) = categorizedLayer(layer, renderer, safeLayerName,
outputProjectFileName, usedFields,
legends, labeltext, cluster, json,
wfsLayers, markerType)
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
(style, markerType) = getLayerStyle(layer, safeLayerName, markerFolder)
(new_obj, legends,
wfsLayers) = graduatedLayer(layer, safeLayerName, renderer,
outputProjectFileName, labeltext, cluster,
json, usedFields, legends, wfsLayers,
markerType)
blend = BLEND_MODES[layer.blendMode()]
new_obj = """{style}
map.createPane('pane_{sln}');
map.getPane('pane_{sln}').style.zIndex = {zIndex};
map.getPane('pane_{sln}').style['mix-blend-mode'] = '{blend}';
{new_obj}""".format(
style=style, sln=safeLayerName, zIndex=zIndex,
blend=blend, new_obj=new_obj)
if usedFields != 0:
new_src += new_pop.decode("utf-8")
new_src += """
""" + new_obj
if is25d(layer, canvas):
pass
else:
new_src += """
bounds_group.addLayer(layer_""" + safeLayerName + """);"""
if visible:
if cluster is False:
new_src += """
feature_group.addLayer(layer_""" + safeLayerName + """);"""
else:
new_src += """
cluster_""" + safeLayerName + """.addTo(map);"""
return new_src, legends, wfsLayers
def layerToJavascript(iface, layer, encode2json, matchCRS, cluster):
if layer.hasScaleBasedVisibility():
minRes = 1 / ((1 / layer.minimumScale()) * 39.37 * 90.7)
maxRes = 1 / ((1 / layer.maximumScale()) * 39.37 * 90.7)
minResolution = "\nminResolution:%s,\n" % unicode(minRes)
maxResolution = "maxResolution:%s,\n" % unicode(maxRes)
else:
minResolution = ""
maxResolution = ""
layerName = safeName(layer.name())
if layer.type() == layer.VectorLayer and not is25d(layer,
iface.mapCanvas()):
renderer = layer.rendererV2()
if cluster and (isinstance(renderer, QgsSingleSymbolRendererV2)
or isinstance(renderer, QgsRuleBasedRendererV2)):
cluster = True
else:
cluster = False
if matchCRS:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs().authid()
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: '%(d)s'}""" % {
"d": mapCRS
}
else:
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857'}"""
if layer.providerType() == "WFS" and not encode2json:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var jsonSource_%(n)s = new ol.source.Vector({
format: format_%(n)s
});''' % {
"n": layerName
}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {
"n": layerName
}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source: ''' % {
"n": layerName
}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});
function get%(n)sJson(geojson) {
var features_%(n)s = format_%(n)s.readFeatures(geojson);
jsonSource_%(n)s.addFeatures(features_%(n)s);
}''' % {
"name": layer.name(),
"n": layerName,
"min": minResolution,
"max": maxResolution
}
return layerCode
else:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var features_%(n)s = format_%(n)s.readFeatures(geojson_%(n)s, %(crs)s);
var jsonSource_%(n)s = new ol.source.Vector();
jsonSource_%(n)s.addFeatures(features_%(n)s);''' % {
"n": layerName,
"crs": crsConvert
}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {
"n": layerName
}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source:''' % {
"n": layerName
}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});''' % {
"name": layer.name(),
"n": layerName,
"min": minResolution,
"max": maxResolution
}
return layerCode
elif layer.type() == layer.RasterLayer:
if layer.providerType().lower() == "wms":
source = layer.source()
layers = re.search(r"layers=(.*?)(?:&|$)", source).groups(0)[0]
url = re.search(r"url=(.*?)(?:&|$)", source).groups(0)[0]
return '''var lyr_%(n)s = new ol.layer.Tile({
source: new ol.source.TileWMS(({
url: "%(url)s",
params: {"LAYERS": "%(layers)s", "TILED": "true"},
})),
title: "%(name)s",
%(minRes)s
%(maxRes)s
});''' % {
"layers": layers,
"url": url,
"n": layerName,
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution
}
elif layer.providerType().lower() == "gdal":
provider = layer.dataProvider()
crsSrc = layer.crs()
crsDest = QgsCoordinateReferenceSystem(3857)
xform = QgsCoordinateTransform(crsSrc, crsDest)
extentRep = xform.transform(layer.extent())
sExtent = "[%f, %f, %f, %f]" % (
extentRep.xMinimum(), extentRep.yMinimum(),
extentRep.xMaximum(), extentRep.yMaximum())
return '''var lyr_%(n)s = new ol.layer.Image({
opacity: 1,
title: "%(name)s",
%(minRes)s
%(maxRes)s
source: new ol.source.ImageStatic({
url: "./layers/%(n)s.png",
projection: 'EPSG:3857',
alwaysInRange: true,
//imageSize: [%(col)d, %(row)d],
imageExtent: %(extent)s
})
});''' % {
"n": layerName,
"extent": sExtent,
"col": provider.xSize(),
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution,
"row": provider.ySize()
}
def layerToJavascript(iface, layer, encode2json, matchCRS, cluster,
restrictToExtent, extent, count):
if layer.hasScaleBasedVisibility():
if layer.minimumScale() != 0:
minRes = 1 / ((1 / layer.minimumScale()) * 39.37 * 90.7)
minResolution = "\nminResolution:%s,\n" % unicode(minRes)
else:
minResolution = ""
if layer.maximumScale() != 0:
maxRes = 1 / ((1 / layer.maximumScale()) * 39.37 * 90.7)
maxResolution = "maxResolution:%s,\n" % unicode(maxRes)
else:
maxResolution = ""
else:
minResolution = ""
maxResolution = ""
layerName = safeName(layer.name()) + unicode(count)
attrText = layer.attribution()
attrUrl = layer.attributionUrl()
layerAttr = '<a href="%s">%s</a>' % (attrUrl, attrText)
if layer.type() == layer.VectorLayer and not is25d(layer,
iface.mapCanvas(),
restrictToExtent,
extent):
renderer = layer.rendererV2()
if (cluster and isinstance(renderer, QgsSingleSymbolRendererV2)):
cluster = True
else:
cluster = False
if isinstance(renderer, QgsHeatmapRenderer):
pointLayerType = "Heatmap"
hmRadius = renderer.radius()
colorRamp = renderer.colorRamp()
hmStart = colorRamp.color1().name()
hmEnd = colorRamp.color2().name()
hmRamp = "['" + hmStart + "', "
hmStops = colorRamp.stops()
for stop in hmStops:
hmRamp += "'" + stop.color.name() + "', "
hmRamp += "'" + hmEnd + "']"
hmWeight = renderer.weightExpression()
hmWeightId = layer.fieldNameIndex(hmWeight)
hmWeightMax = layer.maximumValue(hmWeightId)
else:
pointLayerType = "Vector"
if matchCRS:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs().authid()
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: '%(d)s'}""" % {
"d": mapCRS}
else:
crsConvert = """
{dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857'}"""
if layer.providerType() == "WFS" and not encode2json:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var jsonSource_%(n)s = new ol.source.Vector({
attributions: [new ol.Attribution({html: '%(layerAttr)s'})],
format: format_%(n)s
});''' % {"n": layerName, "layerAttr": layerAttr}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {"n": layerName}
layerCode += '''var lyr_%(n)s = new ol.layer.Vector({
source: ''' % {"n": layerName}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s
style: style_%(n)s,
title: "%(name)s"
});
function get%(n)sJson(geojson) {
var features_%(n)s = format_%(n)s.readFeatures(geojson);
jsonSource_%(n)s.addFeatures(features_%(n)s);
}''' % {
"name": layer.name(), "n": layerName,
"min": minResolution, "max": maxResolution}
return layerCode
else:
layerCode = '''var format_%(n)s = new ol.format.GeoJSON();
var features_%(n)s = format_%(n)s.readFeatures(json_%(n)s, %(crs)s);
var jsonSource_%(n)s = new ol.source.Vector({
attributions: [new ol.Attribution({html: '%(layerAttr)s'})],
});
jsonSource_%(n)s.addFeatures(features_%(n)s);''' % {"n": layerName,
"crs": crsConvert,
"layerAttr": layerAttr}
if cluster:
layerCode += '''cluster_%(n)s = new ol.source.Cluster({
distance: 10,
source: jsonSource_%(n)s
});''' % {"n": layerName}
layerCode += '''var lyr_%(n)s = new ol.layer.%(t)s({
source:''' % {"n": layerName, "t": pointLayerType}
if cluster:
layerCode += 'cluster_%(n)s,' % {"n": layerName}
else:
layerCode += 'jsonSource_%(n)s,' % {"n": layerName}
layerCode += '''%(min)s %(max)s''' % {"min": minResolution,
"max": maxResolution}
if pointLayerType == "Vector":
layerCode += '''
style: style_%(n)s,''' % {"n": layerName}
else:
layerCode += '''
radius: %(hmRadius)d * 2,
gradient: %(hmRamp)s,
blur: 15,
shadow: 250,''' % {"hmRadius": hmRadius, "hmRamp": hmRamp}
if hmWeight != "":
layerCode += '''
weight: function(feature){
var weightField = '%(hmWeight)s';
var featureWeight = feature.get(weightField);
var maxWeight = %(hmWeightMax)d;
var calibratedWeight = featureWeight/maxWeight;
return calibratedWeight;
},''' % {"hmWeight": hmWeight, "hmWeightMax": hmWeightMax}
if isinstance(renderer, QgsSingleSymbolRendererV2):
layerCode += '''
title: '<img src="styles/legend/%(icon)s.png" /> %(name)s'
});''' % {"icon": layerName, "name": layer.name()}
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
icons = ""
for count, cat in enumerate(renderer.categories()):
text = cat.label().replace("'", "\\'")
icons += ("""\\
<img src="styles/legend/%(icon)s_%(count)s.png" /> %(text)s<br />""" %
{"icon": layerName,
"count": count,
"text": text})
layerCode += '''
title: '%(name)s<br />%(icons)s'
});''' % {"icons": icons, "name": layer.name()}
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
icons = ""
for count, ran in enumerate(renderer.ranges()):
text = ran.label().replace("'", "\\'")
icons += ("""\\
<img src="styles/legend/%(icon)s_%(count)s.png" /> %(text)s<br />""" %
{"icon": layerName, "count": count,
"text": text})
layerCode += '''
title: '%(name)s<br />%(icons)s'
});''' % {"icons": icons, "name": layer.name()}
else:
layerCode += '''
title: '%(name)s'
});''' % {"name": layer.name()}
return layerCode
elif layer.type() == layer.RasterLayer:
if layer.providerType().lower() == "wms":
source = layer.source()
opacity = layer.renderer().opacity()
d = parse_qs(source)
if "type" in d and d["type"][0] == "xyz":
return """
var lyr_%s = new ol.layer.Tile({
'title': '%s',
'type': 'base',
'opacity': %f,
%s
%s
source: new ol.source.XYZ({
attributions: [new ol.Attribution({html: '%s'})],
url: '%s'
})
});""" % (layerName, layerName, opacity, minResolution, maxResolution,
layerAttr, d["url"][0])
elif "tileMatrixSet" in d:
layerId = d["layers"][0]
url = d["url"][0]
format = d["format"][0]
style = d["styles"][0]
return '''
var projection_%(n)s = ol.proj.get('EPSG:3857');
var projectionExtent_%(n)s = projection_%(n)s.getExtent();
var size_%(n)s = ol.extent.getWidth(projectionExtent_%(n)s) / 256;
var resolutions_%(n)s = new Array(14);
var matrixIds_%(n)s = new Array(14);
for (var z = 0; z < 14; ++z) {
// generate resolutions and matrixIds arrays for this WMTS
resolutions_%(n)s[z] = size_%(n)s / Math.pow(2, z);
matrixIds_%(n)s[z] = z;
}
var lyr_%(n)s = new ol.layer.Tile({
source: new ol.source.WMTS(({
url: "%(url)s",
attributions: [new ol.Attribution({html: '%(layerAttr)s'})],
"layer": "%(layerId)s",
"TILED": "true",
matrixSet: 'EPSG:3857',
format: '%(format)s',
projection: projection_%(n)s,
tileGrid: new ol.tilegrid.WMTS({
origin: ol.extent.getTopLeft(projectionExtent_%(n)s),
resolutions: resolutions_%(n)s,
matrixIds: matrixIds_%(n)s
}),
style: '%(style)s',
wrapX: true,
"VERSION": "1.0.0",
})),
title: "%(name)s",
opacity: %(opacity)s,
%(minRes)s
%(maxRes)s
});''' % {"layerId": layerId, "url": url,
"layerAttr": layerAttr, "format": format,
"n": layerName, "name": layer.name(),
"opacity": opacity, "style": style,
"minRes": minResolution,
"maxRes": maxResolution}
else:
layers = re.search(r"layers=(.*?)(?:&|$)", source).groups(0)[0]
url = re.search(r"url=(.*?)(?:&|$)", source).groups(0)[0]
metadata = layer.metadata()
needle = "<tr><td>%s</td><td>(.+?)</td>" % (
QCoreApplication.translate("QgsWmsProvider",
"WMS Version"))
result = re.search(needle, metadata)
if result:
version = result.group(1)
else:
version = ""
return '''var lyr_%(n)s = new ol.layer.Tile({
source: new ol.source.TileWMS(({
url: "%(url)s",
attributions: [new ol.Attribution({html: '%(layerAttr)s'})],
params: {
"LAYERS": "%(layers)s",
"TILED": "true",
"VERSION": "%(version)s"},
})),
title: "%(name)s",
opacity: %(opacity)f,
%(minRes)s
%(maxRes)s
});''' % {"layers": layers, "url": url,
"layerAttr": layerAttr,
"n": layerName, "name": layer.name(),
"version": version, "opacity": opacity,
"minRes": minResolution,
"maxRes": maxResolution}
elif layer.providerType().lower() == "gdal":
provider = layer.dataProvider()
crsSrc = layer.crs()
crsDest = QgsCoordinateReferenceSystem(3857)
xform = QgsCoordinateTransform(crsSrc, crsDest)
extentRep = xform.transform(layer.extent())
sExtent = "[%f, %f, %f, %f]" % (extentRep.xMinimum(),
extentRep.yMinimum(),
extentRep.xMaximum(),
extentRep.yMaximum())
return '''var lyr_%(n)s = new ol.layer.Image({
opacity: 1,
title: "%(name)s",
%(minRes)s
%(maxRes)s
source: new ol.source.ImageStatic({
url: "./layers/%(n)s.png",
attributions: [new ol.Attribution({html: '%(layerAttr)s'})],
projection: 'EPSG:3857',
alwaysInRange: true,
//imageSize: [%(col)d, %(row)d],
imageExtent: %(extent)s
})
});''' % {"n": layerName,
"extent": sExtent,
"col": provider.xSize(),
"name": layer.name(),
"minRes": minResolution,
"maxRes": maxResolution,
"layerAttr": layerAttr,
"row": provider.ySize()}
def writeLayersAndGroups(layers, groups, visible, folder, popup,
settings, json, matchCRS, clustered, iface,
restrictToExtent, extent):
canvas = iface.mapCanvas()
basemapList = settings["Appearance"]["Base layer"]
baseLayer = getBasemaps(basemapList)
layerVars = ""
layer_names_id = {}
for count, (layer, encode2json, cluster) in enumerate(zip(layers, json,
clustered)):
layer_names_id[layer.id()] = str(count)
if is25d(layer, canvas, restrictToExtent, extent):
pass
else:
layerVars += "\n".join([layerToJavascript(iface, layer,
encode2json,
matchCRS, cluster,
restrictToExtent,
extent, count)])
(groupVars, groupedLayers) = buildGroups(groups, qms, layer_names_id)
(mapLayers, osmb) = layersAnd25d(layers, canvas, restrictToExtent, extent,
qms)
visibility = getVisibility(mapLayers, visible)
usedGroups = []
(group_list, no_group_list,
usedGroups) = getGroups(canvas, layers, basemapList, restrictToExtent,
extent, groupedLayers)
layersList = []
for layer in (group_list + no_group_list):
layersList.append(layer)
layersListString = "var layersList = [" + ",".join(layersList) + "];"
fieldAliases = ""
fieldImages = ""
fieldLabels = ""
blend_mode = ""
labelgun = ""
for count, (layer, labels) in enumerate(zip(layers, popup)):
sln = safeName(layer.name()) + "_" + unicode(count)
if (layer.type() == layer.VectorLayer and
not isinstance(layer.rendererV2(), QgsHeatmapRenderer) and
not is25d(layer, canvas, restrictToExtent, extent)):
(fieldLabels, fieldAliases, fieldImages,
blend_mode, labelgun) = getPopups(layer, labels, sln, fieldLabels,
fieldAliases, fieldImages)
path = os.path.join(folder, "layers", "layers.js")
with codecs.open(path, "w", "utf-8") as f:
if basemapList:
f.write(baseLayer + "\n")
f.write(layerVars + "\n")
f.write(groupVars + "\n")
f.write(visibility + "\n")
f.write(layersListString + "\n")
f.write(fieldAliases)
f.write(fieldImages)
f.write(fieldLabels)
f.write(blend_mode)
f.write(labelgun)
return osmb
