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

#include <QPainter>

#include <ZxSerializer.h>
#include "IxPtyPano.h"
#include "ZxBaseUtil.h"
#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"

#include "nmObjLineFaultTool.h"
#include "ZxPlot.h"
#include "ZxObjText.h"

#include "nmObjLineFault.h"

#include "nmPlotGraphicBinder.h"
#include "nmDataFault.h"

ZX_DEFINE_DYNAMIC(nObjLineFault, nmObjLineFault)

nmObjLineFault::nmObjLineFault() {
    m_sObjTag = "nObjLineFault";
    nmObjLineFault::init("", NULL, NULL);
}

nmObjLineFault::nmObjLineFault(const QString& sName, \
                               ZxSubAxisX* pAxisX, \
                               ZxSubAxisY* pAxisY) {
    m_sObjTag = "nObjLineFault";
    nmObjLineFault::init(sName, pAxisX, pAxisY);
}

nmObjLineFault::~nmObjLineFault() {
}

void nmObjLineFault::fillPtyPano(IxPtyPano* sheet) {
	nmObjBase::fillPtyPano(sheet);
	IxPtyItem* pProp = ZX_PROP("ObjLineFault.FlowModel", getFaultFlowModel, setFaultFlowModel);

	if(NULL != pProp) {
		QStringList listTags;
		listTags << tr("Leaky") << tr("Composite Limit");
		QList<QVariant> listIndexes;
		listIndexes << 0 << 1;
		pProp->getPtyPano();
		pProp->setOptions(listTags, listIndexes);
	}

	ZX_PROP("ObjLineFault.Leakage", getFaultLeakage, setFaultLeakage);

	// 断层起点位置
	ZX_PROP("ObjLineFaultStartPos.StartPointX", getStartX, setStartX);
	ZX_PROP("ObjLineFaultStartPos.StartPointY", getStartY,setStartY);
	// 断层终点位置
	ZX_PROP("ObjLineFaultEndPos.EndPointX", getEndX, setEndX);
	ZX_PROP("ObjLineFaultEndPos.EndPointY", getEndY, setEndY);
}

void nmObjLineFault::init(const QString& sName, \
                          ZxSubAxisX* pAxisX, \
                          ZxSubAxisY* pAxisY) {
    nmObjBase::init(sName, pAxisX, pAxisY);

    nmObjLineFault::initFlags();
    m_oPen = QPen(QBrush(Qt::green), \
                  0.3f, Qt::SolidLine);

    // 业务属性本地默认值
    m_sFlowModel = tr("Leaky");
    m_dLeakage = 1.0;
    m_pGraphicBinder = nullptr;

    loadTempl();
}

void nmObjLineFault::initTools() {
    m_pTool = new nmObjLineFaultTool();
    nmObjBase::initTools();
}

void nmObjLineFault::initFlags() {
    setLockPos(false);
    setLockSize(false);
    setReadOnly(false);
}

bool nmObjLineFault::hitTest(const QPointF& pt) {
    return nmObjBase::hitTest(pt);
}

bool nmObjLineFault::_runHitTest(const QPointF& pt, int& nOption, int& nSubIndex) {
    if(!nmObjBase::_runHitTest(pt, nOption, nSubIndex)) {
        return false;
    }

    nOption = -1;
    nSubIndex = 0;

    if(NULL == m_pAxisX || NULL == m_pAxisY) {
        return false;
    }

    QVector<QPointF> pts = getPosOf(m_vecPoints);

    // 点
    double r = 1.f;

    for(int i = 0; i < pts.count(); i++) {
        QPointF ptTopLeft = QPointF(pts[i].x() - r,
                                    pts[i].y() - r);
        QSizeF sz = QSizeF(r * 2.f, r * 2.f);

        QRectF rt = QRectF(ptTopLeft, sz);
        bool b = rt.contains(pt);

        if(b) {
            nOption = (int)OHO_Point;
            nSubIndex = i;
            return true;
        }
    }

    // 线
    for(int i = 0; i < pts.count(); i++) {
        int n1 = i;
        int n2 = (i == pts.count() - 1 ? 0 : i + 1);

        if(_isNearLine(pt, pts[n1], pts[n2], 1.f * 2)) {
            // 判断当前线是否已经存在
            if(m_oHitOption == OHO_Bound && m_pTool->isLeftDown()) {
                // 添加新节点
                pts.insert(i + 1, pt);
                m_vecPoints.clear();
                m_vecPoints = getValueOf(pts);
                nOption = (int)OHO_Point;
                nSubIndex = i + 1;
                // 点集变更
                emit sigPointsChanged();
                return true;
            }

            nOption = (int)OHO_Bound;
            nSubIndex = i;
            return true;
        }
    }

    return false;
}

