nmWTAI-Platform/Src/nmNum/nmPlot/nmGuiPlot.cpp

#include "ZxBaseUtil.h"
#include "zxLogInstance.h"

#include <QDebug>

#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"
#include "ZxSubTitle.h"

#include "ZxPlot.h"
#include "ZxObjCurve.h"
#include "nmPlotScene.h"
#include "nmPlotView.h"

#include "nmObjPoint.h"
#include "nmObjLine.h"
#include "nmObjPolygon.h"
#include "nmObjPolygonOutline.h"
#include "nmObjLineCrack.h"
#include "nmObjLineFault.h"
#include "nmObjLineMeasuringScale.h"
#include "nmObjPointWell.h"
#include "nmObjLineMeasure.h"
#include "nmGuiPlotCmdHelper.h"
#include "nmGuiPlot.h"
#include "nmPlotDialogContext.h"
#include "nmPlotDialogContextProvider.h"

#include "nmDataLogFile.h"
#include "nmDataMeasure.h"
#include "nmSingalCenter.h"

#include "ZxDataProject.h"
#include "TreeWxMain.h"

#include "Defines.h"
#include "zxSysUtils.h"

#include "nmObjRectOutline.h"
#include "nmObjRect.h"

#include "nmObjRoundOutline.h"
#include "nmObjRound.h"

#include "nmObjRegion.h"
#include "nmObjRegionMark.h"

#include "nmObjDeleteTool.h"

#include "nmDataAnalyzeManager.h"
#include "nmDataFault.h"
#include "nmDataFracture.h"
#include "nmDataOutline.h"
#include "nmDataRegionMark.h"
#include "nmDataRegion.h"
#include "nmDataAxis.h"

#include "nmPlotGraphicBinder.h"

#include "ZxDataWell.h"

#include "ZxDataGaugeP.h"
#include "ZxDataGaugeF.h"


#include <QMessageBox>
#include <QResizeEvent>
#include <QTimer>
#include <QWidget>

namespace {

void includeMapPoint(const QPointF& oPoint,
                     bool& bHasBounds,
                     double& dMinX,
                     double& dMaxX,
                     double& dMinY,
                     double& dMaxY)
{
    if(!qIsFinite(oPoint.x()) || !qIsFinite(oPoint.y())) {
        return;
    }

    if(!bHasBounds) {
        dMinX = dMaxX = oPoint.x();
        dMinY = dMaxY = oPoint.y();
        bHasBounds = true;
        return;
    }

    dMinX = qMin(dMinX, oPoint.x());
    dMaxX = qMax(dMaxX, oPoint.x());
    dMinY = qMin(dMinY, oPoint.y());
    dMaxY = qMax(dMaxY, oPoint.y());
}

void includeMapPoints(const QVector<QPointF>& vecPoints,
                      bool& bHasBounds,
                      double& dMinX,
                      double& dMaxX,
                      double& dMinY,
                      double& dMaxY)
{
    foreach(const QPointF& oPoint, vecPoints) {
        includeMapPoint(oPoint, bHasBounds,
                        dMinX, dMaxX, dMinY, dMaxY);
    }
}

}

nmGuiPlot::nmGuiPlot(bool bUseBtns, QWidget *parent) :
    iGuiPlot(bUseBtns, parent),
    m_pGraphicBinder(NULL),
    m_pDataManager(nmDataAnalyzeManager::getCurrentInstance()),
    m_bApplyingAxisRange(false),
    m_bAxisInitializationPending(false)
{
    m_bUseBtns = bUseBtns;

    if(NULL != m_pCmdHelper) {
        delete m_pCmdHelper;
        m_pCmdHelper = NULL;
    }

    m_pCmdHelper = new nmGuiPlotCmdHelper(this);
    Q_ASSERT(NULL != m_pCmdHelper);
    connect(m_pCmdHelper, SIGNAL(sigMeasureStarted()), this, SIGNAL(sigMeasureStarted()));

    m_sChartCmdType = "NmDemo2DType";

    setWindowTitle(tr("nmGuiPlot"));

    m_iRegionMarkCount = 0;

    m_pGraphicBinder = new nmPlotGraphicBinder(m_pDataManager, this);

}

nmGuiPlot::~nmGuiPlot()
{
}

void nmGuiPlot::initUI(QString sTitle,
                       QSize szDefault /*= QSize(265, 203)*/)
{
    iGuiPlot::initUI(sTitle, szDefault);
}

void nmGuiPlot::initSheets()
{
    // iGuiPlot::initSheets();
}

void nmGuiPlot::initMainLayout()
{
    iGuiPlot::initMainLayout();
}

QWidget* nmGuiPlot::initChartLayout(QString sTitle, QSize szDefault)
{
    return iGuiPlot::initChartLayout(sTitle, szDefault);
}

void nmGuiPlot::initChartView(QString sTitle, QSize szDefault)
{
    //    iGuiPlot::initChartView(sTitle, szDefault);
    m_pPlotView = new nmPlotView();
    Q_ASSERT(NULL != m_pPlotView);
    m_pPlotScene = new nmPlotScene();
    Q_ASSERT(NULL != m_pPlotScene);
    m_pPlotView->setScene(m_pPlotScene);
    m_pPlotScene->init(m_pPlotView, sTitle, szDefault);

    //m_pPlotView->setSimpleMode(true);

    m_pPlot = m_pPlotScene->m_pPlot;
    m_pPlotView->setMargins(0, 0, 0, 0);
    m_pPlotView->setZoomMode(ZxRenderView::eZoomFitWindow, true);
    connectSignals();

    initDefultGeoObj();
}

void nmGuiPlot::connectSignals()
{
    iGuiPlot::connectSignals();

    // your owns
    if(NULL != m_pPlot) {
        //        disconnect(m_pPlot, SIGNAL(sigUpdate()), \
        //                   m_pPlotView->viewport(), SLOT(update()));
        //        connect(m_pPlot, SIGNAL(sigUpdate()), \
        //                m_pPlotView->viewport(), SLOT(update()));
    }

    nmSingalCenter* sCenter = nmSingalCenter::getInstance();
    connect(sCenter, SIGNAL(sigDeleteWell(QString)), this, SLOT(slotDeleteWell(QString)));
    connect(sCenter, SIGNAL(sigMeasuringScale(QPointF, QPointF, void*)), this, SLOT(slotMeasuringScale(QPointF, QPointF, void*)));
    connect(sCenter, SIGNAL(sigDeleteOneObj(QString, void*)), this, SLOT(slotDeleteOneObj(QString, void*)));
}

void nmGuiPlot::runUpdate()
{
    //    iGuiPlot::updatePlots();
    if(NULL != m_pPlot) {
    }
}

bool nmGuiPlot::runAction(QString sAction)
{
    Q_ASSERT(NULL != m_pCmdHelper);
    return m_pCmdHelper->runAction(sAction);
}

void nmGuiPlot::cancelActiveTools()
{
    nmGuiPlotCmdHelper* helper = dynamic_cast<nmGuiPlotCmdHelper*>(m_pCmdHelper);
    if(helper != NULL) {
        helper->cancelActiveTools();
    }
}


