#include <QGraphicsItem> #include "paintscene.h" #...

Ниже приведён пример, как можно организовать динамический пересчёт периметра для всех фигур и отображение результата в perimeterWindow при каждом изменении (рисовании, масштабировании, вращении, перемещении), а также при переключении на другую фигуру по клику.

1. Виртуальный метод calculatePerimeter() в базовом классе Figure

Чтобы каждая фигура умела считать свой периметр, в базовом классе Figure объявляем чисто виртуальный метод:

cpp
// figure.h
#ifndef FIGURE_H
#define FIGURE_H

#include <QObject>
#include <QGraphicsItem>

class Figure : public QObject, public QGraphicsItem
{
    Q_OBJECT
public:
    explicit Figure(QPointF point, QObject *parent = nullptr);
    ~Figure();

    // Чтобы каждая фигура считала свой периметр
    virtual double calculatePerimeter() const = 0;

    QPointF startPoint() const;
    QPointF endPoint() const;

    void setStartPoint(const QPointF point);
    void setEndPoint(const QPointF point);

    QRectF boundingRect() const override;

signals:
    void pointChanged();

protected:
    QPointF tempStartPoint;
    QPointF tempEndPoint;

    // Обновляет область перерисовки при изменении точек
    void updateArea();

private:
    // ...
};

#endif // FIGURE_H

Обратите внимание, что метод calculatePerimeter() стал чисто виртуальным (= 0) – каждая конкретная фигура сама будет его переопределять.

2. Реализация calculatePerimeter() в конкретных фигурах

В каждой фигуре (Rectangle, Triangle, Ellipse, Rhombus, Square, Hexagon, Circle, Звёзды и т.д.) переопределяем метод. Простейший пример для прямоугольника:

cpp
// rect.h
#ifndef RECT_H
#define RECT_H

#include "figure.h"

class Rect : public Figure
{
public:
    explicit Rect(QPointF point, QObject *parent = nullptr)
        : Figure(point, parent)
    {}

    // Переопределяем метод расчёта периметра
    double calculatePerimeter() const override
    {
        double w = qAbs(endPoint().x() - startPoint().x());
        double h = qAbs(endPoint().y() - startPoint().y());
        return 2 * (w + h);
    }

protected:
    // Переопределяем paint, если нужно рисовать по-своему...
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override
    {
        // ...
    }
};

#endif // RECT_H

Аналогично для остальных фигур. Например, треугольник (если это прямоугольный треугольник по диагонали boundingRect):

cpp
// triangle.h (пример для прямоугольного треугольника)
#ifndef TRIANGLE_H
#define TRIANGLE_H

#include "figure.h"
#include <cmath>

class Triangle : public Figure
{
public:
    explicit Triangle(QPointF point, QObject *parent = nullptr)
        : Figure(point, parent)
    {}

    double calculatePerimeter() const override
    {
        double w = qAbs(endPoint().x() - startPoint().x());
        double h = qAbs(endPoint().y() - startPoint().y());
        // Периметр прямоугольного треугольника: a + b + c
        // где a = w, b = h, c = sqrt(w^2 + h^2)
        return w + h + std::sqrt(w*w + h*h);
    }

protected:
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override
    {
        // ...
    }
};

#endif // TRIANGLE_H

И так далее для Ellipse, Rhombus, Circle, звёзд и прочих. Например, для эллипса (приближённая формула):

cpp
double Ellipse::calculatePerimeter() const
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    // a и b – полуоси
    double a = w / 2.0;
    double b = h / 2.0;
    // Простейшее приближение периметра эллипса
    return 2.0 * M_PI * std::sqrt((a*a + b*b) / 2.0);
}

Для ромба с диагоналями w и h:

cpp
double Rhombus::calculatePerimeter() const
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    // Диагонали: w, h
    // Сторона ромба = sqrt((w/2)^2 + (h/2)^2)
    double side = std::sqrt((w/2)*(w/2) + (h/2)*(h/2));
    return 4.0 * side;
}

И т.п. Важно, чтобы каждую фигуру вы рисовали согласованно с тем, как считаете периметр.

3. Постоянный пересчёт в PaintScene

В вашем PaintScene уже есть метод:

cpp
QString PaintScene::calculatePerimeter()
{
    QList<QGraphicsItem *> selectedItems = this->selectedItems();

    if (!selectedItems.isEmpty())
    {
        QGraphicsItem *selectedItem = selectedItems.first();
        Figure *figure = dynamic_cast<Figure *>(selectedItem);
        if (figure)
        {
            double perimeter = figure->calculatePerimeter();
            QString perimeterText = QString::number(perimeter);
            emit perimeterCalculated(perimeterText);
            return perimeterText;
        }
    }
    return "0.0";
}

