//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate,
const RimEclipseView& activeView)
{
if (!stimPlanFracTemplate->fractureGrid()) return nullptr;
auto displayCoordTransform = activeView.displayCoordTransform();
if (displayCoordTransform.isNull()) return nullptr;
std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid()->fractureCells();
std::vector<cvf::Vec3f> stimPlanMeshVertices;
QString resultNameFromColors = activeView.fractureColors()->uiResultName();
QString resultUnitFromColors = activeView.fractureColors()->unit();
std::vector<double> prCellResults = stimPlanFracTemplate->fractureGridResults(
resultNameFromColors, resultUnitFromColors, stimPlanFracTemplate->activeTimeStepIndex());
m_visibleFracturePolygons.clear();
for (size_t cIdx = 0; cIdx < stimPlanCells.size(); ++cIdx)
{
if (prCellResults[cIdx] > 1e-7)
{
const RigFractureCell& stimPlanCell = stimPlanCells[cIdx];
std::vector<cvf::Vec3d> stimPlanCellPolygon = stimPlanCell.getPolygon();
for (const cvf::Vec3d& cellCorner : stimPlanCellPolygon)
{
stimPlanMeshVertices.push_back(static_cast<cvf::Vec3f>(cellCorner));
}
m_visibleFracturePolygons.push_back(stimPlanCellPolygon);
}
}
if (stimPlanMeshVertices.empty())
{
return nullptr;
}
cvf::Mat4d fractureXf = m_rimFracture->transformMatrix();
std::vector<cvf::Vec3f> stimPlanMeshVerticesDisplayCoords =
transformToFractureDisplayCoords(stimPlanMeshVertices, fractureXf, *displayCoordTransform);
cvf::Vec3fArray* stimPlanMeshVertexList;
stimPlanMeshVertexList = new cvf::Vec3fArray;
stimPlanMeshVertexList->assign(stimPlanMeshVerticesDisplayCoords);
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = new cvf::DrawableGeo;
stimPlanMeshGeo->setVertexArray(stimPlanMeshVertexList);
cvf::ref<cvf::UIntArray> indices = RivFaultGeometryGenerator::lineIndicesFromQuadVertexArray(stimPlanMeshVertexList);
cvf::ref<cvf::PrimitiveSetIndexedUInt> prim = new cvf::PrimitiveSetIndexedUInt(cvf::PT_LINES);
prim->setIndices(indices.p());
stimPlanMeshGeo->addPrimitiveSet(prim.p());
return stimPlanMeshGeo;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QString RivWellFracturePartMgr::resultInfoText(const RimEclipseView& activeView, cvf::Vec3d domainIntersectionPoint) const
{
QString text;
if (m_rimFracture.isNull()) return text;
auto* ellipseFractureTemplate = dynamic_cast<RimEllipseFractureTemplate*>(m_rimFracture->fractureTemplate());
auto* stimPlanTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (ellipseFractureTemplate)
{
text.append("Result value: CONDUCTIVITY ");
text.append(QString::number(ellipseFractureTemplate->conductivity()) + "\n");
}
else if (stimPlanTemplate)
{
const RigFractureCell* cell = getFractureCellAtDomainCoord(domainIntersectionPoint);
if (cell)
{
QString resultNameFromColors = activeView.fractureColors()->uiResultName();
QString resultUnitFromColors = activeView.fractureColors()->unit();
double resultValue = stimPlanTemplate->resultValueAtIJ(
resultNameFromColors, resultUnitFromColors, stimPlanTemplate->activeTimeStepIndex(), cell->getI(), cell->getJ());
QString resultValueText = QString("%1").arg(resultValue);
QString iText = QString::number(cell->getI());
QString jText = QString::number(cell->getJ());
RimStimPlanColors* stimPlanColors = activeView.fractureColors();
if (stimPlanColors)
{
// Conductivity
text.append("Result value: ");
QString resultName = stimPlanTemplate->mapUiResultNameToFileResultName(stimPlanColors->uiResultName());
text.append(resultName + " ");
text.append(resultValueText + "\n");
}
// Cell index
text.append("Cell Index: ");
text.append(iText + ", " + jText + "\n");
}
}
return text;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* model, const RimEclipseView& eclView)
{
if (!m_rimFracture->isChecked() || !eclView.fractureColors()->isChecked()) return;
if (!m_rimFracture->fractureTemplate()) return;
m_visibleFracturePolygons.clear();
double characteristicCellSize = eclView.ownerCase()->characteristicCellSize();
cvf::Collection<cvf::Part> parts;
RimStimPlanFractureTemplate* stimPlanFracTemplate =
dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (stimPlanFracTemplate)
{
if (eclView.fractureColors()->stimPlanResultColorType() == RimStimPlanColors::SINGLE_ELEMENT_COLOR)
{
auto part = createStimPlanElementColorSurfacePart(eclView);
if (part.notNull()) parts.push_back(part.p());
}
else
{
auto part = createStimPlanColorInterpolatedSurfacePart(eclView);
if (part.notNull()) parts.push_back(part.p());
}
if (eclView.fractureColors()->showStimPlanMesh())
{
auto part = createStimPlanMeshPart(eclView);
if (part.notNull()) parts.push_back(part.p());
}
}
else
{
auto part = createEllipseSurfacePart(eclView);
if (part.notNull()) parts.push_back(part.p());
}
double distanceToCenterLine = 1.0;
{
RimWellPathCollection* wellPathColl = nullptr;
m_rimFracture->firstAncestorOrThisOfType(wellPathColl);
if (wellPathColl)
{
distanceToCenterLine = wellPathColl->wellPathRadiusScaleFactor() * characteristicCellSize;
}
RimSimWellInView* simWell = nullptr;
m_rimFracture->firstAncestorOrThisOfType(simWell);
if (simWell)
{
distanceToCenterLine = simWell->pipeRadius();
}
}
// Make sure the distance is slightly smaller than the pipe radius to make the pipe is visible through the fracture
distanceToCenterLine *= 0.1;
if (distanceToCenterLine < 0.03)
{
distanceToCenterLine = 0.03;
}
auto fractureMatrix = m_rimFracture->transformMatrix();
if (m_rimFracture->fractureTemplate() &&
m_rimFracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
{
cvf::Vec3d partTranslation = distanceToCenterLine * cvf::Vec3d(fractureMatrix.col(2));
for (auto& part : parts)
{
RivWellFracturePartMgr::addPartAtPositiveAndNegativeTranslation(model, part.p(), partTranslation);
}
}
else
{
for (auto& part : parts)
{
model->addPart(part.p());
}
}
if (m_rimFracture->fractureTemplate())
{
// Position the containment mask outside the fracture parts
// Always duplicate the containment mask parts
{
auto maskOfFractureAreasOutsideGrid = createMaskOfFractureOutsideGrid(eclView);
if (maskOfFractureAreasOutsideGrid.notNull())
{
double scaleFactor = 0.03;
if (m_rimFracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
{
scaleFactor = 2 * distanceToCenterLine;
}
cvf::Vec3d partTranslation = scaleFactor * cvf::Vec3d(fractureMatrix.col(2));
RivWellFracturePartMgr::addPartAtPositiveAndNegativeTranslation(
model, maskOfFractureAreasOutsideGrid.p(), partTranslation);
}
}
if (m_rimFracture->fractureTemplate()->fractureContainment()->isEnabled())
{
// Position the containment mask outside the fracture parts
// Always duplicate the containment mask parts
auto containmentMask = createContainmentMaskPart(eclView);
if (containmentMask.notNull())
{
double scaleFactor = 0.03;
if (m_rimFracture->fractureTemplate() &&
m_rimFracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
{
scaleFactor = 2 * distanceToCenterLine;
}
cvf::Vec3d partTranslation = scaleFactor * cvf::Vec3d(fractureMatrix.col(2));
RivWellFracturePartMgr::addPartAtPositiveAndNegativeTranslation(model, containmentMask.p(), partTranslation);
}
}
}
appendFracturePerforationLengthParts(eclView, model);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Part> RivWellFracturePartMgr::createStimPlanElementColorSurfacePart(const RimEclipseView& activeView)
{
CVF_ASSERT(m_rimFracture);
RimStimPlanFractureTemplate* stimPlanFracTemplate =
dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
CVF_ASSERT(stimPlanFracTemplate);
if (!stimPlanFracTemplate->fractureGrid()) return nullptr;
auto displayCoordTransform = activeView.displayCoordTransform();
if (displayCoordTransform.isNull()) return nullptr;
std::vector<cvf::Vec3f> stimPlanMeshVertices;
cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray;
const cvf::ScalarMapper* scalarMapper = nullptr;
{
std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid()->fractureCells();
RimRegularLegendConfig* legendConfig = nullptr;
if (activeView.fractureColors() && activeView.fractureColors()->isChecked() &&
activeView.fractureColors()->activeLegend())
{
legendConfig = activeView.fractureColors()->activeLegend();
scalarMapper = legendConfig->scalarMapper();
QString resultNameFromColors = activeView.fractureColors()->uiResultName();
QString resultUnitFromColors = activeView.fractureColors()->unit();
std::vector<double> prCellResults = stimPlanFracTemplate->fractureGridResults(
resultNameFromColors, resultUnitFromColors, stimPlanFracTemplate->activeTimeStepIndex());
textureCoords->reserve(prCellResults.size() * 4);
for (size_t cIdx = 0; cIdx < stimPlanCells.size(); ++cIdx)
{
if (prCellResults[cIdx] > 1e-7)
{
const RigFractureCell& stimPlanCell = stimPlanCells[cIdx];
std::vector<cvf::Vec3d> stimPlanCellPolygon = stimPlanCell.getPolygon();
for (const cvf::Vec3d& cellCorner : stimPlanCellPolygon)
{
stimPlanMeshVertices.push_back(static_cast<cvf::Vec3f>(cellCorner));
textureCoords->add(scalarMapper->mapToTextureCoord(prCellResults[cIdx]));
}
}
}
textureCoords->squeeze();
}
else
{
for (const auto& stimPlanCell : stimPlanCells)
{
for (const auto& cellCorner : stimPlanCell.getPolygon())
{
stimPlanMeshVertices.push_back(static_cast<cvf::Vec3f>(cellCorner));
}
}
}
}
if (stimPlanMeshVertices.empty())
{
return nullptr;
}
cvf::Mat4d fractureXf = m_rimFracture->transformMatrix();
std::vector<cvf::Vec3f> nodeDisplayCoords =
transformToFractureDisplayCoords(stimPlanMeshVertices, fractureXf, *displayCoordTransform);
std::vector<cvf::uint> triIndicesToInclude;
size_t cellCount = stimPlanMeshVertices.size() / 4;
for (cvf::uint i = 0; i < cellCount; i++)
{
triIndicesToInclude.push_back(i * 4 + 0);
triIndicesToInclude.push_back(i * 4 + 1);
triIndicesToInclude.push_back(i * 4 + 2);
triIndicesToInclude.push_back(i * 4 + 0);
triIndicesToInclude.push_back(i * 4 + 2);
triIndicesToInclude.push_back(i * 4 + 3);
}
// Show selected result on the surface geometry and filter out triangles that have result values near 0
if (scalarMapper)
{
if (triIndicesToInclude.empty())
{
return nullptr;
}
cvf::ref<cvf::DrawableGeo> geo = buildDrawableGeoFromTriangles(triIndicesToInclude, nodeDisplayCoords);
geo->setTextureCoordArray(textureCoords.p());
cvf::ref<cvf::Part> surfacePart =
createScalarMapperPart(geo.p(), scalarMapper, m_rimFracture, activeView.isLightingDisabled());
return surfacePart;
}
else
{
// No result is mapped, show the entire StimPlan surface with default color
return createSingleColorSurfacePart(triIndicesToInclude, nodeDisplayCoords, activeView.fractureColors()->defaultColor());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Part> RivWellFracturePartMgr::createStimPlanColorInterpolatedSurfacePart(const RimEclipseView& activeView)
{
CVF_ASSERT(m_rimFracture);
RimStimPlanFractureTemplate* stimPlanFracTemplate =
dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
CVF_ASSERT(stimPlanFracTemplate);
auto displayCoordTransform = activeView.displayCoordTransform();
if (displayCoordTransform.isNull()) return nullptr;
// Note that the filtering and result mapping code below couples closely to the triangulation and vertex layout returned by
// triangleGeometry() If this ever changes, the entire code must be revisited
std::vector<cvf::uint> triangleIndices;
std::vector<cvf::Vec3f> nodeDisplayCoords;
{
std::vector<cvf::Vec3f> nodeCoords;
stimPlanFracTemplate->fractureTriangleGeometry(&nodeCoords, &triangleIndices);
if (triangleIndices.empty() || nodeCoords.empty())
{
return nullptr;
}
cvf::Mat4d fractureXf = m_rimFracture->transformMatrix();
nodeDisplayCoords = transformToFractureDisplayCoords(nodeCoords, fractureXf, *displayCoordTransform);
}
RimRegularLegendConfig* legendConfig = nullptr;
if (activeView.fractureColors() && activeView.fractureColors()->isChecked())
{
legendConfig = activeView.fractureColors()->activeLegend();
}
// Show selected result on the surface geometry and filter out triangles that have result values near 0
if (legendConfig)
{
// Construct array with per node result values that correspond to the node coordinates of the triangle mesh
// Since some time steps don't have result vales, we initialize the array to well known values before populating it
std::vector<double> perNodeResultValues(nodeDisplayCoords.size(), HUGE_VAL);
{
size_t idx = 0;
const std::vector<std::vector<double>> dataToPlot =
stimPlanFracTemplate->resultValues(activeView.fractureColors()->uiResultName(),
activeView.fractureColors()->unit(),
stimPlanFracTemplate->activeTimeStepIndex());
for (const std::vector<double>& dataAtY : dataToPlot)
{
for (double val : dataAtY)
{
perNodeResultValues[idx++] = val;
}
}
}
CVF_ASSERT(perNodeResultValues.size() == nodeDisplayCoords.size());
std::vector<cvf::uint> triIndicesToInclude;
for (size_t i = 0; i < triangleIndices.size(); i += 6)
{
// Include all triangles where at least one of the vertices in the triangle pair has a value above threshold
bool includeThisTrianglePair = false;
for (size_t j = 0; j < 6; j++)
{
if (perNodeResultValues[triangleIndices[i + j]] > 1e-7)
{
includeThisTrianglePair = true;
}
}
if (includeThisTrianglePair)
{
for (size_t j = 0; j < 6; j++)
{
triIndicesToInclude.push_back(triangleIndices[i + j]);
}
}
}
if (triIndicesToInclude.empty())
{
return nullptr;
}
cvf::ref<cvf::DrawableGeo> geo = buildDrawableGeoFromTriangles(triIndicesToInclude, nodeDisplayCoords);
const cvf::ScalarMapper* scalarMapper = legendConfig->scalarMapper();
CVF_ASSERT(scalarMapper);
cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray(nodeDisplayCoords.size());
textureCoords->setAll(cvf::Vec2f(0.5f, 1.0f));
for (size_t i = 0; i < perNodeResultValues.size(); i++)
{
const double val = perNodeResultValues[i];
if (val < HUGE_VAL && val == val)
{
textureCoords->set(i, scalarMapper->mapToTextureCoord(val));
}
}
geo->setTextureCoordArray(textureCoords.p());
cvf::ref<cvf::Part> surfacePart =
createScalarMapperPart(geo.p(), scalarMapper, m_rimFracture, activeView.isLightingDisabled());
return surfacePart;
}
else
{
// No result is mapped, show the entire StimPlan surface with default color
return createSingleColorSurfacePart(triangleIndices, nodeDisplayCoords, activeView.fractureColors()->defaultColor());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Part> RivWellFracturePartMgr::createEllipseSurfacePart(const RimEclipseView& activeView)
{
auto displayCoordTransform = activeView.displayCoordTransform();
if (displayCoordTransform.isNull()) return nullptr;
if (m_rimFracture)
{
std::vector<cvf::uint> triangleIndices;
std::vector<cvf::Vec3f> nodeDisplayCoords;
{
std::vector<cvf::Vec3f> nodeCoords;
m_rimFracture->fractureTemplate()->fractureTriangleGeometry(&nodeCoords, &triangleIndices);
cvf::Mat4d fractureXf = m_rimFracture->transformMatrix();
nodeDisplayCoords = transformToFractureDisplayCoords(nodeCoords, fractureXf, *displayCoordTransform);
}
if (triangleIndices.empty() || nodeDisplayCoords.empty())
{
return nullptr;
}
cvf::ref<cvf::DrawableGeo> geo = buildDrawableGeoFromTriangles(triangleIndices, nodeDisplayCoords);
CVF_ASSERT(geo.notNull());
cvf::ref<cvf::Part> surfacePart = new cvf::Part(0, "FractureSurfacePart_ellipse");
surfacePart->setDrawable(geo.p());
surfacePart->setSourceInfo(new RivObjectSourceInfo(m_rimFracture));
cvf::Color4f fractureColor = cvf::Color4f(activeView.fractureColors()->defaultColor());
RimRegularLegendConfig* legendConfig = nullptr;
if (activeView.fractureColors() && activeView.fractureColors()->isChecked())
{
legendConfig = activeView.fractureColors()->activeLegend();
}
if (legendConfig && legendConfig->scalarMapper())
{
cvf::Color3ub resultColor = cvf::Color3ub(RiaColorTables::undefinedCellColor());
if (activeView.fractureColors()->uiResultName() == RiaDefines::conductivityResultName())
{
RimEllipseFractureTemplate* ellipseFractureTemplate =
dynamic_cast<RimEllipseFractureTemplate*>(m_rimFracture->fractureTemplate());
if (ellipseFractureTemplate)
{
double conductivity = ellipseFractureTemplate->conductivity();
resultColor = legendConfig->scalarMapper()->mapToColor(conductivity);
}
}
fractureColor.set(cvf::Color3f::fromByteColor(resultColor.r(), resultColor.g(), resultColor.b()));
}
caf::SurfaceEffectGenerator surfaceGen(fractureColor, caf::PO_1);
cvf::ref<cvf::Effect> eff = surfaceGen.generateCachedEffect();
surfacePart->setEffect(eff.p());
return surfacePart;
}
return nullptr;
}