void nmGuiPlot::initDefultGeoObj()
{
    nmDataAnalyzeManager* pDataManager = dataManager();
    if(pDataManager == nullptr) {
        return;
    }

    nmDataAxis* pAxisData = pDataManager->getAxisData();

    if(pAxisData == nullptr)	{
        pAxisData = new nmDataAxis;
        // 将 pAxisData 存入数据中心
        pDataManager->setAxisData(pAxisData);
    }

    // 获取井数据，来自数据中心
    QVector<nmDataWellBase*> vecWellDatas = pDataManager->getWellDataList();

    // 数据中心没有一口井数据，添加默认井数据
    if(vecWellDatas.isEmpty()) {
        // 获取当前默认井数据
        ZxDataWell* pWellData = zxCurWell;

        if(pWellData == nullptr) {
            this->setPlotsByDataManger(pDataManager);
            return;
        }

        // 判断是哪一种井类型，初始化对应的参数
        QString wellClass = pWellData->getWellClassEn();
        const NM_WELL_CATEGORY eWellCategory =
                static_cast<NM_WELL_CATEGORY>(
                    pWellData->getWellTypeIndex());
        if(!nmIsValidWellCategory(eWellCategory)) {
            this->setPlotsByDataManger(pDataManager);
            return;
        }

        // 获取当前井的压力、流量数据
        ZxDataObjectList m_listGaugeP = pWellData->getChildren(iDataModelType::sTypeDataGaugeP);
        ZxDataObjectList m_listGaugeF = pWellData->getChildren(iDataModelType::sTypeDataGaugeF);

        ZxDataGaugeP* pGaugeP = nullptr;
        ZxDataGaugeF* pGaugeF = nullptr;

        // 遍历压力数据列表
        for(int i = 0; i < m_listGaugeP.size(); ++i) {
            if(pGaugeP = dynamic_cast<ZxDataGaugeP * >(m_listGaugeP[i])) {  // 拿到第一条压力数据
                break;
            }
        }

        // 遍历流量数据列表
        for(int i = 0; i < m_listGaugeF.size(); ++i) {
            if(pGaugeF = dynamic_cast<ZxDataGaugeF * >(m_listGaugeF[i])) { // 拿到第一条流量数据
                break;
            }
        }

        // 获取的压力、流量数据
        QVector<QPointF> vecPtsP, vecPtsF;
        vecPtsP.clear();
        vecPtsF.clear();
        // 临时存储x，y坐标
        VecDouble vecX, vecY;

        if(pGaugeP != nullptr) {
            // 获取压力数据
            if(pGaugeP->getDataVecXY(vecX, vecY, 0)) {
                for(int i = 0; i < vecX.size(); ++i) {
                    if(i < vecY.size()) {
                        QPointF pt(vecX[i], vecY[i]);
                        vecPtsP.append(pt);
                    }
                }
            }
        }

        if(pGaugeF != nullptr) {
            vecX.clear();
            vecY.clear();

            // 获取流量数据
            // 井别是流量大字段索引，单相井也不能固定读取默认的油相字段。
            if(pGaugeF->getDataVecXY(
                    vecX, vecY, static_cast<int>(eWellCategory))) {
                for(int i = 0; i < vecX.size(); ++i) {
                    if(i < vecY.size()) {
                        QPointF pt(vecX[i], vecY[i]);
                        vecPtsF.append(pt);
                    }
                }
            }
        }

        // 历史数据
        QVector<QVector<double>> vvecHistoryPressureData;
        QVector<QVector<double>> vvecHistoryLogData;
        QVector<QVector<double>> vvecHistorySemiLogData;

        if(ZxBaseUtil::isSameStr(wellClass, "VerticalWell")) {
            // 初始化直井默认参数
            nmDataWellBase* pWell = pDataManager->createWell(NM_WELL_MODEL::Vertical_Well);
            nmDataVerticalWell* m_VerticalWell = dynamic_cast<nmDataVerticalWell*>(pWell);

            if(m_VerticalWell == nullptr) {
                this->setPlotsByDataManger(pDataManager);
                return;
            }

            m_VerticalWell->setWellName(pWellData->getName());
            m_VerticalWell->setWellCode(pWellData->getCode());
            m_VerticalWell->setWellCategory(eWellCategory);
            nmDataAttribute tempAttr = m_VerticalWell->getX();
            tempAttr.setValue(pWellData->getLocationX());
            m_VerticalWell->setX(tempAttr);
            tempAttr = m_VerticalWell->getY();
            tempAttr.setValue(pWellData->getLocationY());
            m_VerticalWell->setY(tempAttr);
            tempAttr = m_VerticalWell->getRadius();
            tempAttr.setValue(pWellData->getWellRadius());
            m_VerticalWell->setRadius(tempAttr);

            // 设置井的压力数据、流量数据
            m_VerticalWell->setPressurePoints(vecPtsP);
            m_VerticalWell->setFlowPoints(vecPtsF);

            // TODO: 计算井的历史双对数/半对数数据
            pDataManager->calculationLogData(m_VerticalWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

            // 存储历史数据到井对象
            m_VerticalWell->setHistoryPressure(vvecHistoryPressureData);
            m_VerticalWell->setHistoryLogLog(vvecHistoryLogData);
            m_VerticalWell->setHistorySemiLog(vvecHistorySemiLogData);

            // 设置为当前查看的井
            pDataManager->setCurWellData(m_VerticalWell);
        } else if(ZxBaseUtil::isSameStr(wellClass, "VerticalFracturedWell")) {

            // 初始化垂直裂缝井默认参数
            nmDataWellBase* pWell = pDataManager->createWell(NM_WELL_MODEL::Vertical_Fractured_Well);
            nmDataVerticalFracturedWell* m_VFracturedWell = dynamic_cast<nmDataVerticalFracturedWell*>(pWell);

            if(m_VFracturedWell == nullptr) {
                this->setPlotsByDataManger(pDataManager);
                return;
            }

            m_VFracturedWell->setWellName(pWellData->getName());
            m_VFracturedWell->setWellCode(pWellData->getCode());
            m_VFracturedWell->setWellCategory(eWellCategory);
            nmDataAttribute tempAttr = m_VFracturedWell->getX();
            tempAttr.setValue(pWellData->getLocationX());
            m_VFracturedWell->setX(tempAttr);
            tempAttr = m_VFracturedWell->getY();
            tempAttr.setValue(pWellData->getLocationY());
            m_VFracturedWell->setY(tempAttr);
            tempAttr = m_VFracturedWell->getRadius();
            tempAttr.setValue(pWellData->getWellRadius());
            m_VFracturedWell->setRadius(tempAttr);

            // 设置井的压力数据、流量数据
            m_VFracturedWell->setPressurePoints(vecPtsP);
            m_VFracturedWell->setFlowPoints(vecPtsF);

            // TODO: 计算井的历史双对数/半对数数据
            pDataManager->calculationLogData(m_VFracturedWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

            // 存储历史数据到井对象
            m_VFracturedWell->setHistoryPressure(vvecHistoryPressureData);
            m_VFracturedWell->setHistoryLogLog(vvecHistoryLogData);
            m_VFracturedWell->setHistorySemiLog(vvecHistorySemiLogData);

            // 更新裂缝位置信息
            m_VFracturedWell->setFracs();

            // 设置为当前查看的井
            pDataManager->setCurWellData(m_VFracturedWell);
        } else if(ZxBaseUtil::isSameStr(wellClass, "HorizontalMultiFracturedWell")) {

            // 初始化多段压裂水平井默认参数
            nmDataWellBase* pWell = pDataManager->createWell(NM_WELL_MODEL::Horizontal_Fractured_Well);
            nmDataHorizontalFracturedWell* m_HFracturedWell = dynamic_cast<nmDataHorizontalFracturedWell*>(pWell);

            if(m_HFracturedWell == nullptr) {
                this->setPlotsByDataManger(pDataManager);
                return;
            }

            m_HFracturedWell->setWellName(pWellData->getName());
            m_HFracturedWell->setWellCode(pWellData->getCode());
            m_HFracturedWell->setWellCategory(eWellCategory);
            nmDataAttribute tempAttr = m_HFracturedWell->getX();
            tempAttr.setValue(pWellData->getLocationX());
            m_HFracturedWell->setX(tempAttr);
            tempAttr = m_HFracturedWell->getY();
            tempAttr.setValue(pWellData->getLocationY());
            m_HFracturedWell->setY(tempAttr);
            tempAttr = m_HFracturedWell->getRadius();
            tempAttr.setValue(pWellData->getWellRadius());
            m_HFracturedWell->setRadius(tempAttr);

            // 设置井的压力数据、流量数据
            m_HFracturedWell->setPressurePoints(vecPtsP);
            m_HFracturedWell->setFlowPoints(vecPtsF);

            // TODO: 计算井的历史双对数/半对数数据
            pDataManager->calculationLogData(m_HFracturedWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

            // 存储历史数据到井对象
            m_HFracturedWell->setHistoryPressure(vvecHistoryPressureData);
            m_HFracturedWell->setHistoryLogLog(vvecHistoryLogData);
            m_HFracturedWell->setHistorySemiLog(vvecHistorySemiLogData);

            // 计算裂缝数据
            m_HFracturedWell->setFracs();

            // 设置为当前查看的井
            pDataManager->setCurWellData(m_HFracturedWell);
        }

        // 重新获取添加后的井数据
        pDataManager->appendNmWellData(pDataManager->getCurWellData());
        vecWellDatas = pDataManager->getWellDataList();
    }

    // 极端兼容入口没有预先建立边界时，也按当前井位置创建一次性默认边界。
    if(pDataManager->getOutlineData() == nullptr) {
        pDataManager->createDefaultOutlineFromWells();
    }

    // 根据数据中心的数据渲染所有的图元，上面只是为了保证打开时有一口井和边界
    this->setPlotsByDataManger(pDataManager);
}

void nmGuiPlot::initAxisFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);
    // 0.坐标轴
    // 0.1 获取坐标轴数据，来自数据中心
    nmDataAxis* pAxisData = pDataManager->getAxisData();
    Q_ASSERT(nullptr !=  pAxisData);

    // 0.2 获取 X 最大值
    nmDataAttribute xMaxAttr = pAxisData->getXMax();
    double xMaxValue = xMaxAttr.getValue().toDouble();

    // 0.3 获取 Y 最大值
    nmDataAttribute yMaxAttr = pAxisData->getYMax();
    double yMaxValue = yMaxAttr.getValue().toDouble();

    // 0.4 获取 X 最小值
    nmDataAttribute xMinAttr = pAxisData->getXMin();
    double xMinValue = xMinAttr.getValue().toDouble();

    // 0.5 获取 Y 最小值
    nmDataAttribute yMinAttr = pAxisData->getYMin();
    double yMinValue = yMinAttr.getValue().toDouble();

    if(qIsFinite(xMinValue) && qIsFinite(xMaxValue) &&
       qIsFinite(yMinValue) && qIsFinite(yMaxValue) &&
       xMaxValue > xMinValue && yMaxValue > yMinValue) {
        applyAxisRange(xMinValue, xMaxValue, yMinValue, yMaxValue);
    } else {
        pAxisData->setInitialViewFitted(false);
    }

    connect(m_pPlot->getMainAxisX(), SIGNAL(sigRangeChanged(double, double, bool, bool)),
            this, SLOT(onRangeXChanged(double, double, bool, bool)),
            Qt::UniqueConnection);
    connect(m_pPlot->getMainAxisY(), SIGNAL(sigRangeChanged(double, double, bool, bool)),
            this, SLOT(onRangeYChanged(double, double, bool, bool)),
            Qt::UniqueConnection);
}

void nmGuiPlot::initBoundaryObjFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 1.边界
    // 1.1 获取边界数据，来自数据中心
    nmDataOutline* pOutlineData = pDataManager->getOutlineData();
    Q_ASSERT(nullptr !=  pOutlineData);

    if(pOutlineData == nullptr) {
        return;
    }

    // 1.2 获取边界位置
    QVector<QPointF> vecOutlinePoints = pOutlineData->getOutlinePoints();
    // 1.3 获取边界名称
    QString sOutlineName = pOutlineData->getName();
    // 1.4 转换坐标
    QVector<QPointF> vecConvertPoints = m_pPlot->getPosForValue(vecOutlinePoints);

    // 1.5 根据边界类型绘制不同类型的边界
    if(pOutlineData->getOutlineType() == NM_Data_Outline_Type::NM_Rect_Outline_Type) {
        // 矩形边界
        // 将当前矩形边界对象添加到地图
        nmObjRectOutline* pRectOutlinePlot = (nmObjRectOutline*)appendOneObj(NMOT_RectOutline, sOutlineName, vecConvertPoints);

        if(pRectOutlinePlot == nullptr) {
            return;
        }

        // 通过 Binder 绑定边界数据到图元对象
        m_pGraphicBinder->bindOutlineToGraphic(pRectOutlinePlot, pOutlineData);
    } else if(pOutlineData->getOutlineType() == NM_Data_Outline_Type::NM_Round_Outline_Type) {
        // 圆形边界
        // 将当前多边形边界对象添加到地图
        nmObjRoundOutline* pPRoundOutlinePlot = (nmObjRoundOutline*)appendOneObj(NMOT_RoundOutline, sOutlineName, vecConvertPoints);

        if(pPRoundOutlinePlot == nullptr) {
            return;
        }

        // 通过 Binder 绑定边界数据到图元对象
        m_pGraphicBinder->bindOutlineToGraphic(pPRoundOutlinePlot, pOutlineData);
    } else if(pOutlineData->getOutlineType() == NM_Data_Outline_Type::NM_Polygon_Outline_Type) {
        // 多边形边界
        // 将当前多边形边界对象添加到地图
        nmObjPolygonOutline* pPolygonOutlinePlot = (nmObjPolygonOutline*)appendOneObj(NMOT_PolygonOutline, sOutlineName, vecConvertPoints);

        if(pPolygonOutlinePlot == nullptr) {
            return;
        }

        // 通过 Binder 绑定边界数据到图元对象
        m_pGraphicBinder->bindOutlineToGraphic(pPolygonOutlinePlot, pOutlineData);
    }
}