Сейчас он вызывается лишь в mouseReleaseEvent(). Чтобы периметр менялся постоянно (во время рисования, масштабирования и т. д.), нужно вызывать этот метод после каждого изменения:

1. В конце mouseMoveEvent(), когда:

   • Рисуем ( currentMode == DrawingMode ),
   • Двигаем фигуру ( MovingMode ),
   • Вращаем ( RotatingMode ),
   • Масштабируем ( ScalingMode ).

2. При нажатии на другую фигуру (чтобы её выделить и сразу увидеть её периметр).

Примерно так:

cpp
void PaintScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == DrawingMode)
    {
        switch (tempFigureType)
        {
            // ... создаём новую фигуру ...
        }
        // Добавляем в сцену и сразу делаем её выделенной,
        // чтобы calculatePerimeter() получал корректную фигуру
        this->addItem(tempFigure);
        clearSelection();
        tempFigure->setSelected(true);

        // После создания новой фигуры сразу считаем периметр
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);

    }
    else if (currentMode == MovingMode)
    {
        selectedItem = itemAt(event->scenePos(), QTransform());
        if (selectedItem)
        {
            clearSelection();
            selectedItem->setSelected(true);
            offset = event->scenePos() - selectedItem->pos();
            
            // Пересчитать периметр при нажатии на фигуру
            QString perimeter = calculatePerimeter();
            emit perimeterCalculated(perimeter);
        }
    }
    else if (currentMode == RotatingMode)
    {
        rotatingItem = itemAt(event->scenePos(), QTransform());
        if (rotatingItem)
        {
            clearSelection();
            rotatingItem->setSelected(true);
            isRotating = true;
            rotationCenter = rotatingItem->boundingRect().center();
            rotatingItem->setTransformOriginPoint(rotationCenter);
            startAngle = std::atan2(event->scenePos().y() - rotationCenter.y(),
                                    event->scenePos().x() - rotationCenter.x());
            // Пересчитать периметр при нажатии
            QString perimeter = calculatePerimeter();
            emit perimeterCalculated(perimeter);
        }
    }
    else if (currentMode == ScalingMode)
    {
        scalingItem = itemAt(event->scenePos(), QTransform());
        if (scalingItem)
        {
            clearSelection();
            scalingItem->setSelected(true);
            scalingItem->setTransformOriginPoint(scalingItem->boundingRect().center());
            startPointScaling = event->scenePos();
            currentScale = scalingItem->scale();

            // Пересчитать периметр при нажатии
            QString perimeter = calculatePerimeter();
            emit perimeterCalculated(perimeter);
        }
    }

    QGraphicsScene::mousePressEvent(event);
}

void PaintScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == DrawingMode && tempFigure)
    {
        tempFigure->setEndPoint(event->scenePos());
        this->update();
        // Постоянно пересчитываем
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == MovingMode && selectedItem)
    {
        selectedItem->setPos(event->scenePos() - offset);
        this->update();
        // Обновляем периметр при каждом движении
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == RotatingMode && isRotating && rotatingItem)
    {
        qreal currentAngle = std::atan2(event->scenePos().y() - rotationCenter.y(),
                                        event->scenePos().x() - rotationCenter.x());
        qreal angleDif = (currentAngle - startAngle) * 180 / M_PI;
        rotatingItem->setRotation(rotatingItem->rotation() + angleDif);
        startAngle = currentAngle;
        this->update();

        // Периметр может не меняться при вращении (для круга – не изменится),
        // но если хотите всё равно пересчитывать:
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == ScalingMode && scalingItem)
    {
        QPointF currentPoint = event->scenePos();
        qreal scaleCoefficient = 1.0 + (currentPoint.y() - startPointScaling.y()) / 100.0;
        if (scaleCoefficient > 0.1)
            scalingItem->setScale(currentScale * scaleCoefficient);
        this->update();

        // При масштабировании периметр меняется
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }

    QGraphicsScene::mouseMoveEvent(event);
}

void PaintScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == MovingMode && selectedItem)
    {
        selectedItem->setSelected(false);
        selectedItem = nullptr;
    }
    else if (currentMode == DrawingMode)
    {
        // Закончили рисовать
        tempFigure = nullptr;
    }
    else if (currentMode == RotatingMode)
    {
        isRotating = false;
        rotatingItem = nullptr;
    }
    else if (currentMode == ScalingMode && scalingItem)
    {
        scalingItem = nullptr;
    }

    QGraphicsScene::mouseReleaseEvent(event);

    // На случай, если хотим снова обновить после отпускания мыши
    QString perimeter = calculatePerimeter();
    emit perimeterCalculated(perimeter);
}

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

4. Отображение результата в MainWindow

В MainWindow уже есть слот showPerimeterValue(const QString&). Нужно убедиться, что сигнал/слот связаны:

cpp
// В конструкторе MainWindow
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    scene = new PaintScene();

    // Подключаем сигнал
    connect(scene, &PaintScene::perimeterCalculated, this, &MainWindow::showPerimeterValue);

    ui->graphicsView->setScene(scene);
    // ...
}

А в самом слоте просто обновляем perimeterWindow:

cpp
void MainWindow::showPerimeterValue(const QString &perimeterValue)
{
    // Например, просто показываем число
    ui->perimeterWindow->setText(perimeterValue);
}

Теперь, когда вы рисуете новую фигуру или кликаете на другую, сцена делает её выделенной и вызывает calculatePerimeter(), посылает сигнал — и в MainWindow вы видите результат в perimeterWindow. При перемещении/масштабировании/вращении периметр будет пересчитываться на лету.

Кратко по ключевым моментам:

1. У каждой фигуры есть свой calculatePerimeter(), который учитывает, как именно вы рисуете фигуру (какие стороны, формулы и т.д.).
2. В PaintScene надо после каждого изменения (mousePress, mouseMove, mouseRelease — в зависимости от режима) звать calculatePerimeter() для текущей выделенной фигуры.
3. С помощью сигнала perimeterCalculated вы передаёте результат в MainWindow, где в слоте обновляете ui->perimeterWindow.

Таким образом, периметр будет динамически меняться и постоянно отображаться на экране. А при клике на другую фигуру произойдёт выделение этой фигуры, и вы сразу увидите её периметр.

Чтобы периметр действительно пересчитывался при каждом изменении и не был равен «0.0», нужно убедиться в двух ключевых вещах:

1. Каждая конкретная фигура (Rect, Triangle, Ellipse и т. д.) действительно переопределяет метод calculatePerimeter(), и в нём возвращается корректное значение (учитывая startPoint(), endPoint() и логику вычисления периметра).

2. В сцене при любом изменении (рисование/масштабирование/вращение/перемещение) фигура действительно “выделена” (selected) и вызывается ваш метод calculatePerimeter(), который берёт именно выделенный элемент через selectedItems(). Если фигура не выделена, selectedItems() будет пустым, и метод вернёт 0.0.

Ниже пошагово, как это исправить.

1. Сделайте у каждой фигуры свой calculatePerimeter()

В файле figure.h:

cpp
class Figure : public QObject, public QGraphicsItem
{
    Q_OBJECT
public:
    // ...
    // Добавляем чисто виртуальный метод — каждая фигура переопределит.
    virtual double calculatePerimeter() const = 0;
    // ...
};

В каждой наследованной фигуре (Rect, Triangle, Ellipse и т. п.) нужно переопределить этот метод:

cpp
double Rect::calculatePerimeter() const
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    return 2 * (w + h);
}

Убедитесь, что у всех фигур формула периметра корректная, иначе при рисовании всегда будет возвращаться либо 0, либо неправильное значение.

2. При создании новой фигуры делайте её выделенной

В вашем mousePressEvent, когда рисуется новая фигура, вы просто создаёте tempFigure и делаете addItem(tempFigure). Но в PaintScene::calculatePerimeter() идёт поиск выделенного (selectedItems()).

Значит, нужно «снять выделение со старой» и выделить новую. Например, так:

cpp
void PaintScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{   
    if (currentMode == DrawingMode)
    {
        switch (tempFigureType)
        {
            case RectangleType:
            {
                Rect *item = new Rect(event->scenePos());
                item->setPos(event->pos());
                tempFigure = item;
                break;
            }
            // ... и т.д. для других фигур ...
        }

        // Добавляем в сцену
        this->addItem(tempFigure);

        // Очистим предыдущее выделение
        clearSelection();
        // Сразу выделяем только что созданную фигуру
        tempFigure->setSelected(true);

        // Сразу после создания можно пересчитать периметр
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    // ...
    // Остальные режимы: MovingMode, RotatingMode, ScalingMode
    // там аналогично можно делать clearSelection() и setSelected(true)
    // когда пользователь кликает на нужную фигуру
    // ...
    QGraphicsScene::mousePressEvent(event);
}

Теперь tempFigure гарантированно будет выделена (selected), и, следовательно, selectedItems().first() вернёт именно её.

3. Пересчитывайте периметр в mouseMoveEvent и mouseReleaseEvent

Чтобы периметр “жил” и менялся во время рисования и других операций, нужно после каждого изменения вызывать ваш метод calculatePerimeter(). Например:

cpp
void PaintScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == DrawingMode && tempFigure)
    {
        // Меняем endPoint у временной фигуры:
        tempFigure->setEndPoint(event->scenePos());
        this->update();

        // Пересчитываем периметр для выделенной фигуры
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == MovingMode && selectedItem)
    {
        selectedItem->setPos(event->scenePos() - offset);
        this->update();

        // Пересчитываем
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == RotatingMode && isRotating && rotatingItem)
    {
        // ...
        rotatingItem->setRotation(rotatingItem->rotation() + angleDif);
        startAngle = currentAngle;
        this->update();

        // Пересчитать периметр (на случай, если хотите отслеживать
        // изменения периметра при вращении)
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }
    else if (currentMode == ScalingMode && scalingItem)
    {
        // ...
        scalingItem->setScale(currentScale * scaleCoefficient);
        this->update();

        // Масштабирование влияет на размеры и, соответственно, на периметр
        QString perimeter = calculatePerimeter();
        emit perimeterCalculated(perimeter);
    }

    QGraphicsScene::mouseMoveEvent(event);
}

