Le portail francophone de la géomatique

from qgis.core import QgsProject, QgsWkbTypes
from PyQt5.QtWidgets import QMessageBox, QInputDialog

# Fonction pour transférer les attributs des points contenus dans les polygones vers les polygones
def transfer_attributes(point_layer, poly_layer):
    # Vérifier si la couche de points est de type vectoriel
    if point_layer.type() != QgsMapLayer.VectorLayer:
        QMessageBox.warning(None, "Avertissement", "La couche sélectionnée n'est pas une couche vectorielle.")
        return
    
    # Vérifier si la couche de polygones est de type vectoriel
    if poly_layer.type() != QgsMapLayer.VectorLayer:
        QMessageBox.warning(None, "Avertissement", "La couche sélectionnée n'est pas une couche vectorielle.")
        return
    
    # Créer une liste des noms des champs de la couche de points
    point_fields = [field.name() for field in point_layer.fields()]
    
    # Créer une liste des noms des champs de la couche de polygones
    poly_fields = [field.name() for field in poly_layer.fields()]
    
    print("Champs de la couche de points :", point_fields)
    print("Champs de la couche de polygones :", poly_fields)
    
    # Créer un dictionnaire pour stocker les valeurs des attributs des points contenus dans les polygones
    contained_point_attributes = {}
    
    # Parcourir les entités de la couche de polygones
    for poly_feature in poly_layer.getFeatures():
        # Récupérer la géométrie du polygone
        poly_geom = poly_feature.geometry()
        
        # Créer une liste pour stocker les attributs des points contenus dans le polygone
        points_in_poly_attributes = []
        
        # Parcourir les entités de la couche de points
        for point_feature in point_layer.getFeatures():
            # Vérifier si le point est contenu dans le polygone
            if poly_geom.contains(point_feature.geometry()):
                points_in_poly_attributes.append(point_feature.attributes())
        
        # Stocker les attributs des points contenus dans le polygone dans le dictionnaire
        contained_point_attributes[poly_feature.id()] = points_in_poly_attributes
    
    print("Attributs des points contenus dans les polygones :", contained_point_attributes)
    
    # Mettre à jour les attributs des polygones avec les valeurs des attributs des points contenus dans les polygones
    poly_layer.startEditing()
    for poly_feature in poly_layer.getFeatures():
        if poly_feature.id() in contained_point_attributes:
            attributes_list = contained_point_attributes[poly_feature.id()]
            if attributes_list:
                attributes = attributes_list[0]  # Utiliser les attributs du premier point contenu dans le polygone
                print(f"Attributs du polygone ({poly_feature.id()}): {attributes}")
                for field in point_fields:
                    if field in poly_fields:  # Vérifier si le champ existe dans la couche de polygones
                        value = attributes[point_fields.index(field)]
                        poly_layer.changeAttributeValue(poly_feature.id(), poly_fields.index(field), value)
                    else:
                        print(f"Le champ '{field}' de la couche de points n'existe pas dans la couche de polygones.")
    
    # Sauvegarder les modifications et arrêter l'édition
    poly_layer.commitChanges()
    poly_layer.triggerRepaint()
    QMessageBox.information(None, "Succès", "Transfert des attributs terminé avec succès.")

# Récupérer les couches actuellement ouvertes dans le projet
root = QgsProject.instance().layerTreeRoot()
layer_groups = root.children()

# Créer une liste des noms des groupes de couches
group_names = [group.name() for group in layer_groups if isinstance(group, QgsLayerTreeGroup)]

# Demander à l'utilisateur de choisir un groupe de couches pour les points
selected_point_group_name, ok = QInputDialog.getItem(None, "Sélectionner un groupe de couches pour les points", "Groupe de couches pour les points :", group_names, 0, False)

if ok:
    # Récupérer le groupe de couches sélectionné pour les points
    selected_point_group_index = group_names.index(selected_point_group_name)
    selected_point_group = layer_groups[selected_point_group_index]
    
    # Créer une liste des couches de points dans le groupe sélectionné
    point_layers = [child.layer() for child in selected_point_group.children() if isinstance(child, QgsLayerTreeLayer) and child.layer().geometryType() == QgsWkbTypes.PointGeometry]
    
    # Vérifier s'il y a des couches de points dans le groupe sélectionné
    if not point_layers:
        QMessageBox.warning(None, "Avertissement", "Aucune couche de points dans le groupe sélectionné.")
    else:
        # Demander à l'utilisateur de choisir la couche de points
        point_layer_names = [layer.name() for layer in point_layers]
        selected_point_layer_name, ok = QInputDialog.getItem(None, "Sélectionner la couche de points", "Couche de points :", point_layer_names, 0, False)
        
        if ok:
            # Récupérer la couche de points sélectionnée
            selected_point_layer_index = point_layer_names.index(selected_point_layer_name)
            selected_point_layer = point_layers[selected_point_layer_index]
            
            # Demander à l'utilisateur de choisir un groupe de couches pour les polygones
            selected_poly_group_name, ok = QInputDialog.getItem(None, "Sélectionner un groupe de couches pour les polygones", "Groupe de couches pour les polygones :", group_names, 0, False)
            
            if ok:
                # Récupérer le groupe de couches sélectionné pour les polygones
                selected_poly_group_index = group_names.index(selected_poly_group_name)
                selected_poly_group = layer_groups[selected_poly_group_index]
                
                # Créer une liste des couches de polygones dans le groupe sélectionné
                poly_layers = [child.layer() for child in selected_poly_group.children() if isinstance(child, QgsLayerTreeLayer) and child.layer().geometryType() == QgsWkbTypes.PolygonGeometry]
                
                # Vérifier s'il y a des couches de polygones dans le groupe sélectionné
                if not poly_layers:
                    QMessageBox.warning(None, "Avertissement", "Aucune couche de polygones dans le groupe sélectionné.")
                else:
                    # Demander à l'utilisateur de choisir la couche de polygones
                    poly_layer_names = [layer.name() for layer in poly_layers]
                    selected_poly_layer_name, ok = QInputDialog.getItem(None, "Sélectionner la couche de polygones", "Couche de polygones :", poly_layer_names, 0, False)
                    
                    if ok:
                        # Récupérer la couche de polygones sélectionnée
                        selected_poly_layer_index = poly_layer_names.index(selected_poly_layer_name)
                        selected_poly_layer = poly_layers[selected_poly_layer_index]
                        
                        # Appeler la fonction pour transférer les attributs
                        transfer_attributes(selected_point_layer, selected_poly_layer)