Skip to content
The Chat Archive
gpt-4o-2024-05-13· OpenAI WildChat-4.8M (AI2)

Построить прямоугольник по 4 точкам matplotlib

  1. User

    Построить прямоугольник по 4 точкам matplotlib

  2. Assistant

    Чтобы построить прямоугольник по четырем точкам с использованием библиотеки matplotlib в Python, вы можете использовать следующие шаги:

    1. Убедитесь, что у вас установлена библиотека matplotlib. Если ее нет, установите ее с помощью команды pip install matplotlib.

    2. Напишите код, который создаст график с прямоугольником, используя заданные 4 точки. Вот пример:

    import matplotlib.pyplot as plt
    import matplotlib.patches as patches
    
    # Задаем координаты четырех точек
    x1, y1 = (1, 1)
    x2, y2 = (1, 4)
    x3, y3 = (4, 4)
    x4, y4 = (4, 1)
    
    # Функция для соединения точек и проверки, что они формируют прямоугольник
    def is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        points = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
        points.sort()  # Сортируем точки для упрощения расчетов
        
        p1, p2, p3, p4 = points
        return (p1[0] == p2[0] and p3[0] == p4[0] and
                p1[1] == p3[1] and p2[1] == p4[1])
    
    # Проверка, что точки формируют прямоугольник
    if is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        fig, ax = plt.subplots()
        # Создаем прямоугольник
        rect = patches.Polygon(((x1, y1), (x2, y2), (x3, y3), (x4, y4)), closed=True, fill=False)
        ax.add_patch(rect)
        
        # Устанавливаем границы графика
        ax.set_xlim(min(x1, x2, x3, x4) - 1, max(x1, x2, x3, x4) + 1)
        ax.set_ylim(min(y1, y2, y3, y4) - 1, max(y1, y2, y3, y4) + 1)
        
        plt.xlabel('X')
        plt.ylabel('Y')
        plt.title('Rectangle from 4 points')
        
        plt.grid(True)
        plt.show()
    else:
        print("Точки не формируют прямоугольник.")
    

    В этом примере мы сначала задаем координаты четырех точек. Затем функция is_rectangle проверяет, что заданные точки формируют прямоугольник, и если это так, то программа строит прямоугольник на графике.

    Этот пример полезен, если точки заданы в порядке координат вершин (левая нижняя, левая верхняя, правая верхняя, правая нижняя) или в другом порядке, где свойство прямоугольника (противоположные стороны параллельны и равны) сохраняется.

  3. User

    Как закрасить прямоугольники?

  4. Assistant

    Для того чтобы закрасить прямоугольник с использованием библиотеки matplotlib, вы можете установить параметр fill=True и задать цвет с помощью параметра facecolor. В библиотеке matplotlib цвет можно задать как именованным цветом (например, 'red', 'blue'), так и в формате RGB.

    Вот обновлённый пример с цветом заливки:

    import matplotlib.pyplot as plt
    import matplotlib.patches as patches
    
    # Задаем координаты четырех точек
    x1, y1 = (1, 1)
    x2, y2 = (1, 4)
    x3, y3 = (4, 4)
    x4, y4 = (4, 1)
    
    # Функция для соединения точек и проверки, что они формируют прямоугольник
    def is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        points = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
        points.sort()  # Сортируем точки для упрощения расчетов
        
        p1, p2, p3, p4 = points
        return (p1[0] == p2[0] and p3[0] == p4[0] and
                p1[1] == p3[1] and p2[1] == p4[1])
    
    # Проверка, что точки формируют прямоугольник
    if is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        fig, ax = plt.subplots()
        # Создаем прямоугольник
        rect = patches.Polygon(((x1, y1), (x2, y2), (x3, y3), (x4, y4)), closed=True, fill=True, facecolor='lightblue')
        ax.add_patch(rect)
        
        # Устанавливаем границы графика
        ax.set_xlim(min(x1, x2, x3, x4) - 1, max(x1, x2, x3, x4) + 1)
        ax.set_ylim(min(y1, y2, y3, y4) - 1, max(y1, y2, y3, y4) + 1)
        
        plt.xlabel('X')
        plt.ylabel('Y')
        plt.title('Filled Rectangle from 4 Points')
        
        plt.grid(True)
        plt.show()
    else:
        print("Точки не формируют прямоугольник.")
    

    В этом примере параметр fill=True указывает, что прямоугольник должен быть закрашен, а параметр facecolor='lightblue' устанавливает цвет заливки.

    Вы можете изменить значение facecolor, чтобы использовать желаемый цвет для заливки прямоугольника. Также можно использовать RGB-формат, передавая кортеж из трех значений (например, (0.5, 0.5, 0.5) для серого цвета).

  5. User

    ДОбавить границы к прямоугольникам

  6. Assistant

    Чтобы добавить границы к прямоугольникам в matplotlib, вам нужно задать параметры edgecolor для определения цвета границы и linewidth для установки толщины линии границы. Вот обновлённый пример с добавленными границами:

    import matplotlib.pyplot as plt
    import matplotlib.patches as patches
    
    # Задаем координаты четырех точек
    x1, y1 = (1, 1)
    x2, y2 = (1, 4)
    x3, y3 = (4, 4)
    x4, y4 = (4, 1)
    
    # Функция для соединения точек и проверки, что они формируют прямоугольник
    def is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        points = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
        points.sort()  # Сортируем точки для упрощения расчетов
        
        p1, p2, p3, p4 = points
        return (p1[0] == p2[0] and p3[0] == p4[0] and
                p1[1] == p3[1] and p2[1] == p4[1])
    
    # Проверка, что точки формируют прямоугольник
    if is_rectangle(x1, y1, x2, y2, x3, y3, x4, y4):
        fig, ax = plt.subplots()
        # Создаем прямоугольник
        rect = patches.Polygon(((x1, y1), (x2, y2), (x3, y3), (x4, y4)), closed=True, fill=True, facecolor='lightblue', edgecolor='black', linewidth=2)
        ax.add_patch(rect)
        
        # Устанавливаем границы графика
        ax.set_xlim(min(x1, x2, x3, x4) - 1, max(x1, x2, x3, x4) + 1)
        ax.set_ylim(min(y1, y2, y3, y4) - 1, max(y1, y2, y3, y4) + 1)
        
        plt.xlabel('X')
        plt.ylabel('Y')
        plt.title('Filled Rectangle with Borders from 4 Points')
        
        plt.grid(True)
        plt.show()
    else:
        print("Точки не формируют прямоугольник.")
    

    В этом примере:

    • facecolor='lightblue' задает цвет заливки прямоугольника.
    • edgecolor='black' задает цвет границы прямоугольника.
    • linewidth=2 задает толщину линии границы прямоугольника.

    Вы можете изменить значения параметров facecolor, edgecolor и linewidth в соответствии с вашими предпочтениями.

  7. User

    Есть два массива данных: I, V = np.meshgrid(np.linspace(IlimMin, IlimMax, 150), np.linspace(VlimMin, VlimMax, 150)) Необходимо нарисовать и объединить в замкнутую фигуру те точки, которые удовлетворяют условиям Imin, Imax = 17.04, 17.49
    Vmin, Vmax = 0.6, 0.74

  8. Assistant

    Для того чтобы нарисовать и объединить в замкнутую фигуру точки, которые удовлетворяют условиям (I_{\text{min}}), (I_{\text{max}}), (V_{\text{min}}) и (V_{\text{max}}), вы можете воспользоваться библиотеками numpy и matplotlib. Вот пример, как это можно сделать:

    1. Генерируем сетку данных (I) и (V) с помощью np.meshgrid.
    2. Фильтруем точки, которые удовлетворяют заданным условиям.
    3. Рисуем замкнутую фигуру, используя библиотеку matplotlib.
    import numpy as np
    import matplotlib.pyplot as plt
    
    # Установите ваши пределы
    IlimMin, IlimMax = 16, 18
    VlimMin, VlimMax = 0.5, 0.8
    
    # Генерация сетки данных
    I, V = np.meshgrid(np.linspace(IlimMin, IlimMax, 150), np.linspace(VlimMin, VlimMax, 150))
    
    # Задаем условия
    Imin, Imax = 17.04, 17.49  
    Vmin, Vmax = 0.6, 0.74  
    
    # Фильтрация точек, удовлетворяющих условиям
    mask = (I >= Imin) & (I <= Imax) & (V >= Vmin) & (V <= Vmax)
    filtered_I = I[mask]
    filtered_V = V[mask]
    
    # Создаем график
    fig, ax = plt.subplots()
    
    # Рисуем замкнутую фигуру
    # Вычисляем границы выделенной области
    vertices = np.array([
        [Imin, Vmin],
        [Imin, Vmax],
        [Imax, Vmax],
        [Imax, Vmin]
    ])
    
    # Создаем полигон
    polygon = plt.Polygon(vertices, closed=True, fill=True, edgecolor='black', facecolor='lightblue')
    
    ax.add_patch(polygon)
    
    # Устанавливаем границы графика для удобного просмотра
    ax.set_xlim(IlimMin, IlimMax)
    ax.set_ylim(VlimMin, VlimMax)
    ax.set_xlabel('I')
    ax.set_ylabel('V')
    ax.set_title('Selected Area in I-V Space')
    plt.grid(True)
    plt.show()
    

    Этот пример впервые генерирует сетку значений для (I) и (V) с использованием np.meshgrid. Затем фильтруются значения, удовлетворяющие условиям (I_{\text{min}}), (I_{\text{max}}), (V_{\text{min}}) и (V_{\text{max}}) с использованием маски mask. После этого создается полигон, который замыкает фильтрованные точки в одну фигуру, и добавляется на график с использованием plt.Polygon.

    Вы можете настроить цветовую схему и параметры графика в соответствии с вашими предпочтениями.

  9. User

    Есть программа, отражающая прямоугольники. Нужно чтобы прямоугольники печатались друг на друге: самый большой ниже всех, самый маленький - выше

  10. Assistant

    Для упорядочивания прямоугольников так, чтобы они рисовались друг на друге, начиная с самого большого внизу и заканчивая самым маленьким наверху, можно использовать сортировку. Приведенный ниже код сортирует прямоугольники по их площади перед рисованием, причем сначала рисуются большие прямоугольники, а потом поверх них - более маленькие.

    Вот пример, демонстрирующий этот подход:

    import matplotlib.pyplot as plt
    import matplotlib.patches as patches
    
    # Список прямоугольников задан в формате: [(x1, y1, x2, y2), ...]
    rectangles = [
        (1, 1, 5, 5),  # Bottom rectangle
        (2, 2, 4, 4),  # Middle rectangle
        (2.5, 2.5, 3.5, 3.5)  # Top rectangle
    ]
    
    # Функция для вычисления площади прямоугольника
    def rectangle_area(rect):
        x1, y1, x2, y2 = rect
        return abs(x2 - x1) * abs(y2 - y1)
    
    # Сортируем прямоугольники по площади в порядке убывания
    rectangles.sort(key=rectangle_area, reverse=True)
    
    # Создаем график
    fig, ax = plt.subplots()
    
    # Рисуем каждый прямоугольник
    for rect in rectangles:
        x1, y1, x2, y2 = rect
        width = abs(x2 - x1)
        height = abs(y2 - y1)
        bottom_left = (min(x1, x2), min(y1, y2))
        # Создаем прямоугольник с границей и заливкой
        patch = patches.Rectangle(bottom_left, width, height, edgecolor='black', facecolor='lightblue')
        ax.add_patch(patch)
    
    # Устанавливаем границы графика
    ax.set_xlim(0, 6)
    ax.set_ylim(0, 6)
    plt.grid(True)
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.title('Rectangles Stacked on Top of Each Other')
    plt.show()
    

    В этом примере:

    1. Изначально у вас есть список прямоугольников, заданных четырьмя точками (x1, y1, x2, y2).
    2. Используется функция rectangle_area, которая вычисляет площадь прямоугольника.
    3. Прямоугольники сортируются по площади в порядке убывания с помощью функции sort с ключом key=rectangle_area и параметром reverse=True.
    4. Прямоугольники рисуются в порядке убывания их площади. Таким образом, самый большой прямоугольник окажется снизу, а самый маленький - наверху.

    Этот метод гарантирует, что прямоугольники будут напечатаны друг на друге в правильном порядке.

  11. User

    Есть программа, отражающая прямоугольники. Нужно чтобы прямоугольники печатались друг на друге: самый большой ниже всех, самый маленький - выше import numpy as np import matplotlib.pyplot as plt import scipy.integrate as integrate import matplotlib.patches as patches

    i_membership = [0, 3.33, 10, 16.66, 20] v_membership = [0, 0.75, 2.25, 3.75, 4.5]

    def background(ax): square1 = np.array([[0, 0], [3.33, 0], [3.33, 0.75], [0, 0.75]]) square2 = np.array([[3.33, 0], [10, 0], [10, 0.75], [3.33, 0.75]]) square3 = np.array([[10, 0], [16.66, 0], [16.66, 0.75], [10, 0.75]]) square4 = np.array([[16.66, 0], [20, 0], [20, 0.75], [16.66, 0.75]])

    square5 = np.array([[3.33, 0.75], [10, 0.75], [10, 2.25], [3.33, 2.25]])
    square6 = np.array([[10, 0.75], [16.66, 0.75], [16.66, 2.25], [10, 2.25]])
    square7 = np.array([[16.66, 0.75], [20, 0.75], [20, 2.25], [16.66, 2.25]])
    
    square8 = np.array([[10, 2.25], [16.66, 2.25], [16.66, 3.75], [10, 3.75]])
    square9 = np.array([[16.66, 2.25], [20, 2.25], [20, 3.75], [16.66, 3.75]])
    
    square10 = np.array([[10, 3.75], [16.66, 3.75], [16.66, 4.5], [10, 4.5]])
    square11 = np.array([[16.66, 3.75], [20, 3.75], [20, 4.5], [16.66, 4.5]])
    sq = [square1, square2, square3, square4, square5, square6, square7, square8, square9, square10, square11]
    colors = ['green', 'gold', 'red', 'firebrick', 'gold', 'gold', 'firebrick', 'gold', 'red', 'red', 'red']
    for i in range(len(sq)):
        rect = patches.Polygon(sq[i], closed=True, fill=True, facecolor=colors[i], edgecolor = 'k', linewidth = 0.5)
        ax.add_patch(rect)
    

    def graph(ax, sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax): I, V = np.meshgrid(np.linspace(IlimMin, IlimMax, 150), np.linspace(VlimMin, VlimMax, 150)) F = np.exp((-(I-muI)2-(np.log(V)-muV)2)/(2 * sigmaI2 * sigmaV2))/(sigmaI * sigmaV * V * 2*np.pi) mask = (I >= Imin) & (I <= Imax) & (V >= Vmin) & (V <= Vmax) # filtered_I = I[mask] # filtered_V = V[mask] vertices = np.array([ [Imin, Vmin], [Imin, Vmax], [Imax, Vmax], [Imax, Vmin] ])

    polygon = plt.Polygon(vertices, closed=True, fill=True, edgecolor='None', facecolor='navy')
    
    ax.add_patch(polygon)
    

    IlimMin = 0 IlimMax = 20 VlimMin = 0 VlimMax = 4.5 fig, ax = plt.subplots() background(ax)

    первый приступ

    sigmaI = 1.7 muI = 12.8 sigmaV = 0.71 muV = -0.554 Imin, Imax = 17.04, 17.49
    Vmin, Vmax = 0.6, 0.74 graph(ax, sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax) #второй приступ sigmaI = 2.33 muI = 11.46 sigmaV = 0.755 muV = -0.611 Imin, Imax = 17.04, 19.67 Vmin, Vmax = 0.55, 0.74

    graph(ax, sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax)

    #третий приступ sigmaI = 2.398 muI = 10.32 sigmaV = 0.75 muV = -0.625 Imin, Imax = 17.04, 19.67 Vmin, Vmax = 0.32, 0.74 graph(ax, sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax)

    ax.set_xlim(IlimMin, IlimMax) ax.set_ylim(VlimMin, VlimMax) plt.show()

  12. Assistant

    Чтобы гарантировать, что прямоугольники будут нарисованы друг на друге в порядке убывания их площади, можно упорядочить их перед вызовом функции graph. Мы создадим список прямоугольников с их параметрами и сначала отсортируем его по площади в порядке убывания.

    Вот обновлённый код с учётом этих требований:

    import numpy as np
    import matplotlib.pyplot as plt
    import scipy.integrate as integrate
    import matplotlib.patches as patches
    
    i_membership = [0, 3.33, 10, 16.66, 20]
    v_membership = [0, 0.75, 2.25, 3.75, 4.5]
    
    def background(ax):
        square1 = np.array([[0, 0], [3.33, 0], [3.33, 0.75], [0, 0.75]])
        square2 = np.array([[3.33, 0], [10, 0], [10, 0.75], [3.33, 0.75]])
        square3 = np.array([[10, 0], [16.66, 0], [16.66, 0.75], [10, 0.75]])
        square4 = np.array([[16.66, 0], [20, 0], [20, 0.75], [16.66, 0.75]])
    
        square5 = np.array([[3.33, 0.75], [10, 0.75], [10, 2.25], [3.33, 2.25]])
        square6 = np.array([[10, 0.75], [16.66, 0.75], [16.66, 2.25], [10, 2.25]])
        square7 = np.array([[16.66, 0.75], [20, 0.75], [20, 2.25], [16.66, 2.25]])
    
        square8 = np.array([[10, 2.25], [16.66, 2.25], [16.66, 3.75], [10, 3.75]])
        square9 = np.array([[16.66, 2.25], [20, 2.25], [20, 3.75], [16.66, 3.75]])
    
        square10 = np.array([[10, 3.75], [16.66, 3.75], [16.66, 4.5], [10, 4.5]])
        square11 = np.array([[16.66, 3.75], [20, 3.75], [20, 4.5], [16.66, 4.5]])
        sq = [square1, square2, square3, square4, square5, square6, square7, square8, square9, square10, square11]
        colors = ['green', 'gold', 'red', 'firebrick', 'gold', 'gold', 'firebrick', 'gold', 'red', 'red', 'red']
        for i in range(len(sq)):
            rect = patches.Polygon(sq[i], closed=True, fill=True, facecolor=colors[i], edgecolor = 'k', linewidth = 0.5)
            ax.add_patch(rect)
    
    def graph(ax, rect_params):
        IlimMin, IlimMax = 0, 20
        VlimMin, VlimMax = 0, 4.5
        I, V = np.meshgrid(np.linspace(IlimMin, IlimMax, 150), np.linspace(VlimMin, VlimMax, 150))
    
        for params in rect_params:
            sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax = params
            vertices = np.array([
                [Imin, Vmin],
                [Imin, Vmax],
                [Imax, Vmax],
                [Imax, Vmin]
            ])
            polygon = plt.Polygon(vertices, closed=True, fill=True, edgecolor='None', facecolor='navy')
            ax.add_patch(polygon)
    
    def rect_area(params):
        _, _, _, _, Imin, Imax, Vmin, Vmax = params
        return (Imax - Imin) * (Vmax - Vmin)
    
    IlimMin = 0
    IlimMax = 20
    VlimMin = 0
    VlimMax = 4.5
    
    rect_params = [
        (1.7, 12.8, 0.71, -0.554, 17.04, 17.49, 0.6, 0.74),
        (2.33, 11.46, 0.755, -0.611, 17.04, 19.67, 0.55, 0.74),
        (2.398, 10.32, 0.75, -0.625, 17.04, 19.67, 0.32, 0.74)
    ]
    
    # Сортировка параметров прямоугольников по площади в порядке убывания
    rect_params.sort(key=rect_area, reverse=True)
    
    fig, ax = plt.subplots()
    background(ax)
    graph(ax, rect_params)
    
    ax.set_xlim(IlimMin, IlimMax)
    ax.set_ylim(VlimMin, VlimMax)
    plt.show()
    

    Объяснение изменений:

    1. Функция rect_area: вычисляет площадь прямоугольника на основе его параметров.
    2. Сортировка rect_params с использованием rect_area: параметры прямоугольников сортируются в порядке убывания площади.
    3. Функция graph принимает список параметров прямоугольников: рисует каждый прямоугольник последовательно по параметрам.
    4. Вызов функции graph после сортировки: рисование всех прямоугольников.

    С данным подходом прямоугольники будут нарисованы друг на друга начиная с самого большого внизу и заканчивая самым маленьким наверху.

  13. User

    Можно ли использовать функцию zorder?

  14. Assistant

    Да, вы можете использовать параметр zorder для управления порядком отрисовки объектов на графике в matplotlib. Параметр zorder определяет уровень, на котором будет нарисован объект. Объекты с более низким значением zorder рисуются под объектами с более высоким значением.

    Для вашего конкретного примера, вы можете назначить более высокие значения zorder небольшим прямоугольникам, чтобы они рисовались поверх больших.

    Вот обновленный пример, использующий zorder:

    import numpy as np
    import matplotlib.pyplot as plt
    import scipy.integrate as integrate
    import matplotlib.patches as patches
    
    i_membership = [0, 3.33, 10, 16.66, 20]
    v_membership = [0, 0.75, 2.25, 3.75, 4.5]
    
    def background(ax):
        square1 = np.array([[0, 0], [3.33, 0], [3.33, 0.75], [0, 0.75]])
        square2 = np.array([[3.33, 0], [10, 0], [10, 0.75], [3.33, 0.75]])
        square3 = np.array([[10, 0], [16.66, 0], [16.66, 0.75], [10, 0.75]])
        square4 = np.array([[16.66, 0], [20, 0], [20, 0.75], [16.66, 0.75]])
    
        square5 = np.array([[3.33, 0.75], [10, 0.75], [10, 2.25], [3.33, 2.25]])
        square6 = np.array([[10, 0.75], [16.66, 0.75], [16.66, 2.25], [10, 2.25]])
        square7 = np.array([[16.66, 0.75], [20, 0.75], [20, 2.25], [16.66, 2.25]])
    
        square8 = np.array([[10, 2.25], [16.66, 2.25], [16.66, 3.75], [10, 3.75]])
        square9 = np.array([[16.66, 2.25], [20, 2.25], [20, 3.75], [16.66, 3.75]])
    
        square10 = np.array([[10, 3.75], [16.66, 3.75], [16.66, 4.5], [10, 4.5]])
        square11 = np.array([[16.66, 3.75], [20, 3.75], [20, 4.5], [16.66, 4.5]])
        sq = [square1, square2, square3, square4, square5, square6, square7, square8, square9, square10, square11]
        colors = ['green', 'gold', 'red', 'firebrick', 'gold', 'gold', 'firebrick', 'gold', 'red', 'red', 'red']
        for i in range(len(sq)):
            rect = patches.Polygon(sq[i], closed=True, fill=True, facecolor=colors[i], edgecolor='k', linewidth=0.5)
            ax.add_patch(rect)
    
    def graph(ax, sigmaI, muI, sigmaV, muV, Imin, Imax, Vmin, Vmax, zorder):
        vertices = np.array([
            [Imin, Vmin],
            [Imin, Vmax],
            [Imax, Vmax],
            [Imax, Vmin]
        ])
        polygon = plt.Polygon(vertices, closed=True, fill=True, edgecolor='None', facecolor='navy', zorder=zorder)
        ax.add_patch(polygon)
        
    IlimMin = 0
    IlimMax = 20
    VlimMin = 0
    VlimMax = 4.5
    
    fig, ax = plt.subplots()
    background(ax)
    
    # Убедитесь, что более крупные прямоугольники имеют меньший zorder, а более мелкие - больший zorder
    # Параметры прямоугольников и их zorder
    rect_params = [
        (1.7, 12.8, 0.71, -0.554, 17.04, 17.49, 0.6, 0.74, 3), # Наивысший zorder для самого маленького прямоугольника
        (2.33, 11.46, 0.755, -0.611, 17.04, 19.67, 0.55, 0.74, 2), 
        (2.398, 10.32, 0.75, -0.625, 17.04, 19.67, 0.32, 0.74, 1) # Низший zorder для самого большого прямоугольника
    ]
    
    # Рисуем прямоугольники
    for params in rect_params:
        graph(ax, *params)
    
    ax.set_xlim(IlimMin, IlimMax)
    ax.set_ylim(VlimMin, VlimMax)
    plt.show()
    

    Объяснение изменений:

    1. Добавление параметра zorder в graph функцию и передача его в plt.Polygon.
    2. Задание значений zorder для каждого прямоугольника в списке rect_params, где большие прямоугольники имеют меньшие значения zorder, а меньшие - большие.

    Теперь прямоугольники будут отрисовываться друг на друга в указанном порядке, где самый низкий zorder будет под всеми, а самый высокий zorder будет на вершине.