OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-10 23:46:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

#3249 Refactoring: Remove the old extractintersectionData.

Browse Source 
Replace it with a separate find method.
Use RiuPickItemInfo in the RicViewerEventObject
This commit is contained in:
Jacob Støren 2018-08-27 14:27:33 +02:00
parent 714ba1e605
commit ad9864240c
8 changed files with 169 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ApplicationCode/Commands/RicViewerEventInterface.h
View File

@ -24,6 +24,7 @@
#include "cvfBase.h"
#include "cvfObject.h"
#include "cvfVector3.h"
#include "RiuPickItemInfo.h"
namespace cvf {
class Part;
@ -37,18 +38,15 @@ class Rim3dView;
class RicViewerEventObject
{
public:
RicViewerEventObject(cvf::Vec3d globalIntersectionPoint,
const std::vector<std::pair<const cvf::Part*,
cvf::uint>>& partAndTriangleIndexPairs, Rim3dView* view)
: m_globalIntersectionPoint(globalIntersectionPoint)
, m_partAndTriangleIndexPairs(partAndTriangleIndexPairs)
RicViewerEventObject(const std::vector<RiuPickItemInfo>& partAndTriangleIndexPairs,
Rim3dView* view)
: m_partAndTriangleIndexPairs(partAndTriangleIndexPairs)
, m_view(view)
{
}
cvf::Vec3d m_globalIntersectionPoint;
std::vector<std::pair<const cvf::Part*, cvf::uint>> m_partAndTriangleIndexPairs;
Rim3dView* m_view;
std::vector<RiuPickItemInfo> m_partAndTriangleIndexPairs;
Rim3dView* m_view;
};

8
ApplicationCode/Commands/WellLogCommands/Ric3dWellLogCurveViewerEventHandler.cpp
View File

@ -46,7 +46,7 @@ bool Ric3dWellLogCurveViewerEventHandler::handleEvent(const RicViewerEventObject
cvf::uint triangleIndex = cvf::UNDEFINED_UINT;
const auto& partAndTriangleIndexPair = eventObject.m_partAndTriangleIndexPairs.front();
const cvf::Part* part = partAndTriangleIndexPair.first;
const cvf::Part* part = partAndTriangleIndexPair.pickedPart();
const RivObjectSourceInfo* sourceInfo = dynamic_cast<const RivObjectSourceInfo*>(part->sourceInfo());
if (sourceInfo)
@ -60,8 +60,10 @@ bool Ric3dWellLogCurveViewerEventHandler::handleEvent(const RicViewerEventObject
cvf::Vec3d closestPoint;
double measuredDepthAtPoint;
double valueAtPoint;
Rim3dWellLogCurve* curve = curveCollection->checkForCurveIntersection(
eventObject.m_globalIntersectionPoint, &closestPoint, &measuredDepthAtPoint, &valueAtPoint);
Rim3dWellLogCurve* curve = curveCollection->checkForCurveIntersection( eventObject.m_partAndTriangleIndexPairs.front().globalPickedPoint(),
&closestPoint,
&measuredDepthAtPoint,
&valueAtPoint);
if (curve)
{
RiuMainWindow::instance()->selectAsCurrentItem(curve);

2
ApplicationCode/Commands/WellPathCommands/RicIntersectionViewerEventHandler.cpp
View File

@ -52,7 +52,7 @@ bool RicIntersectionViewerEventHandler::handleEvent(const RicViewerEventObject&
CVF_ASSERT(rimView);
cvf::ref<caf::DisplayCoordTransform> transForm = rimView->displayCoordTransform();
cvf::Vec3d domainCoord = transForm->transformToDomainCoord(eventObject.m_globalIntersectionPoint);
cvf::Vec3d domainCoord = transForm->transformToDomainCoord(eventObject.m_partAndTriangleIndexPairs.front().globalPickedPoint());
if (intersection->inputPolyLineFromViewerEnabled())
{

10
ApplicationCode/Commands/WellPathCommands/RicWellPathViewerEventHandler.cpp
View File

@ -62,7 +62,7 @@ bool RicWellPathViewerEventHandler::handleEvent(const RicViewerEventObject& even
if(!eventObject.m_partAndTriangleIndexPairs.empty())
{
const auto & partAndTriangleIndexPair = eventObject.m_partAndTriangleIndexPairs.front();
const cvf::Part* part = partAndTriangleIndexPair.first;
const cvf::Part* part = partAndTriangleIndexPair.pickedPart();
if (part)
{
@ -76,7 +76,7 @@ bool RicWellPathViewerEventHandler::handleEvent(const RicViewerEventObject& even
if (eventObject.m_partAndTriangleIndexPairs.size() > 1)
{
const auto& secondPair = eventObject.m_partAndTriangleIndexPairs[1];
const cvf::Part* secondPickedPart = secondPair.first;
const cvf::Part* secondPickedPart = secondPair.pickedPart();
if (secondPickedPart)
{
auto wellPathSourceCandidate =
@ -89,7 +89,7 @@ bool RicWellPathViewerEventHandler::handleEvent(const RicViewerEventObject& even
{
wellPathSourceInfo =
dynamic_cast<const RivWellPathSourceInfo*>(secondPickedPart->sourceInfo());
wellPathTriangleIndex = secondPair.second;
wellPathTriangleIndex = secondPair.faceIdx();
}
}
}
@ -100,7 +100,7 @@ bool RicWellPathViewerEventHandler::handleEvent(const RicViewerEventObject& even
if (dynamic_cast<const RivWellPathSourceInfo*>(part->sourceInfo()))
{
wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>(part->sourceInfo());
wellPathTriangleIndex = partAndTriangleIndexPair.second;
wellPathTriangleIndex = partAndTriangleIndexPair.faceIdx();
}
}
}
@ -111,7 +111,7 @@ bool RicWellPathViewerEventHandler::handleEvent(const RicViewerEventObject& even
if (!rimView) return false;
cvf::ref<caf::DisplayCoordTransform> transForm = rimView->displayCoordTransform();
cvf::Vec3d pickedPositionInUTM = transForm->transformToDomainCoord(eventObject.m_globalIntersectionPoint);
cvf::Vec3d pickedPositionInUTM = transForm->transformToDomainCoord(eventObject.m_partAndTriangleIndexPairs.front().globalPickedPoint());
if (auto intersectionView = dynamic_cast<Rim2dIntersectionView*>(rimView))
{

15
ApplicationCode/UserInterface/RiuPickItemInfo.cpp
View File

@ -22,6 +22,7 @@
#include "cvfPart.h"
#include "cvfDrawableGeo.h"
#include "cvfTransform.h"
#include "cvfHitItemCollection.h"
//--------------------------------------------------------------------------------------------------
@ -48,3 +49,17 @@ RiuPickItemInfo RiuPickItemInfo::extractPickItemInfo(const cvf::HitItem* hitItem
return pickInfo;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RiuPickItemInfo> RiuPickItemInfo::convertToPickItemInfos( const cvf::HitItemCollection &hitItems)
{
std::vector<RiuPickItemInfo> pickItemInfos;
pickItemInfos.reserve(hitItems.count());
for ( size_t i = 0; i < hitItems.count(); i++ )
{
pickItemInfos.emplace_back(RiuPickItemInfo(hitItems.item(i)));
}
return pickItemInfos;
}

5
ApplicationCode/UserInterface/RiuPickItemInfo.h
View File

@ -20,12 +20,14 @@
#include "cvfBase.h"
#include "cvfVector3.h"
#include <vector>
namespace cvf
{
class Part;
class Object;
class HitItem;
class HitItemCollection;
}
@ -58,7 +60,8 @@ public:
cvf::uint faceIdx() const { return m_faceIdx;}
double distanceAlongRay() const { return m_distanceAlongRay;}
static RiuPickItemInfo extractPickItemInfo(const cvf::HitItem* hitItem);
static RiuPickItemInfo extractPickItemInfo(const cvf::HitItem* hitItem);
static std::vector<RiuPickItemInfo> convertToPickItemInfos(const cvf::HitItemCollection &hitItems);
private:
double m_distanceAlongRay;

171
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -148,6 +148,7 @@ void RiuViewerCommands::setOwnerView(Rim3dView * owner)
m_reservoirView = owner;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -162,41 +163,43 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
QMenu menu;
caf::CmdFeatureMenuBuilder menuBuilder;
uint firstPartTriangleIndex = cvf::UNDEFINED_UINT;
cvf::Vec3d localIntersectionPoint(cvf::Vec3d::ZERO);
cvf::Vec3d globalIntersectionPoint(cvf::Vec3d::ZERO);
const cvf::Part* firstHitPart = nullptr;
uint firstPartTriangleIndex = cvf::UNDEFINED_UINT;
m_currentPickPositionInDomainCoords = cvf::Vec3d::UNDEFINED;
// Check type of view
RimGridView* gridView = dynamic_cast<RimGridView*>(m_reservoirView.p());
Rim2dIntersectionView* int2dView = dynamic_cast<Rim2dIntersectionView*>(m_reservoirView.p());
cvf::HitItemCollection hitItems;
if (m_viewer->rayPick(winPosX, winPosY, &hitItems))
{
std::vector<std::pair<const cvf::Part*, cvf::uint>> partAndTriangleIndexPairs;
extractIntersectionData(hitItems, &localIntersectionPoint, &globalIntersectionPoint,
&partAndTriangleIndexPairs, nullptr, nullptr);
std::vector<RiuPickItemInfo> pickItemInfos = RiuPickItemInfo::convertToPickItemInfos(hitItems);
for (const auto& partTringleIndex : partAndTriangleIndexPairs)
cvf::Vec3d globalIntersectionPoint(cvf::Vec3d::ZERO);
if ( pickItemInfos.size() )
{
if (!firstHitPart)
{
auto part = partTringleIndex.first;
const RivObjectSourceInfo* objectSourceInfo = dynamic_cast<const RivObjectSourceInfo*>(part->sourceInfo());
if (objectSourceInfo && dynamic_cast<RimPerforationInterval*>(objectSourceInfo->object()))
{
// Skip picking on perforation interval, display well path context menu
continue;
}
globalIntersectionPoint = pickItemInfos[0].globalPickedPoint();
}
firstHitPart = part;
firstPartTriangleIndex = partTringleIndex.second;
break;
for (const auto& pickItem : pickItemInfos)
{
const RivObjectSourceInfo* objectSourceInfo = dynamic_cast<const RivObjectSourceInfo*>(pickItem.sourceInfo());
if ( objectSourceInfo && dynamic_cast<RimPerforationInterval*>(objectSourceInfo->object()) )
{
// Skip picking on perforation interval, display well path context menu
continue;
}
const RivSourceInfo* rivSourceInfo = dynamic_cast<const RivSourceInfo*>(pickItem.sourceInfo());
if ( rivSourceInfo && rivSourceInfo->hasNNCIndices())
{
// Skip picking on nnc-s
continue;
}
firstHitPart = pickItem.pickedPart();
firstPartTriangleIndex = pickItem.faceIdx();
globalIntersectionPoint = pickItem.globalPickedPoint();
break;
}
cvf::Vec3d displayModelOffset = cvf::Vec3d::ZERO;
@ -209,6 +212,11 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
}
// Check type of view
RimGridView* gridView = dynamic_cast<RimGridView*>(m_reservoirView.p());
Rim2dIntersectionView* int2dView = dynamic_cast<Rim2dIntersectionView*>(m_reservoirView.p());
if (firstHitPart && firstPartTriangleIndex != cvf::UNDEFINED_UINT)
{
const RivSourceInfo* rivSourceInfo = dynamic_cast<const RivSourceInfo*>(firstHitPart->sourceInfo());
@ -518,19 +526,13 @@ void RiuViewerCommands::handlePickAction(int winPosX, int winPosY, Qt::KeyboardM
cvf::HitItemCollection hitItems;
if (m_viewer->rayPick(winPosX, winPosY, &hitItems))
{
std::vector<std::pair<const cvf::Part*, cvf::uint>> partAndTriangleIndexPairs;
extractIntersectionData(hitItems,
&localIntersectionPoint,
&globalIntersectionPoint,
&partAndTriangleIndexPairs,
&firstNncHitPart,
&nncPartTriangleIndex);
if (!partAndTriangleIndexPairs.empty())
if (hitItems.count())
{
RicViewerEventObject viewerEventObject(globalIntersectionPoint,
partAndTriangleIndexPairs,
std::vector<RiuPickItemInfo> pickItemInfos = RiuPickItemInfo::convertToPickItemInfos(hitItems);
RicViewerEventObject viewerEventObject(pickItemInfos,
m_reservoirView);
for (size_t i = 0; i < m_viewerEventHandlers.size(); i++)
{
if (m_viewerEventHandlers[i]->handleEvent(viewerEventObject))
@ -539,8 +541,24 @@ void RiuViewerCommands::handlePickAction(int winPosX, int winPosY, Qt::KeyboardM
}
}
firstHitPart = partAndTriangleIndexPairs.front().first;
firstPartTriangleIndex = partAndTriangleIndexPairs.front().second;
size_t indexToFirstNoneNncItem = -1;
size_t indexToNncItemNearFirstItem = -1;
findFirstItems(pickItemInfos, &indexToFirstNoneNncItem, &indexToNncItemNearFirstItem);
if ( indexToFirstNoneNncItem != -1 )
{
localIntersectionPoint = pickItemInfos[indexToFirstNoneNncItem].localPickedPoint();
globalIntersectionPoint = pickItemInfos[indexToFirstNoneNncItem].globalPickedPoint();
firstHitPart = pickItemInfos[indexToFirstNoneNncItem].pickedPart();
firstPartTriangleIndex = pickItemInfos[indexToFirstNoneNncItem].faceIdx();
}
if (indexToNncItemNearFirstItem != -1)
{
firstNncHitPart = pickItemInfos[indexToNncItemNearFirstItem].pickedPart();
nncPartTriangleIndex = pickItemInfos[indexToNncItemNearFirstItem].faceIdx();
}
}
}
@ -903,8 +921,76 @@ void RiuViewerCommands::findCellAndGridIndex(const RivIntersectionBoxSourceInfo*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewerCommands::findFirstItems(const std::vector<RiuPickItemInfo> & pickItemInfos,
size_t* indexToFirstNoneNncItem,
size_t* indexToNncItemNearFirsItem)
{
CVF_ASSERT(pickItemInfos.size() > 0);
CVF_ASSERT(indexToFirstNoneNncItem);
CVF_ASSERT(indexToNncItemNearFirsItem);
double pickDepthThresholdSquared = 0.05 *0.05;
{
RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
if (eclipseView && eclipseView->mainGrid())
{
double characteristicCellSize = eclipseView->mainGrid()->characteristicIJCellSize();
pickDepthThresholdSquared = characteristicCellSize / 100.0;
pickDepthThresholdSquared = pickDepthThresholdSquared * pickDepthThresholdSquared;
}
}
size_t firstNonNncHitIndex = cvf::UNDEFINED_SIZE_T;
size_t nncNearFirstItemIndex = cvf::UNDEFINED_SIZE_T;
cvf::Vec3d firstOrFirstNonNncIntersectionPoint = pickItemInfos[0].globalPickedPoint();
// Find first nnc part, and store as a separate thing if the nnc is first or close behind the first hit item.
// Find index to first ordinary (non-nnc) part
for (size_t i = 0; i < pickItemInfos.size(); i++)
{
// If hit item is nnc and is close to first (none-nnc) hit, store nncpart and face id
bool canFindRelvantNNC = true;
const RivSourceInfo* rivSourceInfo = dynamic_cast<const RivSourceInfo*>(pickItemInfos[i].sourceInfo());
if ( rivSourceInfo && rivSourceInfo->hasNNCIndices() )
{
if ( nncNearFirstItemIndex == cvf::UNDEFINED_SIZE_T && canFindRelvantNNC)
{
cvf::Vec3d distFirstNonNNCToCandidate = firstOrFirstNonNncIntersectionPoint - pickItemInfos[i].globalPickedPoint();
// This candidate is an NNC hit
if ( distFirstNonNNCToCandidate.lengthSquared() < pickDepthThresholdSquared )
{
nncNearFirstItemIndex = i;
}
else
{
canFindRelvantNNC = false;
}
}
}
else
{
if ( firstNonNncHitIndex == cvf::UNDEFINED_SIZE_T )
{
firstNonNncHitIndex = i;
}
}
if (firstNonNncHitIndex != cvf::UNDEFINED_SIZE_T && (nncNearFirstItemIndex != cvf::UNDEFINED_SIZE_T || !canFindRelvantNNC) )
{
break; // Found what can be found
}
}
(*indexToFirstNoneNncItem) = firstNonNncHitIndex;
(*indexToNncItemNearFirsItem) = nncNearFirstItemIndex;
}
#if 0
//--------------------------------------------------------------------------------------------------
/// If there is an nnc-item within a depth-tolerance distance from the first hit-item
/// return this as nncPart and nncPartFaceHit
@ -917,7 +1003,9 @@ void RiuViewerCommands::extractIntersectionData(const cvf::HitItemCollection& hi
std::vector<std::pair<const cvf::Part*, cvf::uint>>* partAndTriangleIndexPairs,
const cvf::Part** nncPart, uint* nncPartFaceHit)
{
CVF_ASSERT(hitItems.count() > 0);
std::vector<RiuPickItemInfo> pickItemInfos = convertToPickItemInfos(hitItems);
double pickDepthThresholdSquared = 0.05 *0.05;
{
@ -933,14 +1021,8 @@ void RiuViewerCommands::extractIntersectionData(const cvf::HitItemCollection& hi
size_t firstNonNncHitIndex = cvf::UNDEFINED_SIZE_T;
size_t nncHitIndex = cvf::UNDEFINED_SIZE_T;
cvf::Vec3d firstOrFirstNonNncIntersectionPoint = hitItems.item(0)->intersectionPoint();
cvf::Vec3d firstOrFirstNonNncIntersectionPoint = pickItemInfos[0].globalPickedPoint();
std::vector<RiuPickItemInfo> pickItemInfos;
pickItemInfos.reserve(hitItems.count());
for (size_t i = 0; i < hitItems.count(); i++)
{
pickItemInfos.emplace_back(RiuPickItemInfo(hitItems.item(i)));
}
// Find first nnc part, and store as a separate thing if the nnc is first or close behind the first hit item.
// Find index to first ordinary (non-nnc) part
@ -1006,6 +1088,7 @@ void RiuViewerCommands::extractIntersectionData(const cvf::HitItemCollection& hi
}
}
#endif
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

11
ApplicationCode/UserInterface/RiuViewerCommands.h
View File

@ -33,6 +33,7 @@ class Rim3dView;
class RiuViewer;
class RivIntersectionBoxSourceInfo;
class RivIntersectionSourceInfo;
class RiuPickItemInfo;
class QMouseEvent;
@ -64,12 +65,10 @@ private:
void findCellAndGridIndex(const RivIntersectionBoxSourceInfo* intersectionBoxSourceInfo, cvf::uint firstPartTriangleIndex, size_t* cellIndex, size_t* gridIndex);
void ijkFromCellIndex(size_t gridIdx, size_t cellIndex, size_t* i, size_t* j, size_t* k);
void extractIntersectionData(const cvf::HitItemCollection& hitItems,
cvf::Vec3d* localIntersectionPoint,
cvf::Vec3d* globalIntersectionPoint,
std::vector<std::pair<const cvf::Part*, cvf::uint>>* partAndTriangleIndexPairs,
const cvf::Part** nncPart,
uint* nncPartFaceHit);
void findFirstItems(const std::vector<RiuPickItemInfo> & pickItemInfos,
size_t* indexToFirstNoneNncItem,
size_t* indexToNncItemNearFirsItem);
bool handleOverlayItemPicking(int winPosX, int winPosY);