bool nmObjLineFault::runMove(const QPointF& pt1,
                             const QPointF& pt2) {
    if(isLockPos()) {
        return false;
    }

    if(NULL == m_pAxisX || NULL == m_pAxisY) {
        return false;
    }

    int nCount = m_vecPoints.count();
    QVector<QPointF> vecPts = getPosOf(m_vecPoints); // 屏幕值
    bool bRet = false;

    if(m_oHitOption == OHO_Point && m_nHitIndex >= 0) {
		// 如果是点，不用计算偏移量，直接将该点移动到鼠标抬起的位置即可
		vecPts[m_nHitIndex] = pt2;
        bRet = moveToPos(vecPts);
		// 移动后通知点集变更
		emit sigPointsChanged();
        return bRet;
    } else if(m_oHitOption == OHO_Bound && m_nHitIndex >= 0) {
        for(int i = 0; i < nCount; i++) {
            vecPts[i] = offsetPoint(vecPts[i], pt1, pt2);
        }

        m_dOffsetX = pt2.x() - pt1.x();
        m_dOffsetY = pt2.y() - pt1.y();
        bRet = moveToPos(vecPts);
		// 移动后通知点集变更
		emit sigPointsChanged();
        return bRet;
    } else {
        return false;
    }

    return true;
}

void nmObjLineFault::paintBack(QPainter* painter, const ZxPaintParam& param) {
    if(NULL == m_pAxisX || NULL == m_pAxisY || \
            m_pAxisX->getRangeMin() == m_pAxisX->getRangeMax() || \
            m_pAxisY->getRangeMin() == m_pAxisY->getRangeMax()) {
        return;
    }

    // 名称同步，在绘制时通过 Binder 同步到数据中心
    if (m_pGraphicBinder) {
        m_pGraphicBinder->syncFaultName(this);
    }

    painter->save();
    QVector<QPointF> pts = getPosOf(m_vecPoints);

    // 不选中的状态
    if(!pts.empty()) 
	{

        QPen pen = m_oPen;
        painter->setPen(pen);

        for(int i = 0; i < pts.count() - 1; i++) 
		{
            painter->drawLine(pts[i], pts[i + 1]);
        }

		//将名称置于中间线段下方
		QFont ft = qApp->font();
		ft.setPointSize(8);
		painter->setFont(ft);
		painter->setPen(Qt::black);

		int nSegments = pts.count() - 1;

		int middleIndex = (nSegments - 1) / 2;
		QPointF startPoint = pts[middleIndex];
		QPointF endPoint = pts[middleIndex + 1];
		// 计算中点坐标
		QPointF middlePoint((startPoint.x() + endPoint.x()) / 2,
			(startPoint.y() + endPoint.y()) / 2);

		// 计算线段的方向角度
		double dx = endPoint.x() - startPoint.x();
		double dy = endPoint.y() - startPoint.y();
		double angle = qAtan2(dy, dx) * 180.0 / M_PI;
		
		// 偏移距离
		double offsetDistance = -3.0;

		// 线段长度
		double length = std::sqrt(dx * dx + dy * dy);

		// 计算一个垂直于线段方向的单位向量：
		QPointF offset(0, 0);
		if (length > 0) 
		{
			// 选用 (dy, -dx) 作为垂直方向，正负号可根据想要的偏移朝向做调整
			offset = QPointF(offsetDistance * (dy / length),
				offsetDistance * (-dx / length));
		}
		// 最终文字基准点：在原中点的基础上加上垂直方向的偏移
		QPointF textPos = middlePoint + offset;

		painter->save();
		painter->translate(textPos);
		painter->rotate(angle);
		QRectF textRect(-50, -10, 100, 20);
		ZxDrawHelper::drawText(painter,
			textRect,
			Qt::AlignCenter | Qt::AlignVCenter,
			m_sName);

		painter->restore();
    }

    if(isSelected()) { //选中状态下

        for(int i = 0; i < pts.count(); i++) {

            float w = 2.2f;
            QPointF pt = pts[i];
            QRectF rect(pt.x() - w * 0.5f, pt.y() - w * 0.5f, w, w);

            if(m_nHitIndex == i && m_oHitOption == OHO_Point) { // 填充节点
                QBrush br(Qt::red);
                painter->fillRect(rect, br);
            } else {
                painter->setPen(QColor(0, 0, 128));
                painter->drawRect(rect);
            }

            // 击中线
            if(m_nHitIndex == i && m_oHitOption == OHO_Bound) {

                nmDataLogFile::getInstance()->writeLog("select line " + QString::number(i));
                QPen pen(Qt::DashLine);
                painter->setPen(pen);

                for(int i = 0; i < pts.count() - 1; i++) {
                    painter->drawLine(pts[i], pts[i + 1]);
                }
            }
        }
    }

    painter->restore();
}

