Calcul des couleurs des carrés dans une grille vectorielle dans QGIS 2.18.5

J'ai une couche avec de nombreux bâtiments comme points sur une carte. L'un des attributs de chaque bâtiment est "download_speed".

Je veux mettre une grille carrée (100 x 100 mètres) en haut de la carte. Les carrés doivent se comporter comme suit:

1. La place ne doit être visible que s'il y a au moins un bâtiment sur la place.

2. Le carré doit être rouge si aucun des bâtiments du carré n'a un "download_speed"chiffre supérieur à 10 (Mbit / s).

3. Le carré doit être gris si certains des bâtiments du carré ont une valeur "download_speed"supérieure à 10 (Mbit / s)

4. Le carré doit être noir si tous les bâtiments du carré ont une valeur "download_speed"supérieure à 10 (Mbit / s)

Je suis un débutant complet sur QGIS (et les logiciels SIG en général), mais un utilisateur expérimenté de Python en science des données.

Le résultat final devrait ressembler un peu à l'image ci-dessous:

Il y a quelque temps, j'ai écrit un article pour créer une grille vectorielle de polygones:

Comment générer une grille vectorielle de polygones dans QGIS en utilisant Python

ce qui m'a inspiré pour proposer une solution.

Mon approche revient à un script personnalisé de la boîte à outils de traitement (veuillez vous référer au post ci-dessus si vous ne savez pas comment le faire).

En tant que paramètres d'entrée, il nécessite:

• la couche vectorielle ponctuelle;
• l'étendue de la grille;
• l'espacement horizontal, c'est-à-dire la longueur latérale horizontale pour les éléments de la grille;
• l'espacement vertical, c'est-à-dire la longueur verticale du côté pour les éléments de la grille.

En supposant que les vitesses de téléchargement sont stockées sur le "download_speed"terrain, vous pouvez utiliser ce code:

##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)

En tant qu'utilisateur Python expérimenté, vous devriez être en mesure de comprendre facilement le code ci-dessus et de l'adapter à vos besoins spécifiques (sinon, faites-moi savoir si vous avez besoin d'explications). Une dernière chose: je n'ai pas testé en profondeur les conditions pour l'affectation des couleurs, mais cela devrait être une tâche facile pour vous.

Test du code sur ces points aléatoires:

J'obtiens ce résultat:

ce qui semble être ce que vous recherchez.