void nmGuiPlot::initWellObjsFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 2.井
    // 2.1 获取井数据，来自数据中心
    QVector<nmDataWellBase*> vecWellDatas = pDataManager->getWellDataList();

    // 2.2 编辑井数组，获取具体的井数据
    for(int i = 0; i < vecWellDatas.size(); i++) {
        nmDataWellBase* pWellData = vecWellDatas[i];
        Q_ASSERT(nullptr !=  pWellData);

        if(pWellData == nullptr) {
            continue;
        }

        // 2.3 获取当前井坐标
        QPointF ptWell(pWellData->getX().getValue().toDouble(), pWellData->getY().getValue().toDouble());
        QVector<QPointF> vecPtWell;
        vecPtWell.append(ptWell);

        // 2.4 获取井名
        QString sCurWellName = pWellData->getWellName();
        // 2.5 构建井图元
        nmObjPointWell* pWellPlot = (nmObjPointWell*)appendOneObj(NMOT_Point_Well, sCurWellName, vecPtWell);

        if(pWellPlot == nullptr || zxCurProject == nullptr) {
            continue;
        }

        // 2.6 获取当前工区的所有井
        ZxDataObjectList wellList = zxCurProject->getChildren(iDataModelType::sTypeWell);

        // 2.7 遍历找到与当前井数据一致的井
        for(int i = 0; i < wellList.size(); i++) {
            ZxDataWell* pWellObj = (ZxDataWell*)wellList[i];

            if(pWellObj == nullptr) {
                continue;
            }

            if(_isSame(pWellObj->getName(), sCurWellName)) {
                // 设置图元的井数据
                pWellPlot->setWellData(pWellObj);
            }
        }

        // 2.8 移动到正确的位置
        pWellPlot->moveToPos(pWellPlot->getPosOf(pWellPlot->getAllPos()));
        // 2.9 通过 Binder 绑定井数据（推值 + 建立信号连接）
        if (m_pGraphicBinder) {
            m_pGraphicBinder->bindWellToGraphic(pWellPlot, pWellData);
        }
        pWellPlot->afterCreated();
    }
}

void nmGuiPlot::initFaultObjsFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 3.断层
    // 3.1 获取断层数据，来自数据中心
    QVector<nmDataFault*> vecFaultData = pDataManager->getFaultDataList();

    // 3.2 遍历断层数组的数据
    for(int i = 0; i < vecFaultData.size(); i++) {
        nmDataFault* pDataFault = vecFaultData[i];
        Q_ASSERT(nullptr !=  pDataFault);

        if(pDataFault == nullptr) {
            continue;
        }

        // 3.3 获取断层位置
        QVector<QPointF> vecFaultPoints = pDataFault->getFaultPoints();
        // 3.4 获取断层名称
        QString sFaultName = pDataFault->getFaultName();
        // 3.5 转换坐标
        QVector<QPointF> vecConvertPoints = m_pPlot->getPosForValue(vecFaultPoints);

        // 3.6 将当前断层对象添加到地图
        nmObjLineFault* pFaultPlot = (nmObjLineFault*)appendOneObj(NMOT_Line_Fault, sFaultName, vecConvertPoints);

        if(pFaultPlot == nullptr) {
            continue;
        }

        // 3.7 通过 Binder 绑定数据（推值 + 建立信号连接）
        m_pGraphicBinder->bindFaultToGraphic(pFaultPlot, pDataFault);

        // TODO: 设置断层其他属性
    }
}

void nmGuiPlot::initFractureObjsFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 4.裂缝
    // 4.1 获取裂缝数据，来自数据中心
    QVector<nmDataFracture*> vecFractureData = pDataManager->getFractureDataList();

    // 4.2 遍历裂缝数组的数据
    for(int i = 0; i < vecFractureData.size(); i++) {
        nmDataFracture* pDataFracture = vecFractureData[i];
        Q_ASSERT(nullptr !=  pDataFracture);

        if(pDataFracture == nullptr) {
            continue;
        }

        // 4.3 获取裂缝位置
        QVector<QPointF> vecFracturePoints = pDataFracture->getFracturePoints();
        // 4.4 获取裂缝名称
        QString sFractureName = pDataFracture->getFractureName();
        // 4.5 转换坐标
        QVector<QPointF> vecConvertPoints = m_pPlot->getPosForValue(vecFracturePoints);

        // 4.6 将当前裂缝对象添加到地图
        nmObjLineCrack* pFracturePlot = (nmObjLineCrack*)appendOneObj(NMOT_Line_Fracture, sFractureName, vecConvertPoints);

        if(pFracturePlot == nullptr) {
            continue;
        }

        // 4.7 通过 Binder 绑定数据（推值 + 建立信号连接）
        m_pGraphicBinder->bindCrackToGraphic(pFracturePlot, pDataFracture);

        // TODO: 设置裂缝其他属性
    }
}

void nmGuiPlot::initRegionObjsFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 5.区域
    // 5.1 获取区域数据，来自数据中心
    QVector<nmDataRegion*> vecRegionData = pDataManager->getRegionDataList();

    // 5.2 遍历区域数组的数据
    for(int i = 0; i < vecRegionData.size(); i++) {
        nmDataRegion* pDataRegion = vecRegionData[i];
        Q_ASSERT(nullptr !=  pDataRegion);

        if(pDataRegion == nullptr) {
            continue;
        }

        // 5.3 获取区域位置
        QVector<QPointF> vecRegionPoints = pDataRegion->getVecPts();
        // 5.4 获取区域名称
        QString sRegionName = pDataRegion->getRegoinName();
        // 5.5 转换坐标
        QVector<QPointF> vecConvertPoints = m_pPlot->getPosForValue(vecRegionPoints);

        // 5.6 将当前区域对象添加到地图
        nmObjRegion* pRegionPlot = (nmObjRegion*)appendOneObj(NMOT_Region, sRegionName, vecConvertPoints);

        if(pRegionPlot == nullptr) {
            continue;
        }

        // 5.7 通过 Binder 绑定区域数据到图元
        if (m_pGraphicBinder) {
            m_pGraphicBinder->bindRegionToGraphic(pRegionPlot, pDataRegion);
        }
    }
}