double nmObjLineFault::getFaultLeakage() {
	return m_dLeakage;
}

void nmObjLineFault::setFaultLeakage(double newFaultLeakage) {
	m_dLeakage = newFaultLeakage;
	emit sigLeakageChanged(newFaultLeakage);
}

int nmObjLineFault::getFaultFlowModel() {
	if (m_sFlowModel == tr("Leaky"))
		return 0;
	else
		return 1;
}

void nmObjLineFault::setFaultFlowModel(int newFaultFlowModel) {
	if (newFaultFlowModel == 0) {
		m_sFlowModel = tr("Leaky");
	} else {
		m_sFlowModel = tr("Composite limit");
	}
	emit sigFlowModelChanged(newFaultFlowModel);
}

double nmObjLineFault::getStartX() {
	if (!m_vecPoints.isEmpty())
		return m_vecPoints.first().x();
	return 0;
}

void nmObjLineFault::setStartX(double newValue) {
	if (!m_vecPoints.isEmpty()) {
		m_vecPoints.first().setX(newValue);
		emit sigPointsChanged();
	}
}

double nmObjLineFault::getStartY() {
	if (!m_vecPoints.isEmpty())
		return m_vecPoints.first().y();
	return 0;
}

void nmObjLineFault::setStartY(double newValue) {
	if (!m_vecPoints.isEmpty()) {
		m_vecPoints.first().setY(newValue);
		emit sigPointsChanged();
	}
}

double nmObjLineFault::getEndX() {
	if (!m_vecPoints.isEmpty())
		return m_vecPoints.last().x();
	return 0;
}

void nmObjLineFault::setEndX(double newValue) {
	if (!m_vecPoints.isEmpty()) {
		m_vecPoints.last().setX(newValue);
		emit sigPointsChanged();
	}
}

double nmObjLineFault::getEndY() {
	if (!m_vecPoints.isEmpty())
		return m_vecPoints.last().y();
	return 0;
}

void nmObjLineFault::setEndY(double newValue) {
	if (!m_vecPoints.isEmpty()) {
		m_vecPoints.last().setY(newValue);
		emit sigPointsChanged();
	}
}

void nmObjLineFault::onSerialize(ZxSerializer* ser) {
    nmObjBase::onSerialize(ser);
	int flowModel = getFaultFlowModel();
    ser->write("FlowModel", flowModel);
    ser->write("Leakage", m_dLeakage);
}

void nmObjLineFault::onDeserialize(ZxSerializer* ser) {
    nmObjBase::onDeserialize(ser);
	int flowModel;
	double faultLeakage;
	ser->read("FlowModel", flowModel);
	ser->read("Leakage", faultLeakage);

	// 更新Data
	this->setFaultFlowModel(flowModel);
	this->setFaultLeakage(faultLeakage);
}

void nmObjLineFault::onSaveTempl(ZxSerializer* ser) {
    nmObjBase::onSaveTempl(ser);
	int flowModel = getFaultFlowModel();
    ser->write("FlowModel", flowModel);
    ser->write("Leakage", m_dLeakage);
}

void nmObjLineFault::onLoadTempl(ZxSerializer* ser) {
    nmObjBase::onLoadTempl(ser);
    int flowModel;
	double faultLeakage;
    ser->read("FlowModel", flowModel);
    ser->read("Leakage", faultLeakage);

	// 更新Data
	this->setFaultFlowModel(flowModel);
	this->setFaultLeakage(faultLeakage);
}

nmDataFault* nmObjLineFault::getFaultData() const {
	if (m_pGraphicBinder)
		return m_pGraphicBinder->getFaultDataFor(const_cast<nmObjLineFault*>(this));
	return nullptr;
}