Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

Соответствует ли написанный код требованиям, указанным в условиях разработки? Если нет,…

  1. User

    Соответствует ли написанный код требованиям, указанным в условиях разработки? Если нет, то что нужно в нем исправить?

    for index, row in reg_data.iterrows(): geom = row.geometry # полигон субъекта

    if geom.geom_type == 'MultiPolygon':
        max_polygon = max(geom.geoms, key=lambda x: x.area)
        poly = list(max_polygon.exterior.coords)
        acc = poly[::10]
        
    elif geom.geom_type == 'Polygon':
        poly = list(geom.exterior.coords)
        acc = poly[::10]
    
    bound = LineString(poly)
    acc_points = MultiPoint(acc)
    
    voron = shapely.voronoi_polygons(acc_points) #геометриколлекшен из полигонов вороного
    edges = []
    
    for v in voron.geoms: #для каждого полигона вороного
        cell = v.exterior.coords #вершины ячейки
        
        for i in range(0, len(cell)-1):
            start, end = cell[i], cell[i+1]
            edge = LineString([start, end])
            edges.append(edge)
    
    skeleton = []
    
    for edge in edges:
        if shapely.contains_properly(geom, edge) == True:
            skeleton.append(edge)
            
    multiskeleton = MultiLineString(skeleton)
    inner_points = []
    
    for bone in skeleton:
        inner_points.append(bone.coords[0])
        inner_points.append(bone.coords[1])
    
    max_dist = -math.inf
    cur_point = None
    
    for point in inner_points:
        point = Point([point])
        dist = shapely.distance(point, bound)
        
        max_dist = 0
        if dist > max_dist:
            max_dist = dist
            cur_point = point
        else:
            pass
    
    reg_data.at[index, 'skeleton'] = multiskeleton
    reg_data.at[index, 'max_dist'] = max_dist
    reg_data.at[index, 'center_circle'] = cur_point
    

    reg_data

    ЧАСТЬ 1. РАЗРАБОТКА

    I. Напишите функцию find_centers(gdf, acс), которая принимает на вход объект gdf класса GeoDataFrame с полигонами и точность вычислений acc, а возвращает центры максимальных вписанных окружностей и скелеты, на которых они основаны.

    Для этого в цикле по всем полигонам gdf вам понадобится:

    1. Извлечь внешнюю границу (exterior) полигона. Если это мультиполигон, то вам нужно найти из его компонент максимальную по площади и извлечь его границу. Поэтому прежде чем извлекать внешнюю границу, надо установить тип объекта.

    2. Получить координаты внешней границы и оставить из них каждую acc-ую, где acc — параметр функции. Например, если acc = 10, это означает, что вы берете каждую десятую точку, т.е. оставляете 10% от общего числа. Это нужно, чтобы повысить скорость вычислений. Важно, что точки должны выбираться не случайно, а с равным шагом.

    3. Создать на основе полученных координат мультиточку (MultiPoint).

    4. Построить для мультиточки диаграмму Вороного (shapely.voronoi_polygons)

    5. Извлечь границы (boundary) ячеек диаграммы Вороного.

    6. Преобразовать границы в отрезки, состоящие из двух точек. Например, если ячейка диаграммы имеет 5 уникальных вершин, то у вас получится 5 отрезков. Для этого вам придется в цикле пройтись по границам ячеек, далее для каждой границы пройтись по координатам и для каждой пары соседних координат соорудить объект класса LineString. На выходе вы должны получить список отрезков.

    7. Отобрать отрезки, находящиеся целиком внутри (contains_properly) текущего полигона. На этом этапе вы получите скелет фигуры.

    8. Получить координаты вершин оставшихся отрезков.

    9. Соорудить на основе них список точек (Point).

    10. Вычислить расстояния (distance) от каждой точки до границы полигона (1).

    11. Найти максимальное расстояние.

    12. Найти точку, имеющую максимальное расстояние.

    По итогам каждой итерации функция должна накапливать в списке полученные точки (12), соответствующие им расстояния (11) и скелеты (7). По окончанию цикла из точек и расстояний необходимо создать GeoDataFrame и вернуть его вместе со скелетами. Т.е. последняя строка функции будет выглядеть наподобие:

    return centers, skeletons

  2. Assistant

    Исходный код не оформлен в виде функции и не следует всем указанным инструкциям из условий разработки. Для того, чтобы код соответствовал указанным требованиям, необходимо сделать следующие изменения:

    1. Оформить код в функцию find_centers(gdf, acc).
    2. Произвести выборку точек с шагом в acc точек, а не каждую десятую независимо от входного параметра acc.
    3. Использование неправильного метода для проверки наличия отрезка целиком внутри полигона (в коде использован несуществующий метод shapely.contains_properly; на самом деле следует использовать метод geom.contains).
    4. Исправить ошибку в расчете максимального расстояния — неправильная инициализация максимального расстояния внутри цикла означает, что оно будет обнуляться при каждой новой проверке.
    5. Исправить ошибку с созданием точки — Point([point]) некорректно, если point уже является кортежем координат.

    Предлагаемая переделанная версия функции:

    from shapely.geometry import Polygon, MultiPolygon, Point, LineString, MultiPoint, MultiLineString
    from shapely.ops import voronoi_diagram
    import geopandas as gpd
    import math
    
    def find_centers(gdf, acc):
        centers_gdf_data = []
        skeletons = []
        
        for index, row in gdf.iterrows():
            geom = row.geometry  # Получаем геометрию
            
            # Обработка MultiPolygon
            if geom.geom_type == 'MultiPolygon':
                max_polygon = max(geom.geoms, key=lambda x: x.area)
                poly = list(max_polygon.exterior.coords)
            elif geom.geom_type == 'Polygon':
                poly = list(geom.exterior.coords)
            
            acc_poly = poly[::acc]  # Выбираем каждую acc-ую точку
            
            if not acc_poly:  # Если список точек пустой, пропускаем итерацию
                continue
            
            acc_points = MultiPoint(acc_poly)
            voron = voronoi_diagram(acc_points)
            edges = []
            
            for cell in voron.geoms:
                coords = list(cell.exterior.coords)
                for i in range(len(coords) - 1):
                    edge = LineString([coords[i], coords[i + 1]])
                    edges.append(edge)
            
            skeleton = []
            for edge in edges:
                if geom.contains(edge):
                    skeleton.append(edge)
            multiskeleton = MultiLineString(skeleton)
            skeletons.append(multiskeleton)
            
            max_dist = -math.inf
            center_point = None
            for bone in skeleton:
                for point in bone.coords:
                    dist = geom.boundary.distance(Point(point))
                    if dist > max_dist:
                        max_dist = dist
                        center_point = Point(point)
            
            centers_gdf_data.append({'geometry': center_point, 'max_dist': max_dist})
        
        centers_gdf = gpd.GeoDataFrame(centers_gdf_data)
        return centers_gdf, skeletons
    

    Помните, что для работы этого кода в вашей среде должны быть установлены библиотеки Shapely и GeoPandas. В приведенной функции исправлены указанные недостатки и добавлена логика, соответствующая условиям задачи.

  3. User

    как на графике отрисовать skeletons?

    def find_centers(gdf, acc): centers = [] distances = [] skeletons = []

    for index, row in gdf.iterrows():
        geom = row.geometry
        
        if geom.geom_type == 'MultiPolygon':
            max_polygon = max(geom.geoms, key=lambda x: x.area)
            poly = list(max_polygon.exterior.coords)
            acc_points = poly[::acc]
        elif geom.geom_type == 'Polygon':
            poly = list(geom.exterior.coords)
            acc_points = poly[::acc]
        
        bound = LineString(poly)
        acc_points = MultiPoint(acc_points)
        
        voron = shapely.voronoi_polygons(acc_points)
        edges = []
        
        for v in voron.geoms:
            cell = v.exterior.coords
            for i in range(0, len(cell)-1):
                start, end = cell[i], cell[i+1]
                edge = LineString([start, end])
                edges.append(edge)
        
        skeleton = []
        for edge in edges:
            if shapely.contains_properly(geom, edge):
                skeleton.append(edge)
        
        
        inner_points = []
        for bone in skeleton:
            inner_points.append(bone.coords[0])
            inner_points.append(bone.coords[1])
        
        max_dist = -math.inf
        cur_point = None
        
        for point in inner_points:
            point = Point([point])
            dist = shapely.distance(point, bound)
            if dist > max_dist:
                max_dist = dist
                cur_point = point
        
        centers.append(cur_point)
        distances.append(max_dist)
        skeletons.append(MultiLineString(skeleton))
        
    centers_gdf = gpd.GeoDataFrame({'center_circle': centers, 'max_dist': distances}, geometry='center_circle')
    
    return centers_gdf, skeletons
    

    centers_gdf, skeletons = find_centers(reg_data, 10)

    Формирование датафрейма с точками и показателями

    cnt = reg_data.centroid psf = shapely.point_on_surface(reg_data.geometry) cmvc = centers_gdf['center_circle']

    ax = reg_data.plot(color = 'lightgray', edgecolor = 'k', linewidth = 0.5)

    cnt.plot(ax=ax, color='blue') psf.plot(ax=ax, color='red') cmvc.plot(ax=ax, color='green')

  4. Assistant

    Чтобы отрисовать skeletons на графике вместе с другими геометрическими объектами, вам нужно создать GeoSeries или GeoDataFrame из skeletons, который можно будет легко нарисовать с помощью метода .plot() из geopandas. В текущем примере кода ошибка заключается в попытке напрямую нарисовать skeletons, которая является просто списком объектов MultiLineString, не интегрированным в структуру geopandas.

    Вам нужно выполнить следующие шаги:

    1. Преобразуйте skeletons в GeoSeries или GeoDataFrame.
    2. Нарисуйте эту новую структуру данных на графике с помощью метода .plot().

    Давайте внесем корректировки в последнюю часть вашего кода для отображения скелетов:

    from geopandas import GeoSeries
    
    # Прежде чем идти дальше, убедитесь, что find_centers() работает корректно и возвращает данные в ожидаемом формате
    
    centers_gdf, skeletons = find_centers(reg_data, 10)
    
    # Формирование датафрейма с точками и показателями
    cnt = reg_data.centroid  # Центроиды регионов
    psf = reg_data.representative_point()  # Представительные точки для Geometry
    cmvc = centers_gdf['center_circle']  # Центры максимальных вписанных кругов
    
    # Создание GeoSeries из списка skeletons для упрощения визуализации.
    skeletons_gdf = GeoSeries(skeletons)
    
    ax = reg_data.plot(color='lightgray', edgecolor='k', linewidth=0.5)
    
    # Нанесение различных геометрических объектов
    cnt.plot(ax=ax, color='blue', markersize=5, label='Центроиды')
    psf.plot(ax=ax, color='red', markersize=5, label='Представительные точки')
    cmvc.plot(ax=ax, color='green', markersize=5, label='Центры кругов')
    
    # Нанесение скелетов
    skeletons_gdf.plot(ax=ax, color='black', linewidth=1, label='Скелеты')
    
    # Добавление легенды
    ax.legend()
    
    # Показать график
    plt.show()
    

    Помните, что для использования геопространственных данных и визуализации, вам нужно импортировать соответствующие библиотеки. В вашем исходном коде некоторые переменные и функции используются без предварительного объявления и импорта (shapely.voronoi_polygons, shapely.distance, shapely.contains_properly), что указывает на то, что ваш код нуждается в дополнительной доработке.

    Обратите внимание, что shapely.ops.voronoi_diagram нужно использовать для создания диаграммы Вороного, а shapely.geometry.Polygon().boundary.distance(Point()) и shapely.geometry.Polygon().contains() для вычисления расстояния и проверки на включение, соответственно.

  5. User

    Как визуализировать точки поверх скелетов? skeletons_gdf = GeoSeries(skeletons) ax = reg_data.plot(color='lightgray', edgecolor='k', linewidth=0.5)

    skeletons_gdf.plot(ax=ax, color='k', linewidth=0.2, label='Скелеты')

    cnt.plot(ax=ax, color='blue', markersize=5, label='Центроиды') psf.plot(ax=ax, color='red', markersize=5, label='Точка на поверхности') cmvc.plot(ax=ax, color='green', markersize=5, label='Центры окружностей')

    ax.legend() plt.show()

  6. Assistant

    Чтобы визуализировать точки поверх скелетов на графике, важно следить за порядком, в котором вы вызываете метод .plot() для каждого из геообъектов. В указанном вами примере кода, вы уже следуете правильному порядку, сначала рисуя полигоны (reg_data), затем скелеты (skeletons_gdf), и в конце точки (центроиды, точки на поверхности, центры окружностей). Это гарантирует, что точки будут видны поверх скелетов, так как последние объекты, отрисованные на графике, появляются на переднем плане.

    Возможно, проблема не видна сразу из-за масштабирования или цветовой гаммы. Убедитесь, что параметры отображения, такие как markersize и linewidth, адекватны, чтобы все элементы были четко видны. Например, если linewidth для скелетов слишком толстая по сравнению с markersize для точек, точки могут быть визуально скрыты за линиями.

    Если всё ещё возникают проблемы с визуализацией, можно попробовать добавить опцию zorder для контроля порядка слоев. Элементы с более высоким zorder рисуются поверх элементов с низким zorder. В вашем случае, скелетам можно задать zorder меньше, чем точкам:

    from matplotlib import pyplot as plt
    
    # Формирование геосерии из скелетов для упрощения визуализации
    skeletons_gdf = GeoSeries(skeletons)
    
    # Отрисовка фона с полигонами
    ax = reg_data.plot(color='lightgray', edgecolor='k', linewidth=0.5, zorder=1)
    
    # Отрисовка скелетов
    skeletons_gdf.plot(ax=ax, color='k', linewidth=0.2, label='Скелеты', zorder=2)
    
    # Отрисовка геометрических точек поверх скелетов
    cnt.plot(ax=ax, color='blue', markersize=5, label='Центроиды', zorder=3)
    psf.plot(ax=ax, color='red', markersize=5, label='Точка на поверхности', zorder=4)
    cmvc.plot(ax=ax, color='green', markersize=5, label='Центры окружностей', zorder=5)
    
    # Добавление легенды
    ax.legend()
    
    # Показать график
    plt.show()
    

    Обратите внимание, что zorder увеличивается от фона к переднему плану, убедитесь, что zorder для точек выше, чем для линий скелетов. Это должно помочь точкам оставаться видимыми независимо от размеров и цветов конкретных элементов графика.

  7. User

    Вот требования к написанию кода и сам код, который есть на данный момент. Функция find_centers(gdf, acс) уже реализована и работает корректно, для оставшихся функций есть наброски, помоги написать оставшиеся две функции на основу существующего кода

    I. Напишите функцию find_centers(gdf, acс), которая принимает на вход объект gdf класса GeoDataFrame с полигонами и точность вычислений acc, а возвращает центры максимальных вписанных окружностей и скелеты, на которых они основаны.

    Для этого в цикле по всем полигонам gdf вам понадобится:

    1. Извлечь внешнюю границу (exterior) полигона. Если это мультиполигон, то вам нужно найти из его компонент максимальную по площади и извлечь его границу. Поэтому прежде чем извлекать внешнюю границу, надо установить тип объекта.

    2. Получить координаты внешней границы и оставить из них каждую acc-ую, где acc — параметр функции. Например, если acc = 10, это означает, что вы берете каждую десятую точку, т.е. оставляете 10% от общего числа. Это нужно, чтобы повысить скорость вычислений. Важно, что точки должны выбираться не случайно, а с равным шагом.

    3. Создать на основе полученных координат мультиточку (MultiPoint).

    4. Построить для мультиточки диаграмму Вороного (shapely.voronoi_polygons)

    5. Извлечь границы (boundary) ячеек диаграммы Вороного.

    6. Преобразовать границы в отрезки, состоящие из двух точек. Например, если ячейка диаграммы имеет 5 уникальных вершин, то у вас получится 5 отрезков. Для этого вам придется в цикле пройтись по границам ячеек, далее для каждой границы пройтись по координатам и для каждой пары соседних координат соорудить объект класса LineString. На выходе вы должны получить список отрезков.

    7. Отобрать отрезки, находящиеся целиком внутри (contains_properly) текущего полигона. На этом этапе вы получите скелет фигуры.

    8. Получить координаты вершин оставшихся отрезков.

    9. Соорудить на основе них список точек (Point).

    10. Вычислить расстояния (distance) от каждой точки до границы полигона (1).

    11. Найти максимальное расстояние.

    12. Найти точку, имеющую максимальное расстояние.

    По итогам каждой итерации функция должна накапливать в списке полученные точки (12), соответствующие им расстояния (11) и скелеты (7). По окончанию цикла из точек и расстояний необходимо создать GeoDataFrame и вернуть его вместе со скелетами. Т.е. последняя строка функции будет выглядеть наподобие:

    return centers, skeletons

    II. Напишите функцию suggest_size(var, dist, ax, flannery=True), которая вычисляет рекомендуемый минимальный размер диаграммы. Функция принимает на вход: картографируемую переменную var, расстояния от центроидов до границ dist, вычисленные с помощью find_centers() объект matplotlib ax, на который уже нанесены границы полигонов наличие компенсации flannery. Внутри функции необходимо:

    1. Определить количество пунктов изображения в одном метре на местности (этот код мы уже написали на семинаре).

    2. Преобразовать расстояния dist в пункты изображения

    3. Вычислить среднюю площадь вписанной окружности в пунктах.

    4. Вычислить отношение минимального и среднего значения показателя var.

    5. Получить рекомендуемую минимальную площадь диаграммы умножением (3) и (4).

    6. Если flannery=True, то компенсировать размер соответствующим образом.

    7. Вернуть полученный результат.

    III. Напишите функцию map_diagrams(...), которая принимает на вход GeoDataFrame и визуализирует его способом картодиаграмм с заданными параметрами. Определите самостоятельно интерфейс функции (какие параметры она должна принимать).

    Функция должна позволять выбирать картографируемую переменную, способ размещения концептуальной точки, цвет диаграмм, их минимальный и максимальный размер, а также компенсацию Флэннери. При отсутствии заданного минимального размера функция должна определять его самостоятельно посредство suggest_size(). Функция должна рисовать аккуратную легенду карты, заголовок карты и заголовок легенды. Пользователь должен иметь возможность менять заголовки при вызове функции.

    Чтение пространственных данных

    prj = '+proj=aea +lat_1=52 +lat_2=58 +lon_0=45' reg = gpd.read_file('regions.geojson').to_crs(prj) reg.plot('okato')

    migr = pd.read_excel('2022_migration.xlsx', names=['name', 'okato', 'migration'], converters={'okato': lambda x: pd.to_numeric(x, errors="coerce")})

    pop = pd.read_excel('2022_population.xlsx', names=['name', 'okato', 'population'], converters={'okato': lambda x: pd.to_numeric(x, errors="coerce")})

    pop['population'][:-1] = pop['population'][1:] # перенесем население в строчки субъектов (сместим на 1 вверх)

    data = migr.merge(pop, on='okato') # соединим данные по миграции и населению data = data[data['okato'] > 1000] # оставим только субъекты федерации data['migrate'] = 100000 * data['migration'] / data['population'] # сальдо миграции на 100 000 населения

    reg_data = reg.merge(data, on='okato') reg_data

    def find_centers(gdf, acc): centers = [] distances = [] skeletons = []

    for index, row in gdf.iterrows():
        geom = row.geometry
        
        if geom.geom_type == 'MultiPolygon':
            max_polygon = max(geom.geoms, key=lambda x: x.area)
            poly = list(max_polygon.exterior.coords)
            acc_points = poly[::acc]
        elif geom.geom_type == 'Polygon':
            poly = list(geom.exterior.coords)
            acc_points = poly[::acc]
        
        bound = LineString(poly)
        acc_points = MultiPoint(acc_points)
        
        voron = shapely.voronoi_polygons(acc_points)
        edges = []
        
        for v in voron.geoms:
            cell = v.exterior.coords
            for i in range(0, len(cell)-1):
                start, end = cell[i], cell[i+1]
                edge = LineString([start, end])
                edges.append(edge)
        
        skeleton = []
        for edge in edges:
            if shapely.contains_properly(geom, edge):
                skeleton.append(edge)
        
        
        inner_points = []
        for bone in skeleton:
            inner_points.append(bone.coords[0])
            inner_points.append(bone.coords[1])
        
        max_dist = -math.inf
        cur_point = None
        
        for point in inner_points:
            point = Point([point])
            dist = shapely.distance(point, bound)
            if dist > max_dist:
                max_dist = dist
                cur_point = point
        
        centers.append(cur_point)
        distances.append(max_dist)
        skeletons.append(MultiLineString(skeleton))
        
    centers_gdf = gpd.GeoDataFrame({'center_circle': centers, 'max_dist': distances}, geometry='center_circle')
    
    return centers_gdf, skeletons
    

    centers_gdf, skeletons = find_centers(reg_data, 10)

    skeletons_gdf = GeoSeries(skeletons) ax = reg_data.plot(color='lightgray', edgecolor='k', linewidth=0.5, zorder = 1)

    skeletons_gdf.plot(ax=ax, color='k', linewidth=0.2, label='Скелеты', zorder = 2)

    cnt.plot(ax=ax, color='blue', markersize=5, label='Центроиды', zorder = 3) psf.plot(ax=ax, color='red', markersize=5, label='Точка на поверхности', zorder = 3) cmvc.plot(ax=ax, color='green', markersize=5, label='Центры окружностей', zorder = 3)

    ax.legend() plt.show()

    gdf = gpd.GeoDataFrame(reg_data['population'], geometry=cnt)

    gdf.plot(markersize = 'population')

    def get_transform(gdf, varname, smin, smax=None, flannery=True): var = gdf[varname]

    varmin = var.min()
    varmax = var.max()
    dvar = varmax-varmin #разброс значений показателя
    
    if smax == None:
        smax = smin * varmax / varmin
        
    dsize = smax - smin #разброс значений площадей кружков
    
    if flannery:
        return lambda v: 1.01902 * (smin + dsize * (v - varmin) /dvar) ** 1.14325
    else:
        return lambda v: smin + dsize * (v - varmin) /dvar
    

    transform = get_transform(gdf, 'population', 100, flannery = False)

    transform(gdf.population)

    ax = reg_data.plot(color = 'lightgray', edgecolor = 'k', linewidth = 0.5) gdf.assign(size = transform(gdf.population)).plot(markersize = 'size', color = 'green', edgecolor = 'darkgreen', linewidth = 2, alpha = 0.5, ax=ax)

    values = [gdf.population.max(), 0.5 * (gdf.population.max()+gdf.population.min()), gdf.population.mean(), gdf.population.min() ]

    for value in values: ax.scatter([], [], s = transform(value), color = 'green', edgecolor = 'darkgreen', linewidth = 2, alpha = 0.5, label = int((value)/1000)) ax.legend(labelspacing = 4, handletextpad = 2, frameon = False, loc = 'center left', bbox_to_anchor=(1, 0.5), title = 'Тыс. чел.', title_fontsize =13) ax.axis('off')

    ax.add_artist(ScaleBar(dx=1, location='lower left', scale_formatter = lambda value, unit: f"{value} км")) ax.set_title('Численность населения, 2022 г.', fontsize =18)

    нужно обернуть в функцию, которая будет предсказывать максимальный размер кружка для данной конфигурации региона

    onept = ax.figure.dpi / 72 # сколько пунктов в одном пикселе delta = ax.transData.transform((0, 1)) - ax.transData.transform((0, 0)) # сколько пикселей в одном км ptm = delta[1]/ onept # 1 метр в пунктах ptm

  8. Assistant

    Исходя из предоставленной информации и кода, давайте сформируем функции для пунктов II и III.

    Функция suggest_size

    Эта функция предназначена для вычисления рекомендуемого размера диаграммы на основе картографируемой переменной, расстояний и возможности калибровки размера с помощью масштабирования по Флэннери.

    import numpy as np
    
    def suggest_size(var, dist, ax, flannery=True):
        # I. Расчет пунктов на метр на местности
        onept = ax.figure.dpi / 72
        delta = ax.transData.transform((0, 1)) - ax.transData.transform((0, 0))
        ptm = delta[1] / onept * 1000  # перевод в пункты на километр, затем на метры
        
        # II. Преобразование dist в пункты
        dist_pt = dist * ptm
        
        # III. Средняя площадь вписанной окружности в пунктах
        avg_area_pt = np.pi * (dist_pt ** 2)
        
        # IV. Отношение минимального и среднего значения var
        ratio_var = var.min() / var.mean()
        
        # V. Рекомендуемая минимальная площадь диаграммы
        recommended_area = avg_area_pt * ratio_var
        
        # VI. Компенсация Флэннери
        if flannery:
            recommended_size = np.sqrt(recommended_area / np.pi) * 0.57  # Корень из площади, деленной на Пи, чтобы получить радиус, затем корректировка размера
        else:
            recommended_size = np.sqrt(recommended_area / np.pi)  # Просто корень из площади, деленной на Пи
        
        return recommended_size
    

    Функция map_diagrams

    Эта функция визуализирует поданную GeoDataFrame методом картодиаграмм. Размер диаграмм адаптивен и может быть скорректирован с компенсацией по Флэннери.

    from matplotlib_scalebar.scalebar import ScaleBar
    
    def map_diagrams(gdf, variable_name, title='Картодиаграммы', legend_title='Легенда', color='blue',
                     min_size=None, max_size=None, flannery_compensation=True):
        ax = gdf.plot(color = 'lightgray', edgecolor = 'k', linewidth = 0.5)
        ax.set_title(title, fontsize=18)
        
        if min_size is None:
            # В этом случае размеры вычисляются автоматически
            centers_gdf, _ = find_centers(gdf, 10)
            min_size = suggest_size(gdf[variable_name], centers_gdf['max_dist'], ax, flannery=flannery_compensation)
        
        gdf_transformed = gdf.copy()
        gdf_transformed['size'] = get_transform(gdf_transformed, variable_name, min_size, max_size, flannery=flannery_compensation)(gdf_transformed[variable_name])
        
        gdf_transformed.plot(markersize='size', color=color, alpha=0.5, ax=ax, legend=True)
        
        # Создание легенды
        values = [gdf[variable_name].max(),
                  gdf[variable_name].mean(),
                  gdf[variable_name].min()]
        
        # Заглавие легенды и параметры
        for value in values:
            ax.scatter([], [], s=get_transform(gdf_transformed, variable_name, min_size, max_size)(value),
                       color=color, alpha=0.5, label=str(int(value)))
        
        ax.legend(title=legend_title)
        
        # Добавление масштабной линейки
        ax.add_artist(ScaleBar(1, location='lower left', scale_formatter=lambda value, _: f"{value} км"))
        
        plt.show()
    
    # Пример использования
    # map_diagrams(reg_data, 'population', title='Численность населения', legend_title='Население')
    

    Убедитесь, что функции get_transform и find_centers реализованы верно и доступны в вашем контексте выполнения, так как они используются в представленных функциях.

  9. User

    Помоги написать данную функцию:

    III. Напишите функцию map_diagrams(...), которая принимает на вход GeoDataFrame и визуализирует его способом картодиаграмм с заданными параметрами. Определите самостоятельно интерфейс функции (какие параметры она должна принимать).

    Функция должна позволять выбирать картографируемую переменную, способ размещения концептуальной точки, цвет диаграмм, их минимальный и максимальный размер, а также компенсацию Флэннери. При отсутствии заданного минимального размера функция должна определять его самостоятельно посредство suggest_size(). Функция должна рисовать аккуратную легенду карты, заголовок карты и заголовок легенды. Пользователь должен иметь возможность менять заголовки при вызове функции.

    Уже существует следующий код:

    Чтение пространственных данных

    prj = '+proj=aea +lat_1=52 +lat_2=58 +lon_0=45' reg = gpd.read_file('regions.geojson').to_crs(prj) reg.plot('okato')

    migr = pd.read_excel('2022_migration.xlsx', names=['name', 'okato', 'migration'], converters={'okato': lambda x: pd.to_numeric(x, errors="coerce")})

    pop = pd.read_excel('2022_population.xlsx', names=['name', 'okato', 'population'], converters={'okato': lambda x: pd.to_numeric(x, errors="coerce")})

    pop['population'][:-1] = pop['population'][1:] # перенесем население в строчки субъектов (сместим на 1 вверх)

    data = migr.merge(pop, on='okato') # соединим данные по миграции и населению data = data[data['okato'] > 1000] # оставим только субъекты федерации data['migrate'] = 100000 * data['migration'] / data['population'] # сальдо миграции на 100 000 населения

    reg_data = reg.merge(data, on='okato') reg_data

    def find_centers(gdf, acc): centers = [] distances = [] skeletons = []

    for index, row in gdf.iterrows():
        geom = row.geometry
        
        if geom.geom_type == 'MultiPolygon':
            max_polygon = max(geom.geoms, key=lambda x: x.area)
            poly = list(max_polygon.exterior.coords)
            acc_points = poly[::acc]
        elif geom.geom_type == 'Polygon':
            poly = list(geom.exterior.coords)
            acc_points = poly[::acc]
        
        bound = LineString(poly)
        acc_points = MultiPoint(acc_points)
        
        voron = shapely.voronoi_polygons(acc_points)
        edges = []
        
        for v in voron.geoms:
            cell = v.exterior.coords
            for i in range(0, len(cell)-1):
                start, end = cell[i], cell[i+1]
                edge = LineString([start, end])
                edges.append(edge)
        
        skeleton = []
        for edge in edges:
            if shapely.contains_properly(geom, edge):
                skeleton.append(edge)
        
        
        inner_points = []
        for bone in skeleton:
            inner_points.append(bone.coords[0])
            inner_points.append(bone.coords[1])
        
        max_dist = -math.inf
        cur_point = None
        
        for point in inner_points:
            point = Point([point])
            dist = shapely.distance(point, bound)
            if dist > max_dist:
                max_dist = dist
                cur_point = point
        
        centers.append(cur_point)
        distances.append(max_dist)
        skeletons.append(MultiLineString(skeleton))
        
    centers_gdf = gpd.GeoDataFrame({'center_circle': centers, 'max_dist': distances}, geometry='center_circle')
    
    return centers_gdf, skeletons
    

    def suggest_size(var, dist, ax, flannery=True): onept = ax.figure.dpi / 72 # сколько пунктов в одном пикселе delta = ax.transData.transform((0, 1)) - ax.transData.transform((0, 0)) # сколько пикселей в одном км ptm = delta[1]/ onept # 1 метр в пунктах

    areas = []
    for d in dist:
        dist_pt = d * ptm
        area_pt = np.pi * (dist_pt ** 2)
        areas.append(area_pt)
    
    avg_area_pt = sum(areas)/len(areas)
    ratio_var = float(var.min() / var.mean())
    
    size = avg_area_pt * ratio_var
    
    if flannery:
        return 1.01902 * size ** 1.14325
    else:
        return size
    
    

    def get_transform(gdf, varname, smin=None, smax=None, flannery=True): var = gdf[varname]

    varmin = var.min()
    varmax = var.max()
    dvar = varmax - varmin #разброс значений показателя
    
    if smin == None:
        smin = suggest_size(list(var), list(gdf['dist']), ax, flannery)
        
    if smax == None:
        smax = smin * varmax / varmin
        
    dsize = smax - smin #разброс значений площадей кружков
    
    if flannery:
        return lambda v: 1.01902 * (smin + dsize * (v - varmin) /dvar) ** 1.14325
    else:
        return lambda v: smin + dsize * (v - varmin) /dvar
    

    При написании функции map_diagrams(...) опирайся на приемы следующего кода:

    transform = get_transform(gdf, 'population', 100, flannery = False)

    transform(gdf.population)

    ax = reg_data.plot(color = 'lightgray', edgecolor = 'k', linewidth = 0.5) gdf.assign(size = transform(gdf.population)).plot(markersize = 'size', color = 'green', edgecolor = 'darkgreen', linewidth = 2, alpha = 0.5, ax=ax)

    values = [gdf.population.max(), 0.5 * (gdf.population.max()+gdf.population.min()), gdf.population.mean(), gdf.population.min() ]

    for value in values: ax.scatter([], [], s = transform(value), color = 'green', edgecolor = 'darkgreen', linewidth = 2, alpha = 0.5, label = int((value)/1000)) ax.legend(labelspacing = 4, handletextpad = 2, frameon = False, loc = 'center left', bbox_to_anchor=(1, 0.5), title = 'Тыс. чел.', title_fontsize =13) ax.axis('off')

    ax.add_artist(ScaleBar(dx=1, location='lower left', scale_formatter = lambda value, unit: f"{value} км")) ax.set_title('Численность начеления, 2022 г.', fontsize =18)

  10. Assistant

    Вам нужно разработать функцию map_diagrams, которая создаст визуализацию ваших данных методом картодиаграмм на основе заранее подготовленного GeoDataFrame. Вам необходимо определить интерфейс функции с учетом ваших требований к визуализации, включая выбор переменной для картографирования, выбор концептуальной точки (например, центроида), цвета диаграмм, минимального и максимального размера, а также решение о применении компенсации Флэннери.

    Предлагаем следующий вариант реализации:

    import matplotlib.pyplot as plt
    from matplotlib_scalebar.scalebar import ScaleBar
    import geopandas as gpd
    import pandas as pd
    import numpy as np
    import shapely
    from shapely.geometry import Point, LineString, MultiPoint, MultiLineString
    import math
    
    def map_diagrams(gdf, variable, point_method='centroid', color='blue', 
                     min_size=None, max_size=None, flannery=False,
                     title='Картодиаграммы', legend_title='Легенда'):
        
        if point_method == 'centroid':
            points = gdf.centroid
        elif point_method == 'representative_point':
            points = gdf.geometry.apply(lambda x: x.representative_point())
        else:
            raise ValueError("Указан неверный метод для определения точек")
        
        var_data = gdf[variable]
        size_function = get_transform(gdf, variable, min_size, max_size, flannery)
        sizes = var_data.apply(size_function)
        
        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
        gdf.plot(ax=ax, color='lightgray', edgecolor='k', linewidth=0.5)
        
        for idx, point in enumerate(points):
            ax.scatter(point.x, point.y, s=sizes.iloc[idx], color=color, alpha=0.5, edgecolor='black')
        
        # Создание легенды
        if max_size is None:
            max_size = sizes.max()
        legend_elements = []
        
        for size in [var_data.min(), var_data.max(), var_data.mean()]:
            legend_elements.append(plt.scatter([], [], s=size_function(size), color=color,
                                               label="{:0.2f}".format(size), edgecolor='black'))
        
        ax.legend(handles=legend_elements, title=legend_title)
        
        ax.add_artist(ScaleBar(1, location='lower left', scale_formatter=lambda value, _: f"{value} км"))
        ax.set_title(title, fontsize=16)
        ax.axis('off')
    
        plt.show()
    

    Эта функция начинает с определения точек, базируясь на выбранном методе ('centroid' или 'representative_point'), генерирует размеры для каждой диаграммы на основе указанной переменной и заданных параметров размера и компенсации Флэннери, и отображает картодиаграммы на карте.

    Некоторые моменты, которые следует уточитить в вашем коде или реализации:

    • Разберитесь с правильным вычислением min_size внутри функции get_transform, если оно не предоставлено.
    • Удостоверьтесь, что get_transform адаптирована под использование с новым подходом к определению размеров и что она корректно работает с компенсацией Флэннери.
    • Проверьте, что корректно обрабатываете flannery компенсацию на всех этапах.

    Эти рекомендации предполагают, что у вас уже есть корректно работающие функции find_centers и suggest_size, которые используются в коде выше. Если это не так, возможно, потребуется доработка этих функций для интеграции в общий анализ.

  11. User

    Нужно отобразить каждый круг по значению изображаемого явления в точке, определяемой с помощью функции find_centers, нужно добавить ее в условия в центроиду и точке на поверхности

  12. Assistant

    Если вам нужно определить позицию каждого круга картодиаграммы по центральной точке, полученной из функции find_centers, и добавить вариант размещения по "точке на поверхности" и "центроиду", вы должны немного адаптировать предыдущий подход к функции map_diagrams. В вашей задаче find_centers уже возвращает GeoDataFrame с центрами максимальных вписанных окружностей, которые можно использовать в качестве позиции для отображения значений картодиаграмм.

    Итак, допустим, find_centers выглядит следующим образом:

    def find_centers(gdf, acc):
        # Тело функции, которое возвращает centers_gdf, skeletons,
        # где centers_gdf - это GeoDataFrame с геометрией в центрах максимальных вписанных окружностей
        # и может содержать дополнительную информацию, например, 'max_dist' для каждого центра.
        pass
    

    Теперь давайте перепишем функцию map_diagrams, включив возможность выбора между "центроидами", "точками на поверхности", и определённой с помощью find_centers "центральной точкой":

    def map_diagrams(gdf, variable, point_method='find_centers', color='blue', 
                     min_size=None, max_size=None, flannery=False,
                     title='Картодиаграммы', legend_title='Легенда', acc=10):
    
        # Получаем центры через find_centers
        centers_gdf, _ = find_centers(gdf, acc)
        
        # Выбор метода размещения диаграмм
        if point_method == 'centroid':
            points = gdf.centroid
        elif point_method == 'representative_point':
            points = gdf.representative_point()
        elif point_method == 'find_centers':
            points = centers_gdf.geometry
        else:
            raise ValueError("Неверно указанный метод для определения точек")
        
        # Подготовка данных для картодиаграмм
        var_data = gdf[variable]
        size_function = get_transform(gdf, variable, min_size, max_size, flannery)
        sizes = var_data.apply(size_function)
        
        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
        gdf.plot(ax=ax, color='lightgray', edgecolor='k', linewidth=0.5)
        
        # Отображение картодиаграмм
        for idx, point in enumerate(points):
            ax.scatter(point.x, point.y, s=sizes.iloc[idx], color=color, alpha=0.5, edgecolor='black')
        
        # Построение легенды
        build_legend(ax, var_data, size_function, color, legend_title)
        
        ax.add_artist(ScaleBar(1, location='lower left', scale_formatter=lambda value, _: f"{value} км"))
        ax.set_title(title, fontsize=16)
        ax.axis('off')
    
        plt.show()
    

    Эта версия функции предоставляет вам возможность определить позицию каждого круга картодиаграммы с использованием различных методов. Данные для центров из find_centers используются при указании метода 'find_centers'. Остальная часть функции отвечает за отображение этих точек на карте в виде картодиаграмм, размер которых соответствует значению изображаемого явления.

    Обратите внимание, что функция build_legend будет нужна для создания легенды. Эту функцию вам нужно реализовать самостоятельно или интегрировать создание легенды прямо в map_diagrams, как было показано в предыдущем примере.

    Не забудьте импортировать нужные библиотеки (matplotlib.pyplot и другие) и проверить, что функции get_transform и find_centers корректно работают и доступны в вашем контексте выполнения.

  13. User

    Приведи пример вызова этой функции

  14. Assistant

    Чтобы вызвать функцию map_diagrams, как описано в предыдущем ответе, вам сначала нужно убедиться, что у вас есть необходимые данные и все поддерживающие функции (find_centers, get_transform и т.д.) реализованы и работают корректно.

    Допустим, у вас есть GeoDataFrame с данными о регионах, которые называется reg_data, и в этом GeoDataFrame содержится колонка population, отображающая население каждого региона. Вот как может выглядеть вызов функции map_diagrams для отображения картодиаграмм, основанных на данных о населении:

    # Визуализация, используя центроиды каждого полигона как точки для картодиаграмм
    map_diagrams(gdf=reg_data, 
                 variable='population',
                 point_method='centroid',  # Выбор "центроид" для позиционирования диаграмм
                 color='blue',  # Цвет диаграмм
                 min_size=10,  # Минимальный размер диаграммы
                 max_size=100,  # Максимальный размер диаграммы
                 flannery=True,  # Применение компенсации Флэннери
                 title='Распределение населения по регионам',  # Заголовок карты
                 legend_title='Население (чел)')  # Заголовок легенды
    
    # Визуализация с использованием точек, найденных функцией find_centers
    map_diagrams(gdf=reg_data, 
                 variable='population',
                 point_method='find_centers',  # Использование центральных точек, найденных функцией find_centers
                 color='green',  # Цвет диаграмм
                 min_size=None,  # Автоматическое определение минимального размера
                 max_size=200,  # Максимальный размер диаграммы
                 flannery=False,  # Отсутствие компенсации Флэннери
                 title='Распределение населения (центры максимальных окружностей)',  # Заголовок карты
                 legend_title='Население')  # Заголовок легенды
    

    Обратите внимание, что для корректной работы этих вызовов требуется, чтобы функции find_centers и get_transform были уже реализованы и работали в вашем коде, а reg_data корректно подготовлен и содержал необходимые данные.

    Параметры min_size и max_size могут быть опущены или рассчитаны на основе ваших данных для настройки визуализации в зависимости от вашего анализа и предпочтений.

    Убедитесь, что библиотеки Pandas, GeoPandas, Matplotlib, и Shapely установлены в вашем окружении, так как они необходимы для работы с данными и их визуализации.

  15. User

    def find_centers(gdf, acc): centers = [] distances = [] skeletons = []

    for index, row in gdf.iterrows():
        geom = row.geometry
        
        if geom.geom_type == 'MultiPolygon':
            max_polygon = max(geom.geoms, key=lambda x: x.area)
            poly = list(max_polygon.exterior.coords)
            acc_points = poly[::acc]
            
        elif geom.geom_type == 'Polygon':
            poly = list(geom.exterior.coords)
            acc_points = poly[::acc]
        
        bound = LineString(poly)
        acc_points = MultiPoint(acc_points)
        
        voron = shapely.voronoi_polygons(acc_points)
        edges = []
        
        for v in voron.geoms:
            cell = v.exterior.coords
            for i in range(0, len(cell)-1):
                start, end = cell[i], cell[i+1]
                edge = LineString([start, end])
                edges.append(edge)
        
        skeleton = []
        for edge in edges:
            if shapely.contains_properly(geom, edge):
                skeleton.append(edge)
        
        
        inner_points = []
        for bone in skeleton:
            inner_points.append(bone.coords[0])
            inner_points.append(bone.coords[1])
        
        max_dist = -math.inf
        cur_point = None
        
        for point in inner_points:
            point = Point([point])
            dist = shapely.distance(point, bound)
            if dist > max_dist:
                max_dist = dist
                cur_point = point
        
        centers.append(cur_point)
        distances.append(max_dist)
        skeletons.append(MultiLineString(skeleton))
        
    centers_gdf = gpd.GeoDataFrame({'center_circle': centers, 'max_dist': distances}, geometry='center_circle')
    
    return centers_gdf, skeletons
    

    UnboundLocalError Traceback (most recent call last) Cell In[291], line 1 ----> 1 gdf1 = find_centers(gdf, 10) 2 circle = gdf1['center_circle'].geom 3 print(circle)

    Cell In[290], line 18, in find_centers(gdf, acc) 15 poly = list(geom.exterior.coords) 16 acc_points = poly[::acc] ---> 18 bound = LineString(poly) 19 acc_points = MultiPoint(acc_points) 21 voron = shapely.voronoi_polygons(acc_points)

    UnboundLocalError: local variable 'poly' referenced before assignment

  16. Assistant

    Ошибка UnboundLocalError: local variable 'poly' referenced before assignment указывает на то, что переменная poly используется до того, как ей было присвоено значение в одном из ветвлений кода. Это может случиться, если условия if geom.geom_type == 'MultiPolygon': и elif geom.geom_type == 'Polygon': не выполнились, и программа дошла до строки bound = LineString(poly) без инициализации переменной poly.

    Однако, судя по представленному коду, это должно произойти только если геометрия geom не является ни Polygon, ни MultiPolygon. В таких случаях выполняется применение метода .exterior.coords к непроинициализированной переменной poly, что и приводит к указанной ошибке.

    Чтобы решить эту проблему, вы можете добавить инициализацию poly перед условиями if-elif или добавить обработку всех возможных типов геометрий (включая, например, Point, LineString и другие), либо же добавить блок else, который будет обрабатывать случаи, когда тип геометрии не соответствует ожидаемым. Также важно гарантировать, что метод distance вызывается правильно и что shapely.voronoi_polygons реализован корректно, ведь экспортированное API Shapely в стандартной версии это не поддерживает.

    Давайте рассмотрим, как можно изменить вашу функцию, чтобы обработать потенциальное отсутствие определения poly:

    def find_centers(gdf, acc):
        centers = []
        distances = []
        skeletons = []
        
        for index, row in gdf.iterrows():
            geom = row.geometry
            poly = []  # Инициализируем poly как пустой список на случай, если геометрия не Polygon или MultiPolygon
            
            if geom.geom_type == 'MultiPolygon':
                max_polygon = max(geom.geoms, key=lambda x: x.area)
                poly = list(max_polygon.exterior.coords)
                
            elif geom.geom_type == 'Polygon':
                poly = list(geom.exterior.coords)
                
            if not poly:  # Пропускаем итерацию, если poly пустой
                continue
            
            acc_points = poly[::acc]
            bound = LineString(poly)
            acc_points = MultiPoint(acc_points)
            
            voron = shapely.voronoi_polygons(acc_points)  # Убедитесь, что это работает, как ожидается
            edges = []
            
            for v in voron.geoms:
                cell = v.exterior.coords
                for i in range(0, len(cell)-1):
                    start, end = cell[i], cell[i+1]
                    edge = LineString([start, end])
                    edges.append(edge)
            
            skeleton = []
            for edge in edges:
                if geom.contains(edge):  # Замена на .contains
                    skeleton.append(edge)
            
            inner_points = []
            for bone in skeleton:
                inner_points.append(bone.coords[0])
                inner_points.append(bone.coords[1])
            
            max_dist = -math.inf
            cur_point = None
            
            for point in inner_points:
                point = Point(point)  # Удаление избыточных скобок; point уже кортеж
                dist = point.distance(bound)
                if dist > max_dist:
                    max_dist = dist
                    cur_point = point
            
            centers.append(cur_point)
            distances.append(max_dist)
            skeletons.append(MultiLineString(skeleton))
            
        centers_gdf = gpd.GeoDataFrame({'center_circle': centers, 'max_dist': distances}, geometry='center_circle')
        
        return centers_gdf, skeletons
    

    В этом рефакторинге:

    • poly инициализируется как пустой список в начале каждой итерации цикла.
    • Добавлено условие для пропуска итерации, если poly остается пустым.
    • geom.contains_properly(edge) заменен на geom.contains(edge), так как contains_properly может не работать ожидаемым образом или вовсе отсутствовать в вашей версии Shapely.
    • Уточнение использования метода distance функцией point.distance(bound) вместо shapely.distance(point, bound).
  17. User

    AttributeError Traceback (most recent call last) ~\AppData\Local\Temp\ipykernel_12680\717187807.py in ?() ----> 1 map_diagrams(reg_data, 'population', ptype='circle', flannery=True, acc=10, smin=50, smax=100, title='Объем жилищного строительства на душу населения')

    ~\AppData\Local\Temp\ipykernel_12680\2078621373.py in ?(gdf, var, ptype, smin, smax, dcolor, dcolorline, acc, flannery, title, legendtitle) 26 psf.plot(markersize = 'size', color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.5, ax = ax) 27 28 elif ptype == 'circle': 29 circle = gdf1['center_circle'] ---> 30 circle = circle.assign(size=transform(circle[var])) 31 circle['size']=circle['size'].apply(lambda x: float(x)) 32 circle.plot(markersize = 'size', color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.5, ax = ax) 33 else:

    ~.conda\envs\ELZAS_LORAN\lib\site-packages\pandas\core\generic.py in ?(self, name) 6200 and name not in self._accessors 6201 and self._info_axis._can_hold_identifiers_and_holds_name(name) 6202 ): 6203 return self[name] -> 6204 return object.getattribute(self, name)

    AttributeError: 'GeoSeries' object has no attribute 'assign'

    def map_diagrams(gdf, var, ptype, smin = None, smax=None, dcolor='blue', dcolorline='red', acc = 10, flannery=True, title='', legendtitle=''):

    ax = gdf.plot(color = 'lightgray', edgecolor = 'k', linewidth = 0.5)
    ax.axis('off')
    ax.set_title(title)
    ax.add_artist(ScaleBar(dx = 1, location = 'lower left', scale_formatter = lambda value, unit: f"{value} км"))
    
    gdf1 = find_centers(gdf, acc)[0]
    
    transform = get_transform(gdf, var, ax, smin, smax, flannery)
    
    skl = GeoSeries(skeletons)
    skl.plot(color = 'blue', linewidth = 0.2, alpha = 0.5, ax = ax)
    
    if ptype == 'cnt':
        cnt = gdf.centroid
        cnt = cnt.assign(size=transform(cnt[var]))
        cnt['size'] = cnt['size'].apply(lambda x: float(x))
        cnt.plot(markersize = 'size', color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.5, ax = ax)
        
    elif ptype == 'psf':
        psf = shapely.point_on_surface(gdf.geometry)
        psf = psf.assign(size=transform(psf[var]))
        psf['size']=psf['size'].apply(lambda x: float(x))
        psf.plot(markersize = 'size', color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.5, ax = ax)
        
    elif ptype == 'circle':
        circle = gdf1['center_circle']
        circle = circle.assign(size=transform(circle[var]))
        circle['size']=circle['size'].apply(lambda x: float(x))
        circle.plot(markersize = 'size', color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.5, ax = ax)
    else:
        print('Вы не выбрали способ размещения репрезентативной точки. Его можно задать, указав параметр ptype="cnt"|"psf"|"circle" вместе с evals=False')
        return 0
    
    values = [gdf[var].max(),
          0.5 * (gdf[var].max() + gdf[var].min()),
          gdf[var].mean(), 
          gdf[var].min()
         ]
    
    for value in values: 
        ax.scatter([], [], s = transform(value), color = dcolor, edgecolor = dcolorline, linewidth = 1.2, alpha = 0.6, label = int(value)) 
    ax.legend(labelspacing = 2, handletextpad = 1.2, frameon = False, title = legendtitle, title_fontsize = 13, loc = 'center left', bbox_to_anchor = [1, 0.5])
    
  18. Assistant

    Ошибка AttributeError: 'GeoSeries' object has no attribute 'assign' возникает потому, что метод .assign() является методом объекта DataFrame библиотеки Pandas, и его нельзя применить напрямую к GeoSeries из GeoPandas. Чтобы решить эту проблему, вам нужно скорректировать ваш подход к использованию .assign() для GeoSeries.

    В вашем случае, для применения результатов функции transform() к GeoSeries 'circle', вы должны обработать данные в формате, который позволит применять размеры к круглым диаграммам. Ниже представлен способ обхода этой проблемы:

    def map_diagrams(gdf, var, ptype, smin=None, smax=None, dcolor='blue',
                     dcolorline='red', acc=10, flannery=True, title='', legendtitle=''):
        
        ax = gdf.plot(color='lightgray', edgecolor='k', linewidth=0.5)
        ax.axis('off')
        ax.set_title(title)
        ax.add_artist(ScaleBar(dx=1, location='lower left', scale_formatter=lambda value, unit: f"{value} км"))
    
        gdf1, skeletons = find_centers(gdf, acc)
        
        transform = get_transform(gdf, var, ax, smin, smax, flannery)
        
        skl = GeoSeries(skeletons)
        skl.plot(color='blue', linewidth=0.2, alpha=0.5, ax=ax)
    
        # Создаем DataFrame для использования .assign()
        if ptype == 'circle':
            circle_df = pd.DataFrame({'geometry': gdf1['center_circle'], var: gdf[var]})
            circle_df['size'] = transform(gdf[var].values)
            circle_gdf = gpd.GeoDataFrame(circle_df, geometry='geometry')
    
            circle_gdf.plot(markersize='size', color=dcolor, edgecolor=dcolorline, linewidth=1.2, alpha=0.5, ax=ax)
        else:
            print('Неизвестный тип репрезентативной точки. Укажите ptype как "circle".')
    
        # Отрисовка легенды
        values = [gdf[var].max(),
                  0.5 * (gdf[var].max() + gdf[var].min()),
                  gdf[var].mean(), 
                  gdf[var].min()
                 ]
        
        for value in values: 
            ax.scatter([], [], s=transform(value), color=dcolor, edgecolor=dcolorline, linewidth=1.2, alpha=0.6, label='{:.2f}'.format(value)) 
        ax.legend(labelspacing=2, handletextpad=1.2, frameon=False, title=legendtitle, title_fontsize=13,
                  loc='center left', bbox_to_anchor=[1, 0.5])
        
        plt.show()
    

    Обратите внимание:

    • Я изменил применение функции transform к gdf[var].values для получения массива размеров диаграмм.
    • Создание circle_df как DataFrame и последующий перевод его в GeoDataFrame для использования .plot() с параметром markersize.
    • Ваша оригинальная функция transform должна быть способна корректно обработать массив значений var, переданный из основного GeoDataFrame gdf.

    В приведенном коде я рассмотрел только случай для ptype равного 'circle', так как остальные типы репрезентативных точек ('cnt', 'psf') не были полностью заданы в приведенном коде. Вам будет необходимо адаптировать этот подход для обработки этих типов, если вы планируете использовать их.