void nmGuiPlot::initRegionMarkObjsFromData(nmDataAnalyzeManager* pDataManager)
{
    Q_ASSERT(nullptr !=  pDataManager);

    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 6.区域标记
    // 6.1 获取区域标记数据，来自数据中心
    QVector<nmDataRegionMark*> vecRegionMarkData = pDataManager->getRegionMarkDataList();

    // 6.2 遍历区域标记数组的数据
    for(int i = 0; i < vecRegionMarkData.size(); i++) {
        nmDataRegionMark* pDataRegionMark = vecRegionMarkData[i];
        Q_ASSERT(nullptr != pDataRegionMark);

        if(pDataRegionMark == nullptr) {
            continue;
        }

        // 6.3 获取区域标记位置
        QPointF ptRegionMark = pDataRegionMark->getPtPos();
        QVector<QPointF> vecPtRegionMark;
        vecPtRegionMark.append(ptRegionMark);
        // 6.4 获取区域标记名称
        QString sRegionMarkName = pDataRegionMark->getRegionMarkName();
        // 6.5 转换坐标
        QVector<QPointF> vecConvertPoints = m_pPlot->getPosForValue(vecPtRegionMark);

        // 6.6 将当前区域标记对象添加到地图
        nmObjRegionMark* pRegionMarkPlot = (nmObjRegionMark*)appendOneObj(NMOT_RegionMark, sRegionMarkName, vecConvertPoints);

        if(pRegionMarkPlot == nullptr) {
            continue;
        }

        // 6.7 通过 Binder 绑定区域标记数据到图元
        if (m_pGraphicBinder) {
            m_pGraphicBinder->bindRegionMarkToGraphic(pRegionMarkPlot, pDataRegionMark);
        }
    }
}

void nmGuiPlot::deleteAllPlotObjs()
{
    if(m_pPlot == nullptr) {
        return;
    }

    // 这里只清理显示对象，不能调用removeData()删除DataManager中的业务数据。
    // 先解除全部绑定，再倒序删除图元，避免重名对象残留或Binder保存悬空指针。
    if(m_pGraphicBinder != nullptr) {
        m_pGraphicBinder->updateDataMgr(dataManager());
    }
    for(int nIndex = m_pPlot->getObjCount() - 1; nIndex >= 0; --nIndex) {
        m_pPlot->removeObjByIndex(nIndex);
    }
}

nmObjBase* nmGuiPlot::appendOneObj(NM_Obj_Type o, QString& sName, QVector<QPointF>& vec)
{
    nmObjBase* pObj = _createOneObj(o, sName);

    if(NULL == pObj) {
        return NULL;
    }

    pObj->setAllPos(vec);
    //pObj->select(true);
    //pObj->dealSelChanged(true);
    pObj->update();

    // 当对象创建完成之后，进行的操作，如改变按钮Check的状态
    //emit sigObjCompleted(pObj); //通常有Plot触发，而非iGuiPlot
    // 所以直接用 slotObjCompleted
    slotObjCompleted(pObj);

    setModified(true);

    return pObj;
}

nmObjBase* nmGuiPlot::_createOneObj(NM_Obj_Type o, QString& sName)
{
    Q_ASSERT(NULL != m_pPlot);

    // 确保名称不重复
    QStringList listOlds;

    for(int i = 0; i < m_pPlot->getObjCount(); i++) {
        listOlds << m_pPlot->getObjByIndex(i)->getName();
    }

    sName = ZxBaseUtil::getNextOneName(listOlds, sName);

    // 创建，此处代码为了简洁，作了非规范性书写
    nmObjBase* pObj = NULL;

    if(o == NMOT_Point) {
        pObj = new nmObjPoint(sName, NULL, NULL);
    } else if(o == NMOT_Point_Well) {
        pObj = new nmObjPointWell(sName, NULL, NULL);
    } else if(o == NMOT_Line) {
        pObj = new nmObjLine(sName, NULL, NULL);
    } else if(o == NMOT_Polygon) {
        pObj = new nmObjPolygon(sName, NULL, NULL);
    } else if(o == NMOT_PolygonOutline) {
        pObj = new nmObjPolygonOutline(sName, NULL, NULL);
    } else if(o == NMOT_Rect) {    //矩形
        pObj = new nmObjRect(sName, NULL, NULL);
    } else if(o == NMOT_RectOutline) {    //矩形边界
        pObj = new nmObjRectOutline(sName, NULL, NULL);
    } else if(o == NMOT_Round) {    //圆形
        pObj = new nmObjRound(sName, NULL, NULL);
    } else if(o == NMOT_RoundOutline) {    //圆形边界
        pObj = new nmObjRoundOutline(sName, NULL, NULL);
    } else if(o == NMOT_Line_Fracture) {
        pObj = new nmObjLineCrack(sName, NULL, NULL);
    } else if(o == NMOT_Line_Fault) {
        pObj = new nmObjLineFault(sName, NULL, NULL);
    } else if(o == NMOT_Region) {
        pObj = new nmObjRegion(sName, NULL, NULL);
    } else if(o == NMOT_Line_MeasuringScale) {
        pObj = new nmObjLineMeasuringScale(sName, NULL, NULL);
    } else if(o == NMOT_Line_Measure) {
        pObj = new nmObjLineMeasure(sName, NULL, NULL);
    } else if(o == NMOT_RegionMark) {
        pObj = new nmObjRegionMark(sName, NULL, NULL, m_iRegionMarkCount);
        m_iRegionMarkCount++;
    } else {
        qDebug() << tr("Type '%1' not supported.").arg((int)o);
        nmDataLogFile::getInstance()->writeLog(tr("Type '%1' not supported.").arg((int)o));
        return NULL;
    }

    Q_ASSERT(NULL != pObj);
    bindObjSignals(pObj);

    m_pPlot->addOneObj(pObj);

    // 将边界置于最底层
    if(o == NMOT_RectOutline || o == NMOT_PolygonOutline || o == NMOT_RoundOutline) {
        //m_pPlot->sendToBack(pObj);
    }

    return pObj;
}

void nmGuiPlot::bindObjSignals(ZxObjBase* pObj)
{
    Q_ASSERT(NULL != pObj);

    disconnect(pObj, SIGNAL(sigObjSelectionChanged(bool)), \
               this, SLOT(slotObjSelChanged(bool)));
    disconnect(pObj, SIGNAL(sigPtsChanged()), \
               this, SLOT(slotObjPtsChanged()));
    connect(pObj, SIGNAL(sigObjSelectionChanged(bool)), \
            this, SLOT(slotObjSelChanged(bool)));
    connect(pObj, SIGNAL(sigPtsChanged()), \
            this, SLOT(slotObjPtsChanged()));
}

// Obj选择状态改变
void nmGuiPlot::slotObjSelChanged(bool b)
{
    ZxObjBase* p = dynamic_cast<ZxObjBase*>(sender());

    if(NULL != p) {
        emit sigObjSelChanged(p, b);
    }
}

// Obj数据发生了改变
void nmGuiPlot::slotObjPtsChanged()
{
    ZxObjBase* p = dynamic_cast<ZxObjBase*>(sender());

    if(NULL != p) {
        emit sigObjPtsChanged(p);
    }
}

void nmGuiPlot::slotDeleteWell(QString wellID)
{
    nmDataLogFile::getInstance()->writeLog(wellID + " ========");
    // 找到要删除的图片
    nmObjPointWell* obj = (nmObjPointWell*)this->getWellObjById(wellID);

    if(obj == nullptr || m_pPlot == nullptr) {
        return;
    }

    // 创建分析时绑定的主井是流动段及数值输入基准，不能从数值 Map 单独删除。
    if(m_pGraphicBinder && m_pGraphicBinder->isPrimaryWellGraphic(obj)) {
        QMessageBox::information(this,
                                 tr("Cannot Delete Well"),
                                 tr("The primary analysis well cannot be deleted."));
        return;
    }

    //    // 创建一个QTimer对象
    //    QTimer* timer = new QTimer();
    //    // 创建一个要执行的单次任务
    //    QObject::connect(timer, &QTimer::timeout, []() {
    //        // 这里是你想要延迟执行的代码
    //        qDebug() << "任务执行了！";
    //    });
    //    // 设置延迟时间（单位毫秒）
    //    int delay = 2000; // 例如2000毫秒（2秒）
    //    timer->setSingleShot(true); // 设置为单次触发
    //    timer->start(delay); // 开始计时，时间到后执行timeout信号关联的任务
    // 删除结构树里的对象
    if(zxCurProject != nullptr && obj->getWellData() != nullptr) {
        zxCurProject->removeChild(obj->getWellData());
    }

    // 删除图元
    m_pPlot->removeObjByName(obj->getName());
}