И можно дополнительно в mouseReleaseEvent:

cpp
void PaintScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsScene::mouseReleaseEvent(event);

    // В конце обновим периметр (на случай, если нужно зафиксировать финальное значение)
    QString perimeter = calculatePerimeter();
    emit perimeterCalculated(perimeter);
}

4. Убедитесь, что сигнал/слот для вывода в perimeterWindow подключен

В MainWindow в конструкторе:

cpp
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    scene = new PaintScene(this);

    // Подключаем сигнал к слоту
    connect(scene, &PaintScene::perimeterCalculated, this, &MainWindow::showPerimeterValue);

    ui->graphicsView->setScene(scene);
    // ...
}

И в самом слоте showPerimeterValue:

cpp
void MainWindow::showPerimeterValue(const QString &perimeterValue)
{
    ui->perimeterWindow->setText(perimeterValue);
}

Если всё сделано правильно, то:

• При создании новой фигуры (DrawingMode) мы делаем tempFigure->setSelected(true).
• При каждом движении мыши при рисовании (или масштабировании и т. д.) мы вызываем calculatePerimeter().
• calculatePerimeter() находит выделенную фигуру, берёт у неё calculatePerimeter(), возвращает число, вызывает emit perimeterCalculated(...).
• В MainWindow ловится этот сигнал, и perimeterWindow обновляет значение.

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

Самый простой и наглядный путь – завести в интерфейсе отдельную область (например, QLabel, QLineEdit или QTextEdit) для вывода информации о выделенной фигуре. Туда вы сможете одним вызовом записать всю нужную информацию: периметр, площадь и координаты центра масс.

Ниже общий алгоритм с конкретными шагами:

1. Добавьте в базовый класс Figure методы для площади и центра масс

В figure.h помимо calculatePerimeter() можно объявить ещё два виртуальных метода:

cpp
class Figure : public QObject, public QGraphicsItem
{
    Q_OBJECT
public:
    explicit Figure(QPointF point, QObject *parent = nullptr);
    virtual ~Figure();

    // Методы для вычисления периметра, площади и центра масс
    virtual double calculatePerimeter() const = 0;
    virtual double calculateArea() const = 0;
    virtual QPointF calculateCenter() const = 0;

    // ...
};

Каждая конкретная фигура (Rect, Triangle, Ellipse, Rhombus и т.п.) переопределяет все три метода:

cpp
double Rect::calculatePerimeter() const override
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    return 2 * (w + h);
}

double Rect::calculateArea() const override
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    return w * h;
}

QPointF Rect::calculateCenter() const override
{
    // Центр – это просто midpoint между startPoint() и endPoint()
    double cx = (startPoint().x() + endPoint().x()) / 2.0;
    double cy = (startPoint().y() + endPoint().y()) / 2.0;
    return QPointF(cx, cy);
}

Аналогично в Triangle, Circle, Square и т.д.:

1. Периметр (уже реализован).
2. Площадь – по вашим формулам.
3. Центр масс – зависит от того, как именно вы задаёте фигуру, но в простейшем случае это может быть центр boundingRect, если фигура симметрична и вы её рисуете от startPoint до endPoint.

2. Организуйте метод в PaintScene для выдачи всей информации

Вместо (или вместе с) метода calculatePerimeter() можно сделать более общий метод, возвращающий три значения (либо формировать готовую строку). Например, сделаем сигналы:

cpp
// paintscene.h
signals:
    void figureInfoChanged(const QString &info);

Вместо perimeterCalculated(...) будем всегда вычислять полную информацию о фигуре. Пример:

cpp
QString PaintScene::calculateFigureInfo()
{
    QList<QGraphicsItem*> selectedItems = this->selectedItems();
    if (selectedItems.size() > 0)
    {
        Figure *figure = dynamic_cast<Figure*>(selectedItems.first());
        if (figure)
        {
            double perimeter = figure->calculatePerimeter();
            double area = figure->calculateArea();
            QPointF center = figure->calculateCenter();

            // Сформируем удобную строку
            QString infoString = QString("Периметр: %1\n"
                                         "Площадь: %2\n"
                                         "Центр масс: (%3; %4)")
                    .arg(perimeter, 0, 'f', 2)  // 2 знака после запятой
                    .arg(area, 0, 'f', 2)
                    .arg(center.x(), 0, 'f', 2)
                    .arg(center.y(), 0, 'f', 2);

            return infoString;
        }
    }
    return "Фигура не выбрана";
}

И затем при каждом изменении вместо emit perimeterCalculated(...) делаем:

cpp
void PaintScene::updateSelectedFigureInfo()
{
    QString info = calculateFigureInfo();
    emit figureInfoChanged(info);
}

Вызывать updateSelectedFigureInfo(); там же, где раньше вызывали calculatePerimeter(), то есть в mousePressEvent, mouseMoveEvent, mouseReleaseEvent – когда что-то меняется с фигурой (рисование, перемещение, поворот, масштаб).

3. Связать сигнал с MainWindow и вывести в QLabel/QLineEdit

В MainWindow делаете слот, допустим, void MainWindow::onFigureInfoChanged(const QString &info). В нём берёте ui->labelFigureInfo (или что у вас есть) и обновляете текст:

cpp
// mainwindow.cpp
void MainWindow::onFigureInfoChanged(const QString &info)
{
    ui->labelFigureInfo->setText(info);
}

В конструкторе MainWindow подключаем сигнал/слот:

cpp
connect(scene, &PaintScene::figureInfoChanged,
        this, &MainWindow::onFigureInfoChanged);

В дизайнере Qt или в коде убедитесь, что есть подходящий виджет (например, QLabel* labelFigureInfo;) и он находится на форме (в ui->setupUi(this);).

4. Обновляем данные при любом клике и движении

Теперь в местах, где вы меняете фигуру, вызывайте:

cpp
void PaintScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == DrawingMode && tempFigure)
    {
        tempFigure->setEndPoint(event->scenePos());
        update();

        updateSelectedFigureInfo();  // Вызываем
    }
    else if (currentMode == MovingMode && selectedItem)
    {
        selectedItem->setPos(event->scenePos() - offset);
        update();

        updateSelectedFigureInfo();  // Вызываем
    }
    // и т.д.

    QGraphicsScene::mouseMoveEvent(event);
}

Аналогично – в mousePressEvent (когда выделяем новую фигуру или кликаем по уже существующей) и в mouseReleaseEvent.

Итого:

1. Базовый класс Figure: calculatePerimeter(), calculateArea(), calculateCenter().
2. Наследники (Rect, Triangle, и т.д.) переопределяют эти методы.
3. В PaintScene метод calculateFigureInfo() берёт выделенный элемент (через selectedItems()), приводит к Figure, вызывает все три метода и собирает человекочитаемую строку.
4. Вызываем этот метод при любом изменении (рисование/масштаб/вращение/перемещение) – и сигналом отправляем строку в MainWindow.
5. В MainWindow ловим сигнал и выводим строку в специальный QLabel или QLineEdit.

Такое решение простое, и всё всегда будет динамически обновляться.

Основная причина в том, что внутри метода вы берёте список выделенных элементов через:

cpp
QList<QGraphicsItem *> selectedItems = this->selectedItems();

но вместо того, чтобы вызывать dynamic_cast к первому элементу из selectedItems, вы делаете:

cpp
Figure *figure = dynamic_cast<Figure *>(selectedItem);

selectedItem — это совсем другой указатель (вероятно, какое-то поле класса), который может быть не установлен или хранить не то, что вы ожидаете. В итоге dynamic_cast<Figure *>(selectedItem) даёт nullptr, и вы попадаете в ветку return "pupupu";.

Чтобы исправить, нужно в самом методе брать именно тот элемент, который возвращается из selectedItems().first(). Пример:

cpp
QString PaintScene::calculateFigureInfo()
{
    QList<QGraphicsItem *> items = this->selectedItems();
    if (!items.isEmpty())
    {
        QGraphicsItem *item = items.first();               // берём первый выделенный
        Figure *figure = dynamic_cast<Figure *>(item);     // делаем dynamic_cast
        if (figure)
        {
            double perimeter = figure->calculatePerimeter();
            double area = figure->calculateArea();
            QPointF center = figure->calculateCenter();
            
            QString infoString = QString("Perimeter: %1\n"
                                         "Area: %2\n"
                                         "Center of mass: (%3, %4)")
                    .arg(perimeter, 0, 'f', 2)
                    .arg(area, 0, 'f', 2)
                    .arg(center.x(), 0, 'f', 2)
                    .arg(center.y(), 0, 'f', 2);
            return infoString;
        }
    }
    return "pupupu";
}

