Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-235b-a22b-no-thinking· Alibaba (Qwen)Hugging Face Arena Expert 5K

zmodyfikuj kod w ten sposób, że funkcje createlineelevationraster dostaje jako dane…

  1. User

    zmodyfikuj kod w ten sposób, że funkcje create_line_elevation_raster dostaje jako dane wejściowe dostaje całą geometrię poligonu, wraz dziurami, i robi analizę dla wszystkich punktów geometrii, zarówno tych będącymi dziurami jak i zewnętrznymi obrysami: import rasterio from rasterio.features import rasterize from shapely.geometry import LineString, Point, Polygon, MultiPolygon from shapely.ops import linemerge, unary_union import numpy as np from scipy import ndimage import geopandas as gpd

    ---------------------------------------------------------------------------------

    1. Ścieżki do danych

    dem_path = r"c:\2025_rowy\06_lidar\nadzor_aleksandrow\lidar_dociete_profile_raster_mozaika\01K0VH8Q67SK7D5HMYPNQBZ8T2.tif" poly_path = r"c:\2025_rowy\dane_testowe\linia_3d.shp" # <-- POLIGON zamiast linii

    ---------------------------------------------------------------------------------

    2. Wczytaj DEM

    with rasterio.open(dem_path) as src_dem: dem_data = src_dem.read(1) dem_profile = src_dem.profile

    3. Wczytaj POLIGON

    gdf = gpd.read_file(r"c:\2025_rowy\07_analiza_wysokosciowa\analiza_wysokosciowa__profile_rowy_AL__3D.gpkg", layer="Output") poly_geom_one = gdf.geometry.iloc[0] # pierwszy poligon

    poly_geom = Polygon(poly_geom_one.exterior)

    4. Zamień poligon na linię

    if poly_geom.geom_type == "Polygon": # pojedynczy wielokąt boundary = poly_geom.boundary # LineString lub MultiLineString elif poly_geom.geom_type == "MultiPolygon": # zestaw wielokątów # scalamy wszystkie granice w jeden obiekt liniowy boundary = unary_union([p.boundary for p in poly_geom.geoms]) else: raise ValueError("Plik nie zawiera geometrii Polygon/MultiPolygon")

    Jeśli granic jest kilka, tworzymy jedną długą linię

    if boundary.geom_type == "MultiLineString": boundary = linemerge(boundary) # -> LineString lub MultiLineString

    --- (Opcjonalnie) sprawdź, czy linia ma składową Z -----------------------------

    if boundary.has_z: line_3d = boundary # gotowa linia 3D else: # Poligon był 2D – trzeba nadać Z. Najprościej: pobierz wysokość z DEM # dla każdego wierzchołka. Uwaga: dla dużych geometrii może być wolne. coords_with_z = [] for x, y in boundary.coords: # konwersja XY -> wiersz/kolumna rastra row, col = ~dem_profile['transform'] * (x, y) row = int(np.clip(np.floor(row), 0, dem_data.shape[0]-1)) col = int(np.clip(np.floor(col), 0, dem_data.shape[1]-1)) z = float(dem_data[row, col]) coords_with_z.append((x, y, z)) line_3d = LineString(coords_with_z)

    ------------------------------------------------------------------------------

    5. Teraz używamy line_3d tak samo jak wcześniej

    def create_line_elevation_raster(line_3d, dem_profile): """ Zwraca raster (np.ndarray float32) z wysokościami linii 3D zinterpolowanymi do rozdzielczości i zasięgu DEM. Jeśli linia nie przecina niektórych pikseli, wartości są uzupełniane (nearest-neighbour). """ # ------------------ przygotowanie punktów (x,y,z) ------------------ points_2d_z = [(Point(x, y), z) for x, y, z in line_3d.coords]

    height  = dem_profile['height']
    width   = dem_profile['width']
    trans   = dem_profile['transform']
    
    # rasteryzacja samych punktów (piksele linii otrzymają wartość Z)
    line_raster = rasterize(
        points_2d_z,
        out_shape   = (height, width),
        transform   = trans,
        fill        = np.nan,          # Na początku NAN tam, gdzie brak linii
        dtype       = np.float32
    )
    
    # --- maska miejsc bez wartości (NAN) ---
    nan_mask  = np.isnan(line_raster)
    
    # jeżeli wszystkie piksele są NAN (np. linia poza zasięgiem DEM)
    if nan_mask.all():
        raise ValueError("Linia 3D nie przecina zasięgu DEM – brak pikseli do rasteryzacji!")
    
    # ------------------ uzupełnianie braków (nearest neighbour) ---------
    # binary mask: 0–piksel z linią  | 1–brak
    binary = nan_mask.astype(np.uint8)
    
    # odległość + indeks najbliższego piksela z danymi
    dist, (ny, nx) = ndimage.distance_transform_edt(
        binary, return_indices=True
    )
    # skopiuj wysokość z najbliższego nie-nan-a
    filled = line_raster.copy()
    filled[nan_mask] = line_raster[ny[nan_mask], nx[nan_mask]]
    
    # ------------------ obsługa nodata DEM ------------------------------
    # jeżeli DEM ma nodata ustawione, przenieś je do rastra linii
    nodata_val = dem_profile.get('nodata', None)
    if nodata_val is not None:
        filled[np.isnan(filled)] = nodata_val
    
    return filled.astype(np.float32)
    

    line_elevation_raster = create_line_elevation_raster(line_3d, dem_profile)

    6. Różnica wysokości + maska progowa

    diff_raster = np.abs(dem_data - line_elevation_raster) threshold = 100 output_mask = (diff_raster <= threshold).astype(np.uint8)

    out_profile = dem_profile.copy() out_profile.update(dtype=rasterio.uint8, count=1, nodata=0)

    with rasterio.open("output_diff_mask__100m.tif", "w", **out_profile) as dst: dst.write(output_mask, 1)

    print("Gotowe – wynik zapisany do output_diff_mask.tif")

  2. Qwen Assistant

    Aby funkcja create_line_elevation_raster mogła obsłużyć pełną geometrię poligonu wraz z dziurami (interior rings) i uwzględnić wszystkie punkty (zarówno z obrysu zewnętrznego, jak i z dziur), należy zmodyfikować sposób, w jaki wczytywana i przetwarzana jest geometria. W obecnym podejściu zapis Polygon(poly_geom_one.exterior) odrzuca dziury.

    Poniżej znajdziesz zmodyfikowany kod, w którym:

    • Funkcja extract_all_points_from_polygon rekurencyjnie przetwarza wszystkie pierścienie (zarówno zewnętrzne, jak i wewnętrzne) z dowolnie zagnieżdżonych geometrii (w tym MultiPolygon).
    • Funkcja create_line_elevation_raster przyjmuje teraz pełną geometrię poligonu, nie tylko jej obrys.
    • Punkty z całego poligonu (w tym dziur) są wykorzystywane do tworzenia rastra wysokości.

    ✅ Zmodyfikowany kod:

    import rasterio
    from rasterio.features import rasterize
    from shapely.geometry import Point, Polygon, MultiPolygon
    from shapely.ops import unary_union
    import numpy as np
    from scipy import ndimage
    import geopandas as gpd
    
    # ---------------------------------------------------------------------------------
    # 1. Ścieżki do danych
    dem_path   = r"c:\2025_rowy\06_lidar\nadzor_aleksandrow\lidar_dociete_profile_raster_mozaika\01K0VH8Q67SK7D5HMYPNQBZ8T2.tif"
    poly_path  = r"c:\2025_rowy\dane_testowe\linia_3d.shp"   # <-- POLIGON zamiast linii
    # ---------------------------------------------------------------------------------
    
    # 2. Wczytaj DEM
    with rasterio.open(dem_path) as src_dem:
        dem_data    = src_dem.read(1)
        dem_profile = src_dem.profile
    
    # 3. Wczytaj POLIGON
    gdf = gpd.read_file(r"c:\2025_rowy\07_analiza_wysokosciowa\analiza_wysokosciowa__profile_rowy_AL__3D.gpkg", layer="Output")
    poly_geom = gdf.geometry.iloc[0]  # pełna geometria, może zawierać dziury i być MultiPolygon
    
    # Funkcja do ekstrakcji wszystkich punktów z poligonu (w tym dziur)
    def extract_all_points_from_polygon(geom):
        points = []
    
        def recursive_extract(ring):
            nonlocal points
            for x, y in ring.coords:
                points.append((x, y))
    
        if isinstance(geom, Polygon):
            # Zewnętrzny pierścień
            recursive_extract(geom.exterior)
            # Wewnętrzne pierścienie (dziury)
            for interior in geom.interiors:
                recursive_extract(interior)
        elif isinstance(geom, MultiPolygon):
            for poly in geom.geoms:
                recursive_extract(poly.exterior)
                for interior in poly.interiors:
                    recursive_extract(interior)
        else:
            raise ValueError(f"Nieobsługiwany typ geometrii: {geom.geom_type}")
    
        return points
    
    # Wyodrębnij wszystkie punkty (zewnętrzne i dziury)
    all_points_2d = extract_all_points_from_polygon(poly_geom)
    
    # Nadaj im wysokości z DEM
    points_with_z = []
    for x, y in all_points_2d:
        row, col = ~dem_profile['transform'] * (x, y)
        row = int(np.clip(np.floor(row), 0, dem_data.shape[0] - 1))
        col = int(np.clip(np.floor(col), 0, dem_data.shape[1] - 1))
        z = float(dem_data[row, col])
        points_with_z.append((x, y, z))
    
    # Stwórz linię 3D z punktów (dla rasteryzacji)
    line_3d = LineString(points_with_z)
    
    # ------------------------------------------------------------------------------
    
    # 5. Teraz używamy line_3d tak samo jak wcześniej
    def create_line_elevation_raster(line_3d, dem_profile):
        """
        Zwraca raster (np.ndarray float32) z wysokościami linii 3D zinterpolowanymi
        do rozdzielczości i zasięgu DEM.  Jeśli linia nie przecina niektórych
        pikseli, wartości są uzupełniane (nearest-neighbour).
        """
        # ------------------ przygotowanie punktów (x,y,z) ------------------
        points_2d_z = [(Point(x, y), z) for x, y, z in line_3d.coords]
    
        height  = dem_profile['height']
        width   = dem_profile['width']
        trans   = dem_profile['transform']
    
        # rasteryzacja samych punktów (piksele linii otrzymają wartość Z)
        line_raster = rasterize(
            points_2d_z,
            out_shape   = (height, width),
            transform   = trans,
            fill        = np.nan,          # Na początku NAN tam, gdzie brak linii
            dtype       = np.float32
        )
    
        # --- maska miejsc bez wartości (NAN) ---
        nan_mask  = np.isnan(line_raster)
    
        # jeżeli wszystkie piksele są NAN (np. linia poza zasięgiem DEM)
        if nan_mask.all():
            raise ValueError("Linia 3D nie przecina zasięgu DEM – brak pikseli do rasteryzacji!")
    
        # ------------------ uzupełnianie braków (nearest neighbour) ---------
        # binary mask: 0–piksel z linią  | 1–brak
        binary = nan_mask.astype(np.uint8)
    
        # odległość + indeks najbliższego piksela z danymi
        dist, (ny, nx) = ndimage.distance_transform_edt(
            binary, return_indices=True
        )
        # skopiuj wysokość z najbliższego nie-nan-a
        filled = line_raster.copy()
        filled[nan_mask] = line_raster[ny[nan_mask], nx[nan_mask]]
    
        # ------------------ obsługa nodata DEM ------------------------------
        # jeżeli DEM ma nodata ustawione, przenieś je do rastra linii
        nodata_val = dem_profile.get('nodata', None)
        if nodata_val is not None:
            filled[np.isnan(filled)] = nodata_val
    
        return filled.astype(np.float32)
    
    line_elevation_raster = create_line_elevation_raster(line_3d, dem_profile)
    
    # 6. Różnica wysokości + maska progowa
    diff_raster  = np.abs(dem_data - line_elevation_raster)
    threshold    = 100
    output_mask  = (diff_raster <= threshold).astype(np.uint8)
    
    out_profile  = dem_profile.copy()
    out_profile.update(dtype=rasterio.uint8, count=1, nodata=0)
    
    with rasterio.open("output_diff_mask__100m.tif", "w", **out_profile) as dst:
        dst.write(output_mask, 1)
    
    print("Gotowe – wynik zapisany do output_diff_mask.tif")
    

    🔍 Co się zmieniło?

    • Nie odrzucamy dziur w poligonach – wszystkie punkty zewnętrzne i wewnętrzne są przetwarzane.
    • Funkcja extract_all_points_from_polygon rekurencyjnie pobiera wszystkie punkty z dowolnie zagnieżdżonych poligonów.
    • Linia 3D tworzona jest z pełnego zestawu punktów – zarówno z obrysu, jak i z dziur.
    • Dzięki temu analiza wysokościowa obejmuje całą geometrię.

    📌 Uwaga techniczna:

    Jeśli poligon jest bardzo szczegółowy (dużo punktów), przetwarzanie może być czasochłonne. W takim przypadku warto rozważyć uproszczenie geometrii (np. simplify()) lub próbkowanie punktów co określoną odległość.

    Chcesz, żebym dodał opcję próbkowania punktów co określoną odległość?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.