void nmGuiPlot::onSerialize(ZxSerializer* ser)
{
    iGuiPlot::onSerialize(ser);
}

void nmGuiPlot::onDeserialize(ZxSerializer* ser)
{
    iGuiPlot::onDeserialize(ser);
}

void nmGuiPlot::resetAfterDeserialized()
{
    iGuiPlot::resetAfterDeserialized();

    if(NULL == m_pPlot) {
        return;
    }

    connectSignals();
    slotChangeSizeWithChangedXY();
    setModified(false);

    for(int i = 0; i < m_pPlot->getObjCount(); i++) {
        nmObjBase* pObj = (nmObjBase*)m_pPlot->getObjByIndex(i);

        if(NULL != pObj) {
            // 建立信号
            bindObjSignals(pObj);
        }
    }
}

QVector<ZxObjBase*> nmGuiPlot::getObjsByTag(QString objTag)
{
    QVector<ZxObjBase*> pObjVec;

    if(m_pPlot == nullptr) {
        return pObjVec;
    }

    int objCount = m_pPlot->getObjCount();

    for(int i = 0; i < objCount; i++) {
        ZxObjBase* obj = m_pPlot->getObjByIndex(i);

        if(obj != nullptr && _isSame(objTag, obj->getTagName())) {
            pObjVec.append(obj);
        }
    }

    return pObjVec;
}

ZxObjBase* nmGuiPlot::getWellObjById(QString id)
{
    int objCount = m_pPlot->getObjCount();

    for(int i = 0; i < objCount; i++) {
        ZxObjBase* obj = m_pPlot->getObjByIndex(i);
        nmDataLogFile::getInstance()->writeLog(QString::fromStdString(obj->getTagName()) + " ======");

        if(_isSame("nObjPointWell", obj->getTagName())) {
            nmObjPointWell* pWellPlot = dynamic_cast<nmObjPointWell*>(obj);

            if(pWellPlot == nullptr) {
                continue;
            }

            if(_isSame(id, pWellPlot->getWellID())) {
                return pWellPlot;
            }
        }
    }

    return NULL;
}

QVector<QPointF> nmGuiPlot::getOutlinePoints()
{
    QVector<QPointF> pointList;
    // 获取边界的所有点
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjPolygonOutline");

    // 如果是多边形边界
    if(objList.count() > 0) {
        ZxObjBase* outlineObj = objList[0];
        return outlineObj->getValueOf(outlineObj->getAllPos());
    }

    // 获取边界的所有点
    objList = this->getObjsByTag("nObjRectOutline");

    // 如果是多边形边界
    if(objList.count() > 0) {
        ZxObjBase* outlineObj = objList[0];
        return outlineObj->getValueOf(outlineObj->getAllPos());
    }

    // TODO,需要支持圆形边界

    return pointList;
}

QVector<QVector<double >> nmGuiPlot::getWellsInformation()
{
    QVector<QVector<double >> wellsList;
    // 获取边界的所有点
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjPointWell");

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            nmObjPointWell* pWell = (nmObjPointWell*)objList[i];
            QVector<double> wellInfo = pWell->getWellInformation();

            if(wellInfo.count() == 3) {
                wellsList.append(wellInfo);
            }
        }
    }

    return wellsList;
}

QVector<QVector<QPointF> > nmGuiPlot::getCracksInformation()
{
    QVector<QVector<QPointF >> vCracks;
    // 获取裂缝的所有点
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjLineFracture");

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            nmObjLineCrack* pCrack = (nmObjLineCrack*)objList[i];
            vCracks.append(pCrack->getValueOf(pCrack->getAllPos()));
        }
    }

    return vCracks;
}

QVector<QVector<QPointF> > nmGuiPlot::getFaultsInformation()
{
    QVector<QVector<QPointF >> vFaults;
    // 获取裂缝的所有点
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjLineFault");

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            nmObjLineFault* pFault = (nmObjLineFault*)objList[i];
            vFaults.append(pFault->getValueOf(pFault->getAllPos()));
        }
    }

    return vFaults;
}

QVector<QVector<QPointF>> nmGuiPlot::getRegionsInformation()
{
    QVector<QVector<QPointF >> vRegions;
    // 获取裂缝的所有点
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjRegion");

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            nmObjRegion* pRegion = (nmObjRegion*)objList[i];
            QVector<QPointF> vPos = pRegion->getAllPos();

            for(size_t j = 0; j < vPos.size(); j++) {
                QPointF& p = vPos[j];
                qDebug() << QString("%1,%2").arg(p.x()).arg(p.y());
            }

            vRegions.append(pRegion->getValueOf(pRegion->getAllPos()));
        }
    }

    return vRegions;
}

QVector<nmObjPointWell*> nmGuiPlot::getWellPlots()
{
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjPointWell");
    QVector<nmObjPointWell*> wellPlots;

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            wellPlots.append((nmObjPointWell*) objList[i]);
        }
    }

    return wellPlots;
}

QVector<ZxDataWell*> nmGuiPlot::getWellDatas()
{
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjPointWell");
    QVector<ZxDataWell*> wellDatas;

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            wellDatas.append(((nmObjPointWell*) objList[i])->getWellData());
        }
    }

    return wellDatas;
}

QStringList nmGuiPlot::getWellNames()
{
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjPointWell");
    QStringList wellNames;

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            wellNames.append(((nmObjPointWell*) objList[i])->getWellData()->getName());
        }
    }

    return wellNames;
}

QVector<nmObjBase*> nmGuiPlot::getAllPlots()
{
    QVector<nmObjBase*> pObjVec;
    int objCount = m_pPlot->getObjCount();

    for(int i = 0; i < objCount; i++) {
        ZxObjBase* obj = m_pPlot->getObjByIndex(i);
        pObjVec.append(static_cast<nmObjBase*>(obj));
    }

    return pObjVec;
}

void nmGuiPlot::paintEvent(QPaintEvent* e)
{
    iGuiPlot::paintEvent(e);
}

#ifdef QT_DEBUG

ZxObjBase* nmGuiPlot::updatePlotObjBy(QString sName, \
                                      VecDouble& vecX, VecDouble& vecY, \
                                      bool bPressureLike /*= true*/, \
                                      bool bUseY2 /*= false*/, \
                                      bool bClearAll /*= false*/)
{
    if(vecX.count() < 2 || vecX.count() != vecY.count()) {
        return NULL;
    }

    ZxPlot* pPlot = m_pPlot;
    Q_ASSERT(NULL != pPlot);

    // 移除先前图上已经有的曲线
    int n = pPlot->getObjCount();

    for(int i = n - 1; i >= 0; i--) {
        ZxObjBase* pObj = pPlot->getObjByIndex(i);

        if(NULL == pObj) {
            continue;
        }

        if(bClearAll) {
            pPlot->removeObjByIndex(i);
        } else if(_isSame(sName, pObj->getName())) {
            pPlot->removeObjByIndex(i);
            break;
        }
    }

    ZxObjCurve* pObj = NULL;

    if(bPressureLike) {
        pObj = appendSeriesP(vecX, vecY, sName, bUseY2);
    } else {
        pObj = appendSeriesF(vecX, vecY, sName, bUseY2);
    }

    if(NULL != pObj) {
        setPenAndDot(pObj, !bPressureLike, !bPressureLike);

        bindObjSignals(pObj);
    }

    return pObj;
}

#endif

void nmGuiPlot::slotMeasuringScale(QPointF pStart, QPointF pEnd, void* obj)
{
    // 弹出dialog，1、显示 X、Y坐标；2、设置，长度和单位
    double dLength = 0;
    nmPlotDialogContextProvider* pDialogProvider = nmPlotDialogContext::provider();

    if(pDialogProvider != nullptr && pDialogProvider->execMeasuringScaleDialog(pStart, pEnd, &dLength)) {
        if(m_pPlot == nullptr) {
            return;
        }

        ZxSubAxisX* pAxisX = m_pPlot->getMainAxisX();
        ZxSubAxisY* pAxisY = m_pPlot->getMainAxisY();

        if(pAxisX == nullptr || pAxisY == nullptr) {
            return;
        }

        // 计算原始长度
        double dOriLength = sqrt((pStart.x() - pEnd.x()) * (pStart.x() - pEnd.x()) + (pStart.y() - pEnd.y()) *
                                 (pStart.y() - pEnd.y()));
        qDebug() << dOriLength;
        qDebug() << dLength;
        // 根据比例来进行调整整个画布的尺寸
        // 先获取当前的X 和 Y的尺寸
        double dXMin = pAxisX->getRangeMin();
        double dXMax = pAxisX->getRangeMax();
        double dYMin = pAxisY->getRangeMin();
        double dYMax = pAxisY->getRangeMax();
        // 根据给的参数进行比例的计算
        double dScale = dLength / dOriLength;
        double dXRangeScaled = (dXMax - dXMin) * dScale;
        double dYRangeScaled = (dYMax - dYMin) * dScale;
        double dXMaxScaled = dXRangeScaled - dXMin;

        double dYMaxScaled = dYRangeScaled - dYMin;
        // 根据比例，计算得到新的X和Y
        // 设置新的X 和 Y
        // 设置默认的X和Y坐标
        //m_pPlot->getMainAxisX()->setRangeMin(0);
        m_pPlot->getMainAxisX()->setRangeMax(dXMaxScaled);
        //m_pPlot->getMainAxisY()->setRangeMin(0);
        m_pPlot->getMainAxisY()->setRangeMax(dYMaxScaled);
    }

    // 将比例尺对象删除
    nmObjLineMeasuringScale* pScaleObj = (nmObjLineMeasuringScale*)obj;
    //pScaleObj->getAllValues()
    Q_ASSERT(nullptr !=  obj);
    // 删除图元
    m_pPlot->removeObjByName(pScaleObj->getName());
}