Теперь, если в сцене действительно что-то выделено и этот объект наследуется от Figure, вы получите валидный указатель figure, и метод вернёт правильные данные.

Дополнительно проверьте:

1. Вы выделяете (setSelected) нужную фигуру при её создании или при клике по ней:

   cpp
   clearSelection();
   tempFigure->setSelected(true);

   Иначе selectedItems() просто окажется пустым.

2. Все ваши фигуры (Rect, Triangle, Ellipse и т. д.) действительно наследуются от Figure и переопределяют calculatePerimeter(), calculateArea() и т. д. Иначе dynamic_cast тоже будет возвращать nullptr.

Главная причина того, что метод calculateFigureInfo() всегда возвращает "pupupu" (т. е. не находит выделенной фигуры) – в том, что у вас в конце действий (например, при отпускании мыши в режиме перемещения) элемент снимается с выделения:

cpp
if (currentMode == MovingMode && selectedItem)
{
    selectedItem->setSelected(false);  // <-- снимается выделение
    selectedItem = nullptr;
}

и после этого вы вызываете updateSelectedFigureInfo(), а внутри него – this->selectedItems(). Но в списке выделенных элементов уже ничего нет, следовательно, items.isEmpty() оказывается true, и метод возвращает "pupupu".

Чтобы исправить это поведение и сохранять выделение выбранной фигуры (тем самым получая корректный периметр, площадь и т. д.), удалите или закомментируйте строку selectedItem->setSelected(false); в нужных местах (обычно в mouseReleaseEvent) – тогда после перемещения фигура останется выделенной, и selectedItems().first() будет возвращать вашу фигуру.

Пример, где убрано снятие выделения при отпускании мыши:

cpp
void PaintScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == MovingMode && selectedItem)
    {
        // НЕ снимаем выделение!  
        // selectedItem->setSelected(false); // <--- убрать/закомментировать
        selectedItem = nullptr;
    }
    else if (currentMode == DrawingMode)
    {
        tempFigure = nullptr;
    }
    else if (currentMode == RotatingMode)
    {
        isRotating = false;
        rotatingItem = nullptr;
    }
    else if (currentMode == ScalingMode && scalingItem)
    {
        scalingItem = nullptr;
    }

    updateSelectedFigureInfo(); // теперь здесь будет реальная фигура
    QGraphicsScene::mouseReleaseEvent(event);
}

После этого, при отпускании мыши, ваша фигура останется выделенной, а вызов updateSelectedFigureInfo() действительно найдёт её в selectedItems(), сделает dynamic_cast<Figure*> и вернёт корректные значения вместо "pupupu".

Другие проверки, если всё ещё не работает

1. Убедитесь, что в режиме рисования вы делаете:

   cpp
   clearSelection();
   tempFigure->setSelected(true);

   Тогда новая фигура точно становится выделенной.

2. В режиме перемещения (MovingMode) тоже хорошо бы перед выделением нового объекта очистить старое выделение, если хотите иметь только одну выделенную фигуру:

   cpp
   clearSelection();
   selectedItem->setSelected(true);

   Иначе может быть несколько выделенных фигур (если это не нужно – уберите).

3. Проверьте, что все ваши классы-наследники (Rect, Triangle, Ellipse и т. д.) действительно наследуют Figure и имеют виртуальный деструктор, чтобы dynamic_cast работал правильно. Судя по коду, у вас это уже сделано.

4. Убедитесь, что в mouseMoveEvent и mousePressEvent в конце (или в начале) вызывается QGraphicsScene::mousePressEvent(event);/QGraphicsScene::mouseMoveEvent(event);/QGraphicsScene::mouseReleaseEvent(event);, чтобы не ломать внутреннюю логику QGraphicsScene (если хотите воспользоваться частично встроенными механизмами выделения). Но в вашем случае, вы вручную делаете setSelected(true), так что может и не требоваться, главное – не снимайте выделение, если вам нужно сохранить выбор.

В большинстве случаев достаточно не снимать выделение в mouseReleaseEvent (или делать это только когда пользователь явно кликнул по пустому месту) – и тогда this->selectedItems() всегда будет содержать текущую выбранную фигуру, а метод calculateFigureInfo() будет возвращать корректные значения.

Если программа не заходит в метод calculateFigureInfo(), значит, не вызывается метод updateSelectedFigureInfo(). Нужно проверить, почему updateSelectedFigureInfo() не вызывается в нужные моменты.

1. Проверка вызова updateSelectedFigureInfo()

Чтобы убедиться, что метод вообще вызывается, добавьте в updateSelectedFigureInfo() отладочный вывод:

cpp
void PaintScene::updateSelectedFigureInfo()
{
    qDebug() << "updateSelectedFigureInfo() called";  // Проверяем вызов метода
    QString info = calculateFigureInfo();
    emit figureInfoChanged(info);
}

