mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-08 23:23:01 -06:00
427 lines
15 KiB
C++
427 lines
15 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2018- Equinor ASA
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RicHoloLensExportImpl.h"
|
|
|
|
#include "RiaApplication.h"
|
|
#include "RiaPreferences.h"
|
|
|
|
#include "RigMainGrid.h"
|
|
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimFaultInView.h"
|
|
#include "RimGridView.h"
|
|
#include "RimSimWellInView.h"
|
|
#include "RimWellPath.h"
|
|
|
|
#include "RiuViewer.h"
|
|
#include "RivFemPickSourceInfo.h"
|
|
#include "RivGeoMechVizLogic.h"
|
|
#include "RivIntersectionBoxSourceInfo.h"
|
|
#include "RivIntersectionSourceInfo.h"
|
|
#include "RivMeshLinesSourceInfo.h"
|
|
#include "RivSimWellPipeSourceInfo.h"
|
|
#include "RivSourceInfo.h"
|
|
#include "RivTextLabelSourceInfo.h"
|
|
#include "RivWellPathSourceInfo.h"
|
|
|
|
#include "cafEffectGenerator.h"
|
|
|
|
#include "cvfPart.h"
|
|
#include "cvfRenderState.h"
|
|
#include "cvfRenderStateCullFace.h"
|
|
#include "cvfRenderStateTextureBindings.h"
|
|
#include "cvfRenderState_FF.h"
|
|
#include "cvfTexture.h"
|
|
#include "cvfTexture2D_FF.h"
|
|
|
|
#include <QString>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<VdeExportPart> RicHoloLensExportImpl::partsForExport(const RimGridView& view)
|
|
{
|
|
std::vector<VdeExportPart> exportParts;
|
|
|
|
RimEclipseCase* rimEclipseCase = nullptr;
|
|
view.firstAncestorOrThisOfType(rimEclipseCase);
|
|
|
|
if (view.viewer())
|
|
{
|
|
auto visibleParts = view.viewer()->visibleParts();
|
|
|
|
for (auto& visiblePart : visibleParts)
|
|
{
|
|
if (RicHoloLensExportImpl::isGrid(visiblePart.p()))
|
|
{
|
|
VdeExportPart exportPart(visiblePart.p());
|
|
exportPart.setSourceObjectType(VdeExportPart::OBJ_TYPE_GRID);
|
|
|
|
if (rimEclipseCase && rimEclipseCase->mainGrid())
|
|
{
|
|
if (rimEclipseCase->mainGrid()->isFaceNormalsOutwards())
|
|
{
|
|
exportPart.setWinding(VdeExportPart::COUNTERCLOCKWISE);
|
|
}
|
|
else
|
|
{
|
|
exportPart.setWinding(VdeExportPart::CLOCKWISE);
|
|
}
|
|
}
|
|
|
|
{
|
|
auto* sourceInfo = dynamic_cast<RivSourceInfo*>(visiblePart->sourceInfo());
|
|
if (sourceInfo)
|
|
{
|
|
RimFaultInView* faultInView = dynamic_cast<RimFaultInView*>(sourceInfo->object());
|
|
if (faultInView)
|
|
{
|
|
exportPart.setSourceObjectName(faultInView->name());
|
|
exportPart.setColor(faultInView->faultColor());
|
|
}
|
|
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(sourceInfo->object());
|
|
if (eclipseCase)
|
|
{
|
|
QString nameOfObject = rimEclipseCase->gridFileName();
|
|
auto gridSourceInfo = dynamic_cast<const RivSourceInfo*>(visiblePart->sourceInfo());
|
|
if (gridSourceInfo)
|
|
{
|
|
size_t gridIndex = gridSourceInfo->gridIndex();
|
|
|
|
nameOfObject += " Grid " + QString::number(gridIndex);
|
|
}
|
|
|
|
const RimEclipseView* eclipseView = dynamic_cast<const RimEclipseView*>(&view);
|
|
if (eclipseView)
|
|
{
|
|
cvf::Color4f color = eclipseView->colorFromCellCategory(sourceInfo->cellSetType());
|
|
exportPart.setColor(color.toColor3f());
|
|
exportPart.setOpacity(color.a());
|
|
|
|
QString text = RicHoloLensExportImpl::gridCellSetTypeText(sourceInfo->cellSetType());
|
|
exportPart.setSourceObjectCellSetType(text);
|
|
}
|
|
|
|
exportPart.setSourceObjectName(nameOfObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
auto femPartPickInfo = dynamic_cast<RivFemPickSourceInfo*>(visiblePart->sourceInfo());
|
|
if (femPartPickInfo)
|
|
{
|
|
exportPart.setColor(RivGeoMechVizLogic::staticCellColor());
|
|
}
|
|
}
|
|
|
|
if (visiblePart->effect())
|
|
{
|
|
const cvf::RenderStateCullFace* renderStateCullFace = dynamic_cast<const cvf::RenderStateCullFace*>(
|
|
visiblePart->effect()->renderStateOfType(cvf::RenderState::CULL_FACE));
|
|
if (renderStateCullFace)
|
|
{
|
|
// The logic below that inverts the culling mode simply does not make sense. We should be able to just utilize the cull mode set
|
|
// in the render state. The proper solution is probably to put more effort into correctly determining the winding in further up
|
|
// in this function, but currently there is no clear way to accomplish this.
|
|
if (renderStateCullFace->mode() == cvf::RenderStateCullFace::BACK)
|
|
{
|
|
exportPart.setCullFace(VdeExportPart::CF_FRONT);
|
|
}
|
|
else if (renderStateCullFace->mode() == cvf::RenderStateCullFace::FRONT)
|
|
{
|
|
exportPart.setCullFace(VdeExportPart::CF_BACK);
|
|
}
|
|
}
|
|
}
|
|
|
|
appendTextureImage(exportPart, visiblePart.p());
|
|
|
|
exportParts.push_back(exportPart);
|
|
}
|
|
else if (RicHoloLensExportImpl::isPipe(visiblePart.p()))
|
|
{
|
|
VdeExportPart exportPart(visiblePart.p());
|
|
exportPart.setSourceObjectType(VdeExportPart::OBJ_TYPE_PIPE);
|
|
|
|
auto simWellSourceInfo = dynamic_cast<const RivSimWellPipeSourceInfo*>(visiblePart->sourceInfo());
|
|
if (simWellSourceInfo)
|
|
{
|
|
auto simWell = simWellSourceInfo->well();
|
|
if (simWell)
|
|
{
|
|
exportPart.setSourceObjectName(simWell->name());
|
|
exportPart.setColor(simWell->wellPipeColor());
|
|
}
|
|
}
|
|
|
|
auto wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>(visiblePart->sourceInfo());
|
|
if (wellPathSourceInfo)
|
|
{
|
|
RimWellPath* wellPath = wellPathSourceInfo->wellPath();
|
|
if (wellPath)
|
|
{
|
|
exportPart.setSourceObjectName(wellPath->name());
|
|
exportPart.setColor(wellPath->wellPathColor());
|
|
}
|
|
}
|
|
|
|
appendTextureImage(exportPart, visiblePart.p());
|
|
|
|
exportParts.push_back(exportPart);
|
|
}
|
|
else if (RicHoloLensExportImpl::isMeshLines(visiblePart.p()))
|
|
{
|
|
VdeExportPart exportPart(visiblePart.p());
|
|
exportPart.setSourceObjectType(VdeExportPart::OBJ_TYPE_GRID);
|
|
|
|
cvf::Color3f lineColor = RiaApplication::instance()->preferences()->defaultGridLineColors();
|
|
|
|
auto linesSourceInfo = dynamic_cast<const RivMeshLinesSourceInfo*>(visiblePart->sourceInfo());
|
|
if (linesSourceInfo)
|
|
{
|
|
if (dynamic_cast<RimFaultInView*>(linesSourceInfo->object()))
|
|
{
|
|
lineColor = RiaApplication::instance()->preferences()->defaultFaultGridLineColors();
|
|
}
|
|
}
|
|
|
|
exportPart.setColor(lineColor);
|
|
exportPart.setRole(VdeExportPart::MESH_LINES);
|
|
|
|
appendTextureImage(exportPart, visiblePart.p());
|
|
|
|
exportParts.push_back(exportPart);
|
|
}
|
|
}
|
|
}
|
|
|
|
return exportParts;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<std::pair<cvf::Vec3f, cvf::String>> RicHoloLensExportImpl::labelsForExport(const RimGridView& view)
|
|
{
|
|
std::vector<std::pair<cvf::Vec3f, cvf::String>> labelAndPositions;
|
|
|
|
auto visibleParts = view.viewer()->visibleParts();
|
|
|
|
for (auto& visiblePart : visibleParts)
|
|
{
|
|
const RivTextLabelSourceInfo* textLabel = dynamic_cast<const RivTextLabelSourceInfo*>(visiblePart->sourceInfo());
|
|
if (textLabel)
|
|
{
|
|
labelAndPositions.push_back(std::make_pair(textLabel->textPositionDisplayCoord(), textLabel->text()));
|
|
}
|
|
}
|
|
|
|
return labelAndPositions;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicHoloLensExportImpl::appendTextureImage(VdeExportPart& exportPart, cvf::Part* part)
|
|
{
|
|
if (part && part->effect())
|
|
{
|
|
{
|
|
auto textureBindings = dynamic_cast<cvf::RenderStateTextureBindings*>(
|
|
part->effect()->renderStateOfType(cvf::RenderState::TEXTURE_BINDINGS));
|
|
|
|
if (textureBindings && textureBindings->bindingCount() > 0)
|
|
{
|
|
cvf::Texture* textureBinding = textureBindings->texture(0);
|
|
if (textureBinding)
|
|
{
|
|
exportPart.setTextureImage(textureBinding->image());
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
auto textureMappingFF = dynamic_cast<cvf::RenderStateTextureMapping_FF*>(
|
|
part->effect()->renderStateOfType(cvf::RenderState::TEXTURE_MAPPING_FF));
|
|
|
|
if (textureMappingFF && textureMappingFF->texture())
|
|
{
|
|
auto* texture = textureMappingFF->texture();
|
|
if (texture)
|
|
{
|
|
exportPart.setTextureImage(texture->image());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicHoloLensExportImpl::gridCellSetTypeText(RivCellSetEnum cellSetType)
|
|
{
|
|
switch (cellSetType)
|
|
{
|
|
case OVERRIDDEN_CELL_VISIBILITY:
|
|
return "OVERRIDDEN_CELL_VISIBILITY";
|
|
break;
|
|
case ALL_CELLS:
|
|
return "ALL_CELLS";
|
|
break;
|
|
case ACTIVE:
|
|
return "ACTIVE";
|
|
break;
|
|
case ALL_WELL_CELLS:
|
|
return "ALL_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_CELLS:
|
|
return "VISIBLE_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS:
|
|
return "VISIBLE_WELL_FENCE_CELLS";
|
|
break;
|
|
case INACTIVE:
|
|
return "INACTIVE";
|
|
break;
|
|
case RANGE_FILTERED:
|
|
return "RANGE_FILTERED";
|
|
break;
|
|
case RANGE_FILTERED_INACTIVE:
|
|
return "RANGE_FILTERED_INACTIVE";
|
|
break;
|
|
case RANGE_FILTERED_WELL_CELLS:
|
|
return "RANGE_FILTERED_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
|
|
return "VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER";
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER:
|
|
return "VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER";
|
|
break;
|
|
case PROPERTY_FILTERED:
|
|
return "PROPERTY_FILTERED";
|
|
break;
|
|
case PROPERTY_FILTERED_WELL_CELLS:
|
|
return "PROPERTY_FILTERED_WELL_CELLS";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return "INVALID_CELL_SET_TYPE";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicHoloLensExportImpl::isGrid(const cvf::Part* part)
|
|
{
|
|
if (!part) return false;
|
|
|
|
auto sourceInfo = part->sourceInfo();
|
|
|
|
{
|
|
{
|
|
auto sourceInfoOfType = dynamic_cast<const RivSourceInfo*>(sourceInfo);
|
|
if (sourceInfoOfType)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
{
|
|
auto sourceInfoOfType = dynamic_cast<const RivIntersectionSourceInfo*>(sourceInfo);
|
|
if (sourceInfoOfType)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
{
|
|
auto sourceInfoOfType = dynamic_cast<const RivIntersectionBoxSourceInfo*>(sourceInfo);
|
|
if (sourceInfoOfType)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
{
|
|
auto sourceInfoOfType = dynamic_cast<const RivFemPickSourceInfo*>(sourceInfo);
|
|
if (sourceInfoOfType)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicHoloLensExportImpl::isPipe(const cvf::Part* part)
|
|
{
|
|
if (!part) return false;
|
|
|
|
auto sourceInfo = part->sourceInfo();
|
|
|
|
{
|
|
auto simWellSourceInfo = dynamic_cast<const RivSimWellPipeSourceInfo*>(sourceInfo);
|
|
if (simWellSourceInfo)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
{
|
|
auto wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>(sourceInfo);
|
|
if (wellPathSourceInfo)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicHoloLensExportImpl::isMeshLines(const cvf::Part* part)
|
|
{
|
|
if (!part) return false;
|
|
|
|
auto sourceInfo = part->sourceInfo();
|
|
|
|
{
|
|
auto linesSourceInfo = dynamic_cast<const RivMeshLinesSourceInfo*>(sourceInfo);
|
|
if (linesSourceInfo)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|