void nmGuiPlot::deleteMeasureObjects()
{
    QVector<ZxObjBase*> measureObjs = getObjsByTag("nObjLineMeasure");

    for(int i = 0; i < measureObjs.count(); i++) {
        if(measureObjs[i] != nullptr) {
            nmObjLineMeasure* pMeasure = dynamic_cast<nmObjLineMeasure*>(measureObjs[i]);
            if(pMeasure) {
                pMeasure->removeData();
            }
            m_pPlot->removeObjByName(measureObjs[i]->getName());
        }
    }

    // 清空数据对象
    nmDataAnalyzeManager::getCurrentInstance()->removeMeasureData();

    // 恢复画布可编辑状态
    setAllPlotObjectsEditable(true);
}

void nmGuiPlot::clearPreviousMeasure()
{
    QVector<ZxObjBase*> measureObjs = getObjsByTag("nObjLineMeasure");

    for(int i = 0; i < measureObjs.count(); i++) {
        if(measureObjs[i] != nullptr) {
            nmObjLineMeasure* pMeasure = dynamic_cast<nmObjLineMeasure*>(measureObjs[i]);
            if(pMeasure) {
                pMeasure->removeData();
            }
            m_pPlot->removeObjByName(measureObjs[i]->getName());
        }
    }

    nmDataMeasure* data = nmDataAnalyzeManager::getCurrentInstance()->getMeasureData();

    if(data) {
        data->setStartPoint(QPointF(0, 0));
        data->setEndPoint(QPointF(0, 0));
        data->setCurrentPoint(QPointF(0, 0));
        nmDataAttribute lenAttr = data->getLength();
        lenAttr.setValue(0.0);
        data->setLength(lenAttr);
    }
}

void nmGuiPlot::setAllPlotObjectsEditable(bool editable)
{
    if(m_pPlot == nullptr) {
        return;
    }

    int objCount = m_pPlot->getObjCount();

    for(int i = 0; i < objCount; i++) {
        ZxObjBase* obj = m_pPlot->getObjByIndex(i);

        if(obj == nullptr) {
            continue;
        }

        obj->setReadOnly(!editable);
        obj->setLockPos(!editable);
    }
}

void nmGuiPlot::bindPointerPosDialog(QWidget* pointerPosDlg)
{
    if(pointerPosDlg == nullptr || m_pPlotView == nullptr) {
        return;
    }

    disconnect(m_pPlotView, SIGNAL(sigPointerPos(double, double)), pointerPosDlg, SLOT(setPointerPos(double, double)));
    connect(m_pPlotView, SIGNAL(sigPointerPos(double, double)), pointerPosDlg, SLOT(setPointerPos(double, double)));
}

void nmGuiPlot::slotDeleteOneObj(QString sName, void* obj)
{
    if(m_pPlot == nullptr) {
        return;
    }

    if(sName != NULL) {
        // 删除前先校验目标对象。
        // 如果目标不存在，或目标井是固定主分析井，则结束删除工具并直接返回。
        // 预检必须发生在确认对话框和图元删除前，避免数据层拒绝后只剩半套状态。
        nmObjDeleteTool* pDeleteTool = static_cast<nmObjDeleteTool*>(obj);
        nmObjBase* nmObj = dynamic_cast<nmObjBase*>(m_pPlot->getObjByName(sName));

        if(nmObj == nullptr) {
            if(pDeleteTool) {
                m_pPlot->removeTools(pDeleteTool);
            }
            return;
        }

        if(nmObjPointWell* pWellObj = dynamic_cast<nmObjPointWell*>(nmObj)) {
            if(m_pGraphicBinder && m_pGraphicBinder->isPrimaryWellGraphic(pWellObj)) {
                if(pDeleteTool) {
                    m_pPlot->removeTools(pDeleteTool);
                }
                QMessageBox::information(
                        this,
                        tr("Cannot Delete Well"),
                        tr("The primary analysis well cannot be deleted."));
                return;
            }
        }

        nmPlotDialogContextProvider* pDialogProvider = nmPlotDialogContext::provider();

        if(pDialogProvider != nullptr && pDialogProvider->confirmDeleteObject()) {
            nmObjDeleteTool* pDeleteTool = static_cast<nmObjDeleteTool*>(obj);

            if(pDeleteTool) {  // 确保 obj 不是空指针
                m_pPlot->removeTools(pDeleteTool);

                //ZxObjBase* obj = m_pPlot->getObjByName(sName);
                nmObjBase* nmObj = dynamic_cast<nmObjBase*>(m_pPlot->getObjByName(sName));

                if(nmObj) {
                    m_pPlot->removeObjByName(sName);
                    // 先通过 Binder 清理数据绑定（如果是断层/裂缝/边界等 Binder 管理的类型）
                    if (nmObjLineFault* pFault = dynamic_cast<nmObjLineFault*>(nmObj)) {
                        m_pGraphicBinder->removeFaultBinding(pFault);
                    } else if (nmObjLineCrack* pCrack = dynamic_cast<nmObjLineCrack*>(nmObj)) {
                        m_pGraphicBinder->removeCrackBinding(pCrack);
                    } else if (dynamic_cast<nmObjRoundOutline*>(nmObj) ||
                               dynamic_cast<nmObjRectOutline*>(nmObj) ||
                               dynamic_cast<nmObjPolygonOutline*>(nmObj)) {
                        m_pGraphicBinder->removeOutlineBinding(nmObj);
                    } else if (nmObjLineMeasure* pMeasure = dynamic_cast<nmObjLineMeasure*>(nmObj)) {
                        m_pGraphicBinder->removeMeasureBinding(pMeasure);
                    } else if (nmObjRegionMark* pRegionMark = dynamic_cast<nmObjRegionMark*>(nmObj)) {
                        m_pGraphicBinder->removeRegionMarkBinding(pRegionMark);
                    } else if (nmObjRegion* pRegion = dynamic_cast<nmObjRegion*>(nmObj)) {
                        m_pGraphicBinder->removeRegionBinding(pRegion);
                    } else {
                        // 其他类型回退到旧方式
                        nmObj->removeData();
                    }
                }
            }
        } else {
            nmObjDeleteTool* pDeleteTool = static_cast<nmObjDeleteTool*>(obj);

            if(pDeleteTool) {  // 确保 obj 不是空指针
                m_pPlot->removeTools(pDeleteTool);
            }
        }
    }
}

void nmGuiPlot::clearPlotsSelectStates()
{
    // 获取所有图元
    QVector<nmObjBase*> vecObjs = this->getAllPlots();

    // 遍历所有图元对象，如果为选中状态，则恢复为未选中
    foreach(nmObjBase* obj, vecObjs) {
        if(obj->isSelected()) {
            obj->setSelected(false);
        }
    }
}

void nmGuiPlot::deleteAllDFNPlots()
{
    QVector<ZxObjBase*> objList = this->getObjsByTag("nObjLineFracture");

    if(objList.count() > 0) {
        for(int i = 0; i < objList.count() ; i++) {
            nmObjLineCrack* pCrack = (nmObjLineCrack*)objList[i];

            if(pCrack == nullptr || m_pGraphicBinder == nullptr) {
                continue;
            }

            nmDataFracture* pData = m_pGraphicBinder->getCrackDataFor(pCrack);
            if(pData == nullptr) {
                continue;
            }

            if(pData->getFractureType().getValue() == tr("DFN")) {
                // 通过 Binder 清理数据绑定
                m_pGraphicBinder->removeCrackBinding(pCrack);
                // 删除DFN图元
                m_pPlot->removeObjByName(pCrack->getName());
            }
        }
    }
}

nmDataAnalyzeManager* nmGuiPlot::dataManager() const
{
    return m_pDataManager != nullptr
            ? m_pDataManager
            : nmDataAnalyzeManager::getCurrentInstance();
}