Запустите программу и проверьте в qDebug(), появляется ли "updateSelectedFigureInfo() called".
Если нет, значит, updateSelectedFigureInfo() вообще не вызывается → идём дальше.

2. Проверка, где вызывается updateSelectedFigureInfo()

Вы вызываете updateSelectedFigureInfo() в нескольких местах:

• В mousePressEvent(), когда создаётся новая фигура или выбирается существующая:

  cpp
  if (currentMode == DrawingMode)
  {
      this->addItem(tempFigure);
      clearSelection();
      tempFigure->setSelected(true);
      updateSelectedFigureInfo();  // Должен вызываться здесь
  }

  Проверка: Добавьте qDebug() перед вызовом updateSelectedFigureInfo():

  cpp
  qDebug() << "Mouse pressed: updateSelectedFigureInfo() should be called";
  updateSelectedFigureInfo();

  Если "Mouse pressed: updateSelectedFigureInfo() should be called" не появляется в qDebug(), значит, проблема ещё раньше – например, mousePressEvent() вообще не вызывается.

• В mouseMoveEvent(), если фигура перемещается:

  cpp
  else if (currentMode == MovingMode && selectedItem)
  {
      selectedItem->setPos(event->scenePos() - offset);
      this->update();
      updateSelectedFigureInfo();  // Должен вызываться здесь
  }

  Проверка:

  cpp
  qDebug() << "Mouse moving: updateSelectedFigureInfo() should be called";

• В mouseReleaseEvent(), после завершения действий:

  cpp
  updateSelectedFigureInfo();  // Должен вызываться здесь

  Проверка:

  cpp
  qDebug() << "Mouse released: updateSelectedFigureInfo() should be called";

Если qDebug() не показывает эти сообщения, значит, метод updateSelectedFigureInfo() не вызывается → ищем, почему.

3. Проверка mousePressEvent() и mouseMoveEvent()

Если updateSelectedFigureInfo() не вызывается, значит, программа не заходит в mousePressEvent() и mouseMoveEvent().
Проверьте, вызываются ли они:

cpp
void PaintScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    qDebug() << "mousePressEvent triggered";  // Проверяем вызов метода
    ...
    updateSelectedFigureInfo();
}

cpp
void PaintScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    qDebug() << "mouseMoveEvent triggered";  // Проверяем вызов метода
    ...
    updateSelectedFigureInfo();
}

Если mousePressEvent() и mouseMoveEvent() не вызываются, значит:

• Проблема в том, что PaintScene не получает события.
• Возможно, graphicsView блокирует их, либо перехватывает другой объект.
• Убедитесь, что setScene(scene); действительно вызывается в MainWindow.

4. Проверка связи сигнала и слота figureInfoChanged

Вы вызываете:

cpp
emit figureInfoChanged(info);

Но вызывается ли слот в MainWindow?

Проверяем:

cpp
void MainWindow::onFigureInfoChanged(const QString &info)
{
    qDebug() << "onFigureInfoChanged() received info: " << info;
    ui->infoLabel->setText(info);
}

Если "onFigureInfoChanged() received info: ..." не выводится, значит:

• Проблема в connect():

  cpp
  connect(scene, &PaintScene::figureInfoChanged, this, &MainWindow::onFigureInfoChanged);

  Проверьте, что connect() вызывается в MainWindow после scene = new PaintScene(this);.

• Попробуйте перезапустить connect() вручную (например, после создания scene).

5. Итог: что делать

1. Добавьте qDebug() в updateSelectedFigureInfo(), calculateFigureInfo() и mousePressEvent().
2. Проверьте, вызываются ли mousePressEvent() и mouseMoveEvent() (qDebug() внутри них).
3. Проверьте connect() в MainWindow.
4. Посмотрите, доходит ли сигнал figureInfoChanged до слота onFigureInfoChanged().

Если mousePressEvent() и mouseMoveEvent() не вызываются – проблема в graphicsView.
Если calculateFigureInfo() не вызывается – проблема в selectedItems().
Если onFigureInfoChanged() не вызывается – проблема в connect().

Раз метод вызывается, но информация не меняется, скорее всего, проблема в получении выделенного элемента (selectedItems()) или в передаче данных в UI. Давай разберёмся по шагам.**

1. Проверяем, какие элементы реально выделяются

Добавь отладку внутрь calculateFigureInfo():

