Calcular cores dos quadrados em uma grade vetorial no QGIS 2.18.5

Eu tenho uma camada com muitos edifícios como pontos em um mapa. Um dos atributos de cada edifício é "download_speed".

Quero colocar uma grade quadrada (100 x 100 metros) em cima do mapa. Os quadrados devem se comportar da seguinte maneira:

1. A praça só deve ser visível se houver pelo menos um edifício na praça.

2. O quadrado deve ficar vermelho se nenhum dos edifícios no quadrado tiver um valor "download_speed"acima de 10 (Mbit / s).

3. O quadrado deve ficar cinza se alguns dos edifícios no quadrado tiverem "download_speed"acima de 10 (Mbit / s)

4. O quadrado deve ser preto se todos os edifícios do quadrado tiverem "download_speed"acima de 10 (Mbit / s)

Sou um novato completo em QGIS (e software GIS em geral), mas um usuário experiente de Python em ciência de dados.

O resultado final deve se parecer com a figura abaixo:

Há algum tempo, escrevi um post para criar uma grade vetorial de polígonos:

Como gerar uma grade vetorial de polígonos no QGIS usando Python

o que me inspirou a propor uma solução.

Minha abordagem se baseia em um script personalizado da Processing Toolbox (consulte a postagem acima, se você não souber como fazê-lo).

Como parâmetros de entrada, requer:

• a camada vetorial de pontos;
• a extensão da grade;
• o espaçamento horizontal, ou seja, o comprimento lateral horizontal para as características da grade;
• o espaçamento vertical, ou seja, o comprimento lateral vertical dos recursos na grade.

Supondo que as velocidades de download sejam armazenadas no "download_speed"campo, você pode usar este código:

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

Como um usuário experiente do Python, você deve entender facilmente o código acima e adaptá-lo às suas necessidades específicas (caso contrário, deixe-me saber se você precisa de alguma explicação). Mais uma coisa: não testei profundamente os condicionais para a atribuição de cores, mas deve ser uma tarefa fácil para você.

Testando o código nesses pontos aleatórios:

Eu obtenho este resultado:

que parece ser o que você está procurando.