Berechnen der Farben der Quadrate in einem Vektorgitter in QGIS 2.18.5

Ich habe eine Ebene mit vielen Gebäuden als Punkte auf einer Karte. Eines der Attribute jedes Gebäudes ist "download_speed".

Ich möchte ein quadratisches Raster (100 x 100 Meter) auf die Karte setzen. Die Quadrate sollten sich wie folgt verhalten:

1. Der Platz sollte nur sichtbar sein, wenn sich mindestens ein Gebäude auf dem Platz befindet.

2. Das Quadrat sollte rot sein, wenn keines der Gebäude auf dem Quadrat "download_speed"über 10 (Mbit / s) liegt.

3. Das Quadrat sollte grau sein, wenn einige der Gebäude auf dem Quadrat "download_speed"über 10 (Mbit / s) liegen.

4. Das Quadrat sollte schwarz sein, wenn alle Gebäude auf dem Quadrat "download_speed"über 10 (Mbit / s) liegen.

Ich bin ein absoluter Neuling in QGIS (und GIS-Software im Allgemeinen), aber ein erfahrener Benutzer von Python in der Datenwissenschaft.

Das Endergebnis sollte ungefähr so ​​aussehen wie auf dem Bild unten:

Vor einiger Zeit habe ich einen Beitrag zum Erstellen eines Vektorgitters aus Polygonen geschrieben:

So generieren Sie mit Python ein Vektorgitter aus Polygonen in QGIS

Das hat mich dazu inspiriert, eine Lösung vorzuschlagen.

Mein Ansatz greift auf ein benutzerdefiniertes Skript aus der Processing Toolbox zurück (siehe den obigen Beitrag, wenn Sie nicht wissen, wie es geht).

Als Eingabeparameter benötigt es:

• die Punktvektorschicht;
• die Ausdehnung des Gitters;
• der horizontale Abstand, dh die horizontale Seitenlänge für die Merkmale im Raster;
• der vertikale Abstand, dh die vertikale Seitenlänge für die Features im Raster.

Angenommen, die Download-Geschwindigkeiten werden im "download_speed"Feld gespeichert , können Sie diesen Code verwenden:

##Point_layer=vector point
##Grid_extent=extent
##Horizontal_spacing=number 10
##Vertical_spacing=number 10

from qgis.core import *
from qgis.PyQt.QtCore import QVariant
from PyQt4.QtGui import QColor

layer = processing.getObject(Point_layer)
crs = layer.crs().toWkt()

extent = Grid_extent.split(',')
(xmin, xmax, ymin, ymax) = (float(extent[0]), float(extent[1]), float(extent[2]), float(extent[3]))
hspacing = Horizontal_spacing
vspacing = Vertical_spacing

# Create the grid layer
vector_grid = QgsVectorLayer('Polygon?crs='+ crs, 'vector_grid' , 'memory')
prov = vector_grid.dataProvider()

all_features = {}
index = QgsSpatialIndex() # Spatial index
for ft in layer.getFeatures():
    index.insertFeature(ft)
    all_features[ft.id()] = ft

# Add ids and coordinates fields
fields = QgsFields()
fields.append(QgsField('ID', QVariant.Int, '', 10, 0))
fields.append(QgsField('XMIN', QVariant.Double, '', 24, 6))
fields.append(QgsField('XMAX', QVariant.Double, '', 24, 6))
fields.append(QgsField('YMIN', QVariant.Double, '', 24, 6))
fields.append(QgsField('YMAX', QVariant.Double, '', 24, 6))
fields.append(QgsField('Color', QVariant.String, '', 10))
prov.addAttributes(fields)

# Generate the features for the vector grid
id = 0
y = ymax
while y >= ymin:
    x = xmin
    while x <= xmax:
        point1 = QgsPoint(x, y)
        point2 = QgsPoint(x + hspacing, y)
        point3 = QgsPoint(x + hspacing, y - vspacing)
        point4 = QgsPoint(x, y - vspacing)
        vertices = [point1, point2, point3, point4] # Vertices of the polygon for the current id
        inAttr = [id, x, x + hspacing, y - vspacing, y]
        tmp_geom = QgsGeometry().fromPolygon([vertices])
        idsList = index.intersects(tmp_geom.boundingBox())
        if idsList:
            tmp_list = [all_features[id]['download_speed'] for id in idsList]
            if max(tmp_list) <= 10:
                inAttr.append('Red')
            elif min(tmp_list) > 10:
                inAttr.append('Black')
            else:
                inAttr.append('Grey')
            feat = QgsFeature()
            feat.setGeometry(tmp_geom) # Set geometry for the current id
            feat.setAttributes(inAttr) # Set attributes for the current id
            prov.addFeatures([feat])
            id += 1
        x = x + hspacing
    y = y - vspacing

# Update fields for the vector grid
vector_grid.updateFields()

# define the lookup: value -> (color, label)
speeds_colors = {'Red': ('#e31a1c', 'Red'), 'Black': ('#000000', 'Black'), 'Grey': ('#82807f', 'Grey'),}

# create a category for each item in speeds_colors
categories = []
for speed_color, (color, label) in speeds_colors.items():
    symbol = QgsSymbolV2.defaultSymbol(vector_grid.geometryType())
    symbol.setColor(QColor(color))
    category = QgsRendererCategoryV2(speed_color, symbol, label)
    categories.append(category)
print categories
# create the renderer and assign it to the layer
expression = 'Color' # field name
renderer = QgsCategorizedSymbolRendererV2(expression, categories) # categorized symbol renderer
vector_grid.setRendererV2(renderer) # assign the renderer to the layer
vector_grid.triggerRepaint()

# Add the layer to the Layers panel
QgsMapLayerRegistry.instance().addMapLayer(vector_grid)

Als erfahrener Python-Benutzer sollten Sie in der Lage sein, den obigen Code leicht zu verstehen und an Ihre spezifischen Anforderungen anzupassen (andernfalls lassen Sie mich wissen, wenn Sie eine Erklärung benötigen). Noch etwas: Ich habe die Bedingungen für die Zuweisung von Farben nicht gründlich getestet, aber es sollte eine leichte Aufgabe für Sie sein.

Testen des Codes an diesen zufälligen Punkten:

Ich erhalte dieses Ergebnis:

Das scheint das zu sein, wonach Sie suchen.