|
|
#include "nmWxWellboreTrajectoryDisplay.h"
|
|
|
|
|
|
#include <QIcon>
|
|
|
#include <QRadioButton>
|
|
|
#include <QButtonGroup>
|
|
|
#include <QToolBar>
|
|
|
#include <QStackedWidget>
|
|
|
#include <QVBoxLayout>
|
|
|
#include <QHBoxLayout>
|
|
|
#include <QGroupBox>
|
|
|
#include <QAction>
|
|
|
#include <QLabel>
|
|
|
#include <QDebug>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QMouseEvent>
|
|
|
#include <QCursor>
|
|
|
#include <QWheelEvent>
|
|
|
#include <QMessageBox>
|
|
|
|
|
|
#include "nmDataAnalyzeManager.h"
|
|
|
#include "nmDataPerforation.h"
|
|
|
|
|
|
nmWellborePointGraphicsItem::nmWellborePointGraphicsItem(QGraphicsItem *parent)
|
|
|
: QGraphicsEllipseItem(parent),
|
|
|
m_bIsDragging(false)
|
|
|
{
|
|
|
setPen(QPen(Qt::black, 0.5f));
|
|
|
setBrush(QBrush(Qt::darkGreen));
|
|
|
}
|
|
|
|
|
|
void nmWellborePointGraphicsItem::setStyle(const QPen& pen, const QBrush& brush)
|
|
|
{
|
|
|
setPen(pen);
|
|
|
setBrush(brush);
|
|
|
}
|
|
|
|
|
|
void nmWellborePointGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 如果是左键按下，并且允许移动
|
|
|
if(event->button() == Qt::LeftButton && (flags() & QGraphicsItem::ItemIsMovable)) {
|
|
|
m_bIsDragging = true;
|
|
|
// 记录鼠标按下时的场景坐标
|
|
|
m_dragStartPos = event->scenePos();
|
|
|
// 记录图元拖动前的原始位置（左上角）
|
|
|
m_originalPos = pos();
|
|
|
event->accept(); // 接受事件，表示已处理
|
|
|
}
|
|
|
|
|
|
QGraphicsEllipseItem::mousePressEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmWellborePointGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bIsDragging && (event->buttons() & Qt::LeftButton)) {
|
|
|
// 计算偏移量
|
|
|
QPointF delta = event->scenePos() - m_dragStartPos;
|
|
|
setPos(m_originalPos + delta);
|
|
|
emit sigPositionChanging(sceneBoundingRect().center());
|
|
|
event->accept();
|
|
|
}
|
|
|
|
|
|
QGraphicsEllipseItem::mouseMoveEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmWellborePointGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bIsDragging) {
|
|
|
m_bIsDragging = false;
|
|
|
emit sigDragFinished(sceneBoundingRect().center());
|
|
|
event->accept();
|
|
|
}
|
|
|
|
|
|
QGraphicsEllipseItem::mouseReleaseEvent(event);
|
|
|
}
|
|
|
|
|
|
nmWellboreLineGraphicsItem::nmWellboreLineGraphicsItem(QGraphicsItem *parent)
|
|
|
: QGraphicsLineItem(parent)
|
|
|
{
|
|
|
QPen wellborePen(Qt::blue, 2);
|
|
|
wellborePen.setCosmetic(true);
|
|
|
setPen(wellborePen);
|
|
|
}
|
|
|
|
|
|
void nmWellboreLineGraphicsItem::setStyle(const QPen& pen)
|
|
|
{
|
|
|
QPen cosmetic_pen = pen;
|
|
|
cosmetic_pen.setCosmetic(true);
|
|
|
setPen(cosmetic_pen);
|
|
|
}
|
|
|
|
|
|
nmPerforationHandleItem::nmPerforationHandleItem(PerforationHandleType type, QGraphicsItem *parent)
|
|
|
: m_handleType(type),
|
|
|
QGraphicsRectItem(parent)
|
|
|
{
|
|
|
setZValue(5);
|
|
|
}
|
|
|
|
|
|
#include <QPainter>
|
|
|
#include <QStyleOptionGraphicsItem>
|
|
|
#include <QWidget>
|
|
|
#include <QGraphicsScene>
|
|
|
#include <QGraphicsView>
|
|
|
|
|
|
void nmPerforationHandleItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
// 获取视图缩放比例
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 定义手柄和边框的固定像素大小
|
|
|
const qreal fixedHandleSizeInPixels = 13.0;
|
|
|
const qreal fixedBorderWidthInPixels = 2.0; // 定义边框的像素宽度
|
|
|
|
|
|
// 根据缩放比例计算动态大小
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
const qreal dynamicBorderWidth = fixedBorderWidthInPixels / scaleY; // 计算动态边框宽度
|
|
|
|
|
|
// 定义手柄的矩形区域
|
|
|
QRectF handleRect(-dynamicHandleSize / 2, -dynamicHandleSize / 2, dynamicHandleSize, dynamicHandleSize);
|
|
|
|
|
|
// 创建一个新的 QPen 用于绘制边框
|
|
|
QPen pen(Qt::black); // 颜色为黑色
|
|
|
pen.setWidthF(dynamicBorderWidth); // 设置动态计算出的宽度
|
|
|
|
|
|
painter->setPen(pen);
|
|
|
painter->setBrush(Qt::red); // 填充颜色保持为红色
|
|
|
painter->drawRect(handleRect); // 绘制带边框的矩形
|
|
|
}
|
|
|
|
|
|
QRectF nmPerforationHandleItem::boundingRect() const
|
|
|
{
|
|
|
// 获取视图缩放比例
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
// 使用与paint方法相同的动态大小计算
|
|
|
const qreal fixedHandleSizeInPixels = 13.0;
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
|
|
|
// 返回动态计算的矩形，与paint方法绘制的区域一致
|
|
|
return QRectF(-dynamicHandleSize / 2, -dynamicHandleSize / 2,
|
|
|
dynamicHandleSize, dynamicHandleSize);
|
|
|
}
|
|
|
|
|
|
nmPerforationGraphicsItem::nmPerforationGraphicsItem(nmDataPerforation *pPerData, NM_WELL_MODEL wellType, double wellboreStartAbsoluteMd, double totalWellboreMdLength, QGraphicsItem *parent)
|
|
|
: m_pPerforationData(pPerData), // 初始化关联的射孔数据
|
|
|
m_eWellType(wellType), // 初始化井筒类型
|
|
|
m_wellboreStartAbsoluteMd(wellboreStartAbsoluteMd), // 初始化井筒起始MD
|
|
|
m_totalWellboreMdLength(totalWellboreMdLength), // 初始化井筒总长度
|
|
|
QGraphicsRectItem(parent), // 调用基类 QGraphicsRectItem 的构造函数
|
|
|
m_bEditable(false), // 默认不可编辑
|
|
|
m_eCurrentInteractionMode(PerforationInteractionMode::Normal), // 默认正常交互模式
|
|
|
m_dPerWidth(10.0), // 射孔默认宽度
|
|
|
m_handlePen(Qt::black, 1), // 手柄边框笔触
|
|
|
m_handleBrush(Qt::red), // 手柄填充颜色
|
|
|
m_handleSize(0.0), // 手柄尺寸（稍后根据井筒类型设置）
|
|
|
m_pStartHandle(nullptr), // 起点手柄指针初始为空
|
|
|
m_pEndHandle(nullptr), // 终点手柄指针初始为空
|
|
|
m_isDragging(false), // 初始状态，未在拖动
|
|
|
m_tempDragMdStart(0.0), // 拖动过程中使用的临时起点MD
|
|
|
m_tempDragMdEnd(0.0) // 拖动过程中使用的临时终点MD
|
|
|
{
|
|
|
m_initialMdStart = 0.0;
|
|
|
m_initialMdEnd = 0.0;
|
|
|
m_dCroppedMdStart = 0.0;
|
|
|
m_dCroppedMdEnd = 0.0;
|
|
|
|
|
|
// 根据井筒类型设置射孔宽度和手柄大小
|
|
|
|
|
|
if(m_eWellType == NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
m_dPerWidth = 2.0;
|
|
|
m_handleSize = 10.0;
|
|
|
} else {
|
|
|
m_handleSize = m_dPerWidth + 2; // 垂直井筒手柄略大于射孔宽度
|
|
|
}
|
|
|
|
|
|
QPen perforationPen(Qt::red, 1);
|
|
|
perforationPen.setCosmetic(true);
|
|
|
setPen(perforationPen);// 射孔本体边框
|
|
|
|
|
|
setBrush(QBrush(Qt::red));// 射孔本体填充颜色
|
|
|
setFlags(ItemIsSelectable);// 允许射孔本体被选中
|
|
|
setCacheMode(DeviceCoordinateCache);// 缓存绘图，提高性能
|
|
|
|
|
|
m_handlePen.setCosmetic(true);
|
|
|
|
|
|
// 创建起点和终点手柄，并设置父项为当前射孔图形项的父类
|
|
|
m_pStartHandle = new nmPerforationHandleItem(PerforationHandleType::StartHandle, parent);
|
|
|
m_pEndHandle = new nmPerforationHandleItem(PerforationHandleType::EndHandle, parent);
|
|
|
|
|
|
// 设置手柄的样式
|
|
|
m_pStartHandle->setPen(m_handlePen);
|
|
|
m_pStartHandle->setBrush(m_handleBrush);
|
|
|
m_pEndHandle->setPen(m_handlePen);
|
|
|
m_pEndHandle->setBrush(m_handleBrush);
|
|
|
|
|
|
// 默认隐藏手柄，只有在编辑模式下才显示
|
|
|
m_pStartHandle->setVisible(false);
|
|
|
m_pEndHandle->setVisible(false);
|
|
|
|
|
|
// 在创建时，将裁剪范围初始化为原始 MD 范围
|
|
|
m_dCroppedMdStart = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
m_dCroppedMdEnd = m_pPerforationData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
}
|
|
|
|
|
|
nmPerforationGraphicsItem::~nmPerforationGraphicsItem()
|
|
|
{
|
|
|
// 手动删除手柄
|
|
|
if(m_pStartHandle) {
|
|
|
delete m_pStartHandle;
|
|
|
m_pStartHandle = nullptr;
|
|
|
}
|
|
|
|
|
|
if(m_pEndHandle) {
|
|
|
delete m_pEndHandle;
|
|
|
m_pEndHandle = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::setEditMode(bool enable)
|
|
|
{
|
|
|
m_bEditable = enable;
|
|
|
|
|
|
if(m_pStartHandle && m_pEndHandle) {
|
|
|
m_pStartHandle->setVisible(enable); // 根据编辑模式显示或隐藏手柄
|
|
|
m_pEndHandle->setVisible(enable);
|
|
|
}
|
|
|
|
|
|
update(); // 请求重绘以反映手柄的显示/隐藏状态
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::updateGraphics()
|
|
|
{
|
|
|
prepareGeometryChange(); // 通知场景图形项的几何形状即将改变，以便场景更新包围盒和重绘
|
|
|
// 当 Model 变化时，清空拖动标志，确保视图不再使用临时值，而是使用 Model 的真实数据进行渲染
|
|
|
m_isDragging = false;
|
|
|
|
|
|
// 从模型中读取最新的原始 MD 值
|
|
|
double mdStart = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
double mdEnd = m_pPerforationData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
// 更新裁剪范围为原始 MD，因为这是最终状态
|
|
|
m_dCroppedMdStart = mdStart;
|
|
|
m_dCroppedMdEnd = mdEnd;
|
|
|
|
|
|
// 调用渲染函数进行渲染
|
|
|
updatePerforationAndHandleGeometry(m_dCroppedMdStart, m_dCroppedMdEnd);
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* nmPerforationGraphicsItem::getPerforationData()
|
|
|
{
|
|
|
return m_pPerforationData;
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::updateWellboreVisuals(const QPointF& wellboreStartScene, const QPointF& wellboreEndScene, double wellboreStartAbsoluteMd, double totalWellboreMdLength)
|
|
|
{
|
|
|
m_wellboreStartScenePoint = wellboreStartScene;
|
|
|
m_wellboreEndScenePoint = wellboreEndScene;
|
|
|
m_wellboreStartAbsoluteMd = wellboreStartAbsoluteMd;
|
|
|
m_totalWellboreMdLength = totalWellboreMdLength;
|
|
|
|
|
|
m_wellboreVisualLine.setPoints(wellboreStartScene, wellboreEndScene);
|
|
|
|
|
|
// 如果井筒长度为0，避免后续计算中出现除零
|
|
|
if(qFuzzyIsNull(m_totalWellboreMdLength)) {
|
|
|
m_totalWellboreMdLength = 1.0; // 赋一个非零小值，避免除零，但在实际应用中需要更严谨的错误处理
|
|
|
}
|
|
|
|
|
|
updateGraphics(); // 更新图形项的几何形状
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::updateGraphicsForPreview(qreal fractureTopMD, qreal fractureBottomMD)
|
|
|
{
|
|
|
prepareGeometryChange();
|
|
|
|
|
|
// 射孔的原始 MD 值。
|
|
|
// mdStart 是较小的值（更靠近井筒顶部）
|
|
|
// mdEnd 是较大的值（更靠近井筒底部）
|
|
|
double mdStart = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
//double mdEnd = m_pPerforationData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
// 之前裁剪后的 MD 值。
|
|
|
double currentCroppedStart = m_dCroppedMdStart;
|
|
|
double currentCroppedEnd = m_dCroppedMdEnd;
|
|
|
|
|
|
// 裂缝当前位置的新 MD 范围。
|
|
|
double newFractureTop = fractureTopMD;
|
|
|
double newFractureBottom = fractureBottomMD;
|
|
|
|
|
|
// --- 核心逻辑：寻找范围的交集 ---
|
|
|
// 新的裁剪起始 MD 是射孔当前起始 MD 和裂缝新顶部 MD 中的较大者。
|
|
|
// 这正确处理了从顶部进行的裁剪。
|
|
|
double newCroppedStart = qMax(currentCroppedStart, newFractureTop);
|
|
|
|
|
|
// 新的裁剪结束 MD 是射孔当前结束 MD 和裂缝新底部 MD 中的较小者。
|
|
|
// 这正确处理了从底部进行的裁剪。
|
|
|
double newCroppedEnd = qMin(currentCroppedEnd, newFractureBottom);
|
|
|
|
|
|
// 如果新的裁剪范围是有效的（起始 < 结束），我们才进行更新。
|
|
|
if(newCroppedStart < newCroppedEnd) {
|
|
|
m_dCroppedMdStart = newCroppedStart;
|
|
|
m_dCroppedMdEnd = newCroppedEnd;
|
|
|
} else {
|
|
|
// 如果新范围无效（例如，完全超出裂缝范围），
|
|
|
// 我们可以将裁剪范围设置为一个无效状态，以便图元被隐藏。
|
|
|
m_dCroppedMdStart = mdStart;
|
|
|
m_dCroppedMdEnd = mdStart;
|
|
|
}
|
|
|
|
|
|
// 调用渲染函数，并传入更新后的裁剪 MD 值。
|
|
|
updatePerforationAndHandleGeometry(m_dCroppedMdStart, m_dCroppedMdEnd);
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::updatePerforationAndHandleGeometry(double mdStartToRender, double mdEndToRender)
|
|
|
{
|
|
|
// 如果没有关联数据，则不进行更新
|
|
|
if(!m_pPerforationData) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 计算射孔本体在场景中的起始和结束点
|
|
|
QPointF sceneStartPoint = getScenePointFromMd(mdStartToRender); // 计算起点MD对应的场景坐标
|
|
|
QPointF sceneEndPoint = getScenePointFromMd(mdEndToRender); // 计算终点MD对应的场景坐标
|
|
|
|
|
|
// 计算射孔的视觉长度（像素）
|
|
|
double perforationVisualLength = QLineF(sceneStartPoint, sceneEndPoint).length();
|
|
|
|
|
|
// 计算井筒的方向向量和角度 (用于射孔本体和手柄的旋转)
|
|
|
QVector2D wellboreVector = QVector2D(m_wellboreVisualLine.p2() - m_wellboreVisualLine.p1());
|
|
|
qreal wellboreAngleRad = qAtan2(wellboreVector.y(), wellboreVector.x());
|
|
|
qreal wellboreAngleDegrees = wellboreAngleRad * 180.0 / M_PI;
|
|
|
|
|
|
// 计算射孔中心点对应的场景坐标
|
|
|
QPointF scenePerforationCenter = getScenePointFromMd((mdStartToRender + mdEndToRender) / 2.0);
|
|
|
|
|
|
// *** 更新射孔本体的几何形状 ***
|
|
|
// 设置射孔图形项的位置和旋转
|
|
|
// 注意：这里的 setPos 和 setRotation 是针对射孔本体 (this) 的
|
|
|
setPos(scenePerforationCenter); // 设置图形项的中心点到射孔中心
|
|
|
setTransformOriginPoint(0, 0); // 旋转的原点设为图形项的中心
|
|
|
setRotation(wellboreAngleDegrees); // 设置旋转角度，使射孔与井筒对齐
|
|
|
|
|
|
// 设置射孔本体的矩形区域（局部坐标系）
|
|
|
// 这个矩形是相对于 setPos 设置的中心点的
|
|
|
QRectF localPerforationRect(-perforationVisualLength / 2.0, // X 轴起点
|
|
|
-m_dPerWidth / 2.0, // Y 轴起点
|
|
|
perforationVisualLength, // 宽度
|
|
|
m_dPerWidth); // 高度
|
|
|
setRect(localPerforationRect);
|
|
|
|
|
|
// *** 更新手柄的几何形状 ***
|
|
|
// 由于手柄和射孔本体是兄弟项（拥有相同的父项），
|
|
|
// 它们的位置需要直接在共同父项的坐标系中（通常是场景坐标系）设置。
|
|
|
if(m_pStartHandle && m_pEndHandle) {
|
|
|
qreal halfHandleSize = m_handleSize / 2.0;
|
|
|
|
|
|
// 手柄的矩形是相对于其自身的 pos() 的。
|
|
|
// 所以，先设置手柄自身的局部矩形（通常以其自身中心为 (0,0)），
|
|
|
// 然后通过 setPos 将手柄移动到场景中的正确位置。
|
|
|
QRectF handleLocalRect(-halfHandleSize, -halfHandleSize, m_handleSize, m_handleSize);
|
|
|
m_pStartHandle->setRect(handleLocalRect);
|
|
|
m_pEndHandle->setRect(handleLocalRect);
|
|
|
|
|
|
// 关键：直接将手柄的 pos() 设置为场景坐标
|
|
|
// getScenePointFromMd 返回的就是场景坐标，直接用于 setPos()
|
|
|
m_pStartHandle->setPos(sceneStartPoint);
|
|
|
m_pEndHandle->setPos(sceneEndPoint);
|
|
|
|
|
|
// 如果手柄也需要与井筒对齐旋转，则它们也需要设置旋转角度
|
|
|
m_pStartHandle->setTransformOriginPoint(0, 0); // 相对自身中心旋转
|
|
|
m_pEndHandle->setTransformOriginPoint(0, 0);
|
|
|
m_pStartHandle->setRotation(wellboreAngleDegrees);
|
|
|
m_pEndHandle->setRotation(wellboreAngleDegrees);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QPointF nmPerforationGraphicsItem::getScenePointFromMd(double md) const
|
|
|
{
|
|
|
// 防止除零或负长度
|
|
|
if(qFuzzyIsNull(m_totalWellboreMdLength) || m_totalWellboreMdLength < 0) {
|
|
|
return m_wellboreStartScenePoint;
|
|
|
}
|
|
|
|
|
|
// 计算相对MD（从井筒起始MD开始算）
|
|
|
double relativeMd = md - m_wellboreStartAbsoluteMd;
|
|
|
// 计算井筒视觉长度
|
|
|
double wellboreVisualLength = QLineF(m_wellboreStartScenePoint, m_wellboreEndScenePoint).length();
|
|
|
|
|
|
if(qFuzzyIsNull(wellboreVisualLength)) {
|
|
|
return m_wellboreStartScenePoint;
|
|
|
}
|
|
|
|
|
|
// 计算MD到像素的缩放比例
|
|
|
double mdToVisualScale = wellboreVisualLength / m_totalWellboreMdLength;
|
|
|
// 计算沿井筒方向的视觉距离
|
|
|
double distanceAlongWellbore = relativeMd * mdToVisualScale;
|
|
|
// 计算井筒方向的单位向量
|
|
|
QVector2D wellboreDirection = QVector2D(m_wellboreEndScenePoint - m_wellboreStartScenePoint);
|
|
|
|
|
|
if(qFuzzyIsNull(wellboreDirection.length())) {
|
|
|
return m_wellboreStartScenePoint;
|
|
|
}
|
|
|
|
|
|
wellboreDirection.normalize(); // 归一化为单位向量
|
|
|
// 返回根据距离和方向计算出的场景点
|
|
|
return m_wellboreStartScenePoint + (wellboreDirection * distanceAlongWellbore).toPointF();
|
|
|
}
|
|
|
|
|
|
double nmPerforationGraphicsItem::getMdFromScenePointOnWellbore(const QPointF& scenePoint) const
|
|
|
{
|
|
|
// 直井筒的简化计算
|
|
|
if(m_eWellType == NM_WELL_MODEL::Vertical_Well || m_eWellType == NM_WELL_MODEL::Vertical_Fractured_Well) {
|
|
|
double yOffset = scenePoint.y() - m_wellboreStartScenePoint.y();
|
|
|
double wellboreVisualLength = QLineF(m_wellboreStartScenePoint, m_wellboreEndScenePoint).length();
|
|
|
|
|
|
if(qFuzzyIsNull(wellboreVisualLength)) {
|
|
|
return m_wellboreStartAbsoluteMd;
|
|
|
}
|
|
|
|
|
|
double mdScale = m_totalWellboreMdLength / wellboreVisualLength;
|
|
|
return m_wellboreStartAbsoluteMd + yOffset * mdScale;
|
|
|
}
|
|
|
|
|
|
// 针对其他井筒类型，使用投影计算
|
|
|
QPointF p1 = m_wellboreStartScenePoint;
|
|
|
QPointF p2 = m_wellboreEndScenePoint;
|
|
|
QLineF wellboreLine(p1, p2);
|
|
|
|
|
|
if(qFuzzyIsNull(wellboreLine.length()) || qFuzzyIsNull(m_totalWellboreMdLength) || m_totalWellboreMdLength <= 0) {
|
|
|
return m_wellboreStartAbsoluteMd;
|
|
|
}
|
|
|
|
|
|
// 计算点在井筒线上的投影比例
|
|
|
QVector2D vecAP = QVector2D(scenePoint - p1);
|
|
|
QVector2D vecAB = QVector2D(p2 - p1);
|
|
|
double dotProduct_AP_AB = QVector2D::dotProduct(vecAP, vecAB);
|
|
|
double lenSq_AB = vecAB.lengthSquared();
|
|
|
double t = 0.0;
|
|
|
|
|
|
if(!qFuzzyIsNull(lenSq_AB)) {
|
|
|
t = dotProduct_AP_AB / lenSq_AB;
|
|
|
}
|
|
|
|
|
|
t = qBound(0.0, t, 1.0); // 将比例限制在 0.0 到 1.0 之间
|
|
|
// 计算投影点沿井筒的距离
|
|
|
double distanceAlongVisualWellbore = wellboreLine.length() * t;
|
|
|
double wellboreVisualLength = wellboreLine.length();
|
|
|
double mdToVisualScale = 0.0;
|
|
|
|
|
|
if(!qFuzzyIsNull(m_totalWellboreMdLength)) {
|
|
|
mdToVisualScale = wellboreVisualLength / m_totalWellboreMdLength;
|
|
|
}
|
|
|
|
|
|
if(qFuzzyIsNull(mdToVisualScale)) {
|
|
|
return m_wellboreStartAbsoluteMd;
|
|
|
}
|
|
|
|
|
|
// 将视觉距离转换为MD
|
|
|
double relativeMd = distanceAlongVisualWellbore / mdToVisualScale;
|
|
|
return m_wellboreStartAbsoluteMd + relativeMd;
|
|
|
}
|
|
|
|
|
|
double nmPerforationGraphicsItem::getCroppedMdStart()
|
|
|
{
|
|
|
return m_dCroppedMdStart;
|
|
|
}
|
|
|
|
|
|
double nmPerforationGraphicsItem::getCroppedMdEnd()
|
|
|
{
|
|
|
return m_dCroppedMdEnd;
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::updateVisualsForWellboreDrag(const QPointF& wellboreStartScene, const QPointF& wellboreEndScene,
|
|
|
double wellboreStartAbsoluteMd, double originalWellboreLength,
|
|
|
double newWellboreLength)
|
|
|
{
|
|
|
// 如果旧井筒MD长度无效，则直接返回
|
|
|
if(qFuzzyIsNull(originalWellboreLength) || originalWellboreLength <= 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 临时更新井筒的视觉信息，确保 getScenePointFromMd 函数能够使用最新的几何信息
|
|
|
m_wellboreStartScenePoint = wellboreStartScene;
|
|
|
m_wellboreEndScenePoint = wellboreEndScene;
|
|
|
m_wellboreVisualLine.setPoints(wellboreStartScene, wellboreEndScene);
|
|
|
|
|
|
// 从数据模型中获取原始MD值（这些是拖动开始时的旧值）
|
|
|
double originalMdStart = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
double originalMdEnd = m_pPerforationData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
// 关键修正1: 在预览模式下，我们将井筒的总MD长度临时设置为新的井筒像素长度。
|
|
|
// 这样，MD值和像素长度就有了1:1的比例关系，确保了 MD 到像素转换的正确性。
|
|
|
m_totalWellboreMdLength = newWellboreLength;
|
|
|
|
|
|
// 关键修正2: 基于原始MD和旧MD长度，计算射孔的相对比例
|
|
|
double relativeStart = (originalMdStart - wellboreStartAbsoluteMd) / originalWellboreLength;
|
|
|
double relativeEnd = (originalMdEnd - wellboreStartAbsoluteMd) / originalWellboreLength;
|
|
|
|
|
|
// 关键修正3: 根据新的虚拟MD长度（即newWellboreLength），按比例计算出新的MD值
|
|
|
// 这些MD值是临时的，只用于渲染，并不修改数据模型
|
|
|
double newMdStart = wellboreStartAbsoluteMd + relativeStart * m_totalWellboreMdLength;
|
|
|
double newMdEnd = wellboreStartAbsoluteMd + relativeEnd * m_totalWellboreMdLength;
|
|
|
|
|
|
// 调用渲染函数，传入计算出的新MD值进行渲染
|
|
|
updatePerforationAndHandleGeometry(newMdStart, newMdEnd);
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
Q_UNUSED(option);
|
|
|
Q_UNUSED(widget);
|
|
|
|
|
|
// --- 1. 获取视图和缩放比例 ---
|
|
|
// 前提条件检查：必须能获取到场景和视图
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
// 获取场景关联的第一个视图
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 从视图获取变换矩阵，这比从painter获取更稳定
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
// 获取垂直缩放因子。使用 qAbs() 来处理坐标系翻转（scaleY为负）的情况
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
// --- 2. 核心计算（与之前相同，但基于更可靠的scaleY） ---
|
|
|
if (scaleY < 1e-6) { // 安全检查，避免除以一个极小或为零的数
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 定义在屏幕上看到的固定厚度
|
|
|
const qreal fixedVisualHeightInPixels = 15.0;
|
|
|
|
|
|
// 动态计算在当前缩放级别下，为达到目标像素厚度，所需的几何高度
|
|
|
const qreal dynamicGeomHeight = fixedVisualHeightInPixels / scaleY;
|
|
|
|
|
|
// --- 3. 创建并绘制矩形 ---
|
|
|
const QRectF originalGeomRect = this->rect();
|
|
|
|
|
|
// 创建一个用于本次绘制的新矩形
|
|
|
QRectF rectToDraw(0, 0, originalGeomRect.width(), dynamicGeomHeight);
|
|
|
rectToDraw.moveCenter(originalGeomRect.center());
|
|
|
|
|
|
// 使用纯色填充来绘制
|
|
|
painter->setPen(Qt::NoPen);
|
|
|
painter->setBrush(Qt::red);
|
|
|
painter->drawRect(rectToDraw);
|
|
|
}
|
|
|
|
|
|
QRectF nmPerforationGraphicsItem::boundingRect() const
|
|
|
{
|
|
|
return this->rect();
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 如果不可编辑，则调用基类事件并返回
|
|
|
if(!m_bEditable) {
|
|
|
QGraphicsRectItem::mousePressEvent(event);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
m_lastMouseScenePos = event->scenePos(); // 记录鼠标按下的场景坐标
|
|
|
|
|
|
// 获取鼠标点击位置最顶层的图形项
|
|
|
QGraphicsItem* clickedItem = scene()->itemAt(event->scenePos(), QTransform());
|
|
|
|
|
|
// 根据点击的图形项类型设置交互模式
|
|
|
if(clickedItem == m_pStartHandle) { // 点击了起点手柄
|
|
|
double dStartMd = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
bool isStartAtWellboreOrigin = qFuzzyCompare(dStartMd, m_wellboreStartAbsoluteMd);
|
|
|
|
|
|
// 特殊处理水平裂缝井，如果起点在井筒原点，则不允许拖动起点
|
|
|
if(m_eWellType == NM_WELL_MODEL::Horizontal_Fractured_Well && isStartAtWellboreOrigin) {
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::Normal;
|
|
|
event->ignore(); // 忽略事件，不处理
|
|
|
} else {
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::ResizeStart; // 进入调整起点模式
|
|
|
m_initialMdStart = dStartMd; // 记录拖动开始时 Model 的原始起点MD
|
|
|
m_initialMdEnd = m_pPerforationData->getMdEnd().getValue().toDouble(); // 记录拖动开始时 Model 的原始终点MD
|
|
|
// 拖动开始时，设置临时MD值与 Model 真实值一致，并设置拖动标志
|
|
|
m_tempDragMdStart = m_initialMdStart;
|
|
|
m_tempDragMdEnd = m_initialMdEnd;
|
|
|
m_isDragging = true; // 标志开始拖动
|
|
|
event->accept(); // 接受事件，表示已处理
|
|
|
}
|
|
|
} else if(clickedItem == m_pEndHandle) { // 点击了终点手柄
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::ResizeEnd; // 进入调整终点模式
|
|
|
m_initialMdStart = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
m_initialMdEnd = m_pPerforationData->getMdEnd().getValue().toDouble();
|
|
|
// 拖动开始时，设置临时MD值与 Model 真实值一致，并设置拖动标志
|
|
|
m_tempDragMdStart = m_initialMdStart;
|
|
|
m_tempDragMdEnd = m_initialMdEnd;
|
|
|
m_isDragging = true;
|
|
|
event->accept();
|
|
|
} else {
|
|
|
// 如果点击的是射孔本体（而不是手柄）
|
|
|
// 注意：这里的 rect() 和 mapFromScene() 是针对 nmPerforationGraphicsItem 自身的局部坐标系
|
|
|
if(rect().contains(mapFromScene(event->scenePos()))) { // 检查点击点是否在射孔本体的局部矩形内
|
|
|
double dStartMd = m_pPerforationData->getMdStart().getValue().toDouble();
|
|
|
bool isStartAtWellboreOrigin = qFuzzyCompare(dStartMd, m_wellboreStartAbsoluteMd);
|
|
|
|
|
|
// 特殊处理水平裂缝井，如果起点在井筒原点，则不允许移动整个射孔
|
|
|
if(m_eWellType == NM_WELL_MODEL::Horizontal_Fractured_Well && isStartAtWellboreOrigin) {
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::Normal;
|
|
|
event->ignore();
|
|
|
} else {
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::MoveItem; // 进入移动整个项模式
|
|
|
|
|
|
if(flags() & ItemIsSelectable) {
|
|
|
setSelected(true); // 如果可选择，则选中该项
|
|
|
}
|
|
|
|
|
|
// 拖动开始时，设置临时MD值与 Model 真实值一致，并设置拖动标志
|
|
|
m_tempDragMdStart = m_initialMdStart;
|
|
|
m_tempDragMdEnd = m_initialMdEnd;
|
|
|
m_isDragging = true;
|
|
|
event->accept();
|
|
|
}
|
|
|
} else {
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::Normal; // 否则回到正常模式
|
|
|
QGraphicsRectItem::mousePressEvent(event); // 调用基类事件
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 再次检查，如果进入了某种交互模式，则接受事件
|
|
|
if(m_eCurrentInteractionMode != PerforationInteractionMode::Normal) {
|
|
|
event->accept();
|
|
|
} else {
|
|
|
QGraphicsRectItem::mousePressEvent(event); // 否则调用基类事件
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 如果不可编辑，或者不是在拖动，或者不是正在进行交互模式，则调用基类事件并返回
|
|
|
if(!m_bEditable || m_eCurrentInteractionMode == PerforationInteractionMode::Normal || !m_isDragging) {
|
|
|
QGraphicsRectItem::mouseMoveEvent(event);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QPointF currentScenePos = event->scenePos(); // 获取当前鼠标的场景坐标
|
|
|
double newMd = getMdFromScenePointOnWellbore(currentScenePos); // 计算当前鼠标位置对应的MD值
|
|
|
|
|
|
// 应该取自 m_tempDragMdEnd 和 m_tempDragMdStart，以保持与当前拖动状态一致，而不是模型当前值。
|
|
|
// 因为模型尚未更新，如果取模型当前值，可能会导致在拖动过程中再次被旧数据限制。
|
|
|
double dCurrentDragEndMd = m_tempDragMdEnd;
|
|
|
//double dCurrentDragStartMd = m_tempDragMdStart;
|
|
|
|
|
|
double dProposedMdStart = m_initialMdStart; // 默认使用拖动开始时的原始起点MD
|
|
|
double dProposedMdEnd = m_initialMdEnd; // 默认使用拖动开始时的原始终点MD
|
|
|
|
|
|
// 根据当前交互模式计算建议的MD值
|
|
|
if(m_eCurrentInteractionMode == PerforationInteractionMode::ResizeStart) {
|
|
|
dProposedMdStart = newMd; // 如果是调整起点，新起点就是当前鼠标位置的MD
|
|
|
} else if(m_eCurrentInteractionMode == PerforationInteractionMode::ResizeEnd) {
|
|
|
dProposedMdEnd = newMd; // 如果是调整终点，新终点就是当前鼠标位置的MD
|
|
|
} else if(m_eCurrentInteractionMode == PerforationInteractionMode::MoveItem) {
|
|
|
// 计算MD位移量。这里采用了增量计算：当前鼠标位置与上次位置的MD差值
|
|
|
QPointF deltaScene = currentScenePos - m_lastMouseScenePos; // 当前帧的像素位移
|
|
|
|
|
|
double mdDelta;
|
|
|
|
|
|
if(m_eWellType == NM_WELL_MODEL::Vertical_Well) {
|
|
|
mdDelta = deltaScene.y(); // 垂直井筒通常只关注Y轴位移
|
|
|
} else {
|
|
|
QLineF wellboreDirLine(m_wellboreStartScenePoint, m_wellboreEndScenePoint);
|
|
|
|
|
|
if(qFuzzyIsNull(wellboreDirLine.length()) || qFuzzyIsNull(m_totalWellboreMdLength) || m_totalWellboreMdLength <= 0) {
|
|
|
mdDelta = 0.0; // 防止除零
|
|
|
} else {
|
|
|
// 计算鼠标位移在井筒方向上的投影，并转换为MD值
|
|
|
QVector2D wellboreUnitVec = QVector2D(wellboreDirLine.p2() - wellboreDirLine.p1()).normalized();
|
|
|
double visualMoveAlongWellbore = QVector2D::dotProduct(QVector2D(deltaScene), wellboreUnitVec);
|
|
|
mdDelta = visualMoveAlongWellbore / wellboreDirLine.length() * m_totalWellboreMdLength;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 对于移动操作，将计算出的MD位移量累加到当前的临时MD值上
|
|
|
dProposedMdStart = m_tempDragMdStart + mdDelta;
|
|
|
dProposedMdEnd = m_tempDragMdEnd + mdDelta;
|
|
|
}
|
|
|
|
|
|
// 获取父级视图，用于获取MD范围限制
|
|
|
nmAbstractWellboreVisual* parentView = static_cast<nmAbstractWellboreVisual*>(parentItem());
|
|
|
|
|
|
if(parentView) {
|
|
|
double dUpperAllowedMd = -DBL_MAX; // 允许的最小MD值（上限）
|
|
|
double dLowerAllowedMd = DBL_MAX; // 允许的最大MD值（下限）
|
|
|
// 获取射孔允许的MD范围，这个函数应该基于 Model 的当前数据来判断限制
|
|
|
parentView->getWellData()->getPerforationAllowedMdRange(m_pPerforationData, dUpperAllowedMd, dLowerAllowedMd);
|
|
|
|
|
|
// 应用MD范围限制
|
|
|
if(m_eCurrentInteractionMode == PerforationInteractionMode::ResizeStart) {
|
|
|
dProposedMdStart = qMax(dProposedMdStart, dUpperAllowedMd); // 起点不能小于允许的上限
|
|
|
dProposedMdStart = qMin(dProposedMdStart, dCurrentDragEndMd); // 起点不能大于 Model 的当前终点MD
|
|
|
} else if(m_eCurrentInteractionMode == PerforationInteractionMode::ResizeEnd) {
|
|
|
dProposedMdEnd = qMin(dProposedMdEnd, dLowerAllowedMd); // 终点不能大于允许的下限
|
|
|
dProposedMdEnd = qMax(dProposedMdEnd, m_pPerforationData->getMdStart().getValue().toDouble()); // 终点不能小于 Model 的当前起点MD
|
|
|
} else if(m_eCurrentInteractionMode == PerforationInteractionMode::MoveItem) {
|
|
|
// 移动模式下的边界限制
|
|
|
// 使用拖动开始时的原始长度来保持长度不变
|
|
|
double dPerforationLength = m_initialMdEnd - m_initialMdStart;
|
|
|
|
|
|
if(dProposedMdEnd > dLowerAllowedMd) { // 如果终点超出下限
|
|
|
dProposedMdEnd = dLowerAllowedMd; // 将终点设为下限
|
|
|
dProposedMdStart = dProposedMdEnd - dPerforationLength; // 起点也相应调整
|
|
|
}
|
|
|
|
|
|
if(dProposedMdStart < dUpperAllowedMd) { // 如果起点超出上限
|
|
|
dProposedMdStart = dUpperAllowedMd; // 将起点设为上限
|
|
|
dProposedMdEnd = dProposedMdStart + dPerforationLength; // 终点也相应调整
|
|
|
}
|
|
|
|
|
|
if(dProposedMdStart > dProposedMdEnd) { // 确保射孔长度不为负 (起点MD不能大于终点MD)
|
|
|
dProposedMdStart = dProposedMdEnd; // 如果出现这种情况，将起点MD设为终点MD，变为零长度
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 关键：更新临时变量，并使用它们进行局部视图更新
|
|
|
m_tempDragMdStart = dProposedMdStart; // 保存计算出的建议起点MD到临时变量
|
|
|
m_tempDragMdEnd = dProposedMdEnd; // 保存计算出的建议终点MD到临时变量
|
|
|
|
|
|
// 局部更新视图：直接调用 updatePerforationAndHandleGeometry，传入临时MD值进行渲染
|
|
|
// 此时不修改数据模型，也不发射信号，只更新屏幕显示。
|
|
|
// 手柄和射孔本体都会根据这些临时 MD 值重新计算并设置其在场景中的位置。
|
|
|
updatePerforationAndHandleGeometry(m_tempDragMdStart, m_tempDragMdEnd);
|
|
|
|
|
|
m_lastMouseScenePos = currentScenePos; // 更新鼠标位置，为下一次移动做准备
|
|
|
event->accept(); // 接受事件，表示已处理
|
|
|
}
|
|
|
|
|
|
void nmPerforationGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 如果不可编辑，则调用基类事件并返回
|
|
|
if(!m_bEditable) {
|
|
|
QGraphicsRectItem::mouseReleaseEvent(event);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
m_eCurrentInteractionMode = PerforationInteractionMode::Normal; // 鼠标释放后，回到正常模式
|
|
|
|
|
|
QGraphicsRectItem::mouseReleaseEvent(event); // 调用基类的鼠标释放事件
|
|
|
|
|
|
// 关键：鼠标释放（拖动完成）时，发射最终的请求信号
|
|
|
// 只有在确实进行了拖动操作并且关联了数据模型时才发射信号
|
|
|
if(m_isDragging && m_pPerforationData) {
|
|
|
// 发射信号，请求控制器更新数据。直接传递 m_pPerforationData 指针和最终的临时MD值
|
|
|
emit sigRequestPerforationMdUpdate(m_pPerforationData,
|
|
|
m_tempDragMdStart,
|
|
|
m_tempDragMdEnd);
|
|
|
|
|
|
// 同步 m_initialMdStart 和 m_initialMdEnd
|
|
|
// 确保下一次鼠标按下时的“原始位置”是本次拖动结束后的新位置
|
|
|
m_initialMdStart = m_tempDragMdStart;
|
|
|
m_initialMdEnd = m_tempDragMdEnd;
|
|
|
}
|
|
|
|
|
|
// 重置拖动标志
|
|
|
m_isDragging = false; // 拖动操作结束
|
|
|
|
|
|
event->accept(); // 接受事件，表示已处理
|
|
|
}
|
|
|
|
|
|
|
|
|
nmFractureLineHandleItem::nmFractureLineHandleItem(QGraphicsItem *parent)
|
|
|
: QObject(nullptr), // 初始化 QObject 部分
|
|
|
QGraphicsRectItem(parent), // 初始化 QGraphicsRectItem 部分
|
|
|
m_bIsDragging(false)
|
|
|
{
|
|
|
// 默认样式，可以在外部设置
|
|
|
setBrush(QBrush(Qt::red));
|
|
|
setPen(QPen(Qt::black, 1));
|
|
|
setRect(-5, -5, 10, 10); // 默认大小，居中
|
|
|
setZValue(2.0); // 确保在裂缝之上
|
|
|
}
|
|
|
|
|
|
void nmFractureLineHandleItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(event->button() == Qt::LeftButton) {
|
|
|
m_bIsDragging = true;
|
|
|
m_lastMousePos = event->pos(); // 记录鼠标在手柄局部坐标系中的位置
|
|
|
event->accept(); // 接受这个事件，防止事件传递给父项或视图
|
|
|
} else {
|
|
|
event->ignore(); // 忽略其他鼠标按钮
|
|
|
}
|
|
|
|
|
|
//QGraphicsRectItem::mousePressEvent(event); // 调用基类实现（重要）
|
|
|
}
|
|
|
|
|
|
void nmFractureLineHandleItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bIsDragging) {
|
|
|
// 获取当前鼠标位置（场景坐标）
|
|
|
QPointF currentScenePos = event->scenePos();
|
|
|
// 获取上一次鼠标位置（场景坐标）
|
|
|
QPointF lastScenePos = mapToScene(m_lastMousePos);
|
|
|
// 计算增量（场景坐标）
|
|
|
QPointF deltaScene = currentScenePos - lastScenePos;
|
|
|
// 转换为父项坐标的增量
|
|
|
QPointF deltaParent = parentItem()->mapFromScene(currentScenePos) - parentItem()->mapFromScene(lastScenePos);
|
|
|
// 更新位置（父项坐标）
|
|
|
setPos(pos() + deltaParent);
|
|
|
// 发出信号（传递父项坐标）
|
|
|
emit handlePositionChanged(this, pos(), m_bIsDragging);
|
|
|
// 更新记录（局部坐标）
|
|
|
m_lastMousePos = mapFromScene(currentScenePos);
|
|
|
|
|
|
event->accept(); // 接受事件
|
|
|
} else {
|
|
|
event->ignore();
|
|
|
}
|
|
|
|
|
|
QGraphicsRectItem::mouseMoveEvent(event); // 调用基类实现（重要）
|
|
|
}
|
|
|
|
|
|
void nmFractureLineHandleItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bIsDragging) {
|
|
|
m_bIsDragging = false;
|
|
|
|
|
|
// 发出信号通知父级裂缝项，手柄位置已改变
|
|
|
emit handlePositionChanged(this, pos(), m_bIsDragging);
|
|
|
event->accept();
|
|
|
|
|
|
} else {
|
|
|
event->ignore();
|
|
|
}
|
|
|
|
|
|
QGraphicsRectItem::mouseReleaseEvent(event); // 调用基类实现（重要）
|
|
|
}
|
|
|
|
|
|
void nmFractureLineHandleItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
// 1. 获取视图缩放比例
|
|
|
QGraphicsScene* pScene = scene();
|
|
|
if (!pScene || pScene->views().isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QGraphicsView* view = pScene->views().first();
|
|
|
if (!view) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
// 截面图，依然使用 Y 轴缩放
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 2. 定义手柄和边框的固定像素大小
|
|
|
const qreal fixedHandleSizeInPixels = 13.0;
|
|
|
const qreal fixedBorderWidthInPixels = 2.0; // 定义边框的像素宽度
|
|
|
|
|
|
// 3. 根据缩放比例计算动态大小
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
const qreal dynamicBorderWidth = fixedBorderWidthInPixels / scaleY; // 计算动态边框宽度
|
|
|
|
|
|
// 4. 定义手柄的矩形区域
|
|
|
QRectF handleRect(-dynamicHandleSize / 2, -dynamicHandleSize / 2, dynamicHandleSize, dynamicHandleSize);
|
|
|
|
|
|
// 5. 创建一个新的 QPen 用于绘制边框
|
|
|
QPen pen(Qt::black); // 颜色为黑色
|
|
|
pen.setWidthF(dynamicBorderWidth); // 设置动态计算出的宽度
|
|
|
|
|
|
painter->setPen(pen);
|
|
|
painter->setBrush(Qt::red); // 填充颜色保持为红色
|
|
|
painter->drawRect(handleRect); // 绘制带边框的矩形
|
|
|
}
|
|
|
|
|
|
QRectF nmFractureLineHandleItem::boundingRect() const
|
|
|
{
|
|
|
// 1. 获取视图缩放比例
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
// 2. 使用与paint方法相同的动态大小计算
|
|
|
const qreal fixedHandleSizeInPixels = 13.0;
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
|
|
|
// 3. 返回动态计算的矩形
|
|
|
return QRectF(-dynamicHandleSize / 2, -dynamicHandleSize / 2,
|
|
|
dynamicHandleSize, dynamicHandleSize);
|
|
|
}
|
|
|
|
|
|
#include "nmDataVerticalFracturedWell.h"
|
|
|
nmFractureLineGraphicsItem::nmFractureLineGraphicsItem(QGraphicsItem *parent)
|
|
|
: QGraphicsLineItem(parent),
|
|
|
m_bEditMode(false)
|
|
|
{
|
|
|
// 设置裂缝线的样式
|
|
|
//setPen(QPen(QColor("#1e90ff"), 5.0));
|
|
|
//createHandles();
|
|
|
QPen fracturePen(QColor("#1e90ff"), 5.0);
|
|
|
fracturePen.setCosmetic(true);
|
|
|
setPen(fracturePen);
|
|
|
createHandles();
|
|
|
}
|
|
|
|
|
|
void nmFractureLineGraphicsItem::setStyle(const QPen& pen)
|
|
|
{
|
|
|
QPen cosmetic_pen = pen;
|
|
|
cosmetic_pen.setWidth(0);
|
|
|
cosmetic_pen.setCosmetic(true);
|
|
|
setPen(cosmetic_pen);
|
|
|
//setPen(pen);
|
|
|
}
|
|
|
|
|
|
void nmFractureLineGraphicsItem::setEditMode(bool enable)
|
|
|
{
|
|
|
if(m_bEditMode == enable) {
|
|
|
return; // 状态未改变，无需操作
|
|
|
}
|
|
|
|
|
|
m_bEditMode = enable;
|
|
|
|
|
|
if(m_pHandle1 && m_pHandle2) {
|
|
|
m_pHandle1->setVisible(enable); // 根据模式显示或隐藏手柄
|
|
|
m_pHandle2->setVisible(enable);
|
|
|
|
|
|
// 如果进入编辑模式，确保手柄位置是最新的
|
|
|
if(enable) {
|
|
|
updateHandlesPosition();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 强制更新视图，确保手柄的显示/隐藏立即生效
|
|
|
//scene()->update();
|
|
|
}
|
|
|
|
|
|
void nmFractureLineGraphicsItem::createHandles()
|
|
|
{
|
|
|
// 使用裂缝手柄类
|
|
|
m_pHandle1 = new nmFractureLineHandleItem(this); // 以当前裂缝项为父项
|
|
|
m_pHandle2 = new nmFractureLineHandleItem(this);
|
|
|
|
|
|
// 连接手柄的信号到本类的槽函数
|
|
|
connect(m_pHandle1, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
connect(m_pHandle2, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
|
|
|
// 创建完隐藏手柄
|
|
|
m_pHandle1->setVisible(false);
|
|
|
m_pHandle2->setVisible(false);
|
|
|
}
|
|
|
|
|
|
void nmFractureLineGraphicsItem::updateHandlesPosition()
|
|
|
{
|
|
|
if(m_pHandle1 && m_pHandle2) {
|
|
|
// 因为手柄是子项，它们的pos是相对于父项（裂缝项）的
|
|
|
m_pHandle1->setPos(line().p1());
|
|
|
m_pHandle2->setPos(line().p2());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 槽函数的实现
|
|
|
void nmFractureLineGraphicsItem::onHandlePositionChanged(nmFractureLineHandleItem* handle, QPointF newPos, bool isDragging)
|
|
|
{
|
|
|
// 在这里直接调用更新裂缝的函数
|
|
|
if(m_bEditMode) {
|
|
|
updateFractureFromHandle(handle, newPos, isDragging);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 修改 updateFractureFromHandle 的参数类型
|
|
|
void nmFractureLineGraphicsItem::updateFractureFromHandle(nmFractureLineHandleItem* draggedHandle, const QPointF& newHandlePosInParent, bool isDragging)
|
|
|
{
|
|
|
// 因为 nmFractureLineGraphicsItem 的 pos() 已经被设置到井筒位置，所以这个 (0,0) 就是井筒。
|
|
|
QPointF fractureCenterInLocal = QPointF(0, 0);
|
|
|
QPointF p1_new_local, p2_new_local;
|
|
|
|
|
|
if(draggedHandle == m_pHandle1) {
|
|
|
p1_new_local = newHandlePosInParent;
|
|
|
QPointF vecToDragged = p1_new_local - fractureCenterInLocal;
|
|
|
p2_new_local = fractureCenterInLocal - vecToDragged;
|
|
|
} else { // draggedHandle == m_pHandle2
|
|
|
p2_new_local = newHandlePosInParent;
|
|
|
QPointF vecToDragged = p2_new_local - fractureCenterInLocal;
|
|
|
p1_new_local = fractureCenterInLocal - vecToDragged;
|
|
|
}
|
|
|
|
|
|
// 设置裂缝线和手柄位置（此部分应保持在 mouseMoveEvent 链中）
|
|
|
setLine(QLineF(p1_new_local, p2_new_local));
|
|
|
updateHandlesPosition();
|
|
|
|
|
|
// 拖动结束后发送信号
|
|
|
if(!isDragging) {
|
|
|
// 将局部坐标转换为场景坐标
|
|
|
QPointF fractureCenterInScene = mapToScene(fractureCenterInLocal);
|
|
|
QPointF p1_scene = mapToScene(p1_new_local);
|
|
|
|
|
|
// 计算半长
|
|
|
double newHalfLength = QLineF(fractureCenterInScene, p1_scene).length();
|
|
|
|
|
|
// 计算并归一化裂缝角度
|
|
|
double dx = p1_scene.x() - fractureCenterInScene.x();
|
|
|
double dy = p1_scene.y() - fractureCenterInScene.y();
|
|
|
|
|
|
// 使用 qAtan2 获得角度（从正X轴逆时针旋转）
|
|
|
double angleRadians = qAtan2(dy, dx);
|
|
|
double angleDegrees = angleRadians * 180.0 / M_PI;
|
|
|
|
|
|
// 将角度归一化到 [-90, 90] 的范围
|
|
|
// 这一步简化了你原有的复杂if/else结构，但实现了同样的效果
|
|
|
if(angleDegrees > 90) {
|
|
|
angleDegrees -= 180;
|
|
|
} else if(angleDegrees < -90) {
|
|
|
angleDegrees += 180;
|
|
|
}
|
|
|
|
|
|
double finalAngle = angleDegrees;
|
|
|
|
|
|
// 核心修改: 不再直接修改模型，而是发出信号
|
|
|
emit sigFractureGeometryChanged(newHalfLength, finalAngle);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmHorizontalFractureGraphicsItem::nmHorizontalFractureGraphicsItem(int index, QGraphicsItem *parent)
|
|
|
: QObject(nullptr), // QObject初始化
|
|
|
QGraphicsLineItem(parent), // QGraphicsLineItem初始化
|
|
|
m_bEditMode(false),
|
|
|
m_fractureIndex(index)
|
|
|
{
|
|
|
// 设置裂缝线的样式
|
|
|
//QPen fracturePen(QColor("#1e90ff"), 3.0); // 裂缝线条颜色为 #1e90ff
|
|
|
//setPen(fracturePen);
|
|
|
QPen fracturePen(QColor("#1e90ff"), 3.0);
|
|
|
fracturePen.setCosmetic(true);
|
|
|
setPen(fracturePen);
|
|
|
|
|
|
// 创建手柄，以当前裂缝项为父项
|
|
|
m_pHandle1 = new nmFractureLineHandleItem(this);
|
|
|
m_pHandle2 = new nmFractureLineHandleItem(this);
|
|
|
|
|
|
// 连接手柄的信号到本类的槽函数
|
|
|
connect(m_pHandle1, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
connect(m_pHandle2, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
|
|
|
// 初始时手柄隐藏
|
|
|
m_pHandle1->setVisible(false);
|
|
|
m_pHandle2->setVisible(false);
|
|
|
setZValue(3); // 确保在井筒之上，手柄在裂缝之上
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFractureGraphicsItem::setStyle(const QPen& pen)
|
|
|
{
|
|
|
QPen cosmetic_pen = pen;
|
|
|
cosmetic_pen.setWidth(0);
|
|
|
cosmetic_pen.setCosmetic(true);
|
|
|
setPen(cosmetic_pen);
|
|
|
//setPen(pen);
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFractureGraphicsItem::updateFractureLineAndHandles(const QPointF& p1, const QPointF& p2)
|
|
|
{
|
|
|
setLine(QLineF(p1, p2));
|
|
|
|
|
|
if(m_pHandle1 && m_pHandle2) {
|
|
|
// 手柄的pos是相对于父项（裂缝线）的
|
|
|
// 所以直接设置到线的端点即可
|
|
|
m_pHandle1->setPos(p1);
|
|
|
m_pHandle2->setPos(p2);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFractureGraphicsItem::setWellboreInfo(const QPointF& wellboreStartScene, const QPointF& wellboreEndScene)
|
|
|
{
|
|
|
m_wellboreStartScene = wellboreStartScene;
|
|
|
m_wellboreEndScene = wellboreEndScene;
|
|
|
|
|
|
// 将 QPointF 转换为 QVector2D 进行归一化
|
|
|
QVector2D tempWellboreDir = QVector2D(wellboreEndScene - wellboreStartScene);
|
|
|
|
|
|
if(!tempWellboreDir.isNull()) { // 检查是否是零向量
|
|
|
m_wellboreDirection = tempWellboreDir.normalized().toPointF(); // 归一化后转换回 QPointF
|
|
|
} else {
|
|
|
m_wellboreDirection = QPointF(1.0, 0.0); // 默认一个方向
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFractureGraphicsItem::setEditMode(bool enable)
|
|
|
{
|
|
|
m_bEditMode = enable;
|
|
|
|
|
|
if(m_pHandle1 && m_pHandle2) {
|
|
|
m_pHandle1->setVisible(enable);
|
|
|
m_pHandle2->setVisible(enable);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFractureGraphicsItem::onHandlePositionChanged(nmFractureLineHandleItem* handle, QPointF newHandlePosInParent, bool isDragging)
|
|
|
{
|
|
|
if(!m_bEditMode) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 1. 获取裂缝中心点 (交点) 在父项（裂缝线）局部坐标系中的位置
|
|
|
QPointF currentFractureCenterInParent = (line().p1() + line().p2()) / 2.0;
|
|
|
|
|
|
// 将新的手柄位置从父项局部坐标转换为场景坐标
|
|
|
QPointF newHandleScenePos = mapToScene(newHandlePosInParent);
|
|
|
|
|
|
// 将裂缝中心点从父项局部坐标转换为场景坐标
|
|
|
QPointF fractureCenterScene = mapToScene(currentFractureCenterInParent);
|
|
|
|
|
|
// 2. 计算手柄新位置在垂直于井筒方向上的投影点
|
|
|
// 垂直于井筒的方向向量 (使用QPointF直接计算，然后转换为QVector2D进行归一化)
|
|
|
QVector2D rawPerpendicularWellboreDirection = QVector2D(-m_wellboreDirection.y(), m_wellboreDirection.x());
|
|
|
QVector2D perpendicularWellboreDirection = rawPerpendicularWellboreDirection;
|
|
|
|
|
|
if(perpendicularWellboreDirection.isNull()) {
|
|
|
perpendicularWellboreDirection = QVector2D(0.0, 1.0); // 避免零向量
|
|
|
}
|
|
|
|
|
|
perpendicularWellboreDirection = perpendicularWellboreDirection.normalized();
|
|
|
|
|
|
|
|
|
// 向量从裂缝中心到手柄新位置 (转换为QVector2D进行点积运算)
|
|
|
QVector2D vecCenterToHandle = QVector2D(newHandleScenePos - fractureCenterScene);
|
|
|
|
|
|
// 计算vecCenterToHandle在垂直于井筒方向上的投影长度
|
|
|
// 这个 projectionLength 应该带有方向性，表示手柄相对于裂缝中心沿着垂直方向的“位移”
|
|
|
double signedProjectionLength = QVector2D::dotProduct(vecCenterToHandle, perpendicularWellboreDirection);
|
|
|
|
|
|
// 新手柄的有效场景位置 (强制在垂直于井筒的方向上移动)
|
|
|
// 这里的 effectiveNewHandleScenePos 不再直接决定新的半长，而是作为计算端点的中间量
|
|
|
QPointF effectiveNewHandleScenePos = fractureCenterScene + perpendicularWellboreDirection.toPointF() * signedProjectionLength;
|
|
|
|
|
|
// 3. 计算新的裂缝半长
|
|
|
// newHalfLength 现在直接是带符号的投影长度
|
|
|
double newHalfLength = signedProjectionLength;
|
|
|
|
|
|
// 4. 更新图形项自身 (视觉更新)
|
|
|
QPointF p1_new_scene, p2_new_scene;
|
|
|
|
|
|
// 裂缝的两个端点应该分别位于中心点的两侧，距离中心点为 newHalfLength (有符号)
|
|
|
// 根据拖动的是哪个手柄来确定哪个方向是 "正" 半长方向
|
|
|
if(handle == m_pHandle1) { // 如果拖动的是手柄1 (裂缝的p1)
|
|
|
// 手柄1沿着 perpendicularWellboreDirection 的负方向移动
|
|
|
// 所以 newHalfLength 应该取其相反数
|
|
|
newHalfLength = -signedProjectionLength; // 使得 halfLength 总是指向 p2 的方向
|
|
|
} else { // handle == m_pHandle2 (拖动的是手柄2，裂缝的p2)
|
|
|
// 手柄2沿着 perpendicularWellboreDirection 的正方向移动
|
|
|
newHalfLength = signedProjectionLength; // halfLength 保持正值
|
|
|
}
|
|
|
|
|
|
// 计算新的裂缝端点 (场景坐标)
|
|
|
// 注意：裂缝的实际绘制长度是 newHalfLength 的绝对值 * 2
|
|
|
// 但在数据模型中，halfLength 通常是正值。
|
|
|
// 这里我们用 newHalfLength 表示从中心点到被拖动手柄的方向上的“半长”
|
|
|
// 另一个手柄则在反方向
|
|
|
|
|
|
// 裂缝的实际绘制长度（绝对值）
|
|
|
double actualDisplayHalfLength = qAbs(newHalfLength);
|
|
|
|
|
|
// 裂缝的两个端点基于裂缝中心和垂直方向向量
|
|
|
// p1 永远在 perpendicularWellboreDirection 的负方向
|
|
|
// p2 永远在 perpendicularWellboreDirection 的正方向
|
|
|
p1_new_scene = fractureCenterScene - perpendicularWellboreDirection.toPointF() * actualDisplayHalfLength;
|
|
|
p2_new_scene = fractureCenterScene + perpendicularWellboreDirection.toPointF() * actualDisplayHalfLength;
|
|
|
|
|
|
// 如果拖动的是 p1，那么 newHalfLength 应该以 p1 到中心点的距离为准，但数据模型存储的是正的半长。
|
|
|
// 如果是拖动 p1 并且 newHalfLength < 0 (即 p1 移动到原来 p2 的位置)，需要反转
|
|
|
// 否则如果拖动 p2 且 newHalfLength < 0，也需要反转
|
|
|
|
|
|
// 最终向数据模型报告的半长必须是正值
|
|
|
double finalHalfLengthForDataModel = qAbs(newHalfLength);
|
|
|
|
|
|
// 将场景坐标转换回局部坐标并设置线段
|
|
|
QPointF p1_local = mapFromScene(p1_new_scene);
|
|
|
QPointF p2_local = mapFromScene(p2_new_scene);
|
|
|
setLine(QLineF(p1_local, p2_local));
|
|
|
|
|
|
// 5. 更新手柄位置以匹配新的线段端点
|
|
|
updateFractureLineAndHandles(p1_local, p2_local); // 更新手柄视觉位置
|
|
|
|
|
|
// 6. 发出信号通知父项（nmHorizontalFracturedWellTopViewItem）
|
|
|
// ！！！这里发出的半长应该是正值，表示实际的几何长度
|
|
|
emit fractureHalfLengthChanged(finalHalfLengthForDataModel, isDragging, m_fractureIndex);
|
|
|
}
|
|
|
|
|
|
nmFractureRectHandleItem::nmFractureRectHandleItem(HandleType type, QGraphicsItem *parent)
|
|
|
: QGraphicsRectItem(parent), m_eHandleType(type)
|
|
|
{
|
|
|
// 设置手柄的颜色和样式
|
|
|
setBrush(QColor("#808080")); // 灰色填充
|
|
|
setPen(Qt::NoPen); // 无边框
|
|
|
setRect(-5, -5, 10, 10);
|
|
|
// 设置手柄的Z值，确保它在最前面。
|
|
|
setZValue(5);
|
|
|
}
|
|
|
|
|
|
nmFractureRectHandleItem::~nmFractureRectHandleItem()
|
|
|
{
|
|
|
// 析构函数，目前无需特殊清理
|
|
|
}
|
|
|
|
|
|
// 获取手柄类型
|
|
|
HandleType nmFractureRectHandleItem::getHandleType()
|
|
|
{
|
|
|
return m_eHandleType;
|
|
|
}
|
|
|
|
|
|
void nmFractureRectHandleItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 当鼠标左键按下时
|
|
|
if(event->button() == Qt::LeftButton) {
|
|
|
// 只有上下方向的手柄（包括角上的）才触发拖动
|
|
|
if(m_eHandleType == TopLeftHandle ||
|
|
|
m_eHandleType == TopMiddleHandle ||
|
|
|
m_eHandleType == TopRightHandle ||
|
|
|
m_eHandleType == BottomLeftHandle ||
|
|
|
m_eHandleType == BottomMiddleHandle ||
|
|
|
m_eHandleType == BottomRightHandle) {
|
|
|
m_lastMouseScenePos = event->scenePos(); // 记录鼠标在场景坐标系下的按下位置
|
|
|
// 发送信号通知父项（nmFractureRectGraphicsItem）手柄被按下
|
|
|
emit handlePressed(m_eHandleType, m_lastMouseScenePos);
|
|
|
// 仅接受左键事件，防止其他鼠标按钮产生副作用
|
|
|
setAcceptedMouseButtons(Qt::LeftButton);
|
|
|
}
|
|
|
|
|
|
// 如果是 MiddleLeftHandle 或 MiddleRightHandle，这里不发送信号，也不设置 acceptedMouseButtons
|
|
|
// 这样它们就不会进入“拖动”状态，也不会影响父项的 m_eCurrentHandle
|
|
|
}
|
|
|
|
|
|
// 调用基类的鼠标按下事件处理函数
|
|
|
//QGraphicsRectItem::mousePressEvent(event); // 仍然调用基类，以处理可能的默认行为（如选择）
|
|
|
}
|
|
|
|
|
|
void nmFractureRectHandleItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 当鼠标左键被按住并移动时
|
|
|
if(event->buttons() & Qt::LeftButton) {
|
|
|
// 只有上下方向的手柄才发送移动信号
|
|
|
if(m_eHandleType == TopLeftHandle ||
|
|
|
m_eHandleType == TopMiddleHandle ||
|
|
|
m_eHandleType == TopRightHandle ||
|
|
|
m_eHandleType == BottomLeftHandle ||
|
|
|
m_eHandleType == BottomMiddleHandle ||
|
|
|
m_eHandleType == BottomRightHandle) {
|
|
|
// 发送信号通知父项手柄正在移动，并传递当前鼠标的场景坐标
|
|
|
emit handleMoved(m_eHandleType, event->scenePos());
|
|
|
m_lastMouseScenePos = event->scenePos(); // 更新上一次鼠标位置
|
|
|
}
|
|
|
|
|
|
// 如果是 MiddleLeftHandle 或 MiddleRightHandle，则不发送 handleMoved 信号
|
|
|
}
|
|
|
|
|
|
// 调用基类的鼠标移动事件处理函数
|
|
|
//QGraphicsRectItem::mouseMoveEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmFractureRectHandleItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
// 只有上下方向的手柄才发送释放信号
|
|
|
if(m_eHandleType == TopLeftHandle ||
|
|
|
m_eHandleType == TopMiddleHandle ||
|
|
|
m_eHandleType == TopRightHandle ||
|
|
|
m_eHandleType == BottomLeftHandle ||
|
|
|
m_eHandleType == BottomMiddleHandle ||
|
|
|
m_eHandleType == BottomRightHandle) {
|
|
|
// 当鼠标左键释放时，所有手柄都应发送释放信号，以便父项重置 m_eCurrentHandle
|
|
|
emit handleReleased(m_eHandleType, event->scenePos());
|
|
|
// 恢复接受左键事件
|
|
|
setAcceptedMouseButtons(Qt::LeftButton);
|
|
|
}
|
|
|
|
|
|
// 调用基类的鼠标释放事件处理函数
|
|
|
//QGraphicsRectItem::mouseReleaseEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmFractureRectHandleItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
Q_UNUSED(option);
|
|
|
Q_UNUSED(widget);
|
|
|
|
|
|
// 1. 获取视图缩放比例
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) { // 避免除零
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 2. 定义固定的像素大小
|
|
|
const qreal fixedHandleSizeInPixels = 15.0; // 调整像素大小
|
|
|
|
|
|
// 3. 根据缩放比例计算动态大小
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
|
|
|
// 4. 定义手柄的矩形区域 (以 (0,0) 为中心)
|
|
|
QRectF handleRect(-dynamicHandleSize / 2, -dynamicHandleSize / 2, dynamicHandleSize, dynamicHandleSize);
|
|
|
|
|
|
// 5. 绘制
|
|
|
painter->setPen(Qt::NoPen); // 保持无边框
|
|
|
painter->setBrush(QColor("#808080")); // 保持灰色填充
|
|
|
painter->drawRect(handleRect); // 绘制动态计算的矩形
|
|
|
}
|
|
|
|
|
|
QRectF nmFractureRectHandleItem::boundingRect() const
|
|
|
{
|
|
|
// 1. 获取视图缩放比例
|
|
|
if (!scene() || scene()->views().isEmpty()) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
QGraphicsView* view = scene()->views().first();
|
|
|
if (!view) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
const QTransform viewTransform = view->transform();
|
|
|
const qreal scaleY = qAbs(viewTransform.m22());
|
|
|
|
|
|
if (scaleY < 1e-6) {
|
|
|
return QRectF();
|
|
|
}
|
|
|
|
|
|
// 2. 使用与 paint 方法相同的动态大小计算
|
|
|
const qreal fixedHandleSizeInPixels = 15.0; // 必须与 paint 中的值一致
|
|
|
const qreal dynamicHandleSize = fixedHandleSizeInPixels / scaleY;
|
|
|
|
|
|
// 3. 返回动态计算的矩形
|
|
|
return QRectF(-dynamicHandleSize / 2, -dynamicHandleSize / 2,
|
|
|
dynamicHandleSize, dynamicHandleSize);
|
|
|
}
|
|
|
|
|
|
nmFractureRectGraphicsItem::nmFractureRectGraphicsItem(nmDataVerticalFracturedWell* pDataWell, QGraphicsItem *parent)
|
|
|
: m_pDataWell(pDataWell),
|
|
|
QGraphicsItem(parent),
|
|
|
m_bEditMode(false),
|
|
|
m_handleSize(18.0),
|
|
|
m_eCurrentHandle(NoHandle)
|
|
|
|
|
|
{
|
|
|
// 设置Z值，确保裂缝矩形在储层之上，射孔之下
|
|
|
setZValue(-2);
|
|
|
|
|
|
// 获取储层的边界信息
|
|
|
m_minReservoirTop = nmDataAnalyzeManager::getCurrentInstance()->getMinLayerTop();
|
|
|
m_maxReservoirBottom = nmDataAnalyzeManager::getCurrentInstance()->getMaxLayerBottom();
|
|
|
|
|
|
// 初始更新裂缝几何信息。手柄的创建和销毁与编辑模式关联。
|
|
|
updateFractureGeometry();
|
|
|
}
|
|
|
|
|
|
nmFractureRectGraphicsItem::~nmFractureRectGraphicsItem()
|
|
|
{
|
|
|
// 析构函数中销毁所有创建的手柄子项，防止内存泄漏
|
|
|
destroyHandles();
|
|
|
}
|
|
|
|
|
|
QRectF nmFractureRectGraphicsItem::boundingRect() const
|
|
|
{
|
|
|
// 边界矩形只包含裂缝矩形本身。
|
|
|
// 手柄是独立的子项，它们有自己的boundingRect，QGraphicsItem 不会自动包含子项的边界。
|
|
|
return m_fractureRect.normalized();
|
|
|
}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::paint(QPainter *painter,
|
|
|
const QStyleOptionGraphicsItem *option,
|
|
|
QWidget *widget)
|
|
|
{
|
|
|
Q_UNUSED(option); // 避免编译器警告，表示此参数未使用
|
|
|
Q_UNUSED(widget); // 避免编译器警告
|
|
|
|
|
|
painter->setRenderHint(QPainter::Antialiasing); // 开启抗锯齿，使绘制更平滑
|
|
|
|
|
|
// 绘制裂缝矩形
|
|
|
//painter->setPen(QPen(QColor("#0c2e14"), 1.0)); // 绘制边框
|
|
|
//painter->setBrush(QColor("#0000ff")); // 设置填充颜色为蓝色
|
|
|
//painter->drawRect(m_fractureRect); // 绘制裂缝矩形
|
|
|
QPen fracturePen(QColor("#0c2e14"), 1.0);
|
|
|
fracturePen.setCosmetic(true);
|
|
|
painter->setPen(fracturePen);
|
|
|
painter->setBrush(QColor("#0000ff"));
|
|
|
painter->drawRect(m_fractureRect);
|
|
|
}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::setEditMode(bool bEdit)
|
|
|
{
|
|
|
// 如果编辑模式状态发生改变
|
|
|
if(m_bEditMode != bEdit) {
|
|
|
m_bEditMode = bEdit; // 更新编辑模式状态
|
|
|
|
|
|
if(m_bEditMode) {
|
|
|
createHandles(); // 如果进入编辑模式，则创建并显示手柄
|
|
|
} else {
|
|
|
destroyHandles(); // 如果退出编辑模式，则销毁手柄
|
|
|
}
|
|
|
|
|
|
update(); // 请求重新绘制图元，以反映手柄的显示/隐藏状态
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 槽函数实现：当手柄被按下时
|
|
|
void nmFractureRectGraphicsItem::onHandlePressed(HandleType type, QPointF scenePos)
|
|
|
{
|
|
|
m_eCurrentHandle = type; // 记录当前正在拖动的手柄类型
|
|
|
m_lastMouseScenePos = scenePos; // 记录鼠标在场景坐标系中的位置
|
|
|
}
|
|
|
|
|
|
// 槽函数实现：当手柄被拖动时
|
|
|
void nmFractureRectGraphicsItem::onHandleMoved(HandleType type, QPointF scenePos)
|
|
|
{
|
|
|
if(m_eCurrentHandle == NoHandle) return; // 如果没有手柄被激活拖动，则直接返回
|
|
|
|
|
|
prepareGeometryChange(); // 通知 QGraphicsItem 框架几何形状即将改变，以便更新场景
|
|
|
|
|
|
qreal dy = scenePos.y() - m_lastMouseScenePos.y(); // 计算鼠标在垂直方向上的位移
|
|
|
|
|
|
qreal newY = m_fractureRect.y(); // 裂缝新的顶部Y坐标
|
|
|
qreal newHeight = m_fractureRect.height(); // 裂缝新的高度
|
|
|
|
|
|
// 根据当前拖动的手柄类型，调整裂缝的高度和/或位置
|
|
|
switch(m_eCurrentHandle) {
|
|
|
case TopLeftHandle:
|
|
|
case TopMiddleHandle:
|
|
|
case TopRightHandle:
|
|
|
// 拖动顶部手柄，顶部Y坐标改变，高度随之变化
|
|
|
newY += dy;
|
|
|
newHeight -= dy;
|
|
|
break;
|
|
|
|
|
|
case BottomLeftHandle:
|
|
|
case BottomMiddleHandle:
|
|
|
case BottomRightHandle:
|
|
|
// 拖动底部手柄，高度改变，顶部Y坐标不变
|
|
|
newHeight += dy;
|
|
|
break;
|
|
|
|
|
|
case MiddleLeftHandle:
|
|
|
case MiddleRightHandle:
|
|
|
// 左右两个手柄在垂直方向上不起作用。
|
|
|
// 在本例中，裂缝的半长（宽度）是由 nmDataVerticalFracturedWell 固定的，
|
|
|
// 因此这里也不处理水平方向的缩放。
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// --- 应用储层高度限制 ---
|
|
|
qreal potentialTop = newY; // 潜在的裂缝顶部Y坐标
|
|
|
qreal potentialBottom = newY + newHeight; // 潜在的裂缝底部Y坐标
|
|
|
|
|
|
// 1. 如果潜在的新顶部超出了储层顶部边界
|
|
|
if(potentialTop < m_minReservoirTop) {
|
|
|
newY = m_minReservoirTop; // 裂缝顶部固定在储层顶部
|
|
|
newHeight = potentialBottom - newY; // 重新计算高度
|
|
|
}
|
|
|
|
|
|
// 2. 如果潜在的新底部超出了储层底部边界
|
|
|
if(newY + newHeight > m_maxReservoirBottom) {
|
|
|
newHeight = m_maxReservoirBottom - newY; // 重新计算高度
|
|
|
}
|
|
|
|
|
|
// 3. 确保裂缝高度不小于最小值
|
|
|
if(newHeight < 1.0) { // 例如，最小高度设置为1.0像素
|
|
|
newHeight = 1.0;
|
|
|
|
|
|
// 如果是从顶部缩小，且达到了最小高度，则调整 Y 坐标以保持底部不变
|
|
|
if(m_eCurrentHandle == TopLeftHandle || m_eCurrentHandle == TopMiddleHandle ||
|
|
|
m_eCurrentHandle == TopRightHandle) {
|
|
|
newY = m_fractureRect.bottom() - newHeight;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 在拖动过程中，只更新矩形数据，不应用任何业务逻辑（如边界限制） -->
|
|
|
// 只进行实时视觉反馈，不修改模型，也不发送信号。
|
|
|
m_fractureRect.setRect(m_fractureRect.x(), newY, m_fractureRect.width(), newHeight);
|
|
|
|
|
|
|
|
|
updateHandlePositions(); // 裂缝矩形改变后，重新定位所有手柄
|
|
|
m_lastMouseScenePos = scenePos; // 更新上一次鼠标的场景坐标
|
|
|
update(); // 请求重绘整个裂缝矩形图元及其子项（手柄）
|
|
|
|
|
|
// 拖动过程中实时发送裂缝位置
|
|
|
emit sigFractureGeometryChanged(m_fractureRect.top(), m_fractureRect.bottom());
|
|
|
}
|
|
|
|
|
|
// 槽函数实现：当手柄被释放时
|
|
|
void nmFractureRectGraphicsItem::onHandleReleased(HandleType type, QPointF scenePos)
|
|
|
{
|
|
|
// 1. 重置当前拖动的手柄，表示拖动结束
|
|
|
m_eCurrentHandle = NoHandle;
|
|
|
|
|
|
// 2. 发送最终的、经过视图修正后的 MD 值给控制器
|
|
|
// 注意，这里传递的是 m_fractureRect.top() 和 m_fractureRect.bottom()，
|
|
|
// 这些值已经经过了上面的实时修正，所以不会超出视图范围。
|
|
|
// 但是控制器仍然需要再次检查，以确保数据的最终一致性。
|
|
|
emit sigRequestFractureRectUpdate(m_fractureRect.top(), m_fractureRect.bottom());
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::updateFractureGeometry()
|
|
|
{
|
|
|
if(!m_pDataWell)
|
|
|
return;
|
|
|
|
|
|
// 从数据模型中获取裂缝的相关几何数据
|
|
|
double dWellboreX = m_pDataWell->getX().getValue().toDouble(); // 井的X坐标
|
|
|
double dFHalfLength = m_pDataWell->getFractureHalfLength().getValue().toDouble(); // 裂缝半长
|
|
|
double dFHeight = m_pDataWell->getFractureHeight().getValue().toDouble(); // 裂缝高度
|
|
|
double dMidPointHeight = m_pDataWell->getFractureMidPointHeight().getValue().toDouble(); // 裂缝中点高度
|
|
|
|
|
|
// 裂缝的纵向定位
|
|
|
qreal fractureTopY = m_maxReservoirBottom - dMidPointHeight - dFHeight / 2;
|
|
|
|
|
|
// 设置裂缝矩形的位置和尺寸
|
|
|
// X坐标：井中心X - 裂缝半长
|
|
|
// Y坐标：m_minReservoirTop (矩形顶部Y坐标)
|
|
|
// 宽度：裂缝半长 * 2
|
|
|
// 高度：裂缝高度
|
|
|
m_fractureRect.setRect(dWellboreX - dFHalfLength,
|
|
|
fractureTopY,
|
|
|
dFHalfLength * 2.0, // 裂缝宽度 = 裂缝半长 * 2
|
|
|
dFHeight); // 裂缝高度
|
|
|
}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::updateHandlePositions()
|
|
|
{
|
|
|
qreal x = m_fractureRect.x(); // 裂缝矩形的X坐标
|
|
|
qreal y = m_fractureRect.y(); // 裂缝矩形的Y坐标
|
|
|
qreal w = m_fractureRect.width(); // 裂缝矩形的宽度
|
|
|
qreal h = m_fractureRect.height(); // 裂缝矩形的高度
|
|
|
|
|
|
// 我们的手柄在它们的局部坐标系中是 (0,0) 居中的。
|
|
|
// 我们只需要把它们的 `pos()` 设置到父坐标系中的正确位置。
|
|
|
foreach(nmFractureRectHandleItem *handle, m_handles) {
|
|
|
|
|
|
QPointF handlePos; // 用于存储手柄在父项坐标系中的 *中心点* 位置
|
|
|
|
|
|
switch(handle->getHandleType()) {
|
|
|
case TopLeftHandle:
|
|
|
handlePos.setX(x);
|
|
|
handlePos.setY(y);
|
|
|
break;
|
|
|
|
|
|
case TopMiddleHandle:
|
|
|
handlePos.setX(x + w / 2.0);
|
|
|
handlePos.setY(y);
|
|
|
break;
|
|
|
|
|
|
case TopRightHandle:
|
|
|
handlePos.setX(x + w);
|
|
|
handlePos.setY(y);
|
|
|
break;
|
|
|
|
|
|
case MiddleLeftHandle:
|
|
|
handlePos.setX(x);
|
|
|
handlePos.setY(y + h / 2.0);
|
|
|
break;
|
|
|
|
|
|
case MiddleRightHandle:
|
|
|
handlePos.setX(x + w);
|
|
|
handlePos.setY(y + h / 2.0);
|
|
|
break;
|
|
|
|
|
|
case BottomLeftHandle:
|
|
|
handlePos.setX(x);
|
|
|
handlePos.setY(y + h);
|
|
|
break;
|
|
|
|
|
|
case BottomMiddleHandle:
|
|
|
handlePos.setX(x + w / 2.0);
|
|
|
handlePos.setY(y + h);
|
|
|
break;
|
|
|
|
|
|
case BottomRightHandle:
|
|
|
handlePos.setX(x + w);
|
|
|
handlePos.setY(y + h);
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
handle->setPos(handlePos);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//void nmFractureRectGraphicsItem::updateHandlePositions()
|
|
|
//{
|
|
|
// qreal x = m_fractureRect.x(); // 裂缝矩形的X坐标
|
|
|
// qreal y = m_fractureRect.y(); // 裂缝矩形的Y坐标
|
|
|
// qreal w = m_fractureRect.width(); // 裂缝矩形的宽度
|
|
|
// qreal h = m_fractureRect.height(); // 裂缝矩形的高度
|
|
|
//
|
|
|
// qreal hs = m_handleSize / 2.0; // 手柄半宽/高，用于在中心定位手柄
|
|
|
//
|
|
|
// // 遍历所有手柄，并根据其类型设置其在裂缝矩形本地坐标系中的位置和尺寸
|
|
|
// foreach(nmFractureRectHandleItem *handle, m_handles) {
|
|
|
// QRectF handleRect;
|
|
|
//
|
|
|
// switch(handle->getHandleType()) {
|
|
|
// case TopLeftHandle:
|
|
|
// handleRect.setRect(x - hs, y - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case TopMiddleHandle:
|
|
|
// handleRect.setRect(x + w / 2.0 - hs, y - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case TopRightHandle:
|
|
|
// handleRect.setRect(x + w - hs, y - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case MiddleLeftHandle:
|
|
|
// handleRect.setRect(x - hs, y + h / 2.0 - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case MiddleRightHandle:
|
|
|
// handleRect.setRect(x + w - hs, y + h / 2.0 - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case BottomLeftHandle:
|
|
|
// handleRect.setRect(x - hs, y + h - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case BottomMiddleHandle:
|
|
|
// handleRect.setRect(x + w / 2.0 - hs, y + h - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// case BottomRightHandle:
|
|
|
// handleRect.setRect(x + w - hs, y + h - hs, m_handleSize, m_handleSize);
|
|
|
// break;
|
|
|
//
|
|
|
// default:
|
|
|
// break;
|
|
|
// }
|
|
|
//
|
|
|
// handle->setRect(handleRect); // 设置手柄的矩形，QGraphicsRectItem 会自动根据其 rect 绘制
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::createHandles()
|
|
|
{
|
|
|
destroyHandles(); // 在创建新手柄之前，先确保销毁所有旧手柄
|
|
|
|
|
|
// 获取 nmFractureRectGraphicsItem 的父项，也就是 nmVerticalFracturedWellCrossSectionItem
|
|
|
// 确保这个父项存在且是一个 QGraphicsItem
|
|
|
QGraphicsItem* pRootParent = this->parentItem();
|
|
|
|
|
|
if(!pRootParent) {
|
|
|
qWarning() << "nmFractureRectGraphicsItem has no parent item. Handles might not be visible.";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 按照 HandleType 枚举的顺序创建八个手柄
|
|
|
// 将 nmFractureRectGraphicsItem 的父项作为手柄的父项
|
|
|
m_handles.append(new nmFractureRectHandleItem(TopLeftHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(TopMiddleHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(TopRightHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(MiddleLeftHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(MiddleRightHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(BottomLeftHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(BottomMiddleHandle, pRootParent));
|
|
|
m_handles.append(new nmFractureRectHandleItem(BottomRightHandle, pRootParent));
|
|
|
|
|
|
// 连接每个手柄的信号到当前类的槽函数，以便响应手柄的拖动事件
|
|
|
foreach(nmFractureRectHandleItem *handle, m_handles) {
|
|
|
connect(handle, SIGNAL(handlePressed(HandleType, QPointF)),
|
|
|
this, SLOT(onHandlePressed(HandleType, QPointF)));
|
|
|
connect(handle, SIGNAL(handleMoved(HandleType, QPointF)),
|
|
|
this, SLOT(onHandleMoved(HandleType, QPointF)));
|
|
|
connect(handle, SIGNAL(handleReleased(HandleType, QPointF)),
|
|
|
this, SLOT(onHandleReleased(HandleType, QPointF)));
|
|
|
}
|
|
|
|
|
|
updateHandlePositions(); // 更新手柄的位置，使其与裂缝矩形对齐
|
|
|
}
|
|
|
|
|
|
void nmFractureRectGraphicsItem::destroyHandles()
|
|
|
{
|
|
|
qDeleteAll(m_handles); // 删除 QList 中所有 nmFractureRectHandleItem 对象
|
|
|
m_handles.clear(); // 清空 QList，使其不包含任何指针
|
|
|
}
|
|
|
|
|
|
|
|
|
nmReservoirGraphicsItems::nmReservoirGraphicsItems(QGraphicsItem *parent)
|
|
|
: QGraphicsItem(parent)
|
|
|
{
|
|
|
// 设置Z值，确保它总是在所有其他井筒图元的下方绘制
|
|
|
setZValue(-1000); // 确保它是最底层的背景图元
|
|
|
|
|
|
// 获取储层数据
|
|
|
QVector<nmDataLayer*> vecLayers = nmDataAnalyzeManager::getCurrentInstance()->getLayers();
|
|
|
this->setReservoirLayers(vecLayers);
|
|
|
}
|
|
|
|
|
|
nmReservoirGraphicsItems::~nmReservoirGraphicsItems()
|
|
|
{
|
|
|
qDeleteAll(m_internalLayers);
|
|
|
m_internalLayers.clear();
|
|
|
}
|
|
|
|
|
|
QRectF nmReservoirGraphicsItems::boundingRect() const
|
|
|
{
|
|
|
double dMinTop = nmDataAnalyzeManager::getCurrentInstance()->getMinLayerTop();
|
|
|
double dMaxBottom = nmDataAnalyzeManager::getCurrentInstance()->getMaxLayerBottom();
|
|
|
return QRectF(-100000, dMinTop, 200000, dMaxBottom - dMinTop);
|
|
|
//return QRectF(-50, dMinTop, 100, dMaxBottom - dMinTop);
|
|
|
}
|
|
|
|
|
|
void nmReservoirGraphicsItems::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
if(!option) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
|
|
// visibleRect 表示当前需要绘制的区域（在 Item 的本地坐标系中）
|
|
|
QRectF visibleRect = option->exposedRect;
|
|
|
|
|
|
// 如果没有层数据，则什么都不画
|
|
|
if(m_internalLayers.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 定义绘制层的水平范围，使其覆盖当前可见区域的整个宽度
|
|
|
// 这样层在水平方向上就会看起来“无限大”
|
|
|
qreal layerXStart = visibleRect.left();
|
|
|
qreal layerXEnd = visibleRect.right();
|
|
|
qreal currentDrawWidth = layerXEnd - layerXStart; // 根据当前可见区域计算宽度
|
|
|
|
|
|
double dMinTop = nmDataAnalyzeManager::getCurrentInstance()->getMinLayerTop();
|
|
|
double dMaxBottom = nmDataAnalyzeManager::getCurrentInstance()->getMaxLayerBottom();
|
|
|
|
|
|
// 1. 绘制内部储层
|
|
|
for(int i = 0; i < m_internalLayers.size(); ++i) {
|
|
|
const nmDataLayer* layer = m_internalLayers.at(i);
|
|
|
|
|
|
if(!layer) {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
qreal topDepth = layer->getTop();
|
|
|
qreal bottomDepth = layer->getBottom();
|
|
|
QColor fillColor = layer->getColor();
|
|
|
|
|
|
if(topDepth >= bottomDepth) {
|
|
|
continue; // 无效的层
|
|
|
}
|
|
|
|
|
|
// 绘制填充矩形，其宽度为当前可见区域的宽度
|
|
|
painter->setPen(Qt::NoPen);
|
|
|
painter->setBrush(fillColor);
|
|
|
painter->drawRect(layerXStart, topDepth, currentDrawWidth, bottomDepth - topDepth);
|
|
|
|
|
|
//// 绘制层与层之间的分隔线
|
|
|
//if(i < m_internalLayers.size() - 1) {
|
|
|
// painter->setPen(QPen(Qt::black, 0.5)); // 细线
|
|
|
// painter->drawLine(layerXStart, bottomDepth, layerXEnd, bottomDepth);
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
// 2. 绘制最外层的上下边框 (现在它们就是 m_minLayerTop 和 m_maxLayerBottom)
|
|
|
//QColor outerBorderColor = QColor("#8b4513");
|
|
|
//qreal outerBorderPenWidth = 5.0;
|
|
|
|
|
|
//// 绘制最顶部的边框 (对应 m_minLayerTop)
|
|
|
//painter->setPen(QPen(outerBorderColor, outerBorderPenWidth));
|
|
|
//// 边框也应覆盖当前可见区域的整个宽度
|
|
|
//painter->drawLine(layerXStart, dMinTop, layerXEnd, dMinTop);
|
|
|
|
|
|
//// 绘制最底部的边框 (对应 m_maxLayerBottom)
|
|
|
//painter->setPen(QPen(outerBorderColor, outerBorderPenWidth));
|
|
|
//// 边框也应覆盖当前可见区域的整个宽度
|
|
|
//painter->drawLine(layerXStart, dMaxBottom, layerXEnd, dMaxBottom);
|
|
|
|
|
|
// 修改边框绘制
|
|
|
QColor outerBorderColor = QColor("#8b4513");
|
|
|
QPen outerBorderPen(outerBorderColor, 5); // 线宽0表示1像素
|
|
|
outerBorderPen.setCosmetic(true); // 不随变换缩放
|
|
|
|
|
|
painter->setPen(outerBorderPen);
|
|
|
painter->drawLine(layerXStart, dMinTop, layerXEnd, dMinTop);
|
|
|
painter->drawLine(layerXStart, dMaxBottom, layerXEnd, dMaxBottom);
|
|
|
}
|
|
|
|
|
|
qreal nmReservoirGraphicsItems::getMinLayerTop()
|
|
|
{
|
|
|
return nmDataAnalyzeManager::getCurrentInstance()->getMinLayerTop();
|
|
|
}
|
|
|
|
|
|
qreal nmReservoirGraphicsItems::getMaxLayerBottom()
|
|
|
{
|
|
|
return nmDataAnalyzeManager::getCurrentInstance()->getMaxLayerBottom();
|
|
|
}
|
|
|
|
|
|
//void nmReservoirGraphicsItems::setReservoirLayers(const QVector<nmDataLayer*>& layers)
|
|
|
//{
|
|
|
// qDeleteAll(m_internalLayers);
|
|
|
// m_internalLayers.clear();
|
|
|
//
|
|
|
// for(int i = 0; i < layers.size(); ++i) {
|
|
|
// nmDataLayer* layer = layers.at(i);
|
|
|
//
|
|
|
// if(layer) {
|
|
|
// m_internalLayers.append(static_cast<nmDataLayer*>(layer->clone()));
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
// prepareGeometryChange();
|
|
|
// update();
|
|
|
//}
|
|
|
|
|
|
void nmReservoirGraphicsItems::setReservoirLayers(const QVector<nmDataLayer*>& layers)
|
|
|
{
|
|
|
qDeleteAll(m_internalLayers);
|
|
|
m_internalLayers.clear();
|
|
|
|
|
|
for (int i = 0; i < layers.size(); ++i) {
|
|
|
nmDataLayer* layer = layers.at(i);
|
|
|
if (layer) {
|
|
|
// 直接用拷贝构造做深拷贝
|
|
|
m_internalLayers.append(new nmDataLayer(*layer));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
prepareGeometryChange();
|
|
|
update();
|
|
|
}
|
|
|
|
|
|
nmAbstractWellboreVisual::nmAbstractWellboreVisual(QGraphicsItem *parent)
|
|
|
: QGraphicsItemGroup(parent), m_pDataWell(nullptr)
|
|
|
{
|
|
|
// 可以在这里设置一些通用的标志，例如：可选择、可移动等
|
|
|
// setFlags(ItemIsSelectable);
|
|
|
|
|
|
setHandlesChildEvents(false); // 关键：组不处理子项事件
|
|
|
//setFlag(QGraphicsItem::ItemIsMovable, false); // 组本身不可移动
|
|
|
}
|
|
|
|
|
|
// 析构函数实现
|
|
|
nmAbstractWellboreVisual::~nmAbstractWellboreVisual()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
nmDataWellBase* nmAbstractWellboreVisual::getWellData()
|
|
|
{
|
|
|
return m_pDataWell;
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreVisual::removePerforationVisual(nmPerforationGraphicsItem* itemToRemove)
|
|
|
{
|
|
|
if(!itemToRemove) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
m_listPerforations.removeOne(itemToRemove); // 查找并移除指针
|
|
|
|
|
|
// 删除图形项对象，这会自动将其从场景和其父QGraphicsItemGroup中移除
|
|
|
delete itemToRemove;
|
|
|
itemToRemove = nullptr; // 避免悬空指针
|
|
|
|
|
|
// 通知视图几何形状可能已改变，触发重绘
|
|
|
prepareGeometryChange();
|
|
|
update();
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreVisual::clearAllPerforationItems()
|
|
|
{
|
|
|
// 移除并删除射孔段图元
|
|
|
foreach(nmPerforationGraphicsItem* item, m_listPerforations) {
|
|
|
delete item;
|
|
|
}
|
|
|
|
|
|
m_listPerforations.clear();
|
|
|
}
|
|
|
|
|
|
// 清除所有子项的通用方法
|
|
|
void nmAbstractWellboreVisual::clearAllChildItems()
|
|
|
{
|
|
|
// 遍历当前组的所有子项
|
|
|
foreach(QGraphicsItem *child, childItems()) {
|
|
|
removeFromGroup(child); // 从当前组中移除该子项
|
|
|
delete child; // 删除该子项（因为它们是new出来的）
|
|
|
child = nullptr;
|
|
|
}
|
|
|
|
|
|
// 清空内部的跟踪列表
|
|
|
m_listPoints.clear();
|
|
|
m_listLines.clear();
|
|
|
m_listPerforations.clear();
|
|
|
m_listLineFractures.clear();
|
|
|
m_listRectFractures.clear();
|
|
|
}
|
|
|
|
|
|
// 辅助函数：将 nmWellborePointGraphicsItem 添加到组中并记录
|
|
|
void nmAbstractWellboreVisual::addPoint(nmWellborePointGraphicsItem* item)
|
|
|
{
|
|
|
addToGroup(item); // 将项添加到QGraphicsItemGroup中
|
|
|
m_listPoints.append(item); // 添加到内部跟踪列表
|
|
|
}
|
|
|
|
|
|
// 辅助函数：将 nmWellboreLineGraphicsItem 添加到组中并记录
|
|
|
void nmAbstractWellboreVisual::addLine(nmWellboreLineGraphicsItem* item)
|
|
|
{
|
|
|
addToGroup(item);
|
|
|
m_listLines.append(item);
|
|
|
}
|
|
|
|
|
|
// 辅助函数：将 nmPerforationGraphicsItem 添加到组中并记录
|
|
|
void nmAbstractWellboreVisual::addPerforation(nmPerforationGraphicsItem* item)
|
|
|
{
|
|
|
addToGroup(item);
|
|
|
m_listPerforations.append(item);
|
|
|
}
|
|
|
|
|
|
// 辅助函数：将 nmFractureLineGraphicsItem 添加到组中并记录
|
|
|
void nmAbstractWellboreVisual::addFractureLine(nmFractureLineGraphicsItem* item)
|
|
|
{
|
|
|
addToGroup(item);
|
|
|
m_listLineFractures.append(item);
|
|
|
}
|
|
|
|
|
|
// 辅助函数：将 nmFractureRectGraphicsItem 添加到组中并记录
|
|
|
void nmAbstractWellboreVisual::addFractureRect(nmFractureRectGraphicsItem* item)
|
|
|
{
|
|
|
addToGroup(item);
|
|
|
m_listRectFractures.append(item);
|
|
|
}
|
|
|
|
|
|
#include "nmDataWellBase.h"
|
|
|
#include "nmDataVerticalWell.h"
|
|
|
|
|
|
// --- VerticalWellTopViewItem 实现 ---
|
|
|
nmVerticalWellTopViewItem::nmVerticalWellTopViewItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent)
|
|
|
{
|
|
|
m_pWellPoint = nullptr;
|
|
|
m_pOriginalPoint = nullptr;
|
|
|
m_pDashLine = nullptr;
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellTopViewItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange(); // 通知QGraphicsView，此项的几何形状可能发生变化
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配 (垂直井或垂直压裂井在俯视图中显示类似)
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Vertical_Well) {
|
|
|
return; // 不符合类型则不绘制
|
|
|
}
|
|
|
|
|
|
nmDataVerticalWell *pVerticalWell = dynamic_cast<nmDataVerticalWell*>(m_pDataWell);
|
|
|
if(pVerticalWell == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 1. 绘制井筒点 (绿色圆点)
|
|
|
m_pWellPoint = new nmWellborePointGraphicsItem(this); // 创建井点图元，并将其父项设为当前组合图元
|
|
|
//double dRadius = pVerticalWell->getRadius().getValue().toDouble(); // 井点可视化的大小（半径）
|
|
|
double dRadius = 7;
|
|
|
double dX = pVerticalWell->getX().getValue().toDouble(); // 井口横坐标
|
|
|
double dY = pVerticalWell->getY().getValue().toDouble(); // 井口纵坐标
|
|
|
// 设置图元位置到场景坐标系的(dX,dY)
|
|
|
m_pWellPoint->setRect(-dRadius, -dRadius, dRadius * 2, dRadius * 2); // 矩形中心在 (0,0)
|
|
|
m_pWellPoint->setPos(dX, dY); // 将图元移动到场景中的 (dX, dY)
|
|
|
m_pWellPoint->setFlag(QGraphicsItem::ItemIsMovable, false); // 初始不可移动
|
|
|
// 设置Z值，确保在上面
|
|
|
m_pWellPoint->setZValue(1);
|
|
|
|
|
|
// 连接井点拖动相关信号
|
|
|
connect(m_pWellPoint, SIGNAL(sigPositionChanging(QPointF)),
|
|
|
this, SLOT(slotUpdateDashLine(QPointF)));
|
|
|
connect(m_pWellPoint, SIGNAL(sigDragFinished(QPointF)),
|
|
|
this, SLOT(slotWellborePointDragFinished(QPointF)));
|
|
|
|
|
|
addPoint(m_pWellPoint); // 添加到组合图元中并记录
|
|
|
|
|
|
// 绘制原始点 (红色圆点) 和虚线
|
|
|
if(!m_pOriginalPoint) {
|
|
|
m_pOriginalPoint = new nmWellborePointGraphicsItem(this);
|
|
|
}
|
|
|
|
|
|
m_pOriginalPoint->setRect(m_pWellPoint->rect());
|
|
|
m_pOriginalPoint->setPos(m_pWellPoint->pos());
|
|
|
m_pOriginalPoint->setStyle(QPen(Qt::black, 0.5f), QBrush(Qt::red));
|
|
|
m_pOriginalPoint->setFlag(QGraphicsItem::ItemIsMovable, false);
|
|
|
// 设置Z值，确保在绿色图元下面
|
|
|
m_pOriginalPoint->setZValue(0);
|
|
|
m_pOriginalPoint->setVisible(false); // 默认隐藏
|
|
|
|
|
|
if(!m_pDashLine) {
|
|
|
//m_pDashLine = new QGraphicsLineItem(this);
|
|
|
//m_pDashLine->setPen(QPen(Qt::darkGreen, 1, Qt::DashLine));
|
|
|
//m_pDashLine->setZValue(-1);
|
|
|
//m_pDashLine->setVisible(false); // 默认隐藏
|
|
|
m_pDashLine = new QGraphicsLineItem(this);
|
|
|
QPen dashPen(Qt::darkGreen, 0, Qt::DashLine);
|
|
|
dashPen.setCosmetic(true);
|
|
|
m_pDashLine->setPen(dashPen);
|
|
|
m_pDashLine->setZValue(-1);
|
|
|
m_pDashLine->setVisible(false);
|
|
|
}
|
|
|
|
|
|
// 初始虚线连接位置
|
|
|
m_pDashLine->setLine(QLineF(m_pWellPoint->pos(), m_pOriginalPoint->pos()));
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellTopViewItem::setEditMode(bool enabled)
|
|
|
{
|
|
|
if(m_pWellPoint) {
|
|
|
m_pWellPoint->setFlag(QGraphicsItem::ItemIsMovable, enabled); // 启用/禁用绿点移动
|
|
|
|
|
|
// 刷新虚线和红点的位置和可见性
|
|
|
if(m_pOriginalPoint) {
|
|
|
m_pOriginalPoint->setRect(m_pWellPoint->rect());
|
|
|
m_pOriginalPoint->setPos(m_pWellPoint->pos());
|
|
|
m_pOriginalPoint->setVisible(enabled);
|
|
|
}
|
|
|
|
|
|
if(m_pDashLine) {
|
|
|
m_pDashLine->setLine(QLineF(m_pWellPoint->pos(), m_pOriginalPoint->pos()));
|
|
|
m_pDashLine->setVisible(enabled);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellTopViewItem::slotUpdateDashLine(const QPointF& newPos)
|
|
|
{
|
|
|
if(m_pDashLine && m_pOriginalPoint) {
|
|
|
// 更新虚线连接位置
|
|
|
m_pDashLine->setLine(QLineF(newPos, m_pOriginalPoint->pos()));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellTopViewItem::slotWellborePointDragFinished(const QPointF& finalCenterScenePos)
|
|
|
{
|
|
|
// 此时拖动已经结束，发出信号给 nmWxWellboreTopView，它会再将此信号转发给控制器
|
|
|
emit sigWellborePointDragFinished(finalCenterScenePos);
|
|
|
}
|
|
|
|
|
|
nmVerticalWellCrossSectionItem::nmVerticalWellCrossSectionItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent)
|
|
|
{
|
|
|
// 可以在这里设置一些默认的样式或初始化成员变量
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellCrossSectionItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange();
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Vertical_Well) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
nmDataVerticalWell *pVerticalWell = dynamic_cast<nmDataVerticalWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pVerticalWell) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 在纵截面视图中，X轴通常代表左右延伸，Y轴代表深度（向下为正）
|
|
|
double dWellboreX = pVerticalWell->getX().getValue().toDouble();
|
|
|
// 获取井底深
|
|
|
double dBottomholeMD = pVerticalWell->getBottomholeMD().getValue().toDouble();
|
|
|
// 获取井身长度
|
|
|
double dWellLength = pVerticalWell->getWellLength().getValue().toDouble();
|
|
|
|
|
|
// 1. 绘制储层矩形 (nmReservoirGraphicsItems) - 最底层 (Z值: -1000)
|
|
|
nmReservoirGraphicsItems* pReservoirs = new nmReservoirGraphicsItems(this); // 创建实例，Z值在构造函数中已设置
|
|
|
addToGroup(pReservoirs); // 直接添加到组
|
|
|
|
|
|
// 2. 绘制井筒线 (nmWellboreLineGraphicsItem) - 中间层 (Z值: 0)
|
|
|
nmWellboreLineGraphicsItem* pWellboreLine = new nmWellboreLineGraphicsItem(this);
|
|
|
pWellboreLine->setLine(dWellboreX, dBottomholeMD, dWellboreX, dBottomholeMD + dWellLength); // 垂直线
|
|
|
|
|
|
|
|
|
//pWellboreLine->setStyle(QPen(QColor("#d3d3d3"), 2));
|
|
|
QPen wellborePen(QColor("#d3d3d3"), 2);
|
|
|
wellborePen.setCosmetic(true);
|
|
|
pWellboreLine->setStyle(wellborePen);
|
|
|
pWellboreLine->setZValue(2); // 设置Z值为2，确保在射孔段之上
|
|
|
addLine(pWellboreLine); // 添加到组中
|
|
|
|
|
|
// 获取整个组合图元的包围矩形
|
|
|
|
|
|
// 井筒的视觉起点和终点
|
|
|
QPointF wellboreStartScene = QPointF(dWellboreX, dBottomholeMD);
|
|
|
QPointF wellboreEndScene = QPointF(dWellboreX, dBottomholeMD + dWellLength); // 垂直线
|
|
|
|
|
|
// 井筒的MD起始值和总MD长度
|
|
|
double wellboreStartAbsoluteMd = dBottomholeMD;
|
|
|
double totalWellboreMdLength = dWellLength;
|
|
|
|
|
|
// 3. 绘制射孔段 (nmPerforationGraphicsItem) - 最上层 (Z值: 1)
|
|
|
QVector<nmDataPerforation*>& perforations = pVerticalWell->getPerforations(); // 获取射孔段集合
|
|
|
|
|
|
for(int i = 0; i < perforations.size(); ++i) {
|
|
|
nmDataPerforation* pPerfData = perforations.at(i);
|
|
|
|
|
|
nmPerforationGraphicsItem* pPerforation = new nmPerforationGraphicsItem(
|
|
|
pPerfData,
|
|
|
NM_WELL_MODEL::Vertical_Well, // 传递井类型
|
|
|
wellboreStartAbsoluteMd, // 传递井筒的MD起始值
|
|
|
totalWellboreMdLength, // 传递井筒的总MD长度
|
|
|
this
|
|
|
);
|
|
|
|
|
|
pPerforation->setZValue(1); // 设置Z值为1，确保在井筒（Z=2）之下
|
|
|
addPerforation(pPerforation); // 添加到组中
|
|
|
|
|
|
// 初始化射孔段的视觉信息
|
|
|
pPerforation->updateWellboreVisuals(wellboreStartScene, wellboreEndScene,
|
|
|
wellboreStartAbsoluteMd, totalWellboreMdLength);
|
|
|
|
|
|
// 连接射孔拖动信号
|
|
|
connect(pPerforation, SIGNAL(sigRequestPerforationMdUpdate(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)));
|
|
|
}
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
void nmVerticalWellCrossSectionItem::setPerforationEditMode(bool enabled)
|
|
|
{
|
|
|
// TODO,处于编辑状态要做什么
|
|
|
// 遍历射孔段数组，设置为编辑状态
|
|
|
foreach(nmPerforationGraphicsItem* item, m_listPerforations) {
|
|
|
item->setEditMode(enabled);
|
|
|
// 如果需要，可以在这里根据编辑模式切换选中状态，确保一致性
|
|
|
//item->setSelected(enabled);
|
|
|
//item->setFlag(QGraphicsItem::ItemIsMovable, true);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QRectF nmVerticalFracturedWellCrossSectionItem::getFractureMD()
|
|
|
{
|
|
|
return m_pRectFracture->boundingRect();
|
|
|
}
|
|
|
|
|
|
// --- nmVerticalFracturedWellTopViewItem 实现 ---
|
|
|
nmVerticalFracturedWellTopViewItem::nmVerticalFracturedWellTopViewItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent),
|
|
|
m_pFracture(nullptr)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellTopViewItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange(); // 通知QGraphicsView，此项的几何形状可能发生变化
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Vertical_Fractured_Well) {
|
|
|
return; // 不符合类型则不绘制
|
|
|
}
|
|
|
|
|
|
nmDataVerticalFracturedWell *pVerticalFracturedWell = dynamic_cast<nmDataVerticalFracturedWell*>(m_pDataWell);
|
|
|
if(pVerticalFracturedWell == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 1. 绘制井筒点 (绿色圆点)
|
|
|
nmWellborePointGraphicsItem* pWellPoint = new nmWellborePointGraphicsItem(this); // 创建井点图元，并将其父项设为当前组合图元
|
|
|
//double dRadius = pVerticalWell->getRadius().getValue().toDouble(); // 井点可视化的大小（半径）
|
|
|
double dRadius = 7;
|
|
|
double dX = pVerticalFracturedWell->getX().getValue().toDouble(); // 井口横坐标
|
|
|
double dY = pVerticalFracturedWell->getY().getValue().toDouble(); // 井口纵坐标
|
|
|
// 设置图元位置到场景坐标系的(dX,dY)
|
|
|
pWellPoint->setRect(-dRadius, -dRadius, dRadius * 2, dRadius * 2); // 矩形中心在 (0,0)
|
|
|
pWellPoint->setPos(dX, dY); // 将图元移动到场景中的 (dX, dY)
|
|
|
|
|
|
pWellPoint->setFlag(QGraphicsItem::ItemIsMovable, false); // 初始不可移动
|
|
|
|
|
|
// 设置Z值，确保在上面
|
|
|
pWellPoint->setZValue(1);
|
|
|
|
|
|
addPoint(pWellPoint); // 添加到组合图元中并记录
|
|
|
|
|
|
// 2. 绘制裂缝
|
|
|
m_pFracture = new nmFractureLineGraphicsItem(this);
|
|
|
|
|
|
// 将裂缝图元的局部原点 (0,0) 设置到井筒在父项 (nmVerticalFracturedWellTopViewItem) 中的位置
|
|
|
m_pFracture->setPos(dX, dY);
|
|
|
|
|
|
// 获取裂缝位置信息
|
|
|
QVector<QPointF> vecFractures = pVerticalFracturedWell->getFracs();
|
|
|
|
|
|
// 确保有且仅有两个点来构成一条线
|
|
|
if(vecFractures.size() == 2) {
|
|
|
QPointF startPointScene = vecFractures.at(0); // 裂缝起点 (场景坐标)
|
|
|
QPointF endPointScene = vecFractures.at(1); // 裂缝终点 (场景坐标)
|
|
|
|
|
|
// 裂缝图元的局部原点现在是 (dX, dY)，所以需要减去这个偏移量来获得其在 pFracture 内部的相对坐标
|
|
|
QPointF startPointLocal = startPointScene - QPointF(dX, dY);
|
|
|
QPointF endPointLocal = endPointScene - QPointF(dX, dY);
|
|
|
|
|
|
m_pFracture->setLine(QLineF(startPointLocal, endPointLocal)); // 设置裂缝线，它接受局部坐标
|
|
|
} else {
|
|
|
// 如果数据不符合预期，则不绘制裂缝并清理创建的图元
|
|
|
delete m_pFracture;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 设置 Z 值，确保在井点之上
|
|
|
m_pFracture->setZValue(pWellPoint->zValue() + 0.5); // 确保在井点之上，可以稍微高一点
|
|
|
|
|
|
addFractureLine(m_pFracture); // 添加裂缝图元
|
|
|
|
|
|
// 转发裂缝几何位置变化后的位置
|
|
|
connect(m_pFracture, SIGNAL(sigFractureGeometryChanged(double, double)),
|
|
|
this, SIGNAL(sigFracturePosChanged(double, double)));
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellTopViewItem::setEditMode(bool enabled)
|
|
|
{
|
|
|
m_pFracture->setEditMode(enabled);
|
|
|
}
|
|
|
|
|
|
// --- nmVerticalFracturedWellCrossSectionItem 实现 ---
|
|
|
nmVerticalFracturedWellCrossSectionItem::nmVerticalFracturedWellCrossSectionItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent),
|
|
|
m_pRectFracture(nullptr)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange();
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Vertical_Fractured_Well) {
|
|
|
// 如果类型不匹配或数据无效，清空所有子项和映射
|
|
|
for(auto it = m_mapPerforationItem.begin(); it != m_mapPerforationItem.end(); ++it) {
|
|
|
scene()->removeItem(it.value()); // 从场景中移除 (如果 item 尚未被 clearAllChildItems 清除)
|
|
|
delete it.value(); // 释放内存
|
|
|
}
|
|
|
|
|
|
m_mapPerforationItem.clear(); // 清空映射
|
|
|
m_listPerforations.clear();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
nmDataVerticalFracturedWell *pVFWell = dynamic_cast<nmDataVerticalFracturedWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pVFWell) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 在纵截面视图中，X轴通常代表左右延伸，Y轴代表深度（向下为正）
|
|
|
double dWellboreX = pVFWell->getX().getValue().toDouble();
|
|
|
// 获取井底深
|
|
|
double dBottomholeMD = pVFWell->getBottomholeMD().getValue().toDouble();
|
|
|
// 获取井身长度
|
|
|
double dWellLength = pVFWell->getWellLength().getValue().toDouble();
|
|
|
|
|
|
// 1. 绘制储层矩形 (nmReservoirGraphicsItems) - 最底层 (Z值: -1000)
|
|
|
nmReservoirGraphicsItems* pReservoirs = new nmReservoirGraphicsItems(this); // 创建实例，Z值在构造函数中已设置
|
|
|
addToGroup(pReservoirs); // 直接添加到组
|
|
|
|
|
|
// 2. 绘制裂缝矩形
|
|
|
m_pRectFracture = new nmFractureRectGraphicsItem(pVFWell, this);
|
|
|
addFractureRect(m_pRectFracture);
|
|
|
|
|
|
// 连接裂缝编辑时，裂缝拖动完成后的信号
|
|
|
connect(m_pRectFracture, SIGNAL(sigRequestFractureRectUpdate(qreal, qreal)),
|
|
|
this, SLOT(slotFractureDragFinished(qreal, qreal)));
|
|
|
// 连接拖动过程中的实时预览信号
|
|
|
connect(m_pRectFracture, SIGNAL(sigFractureGeometryChanged(qreal, qreal)),
|
|
|
this, SLOT(slotFractureConstraintChanged(qreal, qreal)));
|
|
|
|
|
|
// 3. 绘制井筒线 (nmWellboreLineGraphicsItem) - 中间层 (Z值: 0)
|
|
|
// 井筒的总深度
|
|
|
nmWellboreLineGraphicsItem* pWellboreLine = new nmWellboreLineGraphicsItem(this);
|
|
|
pWellboreLine->setLine(dWellboreX, dBottomholeMD, dWellboreX, dBottomholeMD + dWellLength); // 垂直线
|
|
|
//pWellboreLine->setStyle(QPen(QColor("#d3d3d3"), 2));
|
|
|
QPen wellborePen(QColor("#d3d3d3"), 2);
|
|
|
wellborePen.setCosmetic(true);
|
|
|
pWellboreLine->setStyle(wellborePen);
|
|
|
pWellboreLine->setZValue(2); // 设置Z值为2，确保在射孔段之上
|
|
|
addLine(pWellboreLine); // 添加到组中
|
|
|
|
|
|
updatePerforationChildGraphics();
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::setFractureEditMode(bool enabled)
|
|
|
{
|
|
|
m_pRectFracture->setEditMode(enabled);
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::setPerforationEditMode(bool enabled)
|
|
|
{
|
|
|
// 遍历射孔段数组，设置为编辑状态
|
|
|
foreach(nmPerforationGraphicsItem* item, m_listPerforations) {
|
|
|
item->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::slotFractureConstraintChanged(qreal fractureTopMD, qreal fractureBottomMD)
|
|
|
{
|
|
|
// 这个槽函数只用于实时预览
|
|
|
// 遍历所有射孔图元，从后向前遍历以便安全删除
|
|
|
for(int i = m_listPerforations.size() - 1; i >= 0; --i) {
|
|
|
nmPerforationGraphicsItem* pPerforationItem = m_listPerforations.at(i);
|
|
|
|
|
|
// 获取射孔图元关联的原始数据
|
|
|
// 注意：这里读取的是原始数据，不是裁剪后的数据
|
|
|
nmDataPerforation* pPerfData = pPerforationItem->getPerforationData();
|
|
|
double dPerfStartMD = pPerfData->getMdStart().getValue().toDouble();
|
|
|
double dPerfEndMD = pPerfData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
// 检查是否需要删除图元（如果射孔的原始范围完全在裂缝之外）
|
|
|
if(dPerfEndMD <= fractureTopMD || dPerfStartMD >= fractureBottomMD) {
|
|
|
// 从场景和父组中移除图元
|
|
|
removeFromGroup(pPerforationItem);
|
|
|
scene()->removeItem(pPerforationItem);
|
|
|
// 从列表中移除并删除
|
|
|
m_listPerforations.removeAt(i);
|
|
|
delete pPerforationItem;
|
|
|
} else {
|
|
|
// 如果图元还在裂缝范围内，调用预览函数进行渲染
|
|
|
pPerforationItem->updateGraphicsForPreview(fractureTopMD, fractureBottomMD);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 请求场景重绘，以显示最新的预览效果
|
|
|
scene()->update();
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::slotFractureDragFinished(qreal fractureTopMD, qreal fractureBottomMD)
|
|
|
{
|
|
|
QMap<nmDataPerforation*, QPair<double, double>> updatedPerforations;
|
|
|
|
|
|
// 遍历所有射孔图元，将它们被裁剪后的MD值收集起来
|
|
|
foreach(nmPerforationGraphicsItem* pPerforationItem, m_listPerforations) {
|
|
|
double croppedStart = pPerforationItem->getCroppedMdStart();
|
|
|
double croppedEnd = pPerforationItem->getCroppedMdEnd();
|
|
|
|
|
|
// 存入映射，用于传递给控制器
|
|
|
updatedPerforations.insert(pPerforationItem->getPerforationData(), QPair<double, double>(croppedStart, croppedEnd));
|
|
|
}
|
|
|
|
|
|
// 1. 向控制器发送信号，传递所有被修改的射孔数据
|
|
|
emit sigFractureDragFinished(updatedPerforations);
|
|
|
|
|
|
// 2. 发出更新裂缝的信号
|
|
|
emit sigRequestFractureRectUpdate(fractureTopMD, fractureBottomMD);
|
|
|
}
|
|
|
|
|
|
void nmVerticalFracturedWellCrossSectionItem::updatePerforationChildGraphics()
|
|
|
{
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Vertical_Fractured_Well) {
|
|
|
// 如果数据无效，清空所有射孔图形项
|
|
|
for(auto it = m_mapPerforationItem.begin(); it != m_mapPerforationItem.end(); ++it) {
|
|
|
// 从场景和父组中移除
|
|
|
removeFromGroup(it.value());
|
|
|
scene()->removeItem(it.value());
|
|
|
delete it.value();
|
|
|
}
|
|
|
|
|
|
m_mapPerforationItem.clear();
|
|
|
m_listPerforations.clear();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
nmDataVerticalFracturedWell *pVFWell = dynamic_cast<nmDataVerticalFracturedWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pVFWell) return;
|
|
|
|
|
|
QVector<nmDataPerforation*>& vecCurrentPerforations = pVFWell->getPerforations();
|
|
|
|
|
|
// 1: 找出需要删除的图形项 (数据模型中已不存在的)
|
|
|
QList<nmDataPerforation*> listPerforationsToRemoveFromMap;
|
|
|
|
|
|
for(auto it = m_mapPerforationItem.begin(); it != m_mapPerforationItem.end(); ++it) {
|
|
|
if(!vecCurrentPerforations.contains(it.key())) {
|
|
|
listPerforationsToRemoveFromMap.append(it.key());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
foreach(nmDataPerforation* pPerfData, listPerforationsToRemoveFromMap) {
|
|
|
nmPerforationGraphicsItem* item = m_mapPerforationItem.take(pPerfData);
|
|
|
|
|
|
if(item) {
|
|
|
removeFromGroup(item); // 从父组中移除
|
|
|
scene()->removeItem(item); // 从场景中移除
|
|
|
m_listPerforations.removeOne(item);
|
|
|
delete item; // 释放内存
|
|
|
}
|
|
|
}
|
|
|
|
|
|
double dWellboreX = pVFWell->getX().getValue().toDouble(); // 井口X坐标
|
|
|
|
|
|
// 获取井筒的MD信息
|
|
|
double dWellheadMD = pVFWell->getBottomholeMD().getValue().toDouble(); // 假设有此属性
|
|
|
double dWellLength = pVFWell->getWellLength().getValue().toDouble();
|
|
|
double dWellboreEndMD = dWellheadMD + dWellLength;
|
|
|
|
|
|
// 井筒的MD起始值和总MD长度 (用于nmPerforationGraphicsItem)
|
|
|
double wellboreStartAbsoluteMd = dWellheadMD;
|
|
|
double totalWellboreMdLength = dWellLength;
|
|
|
|
|
|
// 井筒的视觉起点和终点
|
|
|
QPointF wellboreStartScene = QPointF(dWellboreX, dWellheadMD);
|
|
|
QPointF wellboreEndScene = QPointF(dWellboreX, dWellboreEndMD);
|
|
|
|
|
|
// 2: 添加新图形项
|
|
|
foreach(nmDataPerforation* pPerfData, vecCurrentPerforations) {
|
|
|
nmPerforationGraphicsItem* pPerforationItem = nullptr;
|
|
|
|
|
|
// 如果图形项不存在，则创建新的
|
|
|
if(!m_mapPerforationItem.contains(pPerfData)) {
|
|
|
pPerforationItem = new nmPerforationGraphicsItem(
|
|
|
pPerfData,
|
|
|
NM_WELL_MODEL::Vertical_Well, // 传递井类型 (此处仍然是Vertical_Well，因为是纵截面)
|
|
|
wellboreStartAbsoluteMd, // 传递井筒的MD起始值
|
|
|
totalWellboreMdLength, // 传递井筒的总MD长度
|
|
|
this
|
|
|
);
|
|
|
pPerforationItem->setZValue(1); // 设置Z值为1，确保在井筒（Z=2）之下
|
|
|
|
|
|
addPerforation(pPerforationItem); // 添加到父组中
|
|
|
m_mapPerforationItem.insert(pPerfData, pPerforationItem); // 添加到映射中
|
|
|
|
|
|
// 连接射孔拖动信号
|
|
|
connect(pPerforationItem, SIGNAL(sigRequestPerforationMdUpdate(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)));
|
|
|
}
|
|
|
|
|
|
// 无论新建还是现有，都更新其视觉信息，确保实时刷新
|
|
|
if(pPerforationItem) {
|
|
|
pPerforationItem->updateWellboreVisuals(wellboreStartScene, wellboreEndScene,
|
|
|
wellboreStartAbsoluteMd, totalWellboreMdLength);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 请求场景重绘，只重绘受影响的区域
|
|
|
scene()->update();
|
|
|
}
|
|
|
|
|
|
// nmWellboreEndHandleGraphicsItem 类的实现
|
|
|
nmWellboreEndHandleGraphicsItem::nmWellboreEndHandleGraphicsItem(QGraphicsItem *parent)
|
|
|
: QGraphicsRectItem(parent)
|
|
|
{
|
|
|
//// 设置手柄的默认样式
|
|
|
//QPen pen(Qt::black); // 边框为黑色
|
|
|
//QBrush brush(Qt::red); // 填充为红色
|
|
|
//setPen(pen);
|
|
|
//setBrush(brush);
|
|
|
QPen pen(Qt::black, 0);
|
|
|
pen.setCosmetic(true);
|
|
|
QBrush brush(Qt::red);
|
|
|
setPen(pen);
|
|
|
setBrush(brush);
|
|
|
}
|
|
|
|
|
|
void nmWellboreEndHandleGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(event->button() == Qt::LeftButton) {
|
|
|
m_lastMouseScenePos = event->scenePos(); // 记录鼠标按下时的场景坐标
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWellboreEndHandleGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(event->buttons() & Qt::LeftButton) { // 如果左键被按下并拖动
|
|
|
QPointF delta = event->scenePos() - m_lastMouseScenePos; // 计算鼠标移动的增量
|
|
|
moveBy(delta.x(), delta.y()); // 移动手柄图元本身
|
|
|
m_lastMouseScenePos = event->scenePos(); // 更新上次鼠标位置
|
|
|
emit handlePositionChanged(event->scenePos(), true); // 发出信号，通知新的场景位置
|
|
|
}
|
|
|
|
|
|
QGraphicsRectItem::mouseMoveEvent(event); // 调用基类的处理
|
|
|
}
|
|
|
|
|
|
void nmWellboreEndHandleGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
QGraphicsRectItem::mouseReleaseEvent(event); // 调用基类的处理
|
|
|
emit handlePositionChanged(scenePos(), false); // 鼠标释放时，再次发送最终的场景位置，确保精确
|
|
|
}
|
|
|
|
|
|
#include "nmDataHorizontalFracturedWell.h"
|
|
|
|
|
|
// --- nmHorizontalFracturedWellTopViewItem 实现 ---
|
|
|
nmHorizontalFracturedWellTopViewItem::nmHorizontalFracturedWellTopViewItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent),
|
|
|
m_pWellboreLine(nullptr),
|
|
|
m_pEndHandle(nullptr),
|
|
|
m_bEditMode(false)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellTopViewItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange(); // 通知QGraphicsView，此项的几何形状可能发生变化
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
// 清空 m_listFractures
|
|
|
qDeleteAll(m_listFractures);
|
|
|
m_listFractures.clear();
|
|
|
|
|
|
m_pWellboreLine = nullptr;
|
|
|
m_pEndHandle = nullptr;
|
|
|
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配 (垂直井或垂直压裂井在俯视图中显示类似)
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
return; // 不符合类型则不绘制
|
|
|
}
|
|
|
|
|
|
nmDataHorizontalFracturedWell *pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(m_pDataWell);
|
|
|
if(pHFWell == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 1. 绘制井筒点 (绿色圆点)
|
|
|
nmWellborePointGraphicsItem* pWellPoint = new nmWellborePointGraphicsItem(this); // 创建井点图元，并将其父项设为当前组合图元
|
|
|
double dRadius = 7;
|
|
|
double dX = pHFWell->getX().getValue().toDouble(); // 井口横坐标
|
|
|
double dY = pHFWell->getY().getValue().toDouble(); // 井口纵坐标
|
|
|
// 设置图元位置到场景坐标系的(dX,dY)
|
|
|
pWellPoint->setRect(-dRadius, -dRadius, dRadius * 2, dRadius * 2); // 矩形中心在 (0,0)
|
|
|
pWellPoint->setPos(dX, dY); // 将图元移动到场景中的 (dX, dY)
|
|
|
|
|
|
pWellPoint->setFlag(QGraphicsItem::ItemIsMovable, false); // 初始不可移动
|
|
|
|
|
|
// 设置Z值，确保在上面
|
|
|
pWellPoint->setZValue(1);
|
|
|
|
|
|
addPoint(pWellPoint); // 添加到组合图元中并记录
|
|
|
|
|
|
// 2. 绘制井筒(俯视图下)
|
|
|
// 获取几何信息
|
|
|
// 井身长度
|
|
|
double dWellLength = pHFWell->getWellLength().getValue().toDouble();
|
|
|
// 与水平方向的夹角(直角坐标系)
|
|
|
double dDarinAngle = pHFWell->getDrainAngle().getValue().toDouble();
|
|
|
|
|
|
// 将角度从度转换为弧度，因为 Qt 的三角函数通常接受弧度
|
|
|
double dDarinAngleRad = dDarinAngle * M_PI / 180.0;
|
|
|
|
|
|
// 计算井筒的终点坐标
|
|
|
// endX = 起始X + 长度 * cos(角度)
|
|
|
// endY = 起始Y + 长度 * sin(角度)
|
|
|
double endX = dX + dWellLength * qCos(dDarinAngleRad);
|
|
|
double endY = dY + dWellLength * qSin(dDarinAngleRad);
|
|
|
|
|
|
// 创建井筒线段
|
|
|
m_pWellboreLine = new nmWellboreLineGraphicsItem(this);
|
|
|
QPen linePen;
|
|
|
linePen.setColor(QColor("#32cd32")); // 设置线段颜色
|
|
|
linePen.setWidth(5); // 设置线宽
|
|
|
linePen.setCosmetic(true);
|
|
|
m_pWellboreLine->setStyle(linePen); // 应用样式
|
|
|
m_pWellboreLine->setLine(dX, dY, endX, endY); // 设置线段的起始点和终点
|
|
|
m_pWellboreLine->setZValue(2);
|
|
|
addLine(m_pWellboreLine); // 添加到组合图元中并记录
|
|
|
|
|
|
// 创建井筒末端矩形手柄
|
|
|
m_pEndHandle = new nmWellboreEndHandleGraphicsItem(this);
|
|
|
// 设置手柄的矩形区域
|
|
|
m_pEndHandle->setRect(-5, -5, 10, 10);
|
|
|
// 将手柄的中心设置在井筒线的终点
|
|
|
m_pEndHandle->setPos(endX, endY);
|
|
|
m_pEndHandle->setVisible(m_bEditMode);
|
|
|
m_pEndHandle->setZValue(5);
|
|
|
// 连接手柄的 handlePositionChanged 信号到当前类的 onEndHandleMoved 槽函数
|
|
|
connect(m_pEndHandle, SIGNAL(handlePositionChanged(QPointF, bool)),
|
|
|
this, SLOT(onEndHandleMoved(QPointF, bool)));
|
|
|
|
|
|
// 3. 绘制射孔段
|
|
|
QVector<nmDataPerforation*>& vecCurrentPerforations = pHFWell->getPerforations();
|
|
|
|
|
|
// 井筒的MD起始值（多段压裂水平井默认是第一条射孔起点）和总MD长度
|
|
|
double wellboreStartAbsoluteMd = vecCurrentPerforations[0]->getMdStart().getValue().toDouble();
|
|
|
double totalWellboreMdLength = dWellLength;
|
|
|
|
|
|
// 井筒的视觉起点和终点
|
|
|
QPointF wellboreStartScene = QPointF(dX, dY);
|
|
|
QPointF wellboreEndScene = QPointF(endX, endY);
|
|
|
|
|
|
foreach(nmDataPerforation* pPerfData, vecCurrentPerforations) {
|
|
|
nmPerforationGraphicsItem* pPerforationItem = nullptr;
|
|
|
|
|
|
// 构造函数传入最新的MD信息
|
|
|
pPerforationItem = new nmPerforationGraphicsItem(
|
|
|
pPerfData,
|
|
|
NM_WELL_MODEL::Horizontal_Fractured_Well, // 传递井类型
|
|
|
wellboreStartAbsoluteMd, // 传递井筒的MD起始值
|
|
|
totalWellboreMdLength, // 传递井筒的总MD长度
|
|
|
this
|
|
|
);
|
|
|
pPerforationItem->setZValue(3);
|
|
|
|
|
|
addPerforation(pPerforationItem); // 添加到父组中
|
|
|
|
|
|
// 初始化射孔段的视觉信息
|
|
|
pPerforationItem->updateWellboreVisuals(wellboreStartScene, wellboreEndScene,
|
|
|
wellboreStartAbsoluteMd, totalWellboreMdLength);
|
|
|
|
|
|
// 连接射孔拖动信号
|
|
|
connect(pPerforationItem, SIGNAL(sigRequestPerforationMdUpdate(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)));
|
|
|
|
|
|
}
|
|
|
|
|
|
// 4. 绘制裂缝 (使用新的 nmHorizontalFractureGraphicsItem)
|
|
|
// 强制数据模型更新裂缝点，确保其是基于当前井筒几何的最新状态
|
|
|
QVector<QPair<QPointF, QPointF>> vecFracturePoint = pHFWell->getFracs();
|
|
|
|
|
|
int fractureIndex = 0; // 用于给裂缝分配索引
|
|
|
|
|
|
for(QVector<QPair<QPointF, QPointF>>::const_iterator it = vecFracturePoint.constBegin();
|
|
|
it != vecFracturePoint.constEnd(); ++it) {
|
|
|
const QPair<QPointF, QPointF>& fracPair = *it; // 获取当前元素
|
|
|
|
|
|
nmHorizontalFractureGraphicsItem* pFractureItem = new nmHorizontalFractureGraphicsItem(fractureIndex, this);
|
|
|
pFractureItem->updateFractureLineAndHandles(fracPair.first, fracPair.second);
|
|
|
// 传递井筒场景信息和方向，用于裂缝内部的拖动约束
|
|
|
pFractureItem->setWellboreInfo(wellboreStartScene, wellboreEndScene);
|
|
|
pFractureItem->setEditMode(m_bEditMode);
|
|
|
|
|
|
connect(pFractureItem, SIGNAL(fractureHalfLengthChanged(double, bool, int)),
|
|
|
this, SLOT(onSingleFractureHalfLengthChanged(double, bool, int)));
|
|
|
|
|
|
// ！！！将裂缝图元添加到本类自己的列表中
|
|
|
m_listFractures.append(pFractureItem);
|
|
|
pFractureItem->setZValue(1.5); // 井点之上、井筒之下
|
|
|
fractureIndex++;
|
|
|
}
|
|
|
|
|
|
// 清空旧缓存
|
|
|
m_vecFractureMds.clear();
|
|
|
// 从数据模型获取MD值
|
|
|
m_vecFractureMds = pHFWell->getFractureMds();
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellTopViewItem::setEditMode(bool enabled)
|
|
|
{
|
|
|
m_bEditMode = enabled; // 更新内部状态
|
|
|
|
|
|
if(m_pEndHandle) {
|
|
|
m_pEndHandle->setVisible(enabled); // 设置手柄的可见性
|
|
|
}
|
|
|
|
|
|
// 设置裂缝的编辑状态
|
|
|
foreach(nmHorizontalFractureGraphicsItem* pFractureItem, m_listFractures) {
|
|
|
if(pFractureItem) {
|
|
|
pFractureItem->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellTopViewItem::setPerforationEditMode(bool enabled)
|
|
|
{
|
|
|
// 遍历射孔段数组，设置为编辑状态
|
|
|
foreach(nmPerforationGraphicsItem* item, m_listPerforations) {
|
|
|
item->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellTopViewItem::onEndHandleMoved(QPointF newScenePos, bool isDragging)
|
|
|
{
|
|
|
|
|
|
if(!m_bEditMode) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if(!m_pDataWell) return;
|
|
|
|
|
|
nmDataHorizontalFracturedWell *pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pHFWell) return;
|
|
|
|
|
|
prepareGeometryChange();
|
|
|
|
|
|
// 井筒起点是固定的井口坐标
|
|
|
QPointF wellboreStartScene(pHFWell->getX().getValue().toDouble(), pHFWell->getY().getValue().toDouble());
|
|
|
QPointF wellboreEndScene = newScenePos; // 实时终点
|
|
|
|
|
|
// 实时计算井身长度和方向
|
|
|
double currentWellLength = QLineF(wellboreStartScene, wellboreEndScene).length();
|
|
|
QVector2D wellboreDirection = QVector2D(wellboreEndScene - wellboreStartScene).normalized();
|
|
|
QPointF perpendicularDirection = QPointF(-wellboreDirection.y(), wellboreDirection.x());
|
|
|
|
|
|
// 1. 更新井筒线段的终点（实时）
|
|
|
if(m_pWellboreLine) {
|
|
|
m_pWellboreLine->setLine(wellboreStartScene.x(), wellboreStartScene.y(), wellboreEndScene.x(), wellboreEndScene.y());
|
|
|
}
|
|
|
|
|
|
// 2. 实时更新所有射孔图元的视觉状态
|
|
|
// 从数据模型中获取旧的井筒MD数据作为计算比例的基准
|
|
|
double originalWellheadMd = pHFWell->getPerforations()[0]->getMdStart().getValue().toDouble();
|
|
|
double originalWellLength = pHFWell->getWellLength().getValue().toDouble();
|
|
|
|
|
|
foreach(nmPerforationGraphicsItem* pPerforationItem, m_listPerforations) {
|
|
|
if(pPerforationItem) {
|
|
|
// 调用专门用于实时预览的方法，它会根据旧MD比例和新长度计算位置
|
|
|
pPerforationItem->updateVisualsForWellboreDrag(wellboreStartScene, wellboreEndScene,
|
|
|
originalWellheadMd, originalWellLength,
|
|
|
currentWellLength);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 3. 实时更新所有裂缝图元
|
|
|
if(!m_vecFractureMds.empty()) {
|
|
|
double halfLength = pHFWell->getFractureHalfLength().getValue().toDouble(); // 裂缝半长在拖动井身时是固定的
|
|
|
double fractureRelativeAngleRad = pHFWell->getFractureAngle().getValue().toDouble() * M_PI / 180.0;
|
|
|
|
|
|
// 计算裂缝的绝对角度
|
|
|
qreal wellboreAngleRad = qAtan2(wellboreDirection.y(), wellboreDirection.x());
|
|
|
double fractureAbsoluteAngleRad = wellboreAngleRad + fractureRelativeAngleRad;
|
|
|
|
|
|
// 计算裂缝端点的偏移量
|
|
|
double dx_frac = halfLength * cos(fractureAbsoluteAngleRad);
|
|
|
double dy_frac = halfLength * sin(fractureAbsoluteAngleRad);
|
|
|
|
|
|
// 这里的逻辑是保持裂缝在井筒上的“均匀分布”
|
|
|
int fractureCount = m_vecFractureMds.size();
|
|
|
double intervalRatio = (fractureCount > 1) ? 1.0 / (fractureCount - 1) : 0.0;
|
|
|
|
|
|
for(int i = 0; i < fractureCount; ++i) {
|
|
|
nmHorizontalFractureGraphicsItem* pFractureItem = m_listFractures.at(i);
|
|
|
|
|
|
if(pFractureItem) {
|
|
|
// 根据新的总长度和均匀间隔比例，计算每个裂缝中心点在井筒上的位置
|
|
|
double currentPositionAlongWellbore = i * intervalRatio * currentWellLength;
|
|
|
|
|
|
QPointF fractureCenterScene = wellboreStartScene + wellboreDirection.toPointF() * currentPositionAlongWellbore;
|
|
|
|
|
|
QPointF p1_new_scene = QPointF(fractureCenterScene.x() - dx_frac, fractureCenterScene.y() - dy_frac);
|
|
|
QPointF p2_new_scene = QPointF(fractureCenterScene.x() + dx_frac, fractureCenterScene.y() + dy_frac);
|
|
|
|
|
|
pFractureItem->updateFractureLineAndHandles(p1_new_scene, p2_new_scene);
|
|
|
pFractureItem->setWellboreInfo(wellboreStartScene, wellboreEndScene); // 更新井筒信息，供裂缝内部拖动使用
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 4. 只有当拖动结束时，才发出信号给控制器
|
|
|
if(!isDragging) {
|
|
|
emit sigWellboreDragFinished(newScenePos);
|
|
|
// 更新缓存的裂缝MD，临时，可能后面会有时序问题
|
|
|
m_vecFractureMds.clear();
|
|
|
m_vecFractureMds = pHFWell->getFractureMds();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellTopViewItem::onSingleFractureHalfLengthChanged(double newHalfLength, bool isDragging, int fractureIndex)
|
|
|
{
|
|
|
// 获取井筒的场景坐标信息
|
|
|
QPointF wellboreStartScene = m_pWellboreLine->line().p1();
|
|
|
QPointF wellboreEndScene = m_pWellboreLine->line().p2();
|
|
|
double wellboreVisualLength = QLineF(wellboreStartScene, wellboreEndScene).length();
|
|
|
QVector2D wellboreDirection = QVector2D(wellboreEndScene - wellboreStartScene).normalized();
|
|
|
|
|
|
// 获取井筒的总MD长度（这个值在拖动裂缝半长时是固定的）
|
|
|
nmDataHorizontalFracturedWell *pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pHFWell) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
double totalWellboreMdLength = pHFWell->getWellLength().getValue().toDouble();
|
|
|
|
|
|
// 计算垂直于井筒的方向向量
|
|
|
QPointF perpendicularDirection = QPointF(-wellboreDirection.y(), wellboreDirection.x());
|
|
|
|
|
|
// 拖动过程中，实时计算所有裂缝的视觉位置
|
|
|
if(isDragging) {
|
|
|
// 遍历所有裂缝图元，使用缓存的MD值
|
|
|
for(int i = 0; i < m_listFractures.size() && i < m_vecFractureMds.size(); ++i) {
|
|
|
nmHorizontalFractureGraphicsItem* pFractureItem = m_listFractures.at(i);
|
|
|
|
|
|
if(pFractureItem) {
|
|
|
// 根据缓存的MD值计算中心点
|
|
|
double fractureMd = m_vecFractureMds.at(i);
|
|
|
QPointF fractureCenterScene = wellboreStartScene + wellboreDirection.toPointF() * (fractureMd / totalWellboreMdLength * wellboreVisualLength);
|
|
|
|
|
|
// 计算新的裂缝端点
|
|
|
QPointF p1_new_scene = fractureCenterScene - perpendicularDirection * newHalfLength;
|
|
|
QPointF p2_new_scene = fractureCenterScene + perpendicularDirection * newHalfLength;
|
|
|
|
|
|
// 更新图元的视觉状态
|
|
|
pFractureItem->updateFractureLineAndHandles(p1_new_scene, p2_new_scene);
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
// 拖动结束时，发出信号给控制器
|
|
|
emit sigFractureHalfLengthChanged(newHalfLength);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QLineF nmHorizontalFracturedWellTopViewItem::getWellboreLine()
|
|
|
{
|
|
|
return m_pWellboreLine->line();
|
|
|
}
|
|
|
|
|
|
nmCrossSectionFractureItem::nmCrossSectionFractureItem(int fractureIndex, QGraphicsItem *parent)
|
|
|
: QObject(nullptr),
|
|
|
QGraphicsLineItem(parent),
|
|
|
m_pTopHandle(nullptr),
|
|
|
m_pBottomHandle(nullptr),
|
|
|
m_bEditMode(false),
|
|
|
m_fractureIndex(fractureIndex),
|
|
|
m_currentFractureXPosition(0.0),
|
|
|
m_currentFractureMidPointY(0.0),
|
|
|
m_currentFractureHeight(0.0),
|
|
|
m_minReservoirDepth(0.0), // 初始化
|
|
|
m_maxReservoirDepth(0.0), // 初始化
|
|
|
m_isDraggingBody(false)
|
|
|
{
|
|
|
//QPen pen(QColor("#0000ff"), 3);
|
|
|
//setPen(pen);
|
|
|
//setZValue(3); // 确保在井筒和储层之上
|
|
|
QPen pen(QColor("#0000ff"), 3);
|
|
|
pen.setCosmetic(true);
|
|
|
setPen(pen);
|
|
|
setZValue(3);
|
|
|
|
|
|
m_pTopHandle = new nmFractureLineHandleItem(this);
|
|
|
m_pBottomHandle = new nmFractureLineHandleItem(this);
|
|
|
|
|
|
connect(m_pTopHandle, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
connect(m_pBottomHandle, SIGNAL(handlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)),
|
|
|
this, SLOT(onHandlePositionChanged(nmFractureLineHandleItem*, QPointF, bool)));
|
|
|
|
|
|
// 默认禁用所有不必要的视觉效果和交互
|
|
|
setEditMode(false);
|
|
|
}
|
|
|
|
|
|
nmCrossSectionFractureItem::~nmCrossSectionFractureItem()
|
|
|
{
|
|
|
m_pTopHandle = nullptr;
|
|
|
m_pBottomHandle = nullptr;
|
|
|
}
|
|
|
|
|
|
// 更新裂缝的视觉表示，并传入储层深度限制
|
|
|
void nmCrossSectionFractureItem::updateFractureVisuals(double fractureXPosition, double midPointY, double fractureHeight,
|
|
|
double minReservoirDepth, double maxReservoirDepth)
|
|
|
{
|
|
|
prepareGeometryChange(); // 准备几何形状变化通知
|
|
|
|
|
|
m_currentFractureXPosition = fractureXPosition;
|
|
|
m_currentFractureMidPointY = midPointY;
|
|
|
m_currentFractureHeight = fractureHeight;
|
|
|
m_minReservoirDepth = minReservoirDepth; // 存储储层深度限制
|
|
|
m_maxReservoirDepth = maxReservoirDepth; // 存储储层深度限制
|
|
|
|
|
|
// 裂缝作为垂直线，X坐标固定，Y坐标从 (midY - halfHeight) 到 (midY + halfHeight)
|
|
|
double halfHeight = fractureHeight / 2.0;
|
|
|
|
|
|
QPointF p1_local(fractureXPosition, midPointY - halfHeight); // 顶部点
|
|
|
QPointF p2_local(fractureXPosition, midPointY + halfHeight); // 底部点 (假设Y轴向下为正)
|
|
|
|
|
|
setLine(QLineF(p1_local, p2_local));
|
|
|
|
|
|
// 更新把手位置
|
|
|
if(m_pTopHandle) {
|
|
|
m_pTopHandle->setPos(p1_local);
|
|
|
}
|
|
|
|
|
|
if(m_pBottomHandle) {
|
|
|
m_pBottomHandle->setPos(p2_local);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 设置编辑模式，并禁用不必要的视觉效果
|
|
|
void nmCrossSectionFractureItem::setEditMode(bool enable)
|
|
|
{
|
|
|
m_bEditMode = enable;
|
|
|
|
|
|
if(m_pTopHandle) {
|
|
|
m_pTopHandle->setVisible(enable);
|
|
|
m_pTopHandle->setEnabled(enable); // 启用/禁用把手交互
|
|
|
// 确保 nmFractureLineHandleItem 也不修改鼠标样式
|
|
|
// 并在其 paint 方法中不绘制选中框
|
|
|
}
|
|
|
|
|
|
if(m_pBottomHandle) {
|
|
|
m_pBottomHandle->setVisible(enable);
|
|
|
m_pBottomHandle->setEnabled(enable);
|
|
|
// 确保 nmFractureLineHandleItem 也不修改鼠标样式
|
|
|
}
|
|
|
|
|
|
// 禁用 ItemIsSelectable 以避免选中虚线框，因为我们不需要编辑线样式
|
|
|
setFlag(ItemIsSelectable, false);
|
|
|
setFlag(ItemIsMovable, enable); // 启用/禁用图元整体拖动
|
|
|
// setFlag(ItemSendsGeometryChanges, false); // 不需要发送几何变化，因为我们手动处理
|
|
|
}
|
|
|
|
|
|
// 槽函数：响应把手位置变化（主要影响高度）
|
|
|
void nmCrossSectionFractureItem::onHandlePositionChanged(nmFractureLineHandleItem* handle, QPointF newHandlePosInParent, bool isDragging)
|
|
|
{
|
|
|
if(!m_bEditMode) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
double currentTopY = line().p1().y();
|
|
|
double currentBottomY = line().p2().y();
|
|
|
|
|
|
double desiredNewHandleY = newHandlePosInParent.y();
|
|
|
double newHeight;
|
|
|
double newMidPointY = m_currentFractureMidPointY;
|
|
|
|
|
|
if(handle == m_pTopHandle) {
|
|
|
// 拖动顶部把手
|
|
|
// 1. 限制不能穿过底部把手：新的顶部Y不能大于当前底部Y
|
|
|
double maxAllowedTopY = currentBottomY;
|
|
|
// 2. 限制不能超过储层最小深度：新的顶部Y不能小于 m_minReservoirDepth
|
|
|
double minAllowedTopY = m_minReservoirDepth;
|
|
|
|
|
|
// 综合限制
|
|
|
double actualNewTopY = qBound(minAllowedTopY, desiredNewHandleY, maxAllowedTopY);
|
|
|
|
|
|
newHeight = currentBottomY - actualNewTopY;
|
|
|
newMidPointY = currentBottomY - (newHeight / 2.0); // 重新计算中点Y
|
|
|
} else { // handle == m_pBottomHandle
|
|
|
// 拖动底部把手
|
|
|
// 1. 限制不能穿过顶部把手：新的底部Y不能小于当前顶部Y
|
|
|
double minAllowedBottomY = currentTopY;
|
|
|
// 2. 限制不能超过储层最大深度：新的底部Y不能大于 m_maxReservoirDepth
|
|
|
double maxAllowedBottomY = m_maxReservoirDepth;
|
|
|
|
|
|
// 综合限制
|
|
|
double actualNewBottomY = qBound(minAllowedBottomY, desiredNewHandleY, maxAllowedBottomY);
|
|
|
|
|
|
newHeight = actualNewBottomY - currentTopY;
|
|
|
newMidPointY = currentTopY + (newHeight / 2.0); // 重新计算中点Y
|
|
|
}
|
|
|
|
|
|
// 确保高度非负，尽管前面的 qBound 应该已经处理了
|
|
|
newHeight = qMax(0.0, newHeight);
|
|
|
|
|
|
// 更新视觉，使用新的高度和计算出的新中点Y，并传入储层限制
|
|
|
updateFractureVisuals(m_currentFractureXPosition, newMidPointY, newHeight,
|
|
|
m_minReservoirDepth, m_maxReservoirDepth);
|
|
|
|
|
|
// 发出信号通知父图元
|
|
|
emit fractureGeometryChanged(newHeight, newMidPointY, isDragging, m_fractureIndex);
|
|
|
}
|
|
|
|
|
|
// 鼠标按下事件：处理整体拖动
|
|
|
void nmCrossSectionFractureItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bEditMode && event->button() == Qt::LeftButton) {
|
|
|
// 检查鼠标是否在把手上。如果把手接受了事件，则不处理整体拖动。
|
|
|
// 这里需要更精确的判断，因为 QGraphicsItem 默认会把事件传递给子项。
|
|
|
// 如果 event->lastAcceptedItem() 是把手，则不处理。
|
|
|
// 为了简化，我们只检查 event->pos() 是否在把手范围内。
|
|
|
if(!m_pTopHandle->contains(event->pos()) && !m_pBottomHandle->contains(event->pos())) {
|
|
|
m_lastMousePos = event->pos(); // 存储在图元局部坐标系中的位置
|
|
|
m_isDraggingBody = true;
|
|
|
// 不修改鼠标样式
|
|
|
// 立即发出信号，表示开始拖动
|
|
|
emit fractureGeometryChanged(m_currentFractureHeight, m_currentFractureMidPointY, true, m_fractureIndex);
|
|
|
event->accept(); // 接受事件，阻止传递给父级或下层
|
|
|
return; // 提前返回，不调用基类
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QGraphicsLineItem::mousePressEvent(event); // 传递给基类，处理把手或其他默认行为
|
|
|
}
|
|
|
|
|
|
// 鼠标移动事件：处理整体拖动
|
|
|
void nmCrossSectionFractureItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bEditMode && m_isDraggingBody) {
|
|
|
qreal dy = event->pos().y() - m_lastMousePos.y(); // 局部坐标系中的垂直位移
|
|
|
|
|
|
// 计算期望的新中点Y
|
|
|
double desiredNewMidPointY = m_currentFractureMidPointY + dy;
|
|
|
|
|
|
// 计算期望的裂缝顶部和底部Y坐标
|
|
|
double desiredNewTopY = desiredNewMidPointY - m_currentFractureHeight / 2.0;
|
|
|
double desiredNewBottomY = desiredNewMidPointY + m_currentFractureHeight / 2.0;
|
|
|
|
|
|
double actualNewMidPointY = desiredNewMidPointY; // 最终实际的中点Y
|
|
|
|
|
|
// 限制顶部不能超过储层最小深度
|
|
|
if(desiredNewTopY < m_minReservoirDepth) {
|
|
|
actualNewMidPointY = m_minReservoirDepth + m_currentFractureHeight / 2.0;
|
|
|
}
|
|
|
|
|
|
// 限制底部不能超过储层最大深度
|
|
|
if(desiredNewBottomY > m_maxReservoirDepth) {
|
|
|
actualNewMidPointY = m_maxReservoirDepth - m_currentFractureHeight / 2.0;
|
|
|
}
|
|
|
|
|
|
// 如果同时超出上下限（这种情况通常不会发生，除非高度大于储层高度）
|
|
|
// 优先根据顶部限制调整，或者根据哪个超出更多来调整
|
|
|
|
|
|
// 更新视觉，使用受限后的中点Y，高度保持不变
|
|
|
updateFractureVisuals(m_currentFractureXPosition, actualNewMidPointY, m_currentFractureHeight,
|
|
|
m_minReservoirDepth, m_maxReservoirDepth);
|
|
|
|
|
|
m_lastMousePos = event->pos(); // 更新上次鼠标位置
|
|
|
|
|
|
// 发出信号通知父图元中点Y已改变，并处于拖动中
|
|
|
emit fractureGeometryChanged(m_currentFractureHeight, actualNewMidPointY, true, m_fractureIndex);
|
|
|
event->accept();
|
|
|
} else {
|
|
|
QGraphicsLineItem::mouseMoveEvent(event); // 传递给基类
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 鼠标释放事件：结束整体拖动
|
|
|
void nmCrossSectionFractureItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
|
|
|
{
|
|
|
if(m_bEditMode && m_isDraggingBody && event->button() == Qt::LeftButton) {
|
|
|
m_isDraggingBody = false;
|
|
|
// 发出信号通知父图元中点Y改变结束
|
|
|
emit fractureGeometryChanged(m_currentFractureHeight, m_currentFractureMidPointY, false, m_fractureIndex);
|
|
|
event->accept();
|
|
|
} else {
|
|
|
QGraphicsLineItem::mouseReleaseEvent(event); // 传递给基类
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmHorizontalFracturedWellCrossSectionItem::nmHorizontalFracturedWellCrossSectionItem(QGraphicsItem *parent)
|
|
|
: nmAbstractWellboreVisual(parent),
|
|
|
m_pHFWellData(nullptr),
|
|
|
m_listCrossSectionFractures(),
|
|
|
m_pWellboreLine(nullptr),
|
|
|
m_pReservoirsItem(nullptr), // 初始化新增的储层图元指针
|
|
|
m_bEditMode(false)
|
|
|
{
|
|
|
// 可以在这里设置一些默认的样式或初始化成员变量
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellCrossSectionItem::updateGeometryVisuals(nmDataWellBase *pDataWell)
|
|
|
{
|
|
|
prepareGeometryChange();
|
|
|
clearAllChildItems(); // 清除所有已有的子项
|
|
|
|
|
|
// 清除内部管理的裂缝列表和井筒/储层指针
|
|
|
qDeleteAll(m_listCrossSectionFractures);
|
|
|
m_listCrossSectionFractures.clear();
|
|
|
m_pWellboreLine = nullptr;
|
|
|
m_pReservoirsItem = nullptr; // 清空指针
|
|
|
|
|
|
m_pDataWell = pDataWell; // 存储几何数据指针
|
|
|
|
|
|
// 检查几何数据是否有效，且类型是否匹配
|
|
|
if(!m_pDataWell || m_pDataWell->getWellType() != NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
qWarning() << "Invalid data well type or null data for Horizontal Fractured Well.";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
nmDataHorizontalFracturedWell *pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(m_pDataWell);
|
|
|
|
|
|
if(!pHFWell) {
|
|
|
qWarning() << "Failed to dynamic_cast to nmDataHorizontalFracturedWell.";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
m_pHFWellData = pHFWell; // 存储强类型指针
|
|
|
|
|
|
// --- 坐标系统：X轴为井筒水平延伸，Y轴为测深 (MD)，向下为正 ---
|
|
|
|
|
|
// 获取井筒数据
|
|
|
double dWellboreX = m_pHFWellData->getX().getValue().toDouble(); // 井筒在视图X轴的起点
|
|
|
double dWellLength = m_pHFWellData->getWellLength().getValue().toDouble(); // 井身长度
|
|
|
|
|
|
// 获取井筒的固定Y坐标（深度），即第一个射孔段的测深起点
|
|
|
// 确保 pHFWell->getPerforations() 不为空，且索引0有效
|
|
|
double dWellboreFixedDepthY = 0.0;
|
|
|
|
|
|
if(!m_pHFWellData->getPerforations().isEmpty() && m_pHFWellData->getPerforations()[0]) {
|
|
|
double dWellboreFixedDepth = m_pHFWellData->getFractureHeight().getValue().toDouble();
|
|
|
dWellboreFixedDepthY = dWellboreFixedDepth/2;
|
|
|
} else {
|
|
|
// 设定一个默认值以避免崩溃
|
|
|
dWellboreFixedDepthY = 6150.0; // 或者一个合理的默认深度
|
|
|
}
|
|
|
|
|
|
// 1. 绘制储层矩形 (nmReservoirGraphicsItems) - 最底层
|
|
|
m_pReservoirsItem = new nmReservoirGraphicsItems(this); // 创建实例
|
|
|
addToGroup(m_pReservoirsItem); // 直接添加到组
|
|
|
|
|
|
// 获取储层的最小和最大深度，传递给裂缝图元
|
|
|
qreal minReservoirDepth = m_pReservoirsItem->getMinLayerTop();
|
|
|
qreal maxReservoirDepth = m_pReservoirsItem->getMaxLayerBottom();
|
|
|
|
|
|
// 2. 绘制水平井筒线 (nmWellboreLineGraphicsItem)
|
|
|
m_pWellboreLine = new nmWellboreLineGraphicsItem(this);
|
|
|
m_pWellboreLine->setLine(dWellboreX, minReservoirDepth + dWellboreFixedDepthY, dWellboreX + dWellLength, minReservoirDepth + dWellboreFixedDepthY);
|
|
|
QPen wellborePen(QColor("#d3d3d3"), 0);
|
|
|
wellborePen.setCosmetic(true);
|
|
|
m_pWellboreLine->setStyle(wellborePen);
|
|
|
m_pWellboreLine->setZValue(2); // 设置Z值为2，确保在射孔段之上
|
|
|
addLine(m_pWellboreLine); // 添加到组中
|
|
|
|
|
|
// 3. 绘制裂缝
|
|
|
//m_pHFWellData->setFracs(); // 确保数据模型中裂缝信息是最新的
|
|
|
|
|
|
int dFNum = m_pHFWellData->getNumberOfFractures().getValue().toInt();
|
|
|
double dFHeight = m_pHFWellData->getFractureHeight().getValue().toDouble();
|
|
|
double dFMidPointHeightFromBottom = m_pHFWellData->getFractureMidPointHeight().getValue().toDouble();
|
|
|
|
|
|
// 计算裂缝中心点的Y坐标（绝对深度）
|
|
|
double fractureCenterY = maxReservoirDepth - dFMidPointHeightFromBottom;
|
|
|
|
|
|
QVector<double> fractureMDs = m_pHFWellData->getFractureMds();
|
|
|
|
|
|
int numToDraw = qMin(dFNum, fractureMDs.size());
|
|
|
|
|
|
for(int i = 0; i < numToDraw; ++i) {
|
|
|
double fractureMd = fractureMDs.at(i);
|
|
|
nmCrossSectionFractureItem* pFractureItem = new nmCrossSectionFractureItem(i, this);
|
|
|
|
|
|
// 更新裂缝视觉，并传递储层深度限制
|
|
|
pFractureItem->updateFractureVisuals(fractureMd, fractureCenterY, dFHeight,
|
|
|
minReservoirDepth, maxReservoirDepth);
|
|
|
pFractureItem->setEditMode(m_bEditMode);
|
|
|
|
|
|
connect(pFractureItem, SIGNAL(fractureGeometryChanged(double, double, bool, int)),
|
|
|
this, SLOT(onSingleFractureGeometryChanged(double, double, bool, int)));
|
|
|
|
|
|
m_listCrossSectionFractures.append(pFractureItem);
|
|
|
}
|
|
|
|
|
|
update(); // 请求重绘
|
|
|
}
|
|
|
|
|
|
// 设置编辑模式
|
|
|
void nmHorizontalFracturedWellCrossSectionItem::setEditMode(bool enabled)
|
|
|
{
|
|
|
m_bEditMode = enabled;
|
|
|
|
|
|
// 控制所有裂缝图元的编辑模式
|
|
|
foreach(nmCrossSectionFractureItem* pFractureItem, m_listCrossSectionFractures) {
|
|
|
if(pFractureItem) {
|
|
|
pFractureItem->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// TODO: 如果井筒线或其他图元也需要编辑模式，在这里进行控制
|
|
|
}
|
|
|
|
|
|
void nmHorizontalFracturedWellCrossSectionItem::onSingleFractureGeometryChanged(double newHeight, double newMidPointY, bool isDragging, int fractureIndex)
|
|
|
{
|
|
|
if(!m_bEditMode || !m_pHFWellData || !m_pReservoirsItem) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 实时更新视觉，遍历所有裂缝并应用新的高度和中点位置
|
|
|
// 注意：这里的逻辑需要考虑所有裂缝是否同步更新
|
|
|
// 如果所有裂缝的高度和中点都应该相同，那么这里就应该遍历所有裂缝并调用 updateFractureVisuals
|
|
|
qreal minReservoirDepth = m_pReservoirsItem->getMinLayerTop();
|
|
|
qreal maxReservoirDepth = m_pReservoirsItem->getMaxLayerBottom();
|
|
|
|
|
|
QVector<double> fractureMDs = m_pHFWellData->getFractureMds();
|
|
|
|
|
|
for(int i = 0; i < m_listCrossSectionFractures.size() && i < fractureMDs.size(); ++i) {
|
|
|
nmCrossSectionFractureItem* pFractureItem = m_listCrossSectionFractures.at(i);
|
|
|
|
|
|
if(pFractureItem) {
|
|
|
pFractureItem->updateFractureVisuals(fractureMDs.at(i), newMidPointY, newHeight,
|
|
|
minReservoirDepth, maxReservoirDepth);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 拖动结束时，发出信号给控制器，传递所有更新后的数据
|
|
|
if(!isDragging) {
|
|
|
emit sigFractureGeometryChanged(newHeight, newMidPointY);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// nmAbstractWellboreView 构造函数
|
|
|
nmAbstractWellboreView::nmAbstractWellboreView(QWidget *parent)
|
|
|
: QGraphicsView(parent), m_scene(nullptr), m_currentWellboreVisual(nullptr)
|
|
|
{
|
|
|
setupScene(); // 初始化场景
|
|
|
setRenderHint(QPainter::Antialiasing); // 启用抗锯齿渲染，使图形更平滑
|
|
|
//setTransformationAnchor(AnchorUnderMouse); // 设置缩放和平移的锚点为鼠标位置
|
|
|
//setResizeAnchor(AnchorUnderMouse); // 设置调整大小时的锚点
|
|
|
//setDragMode(QGraphicsView::ScrollHandDrag); // 允许平移场景
|
|
|
//setDragMode(QGraphicsView::NoDrag);
|
|
|
//setInteractive(true); // 确保启用交互
|
|
|
|
|
|
//setDragMode(QGraphicsView::ScrollHandDrag); // 允许平移场景
|
|
|
|
|
|
// 禁止拖拽场景
|
|
|
setDragMode(QGraphicsView::NoDrag);
|
|
|
|
|
|
setInteractive(true); // 确保启用交互
|
|
|
setMouseTracking(true); // 启用鼠标跟踪，以便实时获取鼠标位置
|
|
|
|
|
|
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // 关闭水平滚动条
|
|
|
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // 关闭垂直滚动条
|
|
|
|
|
|
// 设置鼠标滚轮缩放和锚点
|
|
|
setTransformationAnchor(QGraphicsView::AnchorUnderMouse); // 缩放和平移的锚点设为鼠标位置
|
|
|
setResizeAnchor(QGraphicsView::AnchorUnderMouse); // 调整大小时的锚点
|
|
|
}
|
|
|
|
|
|
// AbstractWellboreView 析构函数
|
|
|
nmAbstractWellboreView::~nmAbstractWellboreView()
|
|
|
{
|
|
|
// 场景的删除会处理其内部所有图形项的删除
|
|
|
delete m_scene;
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::mouseMoveEvent(QMouseEvent *event)
|
|
|
{
|
|
|
// 将视图坐标（像素）转换为场景坐标
|
|
|
// 场景坐标已经包含了视图自身的变换 (如 Y 轴翻转)
|
|
|
QPointF scenePos = mapToScene(event->pos());
|
|
|
emit mouseCoordinatesChanged(scenePos.x(), scenePos.y());
|
|
|
QGraphicsView::mouseMoveEvent(event); // 调用基类实现，确保拖拽等功能正常
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::enterEvent(QEvent *event)
|
|
|
{
|
|
|
emit mouseEnteredView(); // 鼠标进入视图区域时通知主窗口
|
|
|
QGraphicsView::enterEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::leaveEvent(QEvent *event)
|
|
|
{
|
|
|
emit mouseLeftView(); // 鼠标离开视图区域时通知主窗口
|
|
|
QGraphicsView::leaveEvent(event);
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::wheelEvent(QWheelEvent *event)
|
|
|
{
|
|
|
// 获取滚轮旋转的delta值
|
|
|
int nDelta = event->delta();
|
|
|
|
|
|
// 根据delta值判断缩放方向
|
|
|
if(nDelta > 0) {
|
|
|
// 向上/向前滚动，放大
|
|
|
zoomIn();
|
|
|
} else {
|
|
|
// 向下/向后滚动，缩小
|
|
|
zoomOut();
|
|
|
}
|
|
|
|
|
|
//// 计算缩放因子
|
|
|
//qreal factor = (event->delta() > 0) ? 1.15 : 1.0 / 1.15;
|
|
|
|
|
|
//// 执行缩放
|
|
|
//scale(factor, factor);
|
|
|
|
|
|
//// 1. 获取鼠标在场景中的位置（这将是我们的缩放中心点）
|
|
|
//// Qt4 中使用 event->pos() 获取鼠标在视图中的 QPoint (整数坐标)
|
|
|
//const QPointF scenePos = mapToScene(event->pos());
|
|
|
|
|
|
//// 2. 计算缩放因子
|
|
|
//// Qt4 中使用 event->delta() 获取滚轮滚动的量。
|
|
|
//// 正值通常表示向上滚动（放大），负值表示向下滚动（缩小）。
|
|
|
//qreal scaleFactor = event->delta() > 0 ? 1.15 : 1.0 / 1.15; // 每次缩放的比例
|
|
|
|
|
|
//// 3. 构建新的变换矩阵
|
|
|
//QTransform newTransform;
|
|
|
//// a. 将场景的原点平移到鼠标位置 (scenePos)
|
|
|
//newTransform.translate(scenePos.x(), scenePos.y());
|
|
|
//// b. 在鼠标位置（临时原点）处执行缩放
|
|
|
//newTransform.scale(scaleFactor, scaleFactor);
|
|
|
//// c. 将场景的原点再平移回来
|
|
|
//newTransform.translate(-scenePos.x(), -scenePos.y());
|
|
|
|
|
|
//// 4. 应用新的变换到视图的当前变换之上
|
|
|
//// 顺序很重要：newTransform * this->transform() 意味着先应用当前变换，再应用新的缩放平移
|
|
|
//setTransform(newTransform * this->transform());
|
|
|
|
|
|
// 5. 接受事件，防止事件继续传播
|
|
|
//event->accept();
|
|
|
|
|
|
//qreal s=0;
|
|
|
//bool in = true;
|
|
|
//bool out = true;
|
|
|
|
|
|
//qreal scaleValue = 1.5;
|
|
|
|
|
|
//if(event->delta() >= 0)
|
|
|
//{
|
|
|
// scaleValue += 1;
|
|
|
//}
|
|
|
//if(event->delta() < 0)
|
|
|
//{
|
|
|
// scaleValue -= 1;
|
|
|
//}
|
|
|
|
|
|
//if( scaleValue < -5 )
|
|
|
//{
|
|
|
// scaleValue = -5;
|
|
|
// in = false;
|
|
|
// return;
|
|
|
//}else if( scaleValue > 5 )
|
|
|
//{
|
|
|
// scaleValue = 5;
|
|
|
// out = false;
|
|
|
// return;
|
|
|
//}
|
|
|
|
|
|
//if(in)
|
|
|
//{
|
|
|
// s = qPow(1.01,event->delta()/10);
|
|
|
//}
|
|
|
//if(out)
|
|
|
//{
|
|
|
// s = qPow(1/1.01,-event->delta()/10);
|
|
|
//}
|
|
|
//scale(s,s);
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::zoomIn()
|
|
|
{
|
|
|
qreal qScaleStepFactor = 1.15; // 每次缩放的步长
|
|
|
scale(qScaleStepFactor, qScaleStepFactor);
|
|
|
}
|
|
|
|
|
|
void nmAbstractWellboreView::zoomOut()
|
|
|
{
|
|
|
qreal qScaleStepFactor = 1.15; // 每次缩放的步长
|
|
|
scale(1.0 / qScaleStepFactor, 1.0 / qScaleStepFactor);
|
|
|
}
|
|
|
|
|
|
// 初始化 QGraphicsScene
|
|
|
void nmAbstractWellboreView::setupScene()
|
|
|
{
|
|
|
m_scene = new QGraphicsScene(this); // 创建新的场景
|
|
|
// 不需要设置场景大小范围，默认无限大
|
|
|
//m_scene->setSceneRect(-1000, -1000, 2000, 2000); // 设定场景范围
|
|
|
setScene(m_scene); // 将场景设置到视图上
|
|
|
}
|
|
|
|
|
|
// 清理旧的井筒图元并准备场景以显示新的图元
|
|
|
void nmAbstractWellboreView::clearAndPrepareScene()
|
|
|
{
|
|
|
// 如果存在当前的井筒组合图元，则从场景中移除并删除它
|
|
|
if(m_currentWellboreVisual) {
|
|
|
m_scene->removeItem(m_currentWellboreVisual);
|
|
|
delete m_currentWellboreVisual;
|
|
|
m_currentWellboreVisual = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// === nmWxWellboreTopView 的实现 ===
|
|
|
nmWxWellboreTopView::nmWxWellboreTopView(QWidget *parent)
|
|
|
: nmAbstractWellboreView(parent)
|
|
|
{
|
|
|
m_bIsInAddPerforationMode = false;
|
|
|
m_bIsInDeletePerforationMode = false;
|
|
|
}
|
|
|
|
|
|
// 更新俯视图
|
|
|
void nmWxWellboreTopView::updateView(nmDataWellBase* geometry)
|
|
|
{
|
|
|
// 1. 清理旧的图元，并根据新的geometry更新显示
|
|
|
clearAndPrepareScene(); // 清理旧的井筒图元
|
|
|
|
|
|
// 清空场景
|
|
|
m_scene->clear();
|
|
|
|
|
|
if(!geometry) {
|
|
|
return; // 没有数据则返回
|
|
|
}
|
|
|
|
|
|
m_currentWellboreVisual = createWellboreVisual(geometry->getWellType()); // 创建或获取可视化图元
|
|
|
|
|
|
if(m_currentWellboreVisual) {
|
|
|
m_scene->addItem(m_currentWellboreVisual); // 添加到场景
|
|
|
m_currentWellboreVisual->updateGeometryVisuals(geometry); // 更新图元几何形状
|
|
|
|
|
|
// 仅当是 nmVerticalWellTopViewItem 类型时才连接其井筒点拖拽信号
|
|
|
if(nmVerticalWellTopViewItem * pVerticalWellTopView = dynamic_cast<nmVerticalWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmVerticalWellTopViewItem 的井筒点拖拽完成信号，转发给主视图
|
|
|
connect(pVerticalWellTopView, SIGNAL(sigWellborePointDragFinished(QPointF)),
|
|
|
this, SIGNAL(sigWellborePointMovedInTopView(QPointF)));
|
|
|
}
|
|
|
|
|
|
// 仅当是 nmVerticalFracturedWellTopViewItem 类型时才连接其裂缝拖拽信号
|
|
|
if(nmVerticalFracturedWellTopViewItem * pVFWellTopView = dynamic_cast<nmVerticalFracturedWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmVerticalFracturedWellTopViewItem 的射孔拖拽完成信号，转发给主视图
|
|
|
connect(pVFWellTopView, SIGNAL(sigFracturePosChanged(double, double)),
|
|
|
this, SIGNAL(sigFracturePosChangedInTopView(double, double)));
|
|
|
}
|
|
|
|
|
|
// 仅当是 nmHorizontalFracturedWellTopViewItem 类型时才连接其射孔拖拽信号
|
|
|
if(nmHorizontalFracturedWellTopViewItem * pHFWellTopView = dynamic_cast<nmHorizontalFracturedWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmHorizontalFracturedWellTopViewItem 的射孔拖拽完成信号，转发给主视图
|
|
|
connect(pHFWellTopView, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragInTopView(nmDataPerforation*, double, double)));
|
|
|
// 连接 nmHorizontalFracturedWellTopViewItem 的裂缝半长拖拽完成信号，转发给主视图
|
|
|
connect(pHFWellTopView, SIGNAL(sigFractureHalfLengthChanged(double)),
|
|
|
this, SIGNAL(sigFractureHalfLengthChanged(double)));
|
|
|
// 连接 nmHorizontalFracturedWellTopViewItem 的井身拖拽完成信号，转发给主视图
|
|
|
connect(pHFWellTopView, SIGNAL(sigWellboreDragFinished(QPointF)),
|
|
|
this, SIGNAL(sigWellboreDragFinished(QPointF)));
|
|
|
}
|
|
|
|
|
|
// 获取井口坐标
|
|
|
double dX = geometry->getX().getValue().toDouble();
|
|
|
double dY = geometry->getY().getValue().toDouble();
|
|
|
|
|
|
// 定义场景的可见区域大小（根据视图尺寸动态调整）
|
|
|
qreal viewWidth = this->viewport()->width();
|
|
|
qreal viewHeight = this->viewport()->height();
|
|
|
qreal sceneMargin = 1000.0; // 边距
|
|
|
|
|
|
// 计算场景矩形（以井口为中心，范围略大于视图尺寸）
|
|
|
QRectF sceneRect3(
|
|
|
dX - viewWidth / 2.0 - sceneMargin, // 左边界
|
|
|
dY - viewHeight / 2.0 - sceneMargin, // 上边界
|
|
|
viewWidth + 2 * sceneMargin, // 宽度
|
|
|
viewHeight + 2 * sceneMargin // 高度
|
|
|
);
|
|
|
|
|
|
// TODO:后续再修改，先临时设置
|
|
|
m_scene->setSceneRect(sceneRect3);
|
|
|
|
|
|
//// 2. 重置视图变换，让当前井处于视图中心
|
|
|
//resetViewTransform();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTopView::setPerForationEditMode(bool enabled)
|
|
|
{
|
|
|
if(auto topViewItem = dynamic_cast<nmHorizontalFracturedWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
topViewItem->setPerforationEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTopView::setAddPerforationMode(bool enable)
|
|
|
{
|
|
|
m_bIsInAddPerforationMode = enable;
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTopView::setPerforationDeleteMode(bool enabled)
|
|
|
{
|
|
|
m_bIsInDeletePerforationMode = enabled;
|
|
|
}
|
|
|
|
|
|
#include <QTransform>
|
|
|
|
|
|
void nmWxWellboreTopView::resetViewTransform()
|
|
|
{
|
|
|
resetTransform(); // 重置为单位矩阵，Y轴向上为正
|
|
|
|
|
|
// 应用 Y 轴翻转（向上为正）
|
|
|
scale(1, -1);
|
|
|
|
|
|
// 在所有视图变换设置完毕后，再进行中心化操作
|
|
|
if(m_currentWellboreVisual && m_currentWellboreVisual->getWellData()) {
|
|
|
nmDataWellBase* pGeometry = m_currentWellboreVisual->getWellData();
|
|
|
|
|
|
// 如果是多段压裂水平井，则视图中心为井筒中心
|
|
|
if(pGeometry->getWellType() == NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
nmDataHorizontalFracturedWell* pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(pGeometry);
|
|
|
|
|
|
if(pHFWell) { // 如果是多段压裂水平井
|
|
|
// 获取井的起点
|
|
|
double dStartX = pHFWell->getX().getValue().toDouble();
|
|
|
double dStartY = pHFWell->getY().getValue().toDouble();
|
|
|
|
|
|
// 获取井长和角度
|
|
|
double dWellLength = pHFWell->getWellLength().getValue().toDouble();
|
|
|
double dDrainAngleRad = pHFWell->getDrainAngle().getValue().toDouble() * M_PI / 180.0;
|
|
|
|
|
|
// 计算井的终点
|
|
|
double dEndX = dStartX + dWellLength * qCos(dDrainAngleRad);
|
|
|
double dEndY = dStartY + dWellLength * qSin(dDrainAngleRad);
|
|
|
|
|
|
// 计算井筒的中点
|
|
|
double dCenterX = (dStartX + dEndX) / 2.0;
|
|
|
double dCenterY = (dStartY + dEndY) / 2.0;
|
|
|
|
|
|
centerOn(dCenterX, dCenterY);
|
|
|
}
|
|
|
} else {
|
|
|
double dX = pGeometry->getX().getValue().toDouble();
|
|
|
double dY = pGeometry->getY().getValue().toDouble();
|
|
|
|
|
|
centerOn(dX, dY);
|
|
|
}
|
|
|
} else if(m_scene && !m_scene->items().isEmpty()) {
|
|
|
centerOn(m_scene->itemsBoundingRect().center());
|
|
|
} else {
|
|
|
centerOn(0, 0);
|
|
|
}
|
|
|
|
|
|
update();
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTopView::setEditMode(bool enabled)
|
|
|
{
|
|
|
if(auto vTopViewItem = dynamic_cast<nmVerticalWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
vTopViewItem->setEditMode(enabled);
|
|
|
} else if(auto VFtopViewItem = dynamic_cast<nmVerticalFracturedWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
VFtopViewItem->setEditMode(enabled);
|
|
|
} else if(auto HFtopViewItem = dynamic_cast<nmHorizontalFracturedWellTopViewItem * >(m_currentWellboreVisual)) {
|
|
|
HFtopViewItem->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 工厂方法：根据井类型创建适合俯视图的组合图元实例
|
|
|
nmAbstractWellboreVisual* nmWxWellboreTopView::createWellboreVisual(NM_WELL_MODEL type)
|
|
|
{
|
|
|
switch(type) {
|
|
|
case Vertical_Well:
|
|
|
return new nmVerticalWellTopViewItem();
|
|
|
|
|
|
case Vertical_Fractured_Well:
|
|
|
return new nmVerticalFracturedWellTopViewItem();
|
|
|
|
|
|
case Horizontal_Fractured_Well:
|
|
|
return new nmHorizontalFracturedWellTopViewItem();
|
|
|
|
|
|
default:
|
|
|
return nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTopView::mousePressEvent(QMouseEvent *event)
|
|
|
{
|
|
|
// 添加射孔段模式处理
|
|
|
if(m_bIsInAddPerforationMode && event->button() == Qt::LeftButton) {
|
|
|
nmHorizontalFracturedWellTopViewItem* pHFWellItem =
|
|
|
dynamic_cast<nmHorizontalFracturedWellTopViewItem*>(m_currentWellboreVisual);
|
|
|
|
|
|
if(pHFWellItem) {
|
|
|
QPointF scenePos = mapToScene(event->pos()); // 将鼠标位置转换为场景坐标
|
|
|
double fractureTopMd = -1.0;
|
|
|
double fractureBottomMd = -1.0;
|
|
|
QLineF wellboreVisualLine = pHFWellItem->getWellboreLine();
|
|
|
|
|
|
// 发射信号，传递所有参数
|
|
|
emit sigRequestAddPerforation(scenePos, fractureTopMd, fractureBottomMd, wellboreVisualLine);
|
|
|
}
|
|
|
|
|
|
event->accept(); // 阻止事件进一步传播，确保只处理一次点击
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 删除射孔模式的处理
|
|
|
if(m_bIsInDeletePerforationMode && event->button() == Qt::LeftButton) {
|
|
|
QPointF scenePos = mapToScene(event->pos()); // 将鼠标位置转换为场景坐标
|
|
|
|
|
|
// 获取点击位置的所有图形项，默认按Z值从高到低排序
|
|
|
QList<QGraphicsItem*> clickedItems = scene()->items(scenePos);
|
|
|
nmPerforationGraphicsItem *perforationItem = nullptr;
|
|
|
|
|
|
// 遍历所有点击到的项，找到第一个射孔段图元
|
|
|
foreach(QGraphicsItem *item, clickedItems) {
|
|
|
perforationItem = dynamic_cast<nmPerforationGraphicsItem*>(item);
|
|
|
|
|
|
if(perforationItem) {
|
|
|
// 找到了射孔段图元，停止查找
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if(perforationItem) { // 如果点击的是一个射孔段图形项
|
|
|
nmDataPerforation* pPerforationData = perforationItem->getPerforationData(); // 获取关联的射孔数据
|
|
|
|
|
|
if(pPerforationData) {
|
|
|
// 直接发射信号，将删除请求发送给控制器
|
|
|
emit sigRequestDeletePerforation(pPerforationData);
|
|
|
event->accept();
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmAbstractWellboreView::mousePressEvent(event); // 调用基类的鼠标事件处理
|
|
|
}
|
|
|
|
|
|
// === nmWxWellboreCrossSectionView 的实现 ===
|
|
|
nmWxWellboreCrossSectionView::nmWxWellboreCrossSectionView(QWidget *parent) : nmAbstractWellboreView(parent)
|
|
|
{
|
|
|
m_bIsInAddPerforationMode = false;
|
|
|
m_bIsInDeletePerforationMode = false;
|
|
|
m_isInitialFitDone = false;
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::updateView(nmDataWellBase* geometry)
|
|
|
{
|
|
|
clearAndPrepareScene();
|
|
|
m_scene->clear();
|
|
|
|
|
|
m_currentWellboreVisual = createWellboreVisual(geometry->getWellType()); // 创建或获取可视化图元
|
|
|
|
|
|
if(m_currentWellboreVisual) {
|
|
|
|
|
|
m_scene->addItem(m_currentWellboreVisual); // 添加到场景
|
|
|
m_currentWellboreVisual->updateGeometryVisuals(geometry); // 更新图元几何形状
|
|
|
|
|
|
// 仅当是 nmVerticalWellCrossSectionItem和nmVerticalFracturedWellCrossSectionItem 类型时才连接其井筒点拖拽信号
|
|
|
if(nmVerticalWellCrossSectionItem * pVWellCrossView = dynamic_cast<nmVerticalWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmVerticalWellCrossSectionItem 的射孔拖拽完成信号，转发给主视图
|
|
|
connect(pVWellCrossView, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragInCrossView(nmDataPerforation*, double, double)));
|
|
|
} else if(nmVerticalFracturedWellCrossSectionItem * pVFWellCrossView = dynamic_cast<nmVerticalFracturedWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmVerticalFracturedWellCrossSectionItem 的射孔拖拽完成信号，转发给主视图
|
|
|
connect(pVFWellCrossView, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragInCrossView(nmDataPerforation*, double, double)));
|
|
|
// 转发裂缝几何位置更新的信号
|
|
|
connect(pVFWellCrossView, SIGNAL(sigRequestFractureRectUpdate(qreal, qreal)),
|
|
|
this, SIGNAL(sigRequestFractureRectUpdate(qreal, qreal)));
|
|
|
// 射孔更新
|
|
|
connect(pVFWellCrossView, SIGNAL(sigFractureDragFinished(const QMap<nmDataPerforation*, QPair<double, double>>&)),
|
|
|
this, SIGNAL(sigFractureDragFinished(const QMap<nmDataPerforation*, QPair<double, double>>&)));
|
|
|
} else if(nmHorizontalFracturedWellCrossSectionItem * pHFWellCrossView = dynamic_cast<nmHorizontalFracturedWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
// 连接 nmHorizontalFracturedWellCrossSectionItem 的裂缝拖拽完成信号，转发给主视图
|
|
|
connect(pHFWellCrossView, SIGNAL(sigFractureGeometryChanged(double, double)),
|
|
|
this, SIGNAL(sigFractureGeometryChanged(double, double)));
|
|
|
}
|
|
|
|
|
|
double dCenterX = geometry->getX().getValue().toDouble();
|
|
|
double dWellLength = geometry->getWellLength().getValue().toDouble();
|
|
|
double dBottomholeMD = geometry->getBottomholeMD().getValue().toDouble();
|
|
|
double dCenterY = dBottomholeMD + dWellLength / 2.0;
|
|
|
|
|
|
// 多段压裂水平井的截面图是正常居中的，不需要额外设置
|
|
|
if (geometry->getWellType() ==Horizontal_Fractured_Well)
|
|
|
{
|
|
|
// 获取井的起点
|
|
|
double dStartX = geometry->getX().getValue().toDouble();
|
|
|
double dStartY = geometry->getPerforations()[0]->getMdStart().getValue().toDouble();
|
|
|
|
|
|
// 获取井长
|
|
|
double dWellLength = geometry->getWellLength().getValue().toDouble();
|
|
|
|
|
|
// 计算井的终点
|
|
|
double dEndX = dStartX + dWellLength;
|
|
|
double dEndY = dStartY;
|
|
|
|
|
|
// 计算井筒的中点
|
|
|
dCenterX = (dStartX + dEndX) / 2.0;
|
|
|
dCenterY = (dStartY + dEndY) / 2.0;
|
|
|
}
|
|
|
|
|
|
// 定义场景的可见区域大小（根据视图尺寸动态调整）
|
|
|
qreal viewWidth = this->viewport()->width();
|
|
|
qreal viewHeight = this->viewport()->height();
|
|
|
qreal sceneMargin = 1000.0; // 边距
|
|
|
|
|
|
// 计算场景矩形（以井口为中心，范围略大于视图尺寸）
|
|
|
QRectF sceneRect3(
|
|
|
dCenterX - viewWidth / 2.0 - sceneMargin, // 左边界
|
|
|
dCenterY - viewHeight / 2.0 - sceneMargin, // 上边界
|
|
|
viewWidth + 2 * sceneMargin, // 宽度
|
|
|
viewHeight + 2 * sceneMargin // 高度
|
|
|
);
|
|
|
|
|
|
// TODO:后续再修改，先临时设置
|
|
|
m_scene->setSceneRect(sceneRect3);
|
|
|
|
|
|
m_isInitialFitDone = false;
|
|
|
// 重新设置视图变换以适应新的数据
|
|
|
//resetViewTransform();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::resizeEvent(QResizeEvent *event)
|
|
|
{
|
|
|
// 调用基类的实现
|
|
|
QGraphicsView::resizeEvent(event);
|
|
|
|
|
|
// 如果场景内容为空，或者初始缩放已经完成，则不做任何事
|
|
|
if (!m_scene || m_scene->items().isEmpty() || m_isInitialFitDone) {
|
|
|
return;
|
|
|
}
|
|
|
// 调用缩放函数
|
|
|
resetViewTransform();
|
|
|
|
|
|
// 将标志位置为 true，防止后续的 resize 事件（如用户拖动窗口）再次触发
|
|
|
m_isInitialFitDone = true;
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::setPerForationEditMode(bool enabled)
|
|
|
{
|
|
|
if(auto verticalCrossViewItem = dynamic_cast<nmVerticalWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
verticalCrossViewItem->setPerforationEditMode(enabled);
|
|
|
} else if(auto VerticalFCrossViewItem = dynamic_cast<nmVerticalFracturedWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
VerticalFCrossViewItem->setPerforationEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::setAddPerforationMode(bool enable)
|
|
|
{
|
|
|
m_bIsInAddPerforationMode = enable;
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::setPerforationDeleteMode(bool enabled)
|
|
|
{
|
|
|
m_bIsInDeletePerforationMode = enabled;
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::resetViewTransform()
|
|
|
{
|
|
|
// 1. 检查核心显示对象和场景是否有效
|
|
|
if (!m_currentWellboreVisual || !m_scene || m_scene->items().isEmpty()) {
|
|
|
resetTransform();
|
|
|
centerOn(0, 0);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 2. 从数据管理器获取全局的顶部和底部边界
|
|
|
const qreal minTop = nmDataAnalyzeManager::getCurrentInstance()->getMinLayerTop();
|
|
|
const qreal maxBottom = nmDataAnalyzeManager::getCurrentInstance()->getMaxLayerBottom();
|
|
|
|
|
|
qreal targetHeight = 0;
|
|
|
QPointF viewCenter;
|
|
|
|
|
|
// 3. 检查获取的全局边界是否有效
|
|
|
if (minTop < maxBottom) {
|
|
|
// 3a. 计算目标高度为所有地层的总跨度
|
|
|
targetHeight = maxBottom - minTop;
|
|
|
|
|
|
// 3b. 计算视图的中心点
|
|
|
// 水平中心 (CenterX): 保持不变，依然是井筒的中心X坐标
|
|
|
//const qreal centerX = m_currentWellboreVisual->boundingRect().center().x();
|
|
|
// 垂直中心 (CenterY): 现在是全局地层范围的中心Y坐标
|
|
|
//const qreal centerY = (minTop + maxBottom) / 2.0;
|
|
|
|
|
|
nmDataWellBase* pGeometry = m_currentWellboreVisual->getWellData();
|
|
|
const qreal centerX = pGeometry->getX().getValue().toDouble(); // 井筒X坐标
|
|
|
const qreal centerY = (minTop + maxBottom) / 2.0;
|
|
|
|
|
|
viewCenter.setX(centerX);
|
|
|
viewCenter.setY(centerY);
|
|
|
|
|
|
} else {
|
|
|
// [后备方案] 如果无法获取有效的全局边界 (例如数据未加载),
|
|
|
// 则退回至基于井筒自身边界的显示逻辑。
|
|
|
viewCenter = m_currentWellboreVisual->boundingRect().center();
|
|
|
targetHeight = m_currentWellboreVisual->boundingRect().height();
|
|
|
// 如果井筒本身高度很小或为0，提供一个最小默认高度
|
|
|
if (targetHeight < 1.0) {
|
|
|
targetHeight = 100.0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 4. 为计算出的目标高度增加垂直边距 (padding)，例如总共20%
|
|
|
// 这使得视图的上下边缘与最顶/最底的地层之间有一些空间。
|
|
|
targetHeight *= 1.20;
|
|
|
|
|
|
// 5. 获取视图窗口的宽高比
|
|
|
const QSize viewSize = this->viewport()->size();
|
|
|
if (viewSize.isEmpty() || viewSize.height() == 0) {
|
|
|
centerOn(viewCenter); // 至少执行居中
|
|
|
return;
|
|
|
}
|
|
|
const qreal viewAspectRatio = static_cast<qreal>(viewSize.width()) / viewSize.height();
|
|
|
|
|
|
// 6. 根据目标高度和宽高比，计算目标宽度
|
|
|
const qreal targetWidth = targetHeight * viewAspectRatio;
|
|
|
|
|
|
// 7. 创建目标视野矩形，并将其中心移动到我们计算出的viewCenter
|
|
|
QRectF targetRect(0, 0, targetWidth, targetHeight);
|
|
|
targetRect.moveCenter(viewCenter);
|
|
|
|
|
|
// 8. 应用视图变换，使目标矩形正好填满视图 (逻辑保持不变)
|
|
|
this->fitInView(targetRect, Qt::KeepAspectRatio);
|
|
|
}
|
|
|
|
|
|
//void nmWxWellboreCrossSectionView::resetViewTransform()
|
|
|
//{
|
|
|
// resetTransform();
|
|
|
//
|
|
|
// // 从当前的可视化项中获取数据指针来居中
|
|
|
// if(m_currentWellboreVisual && m_currentWellboreVisual->getWellData()) {
|
|
|
// nmDataWellBase* pGeometry = m_currentWellboreVisual->getWellData();
|
|
|
//
|
|
|
// // 如果是多段压裂水平井，则视图中心为井筒中心
|
|
|
// if(pGeometry->getWellType() == NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
// nmDataHorizontalFracturedWell* pHFWell = dynamic_cast<nmDataHorizontalFracturedWell*>(pGeometry);
|
|
|
//
|
|
|
// if(pHFWell) { // 如果是多段压裂水平井
|
|
|
// // 获取井的起点
|
|
|
// double dStartX = pHFWell->getX().getValue().toDouble();
|
|
|
// double dStartY = pHFWell->getPerforations()[0]->getMdStart().getValue().toDouble();
|
|
|
//
|
|
|
// // 获取井长
|
|
|
// double dWellLength = pHFWell->getWellLength().getValue().toDouble();
|
|
|
//
|
|
|
// // 计算井的终点
|
|
|
// double dEndX = dStartX + dWellLength;
|
|
|
// double dEndY = dStartY;
|
|
|
//
|
|
|
// // 计算井筒的中点
|
|
|
// double dCenterX = (dStartX + dEndX) / 2.0;
|
|
|
// double dCenterY = (dStartY + dEndY) / 2.0;
|
|
|
//
|
|
|
// centerOn(dCenterX, dCenterY);
|
|
|
// }
|
|
|
// } else {
|
|
|
// double dCenterX = pGeometry->getX().getValue().toDouble();
|
|
|
// double dWellLength = pGeometry->getWellLength().getValue().toDouble();
|
|
|
// double dBottomholeMD = pGeometry->getBottomholeMD().getValue().toDouble();
|
|
|
// double dCenterY = dBottomholeMD + dWellLength / 2.0;
|
|
|
//
|
|
|
// centerOn(dCenterX, dCenterY);
|
|
|
// }
|
|
|
//
|
|
|
// } else if(m_scene && !m_scene->items().isEmpty()) {
|
|
|
// // 如果没有特定的 wellData，但场景中有其他 item，居中到场景的 bounding rect
|
|
|
// centerOn(m_scene->itemsBoundingRect().center());
|
|
|
// } else {
|
|
|
// // 场景为空，居中到 (0,0)
|
|
|
// centerOn(0, 0);
|
|
|
// }
|
|
|
//
|
|
|
// update();
|
|
|
//}
|
|
|
|
|
|
nmAbstractWellboreVisual* nmWxWellboreCrossSectionView::createWellboreVisual(NM_WELL_MODEL type)
|
|
|
{
|
|
|
switch(type) {
|
|
|
case Vertical_Well:
|
|
|
return new nmVerticalWellCrossSectionItem(); // 返回新的纵截面图元实例
|
|
|
|
|
|
case Vertical_Fractured_Well:
|
|
|
return new nmVerticalFracturedWellCrossSectionItem(); // 返回新的纵截面图元实例
|
|
|
|
|
|
case Horizontal_Fractured_Well:
|
|
|
return new nmHorizontalFracturedWellCrossSectionItem(); // 返回新的纵截面图元实例
|
|
|
|
|
|
default:
|
|
|
qWarning() << "Unsupported well type for Cross Section View:" << type;
|
|
|
return nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::mousePressEvent(QMouseEvent *event)
|
|
|
{
|
|
|
// 添加射孔段模式处理
|
|
|
if(m_bIsInAddPerforationMode && event->button() == Qt::LeftButton) {
|
|
|
QPointF scenePos = mapToScene(event->pos()); // 将鼠标位置转换为场景坐标
|
|
|
|
|
|
// 裂缝MD范围和井筒线段
|
|
|
double fractureTopMd = -1.0;
|
|
|
double fractureBottomMd = -1.0;
|
|
|
QLineF wellboreVisualLine; // 默认是空行
|
|
|
|
|
|
// 根据当前显示的井筒类型，获取特定的参数
|
|
|
if(m_currentWellboreVisual) {
|
|
|
// 尝试将当前图元转换为垂直裂缝井的视图项
|
|
|
nmVerticalFracturedWellCrossSectionItem* pVFWellItem =
|
|
|
dynamic_cast<nmVerticalFracturedWellCrossSectionItem*>(m_currentWellboreVisual);
|
|
|
|
|
|
// 如果转换成功，说明是垂直裂缝井，获取裂缝的MD范围
|
|
|
if(pVFWellItem) {
|
|
|
QRectF fractureRect = pVFWellItem->getFractureMD();
|
|
|
// boundingRect().top() 和 .bottom() 对应于 MD 范围，假设Y轴向上是深度增加
|
|
|
fractureTopMd = fractureRect.top();
|
|
|
fractureBottomMd = fractureRect.bottom();
|
|
|
}
|
|
|
|
|
|
// 如果转换失败，说明是普通的垂直井，fractureTopMd和fractureBottomMd会保持默认值-1.0
|
|
|
}
|
|
|
|
|
|
// 准备好所有参数后，只发射一次信号
|
|
|
emit sigRequestAddPerforation(scenePos, fractureTopMd, fractureBottomMd, wellboreVisualLine);
|
|
|
|
|
|
event->accept(); // 阻止事件进一步传播，确保只处理一次点击
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 删除射孔模式的处理
|
|
|
if(m_bIsInDeletePerforationMode && event->button() == Qt::LeftButton) {
|
|
|
QPointF scenePos = mapToScene(event->pos()); // 将鼠标位置转换为场景坐标
|
|
|
|
|
|
// 获取点击位置的所有图形项，默认按Z值从高到低排序
|
|
|
QList<QGraphicsItem*> clickedItems = scene()->items(scenePos);
|
|
|
nmPerforationGraphicsItem *perforationItem = nullptr;
|
|
|
|
|
|
// 遍历所有点击到的项，找到第一个射孔段图元
|
|
|
foreach(QGraphicsItem *item, clickedItems) {
|
|
|
perforationItem = dynamic_cast<nmPerforationGraphicsItem*>(item);
|
|
|
|
|
|
if(perforationItem) {
|
|
|
// 找到了射孔段图元，停止查找
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if(perforationItem) { // 如果点击的是一个射孔段图形项
|
|
|
nmDataPerforation* pPerforationData = perforationItem->getPerforationData(); // 获取关联的射孔数据
|
|
|
|
|
|
if(pPerforationData) {
|
|
|
// 直接发射删除信号
|
|
|
emit sigRequestDeletePerforation(pPerforationData);
|
|
|
event->accept();
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmAbstractWellboreView::mousePressEvent(event); // 调用基类的鼠标事件处理
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreCrossSectionView::setFractureEditMode(bool enabled)
|
|
|
{
|
|
|
if(auto VFCrossViewItem = dynamic_cast<nmVerticalFracturedWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
VFCrossViewItem->setFractureEditMode(enabled);
|
|
|
} else if(auto HFCrossViewItem = dynamic_cast<nmHorizontalFracturedWellCrossSectionItem * >(m_currentWellboreVisual)) {
|
|
|
HFCrossViewItem->setEditMode(enabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// === nmWxWellbore3DView 的实现 ===
|
|
|
nmWxWellbore3DView::nmWxWellbore3DView(QWidget *parent) : QWidget(parent)
|
|
|
{
|
|
|
QVBoxLayout *pLayout = new QVBoxLayout(this);
|
|
|
QLabel *pLabel = new QLabel("3D View Content Here (3D View)", this);
|
|
|
pLabel->setAlignment(Qt::AlignCenter);
|
|
|
pLayout->addWidget(pLabel);
|
|
|
setLayout(pLayout);
|
|
|
setStyleSheet("background-color: lightcoral;"); // 方便区分
|
|
|
}
|
|
|
|
|
|
|
|
|
nmWxWellboreTrajectoryDisplay::nmWxWellboreTrajectoryDisplay(QWidget *parent) : QWidget(parent), m_pDataWell(nullptr)
|
|
|
{
|
|
|
this->initUI();
|
|
|
}
|
|
|
|
|
|
nmWxWellboreTrajectoryDisplay::~nmWxWellboreTrajectoryDisplay()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setCurrentWellboreData(nmDataWellBase* pWellData)
|
|
|
{
|
|
|
m_pDataWell = pWellData;
|
|
|
connect(m_pDataWell, SIGNAL(sigWellDataChanged()),
|
|
|
this, SLOT(onWellboreDataChanged()));
|
|
|
|
|
|
// 设置井类型后更新工具栏
|
|
|
this->updateToolBarForCurrentView(m_pStackedWidget->currentIndex());
|
|
|
|
|
|
// 立即触发更新视图
|
|
|
onWellboreDataChanged();
|
|
|
// 视图调整到以井为中心
|
|
|
m_pTopViewWidget->resetViewTransform();
|
|
|
m_pCrossSectionViewWidget->resetViewTransform();
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setEditWellMode(bool enabled)
|
|
|
{
|
|
|
// 将状态传递给当前激活的子视图
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex(); // 获取当前视图索引
|
|
|
|
|
|
if(nCurrentViewIndex == 0 && m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->setEditMode(enabled);
|
|
|
} else if(nCurrentViewIndex == 1 && m_pCrossSectionViewWidget) {
|
|
|
// 截面图是编辑垂直裂缝井下的裂缝
|
|
|
m_pCrossSectionViewWidget->setFractureEditMode(enabled);
|
|
|
}
|
|
|
|
|
|
// 更新父视图的工具栏按钮选中状态
|
|
|
m_pEditWellAction->setChecked(enabled);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setPerforationEditMode(bool enabled)
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex(); // 获取当前视图索引
|
|
|
|
|
|
if(nCurrentViewIndex == 0 && m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->setPerForationEditMode(enabled);
|
|
|
} else if(nCurrentViewIndex == 1 && m_pCrossSectionViewWidget) {
|
|
|
m_pCrossSectionViewWidget->setPerForationEditMode(enabled);
|
|
|
}
|
|
|
|
|
|
m_pEditPerforationsAction->setChecked(enabled);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setAddPerforationMode(bool enabled)
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex(); // 获取当前视图索引
|
|
|
|
|
|
if(nCurrentViewIndex == 0 && m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->setAddPerforationMode(enabled);
|
|
|
} else if(nCurrentViewIndex == 1 && m_pCrossSectionViewWidget) {
|
|
|
m_pCrossSectionViewWidget->setAddPerforationMode(enabled);
|
|
|
}
|
|
|
|
|
|
m_pNewPerforationAction->setChecked(enabled);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setDeletePerforationMode(bool enabled)
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex(); // 获取当前视图索引
|
|
|
|
|
|
if(nCurrentViewIndex == 0 && m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->setPerforationDeleteMode(enabled);
|
|
|
} else if(nCurrentViewIndex == 1 && m_pCrossSectionViewWidget) {
|
|
|
m_pCrossSectionViewWidget->setPerforationDeleteMode(enabled);
|
|
|
}
|
|
|
|
|
|
m_pDeletePerforationAction->setChecked(enabled);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::setSnapPerforationMode(bool enabled)
|
|
|
{
|
|
|
m_pSnapPerforationAction->setChecked(enabled);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::initUI()
|
|
|
{
|
|
|
// 整体垂直布局
|
|
|
QVBoxLayout *pMainLayout = new QVBoxLayout(this);
|
|
|
pMainLayout->setContentsMargins(5, 5, 5, 5);
|
|
|
pMainLayout->setSpacing(5);
|
|
|
|
|
|
// 1. 创建视图选项区
|
|
|
this->createViewOptions();
|
|
|
pMainLayout->addWidget(m_pViewGroupBox);
|
|
|
|
|
|
// 2. 创建工具栏
|
|
|
this->createToolBar();
|
|
|
pMainLayout->addWidget(m_pToolBar);
|
|
|
|
|
|
// 3. 创建堆栈式视图区域
|
|
|
this->createViewWidgets();
|
|
|
pMainLayout->addWidget(m_pStackedWidget);
|
|
|
|
|
|
// 4. 添加显示鼠标坐标位置的 QLabel
|
|
|
// 为鼠标坐标创建浮动标签
|
|
|
m_pMouseCoordLabel = new QLabel(this); // 父对象设置为当前 widget (nmWxWellboreTrajectoryDisplay)
|
|
|
m_pMouseCoordLabel->setStyleSheet("background-color: lightyellow; border: 1px solid gray; padding: 2px;");
|
|
|
m_pMouseCoordLabel->setVisible(false); // 初始时隐藏
|
|
|
m_pMouseCoordLabel->setWordWrap(false); // 防止文本换行导致宽度变化
|
|
|
m_pMouseCoordLabel->setFixedSize(100, 40); // 设置固定大小
|
|
|
|
|
|
m_bMouseLabelEnabled = false;
|
|
|
|
|
|
this->setLayout(pMainLayout); // 设置主布局
|
|
|
|
|
|
// 5. 连接信号和槽
|
|
|
this->connectSignalsSlots();
|
|
|
|
|
|
// 6. 初始状态：选中顶部视图
|
|
|
m_pTopViewRadio->setChecked(true);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::createViewOptions()
|
|
|
{
|
|
|
m_pViewGroupBox = new QGroupBox(tr("View"), this);
|
|
|
QHBoxLayout *pHLayout = new QHBoxLayout(m_pViewGroupBox);
|
|
|
|
|
|
m_pTopViewRadio = new QRadioButton(tr("Top view"), m_pViewGroupBox);
|
|
|
m_pCrossSectionRadio = new QRadioButton(tr("Cross section"), m_pViewGroupBox);
|
|
|
m_p3DViewRadio = new QRadioButton(tr("3D view"), m_pViewGroupBox);
|
|
|
|
|
|
// 添加到布局器中，并设置伸缩因子
|
|
|
pHLayout->addWidget(m_pTopViewRadio, 1);
|
|
|
pHLayout->addWidget(m_pCrossSectionRadio, 1);
|
|
|
pHLayout->addWidget(m_p3DViewRadio, 1);
|
|
|
|
|
|
m_pViewGroupBox->setLayout(pHLayout);
|
|
|
|
|
|
m_pViewButtonGroup = new QButtonGroup(this);
|
|
|
m_pViewButtonGroup->addButton(m_pTopViewRadio, 0); // ID 0
|
|
|
m_pViewButtonGroup->addButton(m_pCrossSectionRadio, 1); // ID 1
|
|
|
m_pViewButtonGroup->addButton(m_p3DViewRadio, 2); // ID 2
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::createToolBar()
|
|
|
{
|
|
|
QString sAppDir = QCoreApplication::applicationDirPath();
|
|
|
sAppDir = sAppDir.section('/', 0, -2); // 获取上一级目录
|
|
|
// 图标目录
|
|
|
QString sIconDir = sAppDir + "/Res/Icon/";
|
|
|
|
|
|
m_pToolBar = new QToolBar("Tools", this);
|
|
|
m_pToolBar->setIconSize(QSize(35, 35));
|
|
|
|
|
|
m_pToolBar->setFixedHeight(47);
|
|
|
|
|
|
// 创建QAction并添加到工具栏
|
|
|
m_pZoomOutAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore1.png"), "Zoom Out"); // 缩小
|
|
|
m_pHomeViewAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore2.png"), "Home View"); // 复位/恢复
|
|
|
m_pZoomInAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore3.png"), "Zoom In"); // 放大
|
|
|
m_pToolBar->addSeparator();
|
|
|
|
|
|
m_pXYAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore4.png"), "XY"); // 坐标显示
|
|
|
m_pEditWellAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore5.png"), "Edit Well"); // 编辑井筒轨迹
|
|
|
m_pLoadAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore6.png"), "Load"); // 加载
|
|
|
m_pToolBar->addSeparator();
|
|
|
|
|
|
m_pEditPerforationsAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore7.png"), "Edit Perforations"); // 编辑射孔
|
|
|
m_pNewPerforationAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore8.png"), "New Perforation"); // 添加射孔段
|
|
|
m_pDeletePerforationAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore9.png"), "Delete Perforation"); // 删除射孔段
|
|
|
m_pSnapPerforationAction = m_pToolBar->addAction(QIcon(sIconDir + "NmWellbore10.png"), "Snap Perforation"); // 对齐/吸附
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::createViewWidgets()
|
|
|
{
|
|
|
m_pStackedWidget = new QStackedWidget(this);
|
|
|
|
|
|
m_pTopViewWidget = new nmWxWellboreTopView(this);
|
|
|
m_pCrossSectionViewWidget = new nmWxWellboreCrossSectionView(this);
|
|
|
m_p3DViewWidget = new nmWxWellbore3DView(this);
|
|
|
|
|
|
m_pStackedWidget->addWidget(m_pTopViewWidget); // 索引 0
|
|
|
m_pStackedWidget->addWidget(m_pCrossSectionViewWidget); // 索引 1
|
|
|
m_pStackedWidget->addWidget(m_p3DViewWidget); // 索引 2
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::connectSignalsSlots()
|
|
|
{
|
|
|
// 连接QButtonGroup的buttonClicked信号，现在视图切换会发出信号给控制器
|
|
|
connect(m_pViewButtonGroup, SIGNAL(buttonClicked(int)),
|
|
|
this, SLOT(onViewRadioButtonToggled(int)));
|
|
|
|
|
|
// 连接工具栏QAction的triggered信号，现在这些槽函数将发出请求信号给控制器
|
|
|
connect(m_pZoomOutAction, SIGNAL(triggered()), this, SLOT(onZoomOutClicked()));
|
|
|
connect(m_pHomeViewAction, SIGNAL(triggered()), this, SLOT(onHomeViewClicked()));
|
|
|
connect(m_pZoomInAction, SIGNAL(triggered()), this, SLOT(onZoomInClicked()));
|
|
|
|
|
|
connect(m_pXYAction, SIGNAL(triggered()), this, SLOT(onXYClicked())); // XY 坐标显示仍然在视图内管理
|
|
|
|
|
|
// ============== 模式请求信号连接 ==============
|
|
|
// 这些槽函数现在将发出请求给控制器
|
|
|
connect(m_pEditWellAction, SIGNAL(triggered()), this, SLOT(onEditWellClicked()));
|
|
|
connect(m_pEditPerforationsAction, SIGNAL(triggered()), this, SLOT(onEditPerforationsClicked()));
|
|
|
connect(m_pNewPerforationAction, SIGNAL(triggered()), this, SLOT(onNewPerforationClicked()));
|
|
|
connect(m_pDeletePerforationAction, SIGNAL(triggered()), this, SLOT(onDeletePerforationClicked()));
|
|
|
connect(m_pSnapPerforationAction, SIGNAL(triggered()), this, SLOT(onSnapPerforationClicked()));
|
|
|
// ============================================
|
|
|
|
|
|
// 连接来自俯视图的井筒点移动信号 (只在拖动结束时触发)
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigWellborePointMovedInTopView(QPointF)),
|
|
|
this, SIGNAL(sigWellboreTrajectoryPointMoved(QPointF)));
|
|
|
|
|
|
// 连接来自俯视图的射孔段移动信号 (只在拖动结束时触发)
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigPerforationDragInTopView(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)));
|
|
|
// 连接来自纵截面图的射孔段移动信号 (只在拖动结束时触发)
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigPerforationDragInCrossView(nmDataPerforation*, double, double)),
|
|
|
this, SIGNAL(sigPerforationDragFinished(nmDataPerforation*, double, double)));
|
|
|
|
|
|
// 连接添加射孔模式下获取到的相关位置
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigRequestAddPerforation(QPointF, double, double, QLineF)),
|
|
|
this, SIGNAL(sigTryAddNewPerforation(QPointF, double, double, QLineF)));
|
|
|
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigRequestAddPerforation(QPointF, double, double, QLineF)),
|
|
|
this, SIGNAL(sigTryAddNewPerforation(QPointF, double, double, QLineF)));
|
|
|
|
|
|
// 连接请求删除射孔信号
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigRequestDeletePerforation(nmDataPerforation*)),
|
|
|
this, SIGNAL(sigTryDeletePerforation(nmDataPerforation*)));
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigRequestDeletePerforation(nmDataPerforation*)),
|
|
|
this, SIGNAL(sigTryDeletePerforation(nmDataPerforation*)));
|
|
|
|
|
|
// 连接俯视图下更新裂缝位置的信号
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigFracturePosChangedInTopView(double, double)),
|
|
|
this, SIGNAL(sigFractureGeometryDragFinished(double, double)));
|
|
|
// 连接截面图下更新裂缝位置的信号
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigRequestFractureRectUpdate(qreal, qreal)),
|
|
|
this, SIGNAL(sigRequestFractureRectUpdate(qreal, qreal)));
|
|
|
// 射孔更新
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigFractureDragFinished(const QMap<nmDataPerforation*, QPair<double, double>>&)),
|
|
|
this, SIGNAL(sigFractureDragFinished(const QMap<nmDataPerforation*, QPair<double, double>>&)));
|
|
|
// 多段压裂水平井俯视图裂缝半长更新
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigFractureHalfLengthChanged(double)),
|
|
|
this, SIGNAL(sigFractureHalfLengthChanged(double)));
|
|
|
// 多段压裂水平井俯视图井身位置
|
|
|
connect(m_pTopViewWidget, SIGNAL(sigWellboreDragFinished(QPointF)),
|
|
|
this, SIGNAL(sigWellboreDragFinished(QPointF)));
|
|
|
// 多段压裂水平井截面图裂缝位置更新
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(sigFractureGeometryChanged(double, double)),
|
|
|
this, SIGNAL(sigFractureGeometryChanged(double, double)));
|
|
|
|
|
|
// 连接各个 QGraphicsView 的鼠标坐标和进入/离开信号到主窗口的槽
|
|
|
connect(m_pTopViewWidget, SIGNAL(mouseCoordinatesChanged(double, double)),
|
|
|
this, SLOT(onMouseMovedOnPlot(double, double)));
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(mouseCoordinatesChanged(double, double)),
|
|
|
this, SLOT(onMouseMovedOnPlot(double, double)));
|
|
|
|
|
|
connect(m_pTopViewWidget, SIGNAL(mouseEnteredView()), this, SLOT(onMouseEnteredAnyView()));
|
|
|
connect(m_pTopViewWidget, SIGNAL(mouseLeftView()), this, SLOT(onMouseLeftAnyView()));
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(mouseEnteredView()), this, SLOT(onMouseEnteredAnyView()));
|
|
|
connect(m_pCrossSectionViewWidget, SIGNAL(mouseLeftView()), this, SLOT(onMouseLeftAnyView()));
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onViewRadioButtonToggled(int id)
|
|
|
{
|
|
|
QRadioButton *pSelectedButton = qobject_cast<QRadioButton*>(m_pViewButtonGroup->button(id));
|
|
|
|
|
|
if(pSelectedButton && pSelectedButton->isChecked()) {
|
|
|
m_pStackedWidget->setCurrentIndex(id);
|
|
|
|
|
|
// === 关通知控制器视图已切换，控制器会负责清空模式和重新设置 ===
|
|
|
emit currentViewChanged(id);
|
|
|
|
|
|
// 更新工具栏按钮的启用/禁用状态 (这只与井类型和当前视图有关，与编辑模式状态无关)
|
|
|
updateToolBarForCurrentView(id);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onZoomOutClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
qDebug() << "Zoom Out clicked for current view (ID:" << nCurrentViewIndex << ")";
|
|
|
|
|
|
// 根据当前视图类型调用对应的视图Widget的缩放方法
|
|
|
// 你需要在 nmWxWellboreTopView, nmWxWellboreCrossSectionView, nmWxWellbore3DView 中实现这些方法
|
|
|
switch(nCurrentViewIndex) {
|
|
|
case 0: // Top View
|
|
|
if(m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->zoomOut();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 1: // Cross Section View
|
|
|
if(m_pCrossSectionViewWidget) {
|
|
|
m_pCrossSectionViewWidget->zoomOut();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 2: // 3D View
|
|
|
// if (m_p3DViewWidget) m_p3DViewWidget->zoomOut();
|
|
|
qDebug() << "3D View: Performing Zoom Out";
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onHomeViewClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
qDebug() << "Home View clicked for current view (ID:" << nCurrentViewIndex << ")";
|
|
|
|
|
|
// 类似，调用对应视图的 homeView() 或 resetView() 方法
|
|
|
switch(nCurrentViewIndex) {
|
|
|
case 0: // Top View
|
|
|
if(m_pTopViewWidget) {
|
|
|
// 重置视图变换
|
|
|
m_pTopViewWidget->resetViewTransform();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 1: // Cross Section View
|
|
|
if(m_pCrossSectionViewWidget) {
|
|
|
// 重置视图变换
|
|
|
m_pCrossSectionViewWidget->resetViewTransform();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 2: // 3D View
|
|
|
// if (m_p3DViewWidget) m_p3DViewWidget->homeView();
|
|
|
qDebug() << "3D View: Resetting View";
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onZoomInClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
qDebug() << "Zoom In clicked for current view (ID:" << nCurrentViewIndex << ")";
|
|
|
|
|
|
// 类似 onZoomOutClicked，调用对应视图的 zoomIn() 方法
|
|
|
switch(nCurrentViewIndex) {
|
|
|
case 0: // Top View
|
|
|
if(m_pTopViewWidget) {
|
|
|
m_pTopViewWidget->zoomIn();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 1: // Cross Section View
|
|
|
if(m_pCrossSectionViewWidget) {
|
|
|
m_pCrossSectionViewWidget->zoomIn();
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 2: // 3D View
|
|
|
// if (m_p3DViewWidget) m_p3DViewWidget->zoomIn();
|
|
|
qDebug() << "3D View: Performing Zoom In";
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onXYClicked()
|
|
|
{
|
|
|
// 切换全局开关状态
|
|
|
m_bMouseLabelEnabled = !m_bMouseLabelEnabled;
|
|
|
|
|
|
// 根据新的开关状态直接设置标签的可见性
|
|
|
if(m_bMouseLabelEnabled) {
|
|
|
// 如果启用，当鼠标下次进入视图时会显示
|
|
|
// 这里不需要立即设置 m_pMouseCoordLabel->setVisible(true)，
|
|
|
// 因为 mouseMoveEvent 会触发
|
|
|
} else {
|
|
|
// 如果禁用，立即隐藏标签并清空文本
|
|
|
m_pMouseCoordLabel->setVisible(false);
|
|
|
m_pMouseCoordLabel->setText("");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onEditWellClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
// 发出请求信号，控制器会根据 nCurrentViewIndex 决定激活何种模式
|
|
|
emit requestedEditWellMode(nCurrentViewIndex);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onLoadClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
qDebug() << "Load Data clicked for current view (ID:" << nCurrentViewIndex << ")";
|
|
|
// 实现加载数据的逻辑，可能弹出文件对话框或发出信号给控制器
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onEditPerforationsClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
emit requestedEditPerforationsMode(nCurrentViewIndex);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onNewPerforationClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
emit requestedNewPerforationMode(nCurrentViewIndex);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onDeletePerforationClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
emit requestedDeletePerforationMode(nCurrentViewIndex);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onSnapPerforationClicked()
|
|
|
{
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
emit requestedSnapPerforationMode(nCurrentViewIndex);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onWellboreDataChanged()
|
|
|
{
|
|
|
// 1. 通知控制器，清理当前状态
|
|
|
emit sigClearViewStates();
|
|
|
// 2. 更新视图
|
|
|
m_pTopViewWidget->updateView(m_pDataWell);
|
|
|
m_pCrossSectionViewWidget->updateView(m_pDataWell);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onMouseMovedOnPlot(double x, double y)
|
|
|
{
|
|
|
// 获取当前鼠标在 nmWxWellboreTrajectoryDisplay 窗口中的全局位置
|
|
|
QPoint globalMousePos = QCursor::pos();
|
|
|
// 将全局位置转换为 nmWxWellboreTrajectoryDisplay 窗口的局部位置
|
|
|
QPoint localMousePos = this->mapFromGlobal(globalMousePos);
|
|
|
|
|
|
QString axisYLabel;
|
|
|
int nCurrentViewIndex = m_pStackedWidget->currentIndex();
|
|
|
|
|
|
switch(nCurrentViewIndex) {
|
|
|
case 0: // Top View
|
|
|
axisYLabel = "Y";
|
|
|
break;
|
|
|
|
|
|
case 1: // Cross Section View
|
|
|
axisYLabel = "TVD";
|
|
|
break;
|
|
|
|
|
|
case 2: // 3D View (如果它也基于 QGraphicsView)
|
|
|
axisYLabel = "Z";
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
axisYLabel = "Y";
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
m_pMouseCoordLabel->setText(QString("x = %1 m\n%2 = %3 m").arg(x, 0, 'f', 2).arg(axisYLabel).arg(y, 0, 'f', 2));
|
|
|
|
|
|
// 计算 QLabel 的新位置
|
|
|
int labelX = localMousePos.x();
|
|
|
int labelY = localMousePos.y() - m_pMouseCoordLabel->height();
|
|
|
|
|
|
m_pMouseCoordLabel->move(labelX, labelY);
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onMouseEnteredAnyView()
|
|
|
{
|
|
|
// 只有当全局开关m_bMouseLabelEnabled为true时，才显示标签
|
|
|
if(m_bMouseLabelEnabled) {
|
|
|
m_pMouseCoordLabel->setVisible(true);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::onMouseLeftAnyView()
|
|
|
{
|
|
|
// 鼠标离开任何一个视图时，隐藏标签并清空文本
|
|
|
m_pMouseCoordLabel->setVisible(false);
|
|
|
m_pMouseCoordLabel->setText("");
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::updateToolBarForCurrentView(int viewIndex)
|
|
|
{
|
|
|
// 默认所有工具都可用，然后根据视图类型进行调整
|
|
|
m_pZoomOutAction->setEnabled(true);
|
|
|
m_pHomeViewAction->setEnabled(true);
|
|
|
m_pZoomInAction->setEnabled(true);
|
|
|
|
|
|
m_pXYAction->setEnabled(true);
|
|
|
m_pEditWellAction->setEnabled(true);
|
|
|
m_pLoadAction->setEnabled(true);
|
|
|
m_pEditPerforationsAction->setEnabled(true);
|
|
|
m_pNewPerforationAction->setEnabled(true);
|
|
|
m_pDeletePerforationAction->setEnabled(true);
|
|
|
m_pSnapPerforationAction->setEnabled(true);
|
|
|
|
|
|
// 默认所有射孔相关工具都禁用
|
|
|
m_pEditPerforationsAction->setEnabled(false);
|
|
|
m_pNewPerforationAction->setEnabled(false);
|
|
|
m_pDeletePerforationAction->setEnabled(false);
|
|
|
m_pSnapPerforationAction->setEnabled(false);
|
|
|
|
|
|
// 获取当前井的类型，如果 m_pDataWell 为空，则默认为未知类型
|
|
|
NM_WELL_MODEL currentWellType = NM_WELL_MODEL::Unknow_Well;
|
|
|
|
|
|
if(m_pDataWell) {
|
|
|
currentWellType = m_pDataWell->getWellType();
|
|
|
}
|
|
|
|
|
|
switch(viewIndex) {
|
|
|
case 0: // nmWxWellboreTopView (俯视图)
|
|
|
qDebug() << "Updating toolbar for Top View";
|
|
|
|
|
|
// 如果是多段压裂水平井，则在俯视图中启用射孔操作
|
|
|
if(currentWellType == NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
m_pEditPerforationsAction->setEnabled(true);
|
|
|
m_pNewPerforationAction->setEnabled(true);
|
|
|
m_pDeletePerforationAction->setEnabled(true);
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 1: // nmWxWellboreCrossSectionView (纵截面视图)
|
|
|
|
|
|
// 如果是直井，则在纵截面视图中启用射孔操作
|
|
|
if(currentWellType != NM_WELL_MODEL::Horizontal_Fractured_Well) {
|
|
|
m_pEditPerforationsAction->setEnabled(true);
|
|
|
m_pNewPerforationAction->setEnabled(true);
|
|
|
m_pDeletePerforationAction->setEnabled(true);
|
|
|
m_pSnapPerforationAction->setEnabled(true);
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case 2: // nmWxWellbore3DView (3D视图)
|
|
|
qDebug() << "Updating toolbar for 3D View";
|
|
|
// 3D视图中，所有射孔操作保持禁用状态
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
qDebug() << "Updating toolbar for unknown view index:" << viewIndex;
|
|
|
// 对于未知视图类型，射孔操作保持禁用状态
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxWellboreTrajectoryDisplay::updataCrossSectionView()
|
|
|
{
|
|
|
m_pCrossSectionViewWidget->updateView(m_pDataWell);
|
|
|
m_pCrossSectionViewWidget->resetViewTransform();
|
|
|
}
|