bool nmGuiPlot::calculateVisibleContentBounds(QRectF& oBounds) const
{
    nmDataAnalyzeManager* pDataManager = dataManager();
    if(pDataManager == nullptr) {
        return false;
    }

    bool bHasBounds = false;
    double dMinX = 0.0;
    double dMaxX = 0.0;
    double dMinY = 0.0;
    double dMaxY = 0.0;

    nmDataOutline* pOutlineData = pDataManager->getOutlineData();
    if(pOutlineData != nullptr && pOutlineData->getPlotVisible()) {
        if(pOutlineData->getOutlineType() == NM_Round_Outline_Type) {
            const QPointF oCenter = pOutlineData->getCenter();
            const double dRadius = qAbs(pOutlineData->getRadius());
            includeMapPoint(QPointF(oCenter.x() - dRadius,
                                    oCenter.y() - dRadius),
                            bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
            includeMapPoint(QPointF(oCenter.x() + dRadius,
                                    oCenter.y() + dRadius),
                            bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        } else {
            includeMapPoints(pOutlineData->getOutlinePoints(),
                             bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    const QVector<nmDataWellBase*> vecWells = pDataManager->getWellDataList();
    foreach(nmDataWellBase* pWellData, vecWells) {
        if(pWellData != nullptr && pWellData->getPlotVisible()) {
            includeMapPoint(QPointF(
                    pWellData->getX().getValue().toDouble(),
                    pWellData->getY().getValue().toDouble()),
                    bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    const QVector<nmDataFault*> vecFaults = pDataManager->getFaultDataList();
    foreach(nmDataFault* pFaultData, vecFaults) {
        if(pFaultData != nullptr && pFaultData->getPlotVisible()) {
            includeMapPoints(pFaultData->getFaultPoints(),
                             bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    const QVector<nmDataFracture*> vecFractures =
            pDataManager->getFractureDataList();
    foreach(nmDataFracture* pFractureData, vecFractures) {
        if(pFractureData != nullptr && pFractureData->getPlotVisible()) {
            includeMapPoints(pFractureData->getFracturePoints(),
                             bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    const QVector<nmDataRegion*> vecRegions = pDataManager->getRegionDataList();
    foreach(nmDataRegion* pRegionData, vecRegions) {
        if(pRegionData != nullptr && pRegionData->getPlotVisible()) {
            includeMapPoints(pRegionData->getVecPts(),
                             bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    const QVector<nmDataRegionMark*> vecRegionMarks =
            pDataManager->getRegionMarkDataList();
    foreach(nmDataRegionMark* pRegionMarkData, vecRegionMarks) {
        if(pRegionMarkData != nullptr && pRegionMarkData->getPlotVisible()) {
            includeMapPoint(pRegionMarkData->getPtPos(),
                            bHasBounds, dMinX, dMaxX, dMinY, dMaxY);
        }
    }

    if(!bHasBounds) {
        return false;
    }

    oBounds = QRectF(QPointF(dMinX, dMinY),
                     QPointF(dMaxX, dMaxY)).normalized();
    return true;
}

void nmGuiPlot::applyAxisRange(double dXMin, double dXMax,
                               double dYMin, double dYMax)
{
    if(m_pPlot == nullptr ||
       !qIsFinite(dXMin) || !qIsFinite(dXMax) ||
       !qIsFinite(dYMin) || !qIsFinite(dYMax) ||
       dXMax <= dXMin || dYMax <= dYMin) {
        return;
    }

    const bool bOldApplying = m_bApplyingAxisRange;
    m_bApplyingAxisRange = true;
    m_pPlot->getMainAxisX()->setRangeMinMax(dXMin, dXMax, true, false);
    m_pPlot->getMainAxisY()->setRangeMinMax(dYMin, dYMax, true, false);

    nmDataAnalyzeManager* pDataManager = dataManager();
    nmDataAxis* pAxisData = pDataManager != nullptr
            ? pDataManager->getAxisData() : nullptr;
    if(pAxisData != nullptr) {
        pAxisData->getXMin().setValue(dXMin);
        pAxisData->getXMax().setValue(dXMax);
        pAxisData->getYMin().setValue(dYMin);
        pAxisData->getYMax().setValue(dYMax);
    }
    m_bApplyingAxisRange = bOldApplying;
}

bool nmGuiPlot::fitInitialAxisToContent()
{
    if(m_pPlot == nullptr) {
        return false;
    }

    QRectF oBounds;
    if(!calculateVisibleContentBounds(oBounds)) {
        return false;
    }

    QRectF oPlotRect = m_pPlot->getInnerRectF();
    if(oPlotRect.width() <= 0.0 || oPlotRect.height() <= 0.0) {
        return false;
    }

    double dCenterX = (oBounds.left() + oBounds.right()) * 0.5;
    double dCenterY = (oBounds.top() + oBounds.bottom()) * 0.5;
    double dRangeX = oBounds.width();
    double dRangeY = oBounds.height();

    // 退化为点或直线时补足基础跨度，避免产生零范围坐标轴。
    if(dRangeX <= 0.0) {
        dRangeX = 1500.0;
    }
    if(dRangeY <= 0.0) {
        dRangeY = 1500.0;
    }

    // 内容四周各增加最大边长的 5%，边界本身不因此发生变化。
    const double dPadding = qMax(dRangeX, dRangeY) * 0.05;
    dRangeX += dPadding * 2.0;
    dRangeY += dPadding * 2.0;

    const double dViewRatio = oPlotRect.width() / oPlotRect.height();
    const double dContentRatio = dRangeX / dRangeY;
    if(dContentRatio < dViewRatio) {
        dRangeX = dRangeY * dViewRatio;
    } else {
        dRangeY = dRangeX / dViewRatio;
    }

    applyAxisRange(dCenterX - dRangeX * 0.5,
                   dCenterX + dRangeX * 0.5,
                   dCenterY - dRangeY * 0.5,
                   dCenterY + dRangeY * 0.5);
    return true;
}

void nmGuiPlot::scheduleInitialAxisView()
{
    if(m_bAxisInitializationPending) {
        return;
    }

    m_bAxisInitializationPending = true;
    QTimer::singleShot(0, this, SLOT(initializeAxisView()));
}

void nmGuiPlot::initializeAxisView()
{
    m_bAxisInitializationPending = false;
    nmDataAnalyzeManager* pDataManager = dataManager();
    nmDataAxis* pAxisData = pDataManager != nullptr
            ? pDataManager->getAxisData() : nullptr;
    if(pAxisData == nullptr || pAxisData->isInitialViewFitted()) {
        return;
    }

    // 只有真实绘图区和图元均准备好后才封闭初始化，失败时等待下一次显示尺寸变化。
    if(fitInitialAxisToContent()) {
        pAxisData->setInitialViewFitted(true);
    }
}

void nmGuiPlot::resizeEvent(QResizeEvent* pEvent)
{
	nmDataAnalyzeManager* pDataManager = dataManager();
	nmDataAxis* pAxisData = pDataManager != nullptr
			? pDataManager->getAxisData() : nullptr;
	const bool bWaitingForInitialView =
			pAxisData != nullptr && !pAxisData->isInitialViewFitted();
	const bool bOldApplying = m_bApplyingAxisRange;
	if(bWaitingForInitialView) {
		// 布局阶段可能触发轴信号，不能把它误认为用户已经设置了范围。
		m_bApplyingAxisRange = true;
	}
    iGuiPlot::resizeEvent(pEvent);
	m_bApplyingAxisRange = bOldApplying;
	if(bWaitingForInitialView) {
		scheduleInitialAxisView();
	}
}

void nmGuiPlot::onRangeXChanged(double dMin, double dMax, bool bRecalTicks, bool bAdjustRectZoomRatio)
{
    nmDataAnalyzeManager* pDataManager = dataManager();
    nmDataAxis* pAxisData = pDataManager != nullptr
            ? pDataManager->getAxisData() : nullptr;

    if(pAxisData == nullptr) {
        return;
    }

    // 获取 X 最大值
    pAxisData->getXMax().setValue(dMax);

    // 获取 X 最小值
    pAxisData->getXMin().setValue(dMin);

    if(!m_bApplyingAxisRange) {
        // 任一用户轴操作都终止首次初始化，后续范围完全由用户控制。
        pAxisData->setInitialViewFitted(true);
    }
}

void nmGuiPlot::onRangeYChanged(double dMin, double dMax, bool bRecalTicks, bool bAdjustRectZoomRatio)
{
    nmDataAnalyzeManager* pDataManager = dataManager();
    nmDataAxis* pAxisData = pDataManager != nullptr
            ? pDataManager->getAxisData() : nullptr;

    if(pAxisData == nullptr) {
        return;
    }

    // 获取 Y 最大值
    pAxisData->getYMax().setValue(dMax);

    // 获取 Y 最小值
    pAxisData->getYMin().setValue(dMin);

    if(!m_bApplyingAxisRange) {
        pAxisData->setInitialViewFitted(true);
    }
}

// ============================== 可见性设置方法实现 ==============================

void nmGuiPlot::setContourVisibility(bool bIsVisible)
{

    // 边界图元对象
    QVector<ZxObjBase*> vecPlotObjs;

    // 1、从数据中心获取当前边界类型
    nmDataAnalyzeManager* pManager = nmDataAnalyzeManager::getCurrentInstance();

    if(pManager == nullptr || pManager->getOutlineData() == nullptr) {
        return;
    }

    NM_Data_Outline_Type eOutlineType = pManager->getOutlineData()->getOutlineType();

    // 2、根据边界类型设置是否可见
    if(eOutlineType == NM_Data_Outline_Type::NM_Rect_Outline_Type) {
        vecPlotObjs = this->getObjsByTag("nObjRectOutline");

        if(vecPlotObjs.count() > 0) {
            for(int i = 0; i < vecPlotObjs.count() ; i++) {
                nmObjRectOutline* pOutline = (nmObjRectOutline*)vecPlotObjs[i];

                if(pOutline != nullptr) {
                    pOutline->setVisible(bIsVisible);
                }
            }
        }
    } else if(eOutlineType == NM_Data_Outline_Type::NM_Polygon_Outline_Type) {
        vecPlotObjs = this->getObjsByTag("nObjPolygonOutline");

        if(vecPlotObjs.count() > 0) {
            for(int i = 0; i < vecPlotObjs.count() ; i++) {
                nmObjPolygonOutline* pOutline = (nmObjPolygonOutline*)vecPlotObjs[i];

                if(pOutline != nullptr) {
                    pOutline->setVisible(bIsVisible);
                }
            }
        }
    } else if(eOutlineType == NM_Data_Outline_Type::NM_Round_Outline_Type) {
        vecPlotObjs = this->getObjsByTag("nObjRoundOutline");

        if(vecPlotObjs.count() > 0) {
            for(int i = 0; i < vecPlotObjs.count() ; i++) {
                nmObjRoundOutline* pOutline = (nmObjRoundOutline*)vecPlotObjs[i];

                if(pOutline != nullptr) {
                    pOutline->setVisible(bIsVisible);
                }
            }
        }
    }
}

void nmGuiPlot::setImagesVisibility(bool bIsVisible)
{
    // TODO:
    // 从数据中心获取背景图片信息
    nmDataAnalyzeManager* pManager = nmDataAnalyzeManager::getCurrentInstance();

    if(pManager) {
        BackgroundImageInfo currentInfo = pManager->getBackgroundImageInfo();
        currentInfo.bIsVisible = bIsVisible; // 更新可见性状态
        pManager->setBackgroundImageInfo(currentInfo); // 更新数据中心

        if(bIsVisible) {
            // 重新设置背景
            m_pPlot->setBkImgFile(currentInfo.sFilePath);
        } else {
            // 设置空地址作为背景图片，即不可见
            m_pPlot->setBkImgFile("");
        }
    }
}

/**
 * @brief 设置所有井的可见性
 */
void nmGuiPlot::setAllWellsVisible(bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjPointWell");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjPointWell* pWell = static_cast<nmObjPointWell*>(vecPlotObjs.at(i));
        pWell->setVisible(bIsVisible);
    }
}

/**
 * @brief 设置单个井的可见性
 */
void nmGuiPlot::setWellVisible(QString sObjName, bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjPointWell");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjPointWell* pWell = static_cast<nmObjPointWell*>(vecPlotObjs.at(i));

        if(pWell->getName() == sObjName) {
            pWell->setVisible(bIsVisible);
            break;
        }
    }
}

/**
 * @brief 设置所有断层的可见性
 */
void nmGuiPlot::setAllFaultsVisible(bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjLineFault");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjLineFault* pFault = static_cast<nmObjLineFault*>(vecPlotObjs.at(i));
        pFault->setVisible(bIsVisible);
    }
}

/**
 * @brief 设置单个断层的可见性
 */
void nmGuiPlot::setFaultVisible(QString sObjName, bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjLineFault");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjLineFault* pFault = static_cast<nmObjLineFault*>(vecPlotObjs.at(i));

        if(pFault->getName() == sObjName) {
            pFault->setVisible(bIsVisible);
            break;
        }
    }
}

/**
 * @brief 设置所有裂缝的可见性
 */
void nmGuiPlot::setAllFracturesVisible(bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjLineFracture");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjLineCrack* pFracture = static_cast<nmObjLineCrack*>(vecPlotObjs.at(i));
        pFracture->setVisible(bIsVisible);
    }
}

/**
 * @brief 设置单个裂缝的可见性
 */
void nmGuiPlot::setFractureVisible(QString sObjName, bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjLineFracture");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjLineCrack* pFracture = static_cast<nmObjLineCrack*>(vecPlotObjs.at(i));

        if(pFracture->getName() == sObjName) {
            pFracture->setVisible(bIsVisible);
            break;
        }
    }
}

/**
 * @brief 设置所有区域的可见性
 */
void nmGuiPlot::setAllRegionsVisible(bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjRegion");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjRegion* pRegion = static_cast<nmObjRegion*>(vecPlotObjs.at(i));
        pRegion->setVisible(bIsVisible);
    }
}

/**
 * @brief 设置单个区域的可见性
 */
void nmGuiPlot::setRegionVisible(QString sObjName, bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjRegion");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjRegion* pRegion = static_cast<nmObjRegion*>(vecPlotObjs.at(i));

        if(pRegion->getName() == sObjName) {
            pRegion->setVisible(bIsVisible);
            break;
        }
    }
}

/**
 * @brief 设置所有区域标记的可见性
 */
void nmGuiPlot::setAllRegionMarksVisible(bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjRegionMark");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjRegionMark* pRegionMark = static_cast<nmObjRegionMark*>(vecPlotObjs.at(i));
        pRegionMark->setVisible(bIsVisible);
    }
}

/**
 * @brief 设置单个区域标记的可见性
 */
void nmGuiPlot::setRegionMarkVisible(QString sObjName, bool bIsVisible)
{
    QVector<ZxObjBase*> vecPlotObjs = this->getObjsByTag("nObjRegionMark");

    for(int i = 0; i < vecPlotObjs.count(); ++i) {
        nmObjRegionMark* pRegionMark = static_cast<nmObjRegionMark*>(vecPlotObjs.at(i));

        if(pRegionMark->getName() == sObjName) {
            pRegionMark->setVisible(bIsVisible);
            break;
        }
    }
}

void nmGuiPlot::finishMeasure()
{
    nmGuiPlotCmdHelper* helper = dynamic_cast<nmGuiPlotCmdHelper*>(m_pCmdHelper);

    if(helper != nullptr) {
        helper->finishMeasure();
    }
}

bool nmGuiPlot::setPlotsByDataManger(nmDataAnalyzeManager* pDataManager)
{
    if(pDataManager == nullptr || m_pPlot == nullptr) {
        return false;
    }

    // 本函数按DataManager完整重建Map，重复调用也只能保留一套图元。
    // 清理过程不删除业务数据，因此同一分析刷新和跨分析切换可使用同一路径。
    deleteAllPlotObjs();
    if(m_pGraphicBinder != nullptr) {
        m_pGraphicBinder->updateDataMgr(pDataManager);
    }
    m_pDataManager = pDataManager;
	nmDataAxis* pAxisData = pDataManager->getAxisData();
	const bool bWaitingForInitialView =
			pAxisData != nullptr && !pAxisData->isInitialViewFitted();
	const bool bOldApplying = m_bApplyingAxisRange;
	if(bWaitingForInitialView) {
		// 图元创建过程可能发出轴范围信号，首次适配完成前统一按内部更新处理。
		m_bApplyingAxisRange = true;
	}
    // 0.坐标轴
    this->initAxisFromData(pDataManager);
    // 1.边界
    this->initBoundaryObjFromData(pDataManager);
    // 2.井
    this->initWellObjsFromData(pDataManager);
    // 3.断层
    this->initFaultObjsFromData(pDataManager);
    // 4.裂缝
    this->initFractureObjsFromData(pDataManager);
    // 5.区域
    this->initRegionObjsFromData(pDataManager);
    // 6.区域标记
    this->initRegionMarkObjsFromData(pDataManager);
	m_bApplyingAxisRange = bOldApplying;

    if(pAxisData != nullptr && !pAxisData->isInitialViewFitted()) {
        // 等本轮布局和坐标轴内边距稳定后只初始化一次。
        scheduleInitialAxisView();
    }

    return true;
}

void nmGuiPlot::removeWellPlotByData(nmDataWellBase* pData)
{
    if(pData != nullptr) {
        // 移除井图元
        int objCount = m_pPlot->getObjCount();

        for(int i = 0; i < objCount; i++) {
            ZxObjBase* obj = m_pPlot->getObjByIndex(i);

            if(_isSame(obj->getName(), pData->getWellName())) {
                // 删除图元
                m_pPlot->removeObjByName(obj->getName());
                break;
            }
        }
    }
}

void nmGuiPlot::removeAllWellPlot()
{
    // 移除所有井图元
    int objCount = m_pPlot->getObjCount();

    for(int i = 0; i < objCount; i++) {
        ZxObjBase* obj = m_pPlot->getObjByIndex(i);

        if(_isSame("nObjPointWell", obj->getTagName())) {
            // 删除井图元
            m_pPlot->removeObjByName(obj->getName());
        }
    }
}