#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 "nmObjDeleteTool.h"

#include "nmDataAnalyzeManager.h"
#include "nmDataOutline.h"
#include "nmDataAxis.h"

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


#include <QWidget>

nmGuiPlot::nmGuiPlot(bool bUseBtns, QWidget *parent) :
    iGuiPlot(bUseBtns, parent)
{
    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;

}

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::initDefultGeoObj()
{
    // 获取边界数据，来自数据中心
    nmDataOutline* pOutlineData = nmDataAnalyzeManager::getCurrentInstance()->getOutlineData();

    nmDataAxis* pAxisData = nmDataAnalyzeManager::getCurrentInstance()->getAxisData();

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

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

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

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

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

    connect(m_pPlot->getMainAxisX(), SIGNAL(sigRangeChanged(double, double, bool, bool)),
            this, SLOT(onRangeXChanged(double, double, bool, bool)));

    connect(m_pPlot->getMainAxisY(), SIGNAL(sigRangeChanged(double, double, bool, bool)),
            this, SLOT(onRangeYChanged(double, double, bool, bool)));

    // 数据中心无边界数据，创建默认边界数据
    if(pOutlineData == nullptr)	{
        pOutlineData = nmDataAnalyzeManager::getCurrentInstance()->createOutline();

        // 设置默认边界名称
        pOutlineData->setName("");

        // 设置边界点
        QVector<QPointF> vecPoints;
        vecPoints << QPointF(-1000.00, 1000.00)
                  << QPointF(1000.00, 1000.00)
                  << QPointF(1000.00, -1000.00)
                  << QPointF(-1000.00, -1000.00);
        pOutlineData->setOutlinePoints(vecPoints);

        // 设置边界类型
        pOutlineData->setOutlineType(NM_Rect_Outline_Type);

        // 设置流型列表（假设全部为0）
        QVector<int> vecFlowTypes(vecPoints.size(), 0);
        pOutlineData->setFlowTypeList(vecFlowTypes);
    }

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

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

        if(pWellData == nullptr) {
            this->setPlotsByDataManger(nmDataAnalyzeManager::getCurrentInstance());
            return;
        }

        // 判断是哪一种井类型，初始化对应的参数
        QString wellClass = pWellData->getWellClassEn();

        // 获取当前井的压力、流量数据
        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)) {
                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)) {
                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 = nmDataAnalyzeManager::getCurrentInstance()->createWell(NM_WELL_MODEL::Vertical_Well);
            nmDataVerticalWell* m_VerticalWell = dynamic_cast<nmDataVerticalWell*>(pWell);

            if(m_VerticalWell == nullptr) {
                this->setPlotsByDataManger(nmDataAnalyzeManager::getCurrentInstance());
                return;
            }

            m_VerticalWell->setWellName(pWellData->getName());
            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: 计算井的历史双对数/半对数数据
            nmDataAnalyzeManager::getCurrentInstance()->calculationLogData(m_VerticalWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

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

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

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

            if(m_VFracturedWell == nullptr) {
                this->setPlotsByDataManger(nmDataAnalyzeManager::getCurrentInstance());
                return;
            }

            m_VFracturedWell->setWellName(pWellData->getName());
            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: 计算井的历史双对数/半对数数据
            nmDataAnalyzeManager::getCurrentInstance()->calculationLogData(m_VFracturedWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

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

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

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

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

            if(m_HFracturedWell == nullptr) {
                this->setPlotsByDataManger(nmDataAnalyzeManager::getCurrentInstance());
                return;
            }

            m_HFracturedWell->setWellName(pWellData->getName());
            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: 计算井的历史双对数/半对数数据
            nmDataAnalyzeManager::getCurrentInstance()->calculationLogData(m_HFracturedWell, vvecHistoryPressureData, vvecHistoryLogData, vvecHistorySemiLogData);

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

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

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

        // 重新获取添加后的井数据
        vecWellDatas = nmDataAnalyzeManager::getCurrentInstance()->getWellDataList();
    }

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

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

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

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

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

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

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

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;
        }

        // 绑定边界数据到图元对象上
        pRectOutlinePlot->setOutlineData(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;
        }

        // 绑定边界数据到图元对象上
        pPRoundOutlinePlot->setOutlineData(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;
        }

        // 绑定边界数据到图元对象上
        pPolygonOutlinePlot->setOutlineData(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 图元绑定来自数据中心的井数据
        pWellPlot->setNmWellData(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 绑定裂缝数据到图元对象上
        pFaultPlot->setFaultData(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 绑定裂缝数据到图元对象上
        pFracturePlot->setFractureData(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 绑定区域数据到图元对象上
        pRegionPlot->setRegionData(pDataRegion);

        // TODO: 设置区域其他属性
    }
}

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 绑定区域标记数据到图元对象上
        //pRegionMarkPlot->set(pDataRegionMark);

        // TODO: 设置区域标记其他属性
    }
}

void nmGuiPlot::deleteAllPlotObjs()
{
    QVector<nmObjBase*> vecObjs = this->getAllPlots();

    foreach(nmObjBase* pObj, vecObjs) {
        // 1、移除图元
        m_pPlot->removeObjByName(pObj->getName());
        // 2、清理数据
        //pObj->removeData();
    }
}

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;
    }

    // 当前井作为活动分析井保留,不允许从地图中直接删除
    if(obj->getNmWellData() == nmDataAnalyzeManager::getCurrentInstance()->getCurWellData()) {
        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) {
            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) {
            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)) {
            nmDataWellBase* pCurWell = nmDataAnalyzeManager::getCurrentInstance()->getCurWellData();

            if(pWellObj->getNmWellData() == pCurWell) {
                if(pDeleteTool) {
                    m_pPlot->removeTools(pDeleteTool);
                }
                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);
                    // 删除数据对象
                    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 || pCrack->getFractureData() == nullptr) {
                continue;
            }

            if(pCrack->getFractureData()->getFractureType().getValue() == tr("DFN")) {
                // 清空绑定的数据
                pCrack->removeData();
                // 删除DFN图元
                m_pPlot->removeObjByName(pCrack->getName());
            }
        }
    }
}

void nmGuiPlot::onRangeXChanged(double dMin, double dMax, bool bRecalTicks, bool bAdjustRectZoomRatio)
{
    nmDataAxis* pAxisData = nmDataAnalyzeManager::getCurrentInstance()->getAxisData();

    if(pAxisData == nullptr) {
        return;
    }

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

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

void nmGuiPlot::onRangeYChanged(double dMin, double dMax, bool bRecalTicks, bool bAdjustRectZoomRatio)
{
    nmDataAxis* pAxisData = nmDataAnalyzeManager::getCurrentInstance()->getAxisData();

    if(pAxisData == nullptr) {
        return;
    }

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

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

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

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)
{
    // 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);

    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());
        }
    }
}