cpp
QString PaintScene::calculateFigureInfo()
{
    QList<QGraphicsItem *> items = this->selectedItems();
    qDebug() << "calculateFigureInfo() called. Selected items count:" << items.size();

    if (!items.isEmpty())
    {
        QGraphicsItem *item = items.first();
        Figure *figure = dynamic_cast<Figure *>(item);

        qDebug() << "Dynamic cast successful?" << (figure != nullptr);

        if (figure)
        {
            double perimeter = figure->calculatePerimeter();
            double area = figure->calculateArea();
            QPointF center = figure->calculateCenter();

            qDebug() << "Perimeter:" << perimeter << "Area:" << area << "Center:" << center;

            QString infoString = QString("Perimeter: %1\n"
                                         "Area: %2\n"
                                         "Center of mass: (%3, %4)")
                                     .arg(perimeter, 0, 'f', 2)
                                     .arg(area, 0, 'f', 2)
                                     .arg(center.x(), 0, 'f', 2)
                                     .arg(center.y(), 0, 'f', 2);
            return infoString;
        }
    }
    
    qDebug() << "No valid figure selected!";
    return "pupupu";
}

Теперь запусти программу и посмотри в qDebug(), что происходит при выделении фигуры.
Вот возможные проблемы и их решения:

2. Проверяем, выделяется ли фигура

Если selectedItems() пустой, значит фигура не выделяется.

Добавь qDebug() в mousePressEvent():

cpp
void PaintScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if (currentMode == DrawingMode)
    {
        switch (tempFigureType)
        {
            case RectangleType:
                tempFigure = new Rect(event->scenePos());
                break;
            case TriangleType:
                tempFigure = new Triangle(event->scenePos());
                break;
            case EllipseType:
                tempFigure = new Ellipse(event->scenePos());
                break;
        }

        this->addItem(tempFigure);
        clearSelection();
        tempFigure->setSelected(true);

        qDebug() << "New figure created and selected!";
        updateSelectedFigureInfo();
    }
    else if (currentMode == MovingMode)
    {
        selectedItem = itemAt(event->scenePos(), QTransform());
        if (selectedItem)
        {
            clearSelection();
            selectedItem->setSelected(true);

            qDebug() << "Existing figure selected!";
            updateSelectedFigureInfo();
        }
    }

    QGraphicsScene::mousePressEvent(event);
}

Запусти программу и посмотри в qDebug(), появляется ли New figure created and selected! или Existing figure selected!.
Если нет – проверь, нет ли кода, который снимает выделение (setSelected(false))!

3. Проверяем, передаётся ли информация в MainWindow

Добавь qDebug() в слот onFigureInfoChanged() в MainWindow:

cpp
void MainWindow::onFigureInfoChanged(const QString &info)
{
    qDebug() << "onFigureInfoChanged received info: " << info;
    ui->infoLabel->setText(info);
}

Если qDebug() не показывает, что onFigureInfoChanged() вызывается, значит:

1. connect() в MainWindow сломан:

   cpp
   connect(scene, &PaintScene::figureInfoChanged, this, &MainWindow::onFigureInfoChanged);

   Убедись, что connect() вызывается после scene = new PaintScene(this);!

2. emit figureInfoChanged(info); не вызывается → Проверь, вызывается ли updateSelectedFigureInfo().

4. Проверяем методы calculatePerimeter(), calculateArea(), calculateCenter()

Добавь qDebug() в rect.cpp:

cpp
double Rect::calculatePerimeter() const
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    qDebug() << "calculatePerimeter() called: w =" << w << ", h =" << h;
    return 2 * (w + h);
}

cpp
double Rect::calculateArea() const
{
    double w = qAbs(endPoint().x() - startPoint().x());
    double h = qAbs(endPoint().y() - startPoint().y());
    qDebug() << "calculateArea() called: w =" << w << ", h =" << h;
    return w * h;
}

cpp
QPointF Rect::calculateCenter() const
{
    double cx = (startPoint().x() + endPoint().x()) / 2.0;
    double cy = (startPoint().y() + endPoint().y()) / 2.0;
    qDebug() << "calculateCenter() called: center =" << cx << "," << cy;
    return QPointF(cx, cy);
}

Если w = 0 и h = 0, значит, startPoint() и endPoint() не обновляются!
Проверь, вызывается ли setEndPoint(event->scenePos()); в mouseMoveEvent().

Что делать?

1. Добавь qDebug() в calculateFigureInfo().
   Если selectedItems().isEmpty(), то выделение не работает → Проверь setSelected(true).

2. Добавь qDebug() в mousePressEvent().
   Если "New figure created and selected!" не появляется, значит, setSelected(true) не сработал.

3. Добавь qDebug() в onFigureInfoChanged().
   Если слот не вызывается, проблема в connect().
   Если вызывается, но infoLabel не меняется – проблема в UI.

4. Добавь qDebug() в calculatePerimeter() и calculateArea().
   Если они всегда 0, то setEndPoint() не работает → Проверь mouseMoveEvent().

После этого посмотри, где ломается логика и исправь соответствующий шаг.